Author: martin
Date: 2005-04-18 11:32:48 -0400 (Mon, 18 Apr 2005)
New Revision: 43226

Modified:
   trunk/mcs/gmcs/ChangeLog
   trunk/mcs/gmcs/ecore.cs
   trunk/mcs/gmcs/expression.cs
Log:
**** Merged r42432 from MCS ****


Modified: trunk/mcs/gmcs/ChangeLog
===================================================================
--- trunk/mcs/gmcs/ChangeLog    2005-04-18 15:32:18 UTC (rev 43225)
+++ trunk/mcs/gmcs/ChangeLog    2005-04-18 15:32:48 UTC (rev 43226)
@@ -1,3 +1,17 @@
+2005-03-31  Raja R Harinath  <[EMAIL PROTECTED]>
+
+       Clean up semantics of invoking ResolveMemberAccess.
+       * ecore.cs (SimpleName.DoSimpleNameResolve): If a MemberExpression
+       can have an instance, ensure that we pass in a non-TypeExpression
+       to ResolveMemberAccess.  Tighten up IdenticalNameAndTypeName checks.
+       (MemberExpr.DoSimpleNameResolve): Remove type_is_inferred
+       argument.  Update to changes and simplify.
+       (FieldExpr.Emitinstance): Remove CS0120 check.
+       (PropertyExpr.EmitInstance): Likewise.
+       * expression.cs (Argument.Resolve): Likewise.
+       (Invocation.DoResolve): Update to changes in semantics of
+       InstanceExpression.
+
 2005-03-31  Marek Safar  <[EMAIL PROTECTED]>
 
        Fix #74241

Modified: trunk/mcs/gmcs/ecore.cs
===================================================================
--- trunk/mcs/gmcs/ecore.cs     2005-04-18 15:32:18 UTC (rev 43225)
+++ trunk/mcs/gmcs/ecore.cs     2005-04-18 15:32:48 UTC (rev 43226)
@@ -2271,11 +2271,35 @@
 
                        if (e is MemberExpr) {
                                MemberExpr me = (MemberExpr) e;
-                               Expression left = (ec.IsStatic || 
ec.IsFieldInitializer)
-                                       ? (Expression) new TypeExpression 
(ec.ContainerType, loc)
-                                       : (Expression) ec.GetThis (loc);
-                       
-                               e = me.ResolveMemberAccess (ec, left, loc, 
(intermediate ? this : null), true);
+
+                               Expression left;
+                               if (me.IsInstance) {
+                                       if (ec.IsStatic || 
ec.IsFieldInitializer) {
+                                               //
+                                               // Note that an MemberExpr can 
be both IsInstance and IsStatic.
+                                               // An unresolved 
MethodGroupExpr can contain both kinds of methods
+                                               // and each predicate is true 
if the MethodGroupExpr contains
+                                               // at least one of that kind of 
method.
+                                               //
+
+                                               if (!me.IsStatic &&
+                                                   (!intermediate || 
!IdenticalNameAndTypeName (ec, me, loc))) {
+                                                       Error_ObjectRefRequired 
(ec, loc, Name);
+                                                       return null;
+                                               }
+
+                                               //
+                                               // Pass the buck to 
MemberAccess and Invocation.
+                                               //
+                                               left = EmptyExpression.Null;
+                                       } else {
+                                               left = ec.GetThis (loc);
+                                       }
+                               } else {
+                                       left = new TypeExpression 
(ec.ContainerType, loc);
+                               }
+
+                               e = me.ResolveMemberAccess (ec, left, loc, 
null);
                                if (e == null)
                                        return null;
 
@@ -2291,12 +2315,6 @@
                                        return mg.ResolveGeneric (ec, 
Arguments);
                                }
 
