Error msg when accessing non-static outer class member

C# shows this error:
error CS0038: Cannot access a nonstatic member of outer type 'OuterClass' via nested type 'OuterClass.InnerClass'

Btw: I think an inner class has a reference to an outer class instance in most cases, so why shouldn't boo use a different inner class model as C#?
It would be great if inner classes would get the reference automatically inserted by the compiler. Constructing an inner class would then only be possible on an instance of the outer class.
Boo: a = instanceOfOuterClass.InnerClass()
C#: a = new OuterClass.InnerClass(instanceOfOuterClass);

OK, if that's the error C# gives, then probably my fix is the way to do it. We can't change name resolution to handle this special case. The error message boo will give is:
An instance of type 'Outer' is required to access non-static member 'whatever'.

About your 2nd comment, I thought maybe we could insert a field in the inner class that stores an instance of the outer class. But what instance would we use? What if the Outer class doesn't have a zero-param constructor? But if there is a solution to do what you are proposing, that's great.

For Arron, here is how to do your example using a stored instance of the outer class (this is how C# does it too):

class foo:
types = ['hello', 'world!']
def fu():
b = bar(self)
b.fark()
class bar:
_outer as foo
def constructor(outer as foo):
_outer = outer
def fark():
print _outer.types //should work even if types is a private field

f = foo()
f.fu()

> But what instance would we use?
The instance that created the inner class.
Inner classes would automatically get a constructor that accepts an instance of the outer class as parameter.
If the inner class already has constructors, the compiler would add the parameter that accepts an instance of the outer class.
The constructors would assign the value of that parameter into a field.

When calling the constructor, the compiler could automatically insert the reference to the outer class to the argument list.
You would call the constructor on the instance of the outer class, thus "self.InnerClass()" would be a valid constructor call. (maybe this could be implemented by renaming the inner class internally and creating a instance method on the outer class with the inner classes' old name)

References to outer classes' instance fields would then be redirectly to use the compiler generated field.

So the effect would be that the original code (first post in the thread mentioned in the description) would be valid.

http://groups-beta.google.com/group/boolang/msg/aa2f2c25090b6d64

Put in patch form with test case.

Patch applied. Thanks!