Add operator overloading for joins 
Sorry, that's not going to work, as we overload those already for the creation of expressions. This would require treating expression objects differently in the context of the `.join()` method. The way you've got `.on()` and the absence of parentheses presents even more difficulties. Sorry, but I don't see the problem. 
`User.t` - `t` - is not the field,  but magic model self-reference, so it doesn't overlap with field-expressions

Here is dirty but working example to demonstrate the concept:
```python
import os
from peewee import *
import datetime

fp = os.path.join(os.path.dirname(__file__), 'my_database.db')


db = SqliteDatabase(fp)


class ModelRef:
    def __init__(self, cls):
        self._cls = cls
        self._right = None
        self._join_type = None
        self._on = None

    def __and__(self, model_to_join):
        self._join_type = JOIN.INNER
        self._right = model_to_join
        return self

    def on(self, expression):
        self._on = expression
        return self

    def __call__(self):
        return (
            self._right._cls,
            self._join_type,
            self._right._on,
        )


class BaseModel(Model):

    # should be @classproperty
    @classmethod
    def t(cls):
        return ModelRef(cls)

    class Meta:
        database = db


class User(BaseModel):
    username = CharField(unique=True)


class Tweet(BaseModel):
    user = ForeignKeyField(User, backref='tweets')
    message = TextField()
    created_date = DateTimeField(default=datetime.datetime.now)
    is_published = BooleanField(default=True)


query = (
    User
    .select(User, Tweet)
    .join(*(
        User.t()
        & Tweet.t().on(Tweet.user == User.id)
    )())
)

print(query)

``` @coleifer  so it only requires proper `ModelRef` implementation and `isinstance(dest, ModelRef)`-logic in `ModelSelect.join`-method
@coleifer  Hi! Thank you for great project!
So I have an idea:
```python
query = (Foo
         .select(...)
         .join(
            Foo.t 
            & Bar.t.on(...)  #  INNER JOIN
            + Baz.t.on(),    #  LEFT JOIN
            # switch to Foo-context (notice comma above)
            Foo.t  
            & Whatever.t.on(...)   
            ...
         ) 
         .where(...))
```