For this same reason I really dislike that in C++ you can just implicitly drop the "this->" to target class members. You can never tell at a glance what "foo = blah" does if you don't know whether "foo" is a member of "this" or not.

I think your page demonstrates what I mean in the "nested WithStatement" example:

    Foo foo;
    Bar bar;
    Baz baz;

    f();               // prints "f"

    with(foo)
    {
        f();           // prints "Foo.f"

        with(bar)
        {
            f();       // prints "Bar.f"

            with(baz)
            {
                f();   // prints "Bar.f".  `Baz` does not implement `f()` so
                       // resolution is forwarded to `with(bar)`'s scope
            }
        }
        with(baz)
        {
            f();       // prints "Foo.f".  `Baz` does not implement `f()` so
                       // resolution is forwarded to `with(foo)`'s scope
        }
    }
    with(baz)
    {
        f();           // prints "f".  `Baz` does not implement `f()` so
                       // resolution is forwarded to `main`'s scope. `f()` is
                       // not implemented in `main`'s scope, so resolution is
                       // subsequently forward to module scope.
    }

I get that sometimes it can cut on a lot of repetition, but I think I would be fine if the syntax was more explicit while still avoiding repetition, for instance:

    with (some_object) {
        .some_member = 1;
        .some_other = 4;
        not_a_member = .some_method();
    }

In my experience that would account for 99% of uses of `with` while making the code a lot more readable without requiring a lot of context to make sense of it.

Although frankly even that might arguably overkill, for dynamic languages or ones with type inference you might as well just do something like:

    {
        let v = &mut some_annoyingly.long.thing();

        v.foo = bar;
        v.baz();
    }