-                               // This fails if ResolveMemberAccess() was 
unable to decide whether
-                               // it's a field or a type of the same name.
-                               if (!me.IsStatic && me.InstanceExpression == 
null && 
-                                   (intermediate && IdenticalNameAndTypeName 
(ec, e, loc)))
-                                       return e;
-
                                if (!me.IsStatic &&
                                    TypeManager.IsNestedFamilyAccessible 
(me.InstanceExpression.Type, me.DeclaringType) &&
                                    me.InstanceExpression.Type != 
me.DeclaringType &&
@@ -2663,19 +2681,15 @@
                // TODO: possible optimalization
                // Cache resolved constant result in FieldBuilder <-> 
expression map
                public virtual Expression ResolveMemberAccess (EmitContext ec, 
Expression left, Location loc,
-                                                               SimpleName 
original, bool left_is_inferred)
+                                                              SimpleName 
original)
                {
                        //
                        // Precondition:
-                       //   original == null || original.Resolve (...) === 
(left_is_inferred ? this : left)
+                       //   original == null || original.Resolve (...) ==> left
                        //
 
                        if (left is TypeExpr) {
                                if (!IsStatic) {
-                                       if ((ec.IsFieldInitializer || 
ec.IsStatic) && left_is_inferred &&
-                                           original != null && 
original.IdenticalNameAndTypeName (ec, this, loc))
-                                               return this;
-
                                        SimpleName.Error_ObjectRefRequired (ec, 
loc, Name);
                                        return null;
                                }
@@ -2684,8 +2698,7 @@
                        }
                                
                        if (!IsInstance) {
-                               if (left_is_inferred ||
-                                   (original != null && 
original.IdenticalNameAndTypeName (ec, left, loc)))
+                               if (original != null && 
original.IdenticalNameAndTypeName (ec, left, loc))
                                        return this;
 
                                error176 (loc, Name);
@@ -2806,14 +2819,13 @@
                }
 
                public override Expression ResolveMemberAccess (EmitContext ec, 
Expression left, Location loc,
-                                                                SimpleName 
original, bool left_is_inferred)
+                                                               SimpleName 
original)
                {
-                       if (!left_is_inferred &&
-                           !(left is TypeExpr) &&
+                       if (!(left is TypeExpr) &&
                            original != null && 
original.IdenticalNameAndTypeName (ec, left, loc))
                                IdenticalTypeName = true;
 
-                       return base.ResolveMemberAccess (ec, left, loc, 
original, left_is_inferred);
+                       return base.ResolveMemberAccess (ec, left, loc, 
original);
                }
                
                override public Expression DoResolve (EmitContext ec)
@@ -2977,7 +2989,7 @@
                }
 
                public override Expression ResolveMemberAccess (EmitContext ec, 
Expression left, Location loc,
-                                                               SimpleName 
original, bool left_is_inferred)
+                                                               SimpleName 
original)
                {
                        bool left_is_type = left is TypeExpr;
 
@@ -3000,7 +3012,7 @@
 
                                        Expression exp = Constantify 
(real_value, t);
                                        
-                                       if (!left_is_inferred && !left_is_type 
&& 
+                                       if (!left_is_type && 
                                            (original == null || 
!original.IdenticalNameAndTypeName (ec, left, loc))) {
                                                
Report.SymbolRelatedToPreviousError (c);
                                                error176 (loc, 
c.GetSignatureForError ());
@@ -3027,7 +3039,7 @@
                                        o = fi.GetValue (fi);
                                
                                if (decl_type.IsSubclassOf 
(TypeManager.enum_type)) {
-                                       if (!left_is_inferred && !left_is_type 
&&
+                                       if (!left_is_type &&
                                            (original == null || 
!original.IdenticalNameAndTypeName (ec, left, loc))) {
                                                error176 (loc, fi.Name);
                                                return null;
@@ -3050,7 +3062,7 @@
                                
                                Expression exp = Constantify (o, t);
                                
-                               if (!left_is_inferred && !left_is_type) {
+                               if (!left_is_type) {
                                        error176 (loc, fi.Name);
                                        return null;
                                }
@@ -3063,7 +3075,7 @@
                                return null;
                        }
 
-                       return base.ResolveMemberAccess (ec, left, loc, 
original, left_is_inferred);
+                       return base.ResolveMemberAccess (ec, left, loc, 
original);
                }
 
                override public Expression DoResolve (EmitContext ec)
@@ -3318,16 +3330,6 @@
 
                void EmitInstance (EmitContext ec)
                {
-                       //
-                       // In case it escapes StaticMemberCheck due to 
IdenticalTypeAndName.
-                       // This happens in cases like 'string String', 'int 
Int32', etc.
-                       // where the "IdenticalTypeAndName" mechanism is fooled.
-                       //
-                       if (InstanceExpression == null) {
-                               SimpleName.Error_ObjectRefRequired (ec, loc, 
FieldInfo.Name);
-                               return;
-                       }
-
                        if (InstanceExpression.Type.IsValueType) {
                                if (InstanceExpression is IMemoryLocation) {
                                        ((IMemoryLocation) 
InstanceExpression).AddressOf (ec, AddressOp.LoadStore);
@@ -3709,16 +3711,6 @@
                        if (is_static)
                                return;
 
-                       //
-                       // In case it escapes StaticMemberCheck due to 
IdenticalTypeAndName.
-                       // This happens in cases like 'string String', 'int 
Int32', etc.
-                       // where the "IdenticalTypeAndName" mechanism is fooled.
-                       //
-                       if (InstanceExpression == null) {
-                               SimpleName.Error_ObjectRefRequired (ec, loc, 
PropertyInfo.Name);
-                               return;
-                       }
-
                        if (InstanceExpression.Type.IsValueType) {
                                if (InstanceExpression is IMemoryLocation) {
                                        ((IMemoryLocation) 
InstanceExpression).AddressOf (ec, AddressOp.LoadStore);
@@ -3853,7 +3845,7 @@
                }
 
                public override Expression ResolveMemberAccess (EmitContext ec, 
Expression left, Location loc,
-                                                                SimpleName 
original, bool left_is_inferred)
+                                                               SimpleName 
original)
                {
                        //
                        // If the event is local to this class, we transform 
ourselves into a FieldExpr
@@ -3870,14 +3862,14 @@
                                                Report.Error (-200, loc, 
"Internal error!!");
                                                return null;
                                        }
+
+                                       InstanceExpression = null;
                                
-                                       InstanceExpression = left_is_inferred ? 
null : left;
-                               
-                                       return ml.ResolveMemberAccess (ec, 
left, loc, original, left_is_inferred);
+                                       return ml.ResolveMemberAccess (ec, 
left, loc, original);
                                }
                        }
 
-                       return base.ResolveMemberAccess (ec, left, loc, 
original, left_is_inferred);
+                       return base.ResolveMemberAccess (ec, left, loc, 
original);
                }
 
 

Modified: trunk/mcs/gmcs/expression.cs
===================================================================
--- trunk/mcs/gmcs/expression.cs        2005-04-18 15:32:18 UTC (rev 43225)
+++ trunk/mcs/gmcs/expression.cs        2005-04-18 15:32:48 UTC (rev 43226)
@@ -4278,32 +4278,6 @@
                        if (Expr == null)
                                return false;
 
-                       if (Expr is MemberExpr) {
-                               MemberExpr me = Expr as MemberExpr;
-
-                               //
-                               // This can happen with the following code:
-                               //
-                               //   class X {}
-                               //   class Y {
-                               //     public Y (X x) {}
-                               //   }
-                               //   class Z : Y {
-                               //     X X;
-                               //     public Z () : base (X) {}
-                               //   }
-                               //
-                               // SimpleNameResolve is conservative about 
flagging the X as
-                               // an error since it has identical name and 
type.  However,
-                               // because there's no MemberAccess, that is not 
really justified.
-                               // It is still simpler to fix it here, rather 
than in SimpleNameResolve.
-                               //
-                               if (me.IsInstance && me.InstanceExpression == 
null) {
-                                       SimpleName.Error_ObjectRefRequired (ec, 
loc, me.Name);
-                                       return false;
-                               }
-                       }
-
                        if (ArgType == AType.Expression)
                                return true;
                        else {
@@ -5347,19 +5321,21 @@
                        MethodInfo mi = method as MethodInfo;
                        if (mi != null) {
                                type = TypeManager.TypeToCoreType 
(mi.ReturnType);
-                               if (!mi.IsStatic && mg.InstanceExpression == 
null) {
-                                       SimpleName.Error_ObjectRefRequired (ec, 
loc, mi.Name);
-                                       return null;
-                               }
-
                                Expression iexpr = mg.InstanceExpression;
-                               if (mi.IsStatic && (iexpr != null) && !(iexpr 
is This)) {
-                                       if (mg.IdenticalTypeName)
+                               if (mi.IsStatic) {
+                                       if (iexpr == null || 
+                                           iexpr is This || iexpr is 
EmptyExpression ||
+                                           mg.IdenticalTypeName) {
                                                mg.InstanceExpression = null;
-                                       else {
+                                       } else {
                                                MemberExpr.error176 (loc, 
mi.Name);
                                                return null;
                                        }
+                               } else {
+                                       if (iexpr == null || iexpr is 
EmptyExpression) {
+                                               
SimpleName.Error_ObjectRefRequired (ec, loc, mi.Name);
+                                               return null;
+                                       }
                                }
                        }
 
@@ -7516,7 +7492,7 @@
                        }
 
                        MemberExpr me = (MemberExpr) member_lookup;
-                       member_lookup = me.ResolveMemberAccess (ec, expr, loc, 
original, false);
+                       member_lookup = me.ResolveMemberAccess (ec, expr, loc, 
original);
                        if (member_lookup == null)
                                return null;
 
@@ -8633,7 +8609,7 @@
 
                        MemberExpr me = (MemberExpr) member_lookup;
                        
-                       Expression e = me.ResolveMemberAccess (ec, left, loc, 
null, false);
+                       Expression e = me.ResolveMemberAccess (ec, left, loc, 
null);
 
                        if (e is PropertyExpr) {
                                PropertyExpr pe = (PropertyExpr) e;

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to