ObjC/ObjC++ - fixed Objective-C 2.0 dot-syntax with 'self' and 'super'

This patch fixes using the Objective-C 2.0 dot-syntax with 'self' and 'super', both in class 
and instance methods.

This was nasty for a number of reasons.  The main is that properly building method calls to 'self' and 'super'
requires knowledge of the context (interface/method being compiled, etc); but our getter calls were generated 
at gimplify stage when this information is not there any more.  I experimented for a while saving/restoring
such information for the gimplification stage and it was messy and fragile as I kept realizing there was yet
another piece of information to save/restore to get all testcases to work.

Now since we were already generating a getter call expression when the 'object.accessor' expression is compiled 
(to get the getter selector in the selector table, which you can't do at gimplify stage) I finally decided to simply 
put that getter call expression into the PROPERTY_REF instead of throwing it away, so that at gimplify stage all 
there is to do is swap the PROPERTY_REF with the getter call expression (already built) available as its Operand 2.
It's a little inefficient, because if the PROPERTY_REF becomes a setter we have built a getter call but never used it
(which I was planning to maybe get rid of), but at least the getter call is always built correctly with no hacks required
and that is guaranteed because it's built at the right time in the right context.  All my testcases now work correctly. :-)

Anyway, with this patch, the following things are now fixed:

 * using the Objective-C 2.0 dot-syntax with 'self' in a class method, ie, using "self.accessor" in a class method.

 * using the Objective-C 2.0 dot-syntax with 'super' in an instance or class method, ie, using "super.accessor"
or "super.property" in an instance method, and "super.accessor" in a class method.

 * using the Objective-C 2.0 dot-syntax with 'self' in an instance/class method, and using an accessor which is not 
declared in the @interface, but was implemented in the same @implementation (exactly like it works for methods, where 
you can use [self name] if -name was implemented in the same @implementation a few lines above, even if it's not declared 
in the @interface)

As a final note, we have a testcase (property-neg-4.m) with a class and an attempt to use a class accessor which matched 
an instance accessor of the same class but no class accessor; the testcase was expected to produce an error.  But, in
the testcase the class was a root class, which means that assuming we're looking up accessors in the normal way that methods 
are looked up (which is what I implemented), the testcase would pass and run because if a class method is not found, 
the instance methods of the root class are looked up.  I was tempted to fix the testcase to have it pass, but then I 
checked the testcases for Apple's llvm-gcc and they still have the same testcase, so I assume it was intended to work 
that way (and it's not just a bug) and I changed our implementation to match that behaviour.  It should rarely matter anyway,
so I just decided to do whatever the Apple compiler does.

I added 12 testcases, covering all of the above and a number of other dot-syntax situations (cast, typedef, etc) that I looked
at while developing the patch.  They all pass with this patch. :-)

We are getting there ... 

Ok to commit to trunk ?

Thanks

In gcc/objc/:
2010-11-05  Nicola Pero  <nicola.pero@meta-innovation.com>

        Fixed using the Objective-C 2.0 syntax with self and super.
        * objc-act.c (OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS): New.
        (maybe_make_artificial_property_decl): Added 'implementation'
        argument.  Use OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS when
        looking up getters or setters for a class.  If an implementation
        is specified, search it as well for a getter or setter.
        (objc_maybe_build_component_ref): Updated calls to
        maybe_make_artificial_property_decl; added code to deal with
        'self' and 'super' and with methods declared locally in the
        implementation.  Store the getter call expression in the
        PROPERTY_REF instead of throwing it away.
        (objc_build_class_component_ref): Updated calls to
        maybe_make_artificial_property_decl, and store the getter call
        expression in PROPERTY_REF instead of throwing it away.
        (lookup_method_static): Implemented
        OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS option.
        (objc_gimplify_property_ref): Do not build the getter method call
        here; instead use the one stored in the PROPERTY_REF.  If it's not
        there, produce helpful error messages.
        * objc-tree.def (PROPERTY_REF): Increased the number of operands
        from 2 to 3.  Updated comments.
        * objc-act.h (PROPERTY_REF_GETTER_CALL): New.

In gcc/testsuite/:
2010-11-05  Nicola Pero  <nicola.pero@meta-innovation.com>

        Fixed using the Objective-C 2.0 dot-syntax with self and super.
        * objc.dg/property/dotsyntax-5.m: New.
        * objc.dg/property/dotsyntax-6.m: New.
        * objc.dg/property/dotsyntax-7.m: New.
        * objc.dg/property/dotsyntax-8.m: New.
        * objc.dg/property/dotsyntax-9.m: New.
        * objc.dg/property/dotsyntax-10.m: New.
        * objc.dg/property/dotsyntax-11.m: New.
        * obj-c++.dg/property/dotsyntax-5.mm: New.
        * obj-c++.dg/property/dotsyntax-6.mm: New.
        * obj-c++.dg/property/dotsyntax-7.mm: New.
        * obj-c++.dg/property/dotsyntax-8.mm: New.
        * obj-c++.dg/property/dotsyntax-9.mm: New.
        * obj-c++.dg/property/dotsyntax-10.mm: New.
        * obj-c++.dg/property/dotsyntax-11.mm: New.

ObjC/ObjC++ - fixed Objective-C 2.0 dot-syntax with 'self' and 'super'

Commit Message

Comments

Patch