Anonymous objects from nothing

[lkuper]

Is there a reason why we'd want to be able to create an anonymous object from nothing, rather than extending an existing one?

For example, should we support being able to do this:

fn main() {

    // Anonymous object that doesn't extend an existing one.
    let my_obj = obj () {
        fn foo() -> int { ret 2; }
        fn bar() -> int { ret self.foo(); }
    };

    assert (my_obj.foo() == 2);
    assert (my_obj.bar() == 2);

}

If the answer is yes, then we need to finish implementing support for it. Right now, the parser and translator don't require an anon obj to have a "with" clause, and if there isn't one, translating an anon obj proceeds much like translating a regular obj would, with no forwarding/backwarding vtable slots created. But the above program fails in typechecking because the typechecker doesn't know what "self" is.

If the answer is no, we don't care about having this feature, we should get rid of what support does exist. Doing so would streamline the implementation of the object system a little.

[graydon]

I'd go with "yes" if it's not too difficult. Seems like a natural sort of thing to do; I imagine people will want an environment-capturing variant too, eventually.

[marijnh]

(As an extra data point, consider that half the object in rustc are locally defined inside a function, and then immediately have their constructor called, with care taken to align the arguments in the call and the arglist. Object expressions would work much more natural in these cases.)

[lkuper]

As it turns out, anon-objs-from-nothing already work fine as such. The above example doesn't work because it doesn't work in general to have a method A referring to another method B that is being added to an object at the same time as A. That's a problem, but has nothing to do with from-nothing objects as such. So I'll open a different issue for that bug, and close this one.