Merge pull request #899 from UCIS/patch-4

[mono.git] / mcs / mcs / complete.cs

diff --git a/mcs/mcs/complete.cs b/mcs/mcs/complete.cs
index a1bb8ec00f48c249eebd4ec1928ab0110c9dce1e..f66a7bd9fba44bed618ed76e01838f45c1967ee8 100644 (file)
--- a/mcs/mcs/complete.cs
+++ b/mcs/mcs/complete.cs
@@ -109,40 +109,58 @@ namespace Mono.CSharp {
                        this.targs = targs;
                }
                
-               protected override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext rc)
                {
-                       Expression expr_resolved = expr.Resolve (ec,
-                               ResolveFlags.VariableOrValue | ResolveFlags.Type);
+                       var sn = expr as SimpleName;
+                       const ResolveFlags flags = ResolveFlags.VariableOrValue | ResolveFlags.Type;
+
+                       if (sn != null) {
+                               expr = sn.LookupNameExpression (rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity);
+
+                               //
+                               // Resolve expression which does have type set as we need expression type
+                               // with disable flow analysis as we don't know whether left side expression
+                               // is used as variable or type
+                               //
+                               if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess) {
+                                       expr = expr.Resolve (rc);
+                               } else if (expr is TypeParameterExpr) {
+                                       expr.Error_UnexpectedKind (rc, flags, sn.Location);
+                                       expr = null;
+                               }
+                       } else {
+                               expr = expr.Resolve (rc, flags);
+                       }
 
-                       if (expr_resolved == null)
+                       if (expr == null)
                                return null;
 
-                       TypeSpec expr_type = expr_resolved.Type;
+                       TypeSpec expr_type = expr.Type;
                        if (expr_type.IsPointer || expr_type.Kind == MemberKind.Void || expr_type == InternalType.NullLiteral || expr_type == InternalType.AnonymousMethod) {
-                               expr_resolved.Error_OperatorCannotBeApplied (ec, loc, ".", expr_type);
+                               expr.Error_OperatorCannotBeApplied (rc, loc, ".", expr_type);
                                return null;
                        }
 
                        if (targs != null) {
-                               if (!targs.Resolve (ec))
+                               if (!targs.Resolve (rc))
                                        return null;
                        }
 
                        var results = new List<string> ();
-                       if (expr_resolved is Namespace){
-                               Namespace nexpr = expr_resolved as Namespace;
+                       var nexpr = expr as NamespaceExpression;
+                       if (nexpr != null) {
                                string namespaced_partial;
 
                                if (partial_name == null)
-                                       namespaced_partial = nexpr.Name;
+                                       namespaced_partial = nexpr.Namespace.Name;
                                else
-                                       namespaced_partial = nexpr.Name + "." + partial_name;
+                                       namespaced_partial = nexpr.Namespace.Name + "." + partial_name;
 
-                               ec.CurrentMemberDefinition.GetCompletionStartingWith (namespaced_partial, results);
+                               rc.CurrentMemberDefinition.GetCompletionStartingWith (namespaced_partial, results);
                                if (partial_name != null)
                                        results = results.Select (l => l.Substring (partial_name.Length)).ToList ();
                        } else {
-                               var r = MemberCache.GetCompletitionMembers (ec, expr_type, partial_name).Select (l => l.Name);
+                               var r = MemberCache.GetCompletitionMembers (rc, expr_type, partial_name).Select (l => l.Name);
                                AppendResults (results, partial_name, r);
                        }