mcs/error recovery: handle errors caused by closing braces after a statement expressi...

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

diff --git a/mcs/mcs/complete.cs b/mcs/mcs/complete.cs
index 43cc8fad7f8e9b0449712914eafcb99133b9f305..a1bb8ec00f48c249eebd4ec1928ab0110c9dce1e 100644 (file)
--- a/mcs/mcs/complete.cs
+++ b/mcs/mcs/complete.cs
@@ -7,6 +7,7 @@
 //
 // Copyright 2001, 2002, 2003 Ximian, Inc.
 // Copyright 2003-2009 Novell, Inc.
+// Copyright 2011 Xamarin Inc
 //
 // Completion* classes derive from ExpressionStatement as this allows
 // them to pass through the parser in many conditions that require
@@ -43,19 +44,24 @@ namespace Mono.CSharp {
                        }
                }
 
-               public override void EmitStatement (EmitContext ec)
+               public override bool ContainsEmitWithAwait ()
                {
-                       // Do nothing
+                       return false;
                }
 
-               public override void Emit (EmitContext ec)
+               public override Expression CreateExpressionTree (ResolveContext ec)
+               {
+                       return null;
+               }
+
+               public override void EmitStatement (EmitContext ec)
                {
                        // Do nothing
                }
 
-               public override Expression CreateExpressionTree (ResolveContext ec)
+               public override void Emit (EmitContext ec)
                {
-                       return null;
+                       // Do nothing
                }
        }
        
@@ -72,11 +78,9 @@ namespace Mono.CSharp {
                {
                        var results = new List<string> ();
 
-                       AppendResults (results, Prefix, Evaluator.GetVarNames ());
-                       AppendResults (results, Prefix, ec.CurrentMemberDefinition.Parent.NamespaceEntry.CompletionGetTypesStartingWith (Prefix));
-                       AppendResults (results, Prefix, Evaluator.GetUsingList ());
-                       
-                       throw new CompletionResult (Prefix, results.ToArray ());
+                       ec.CurrentMemberDefinition.GetCompletionStartingWith (Prefix, results);
+
+                       throw new CompletionResult (Prefix, results.Distinct ().Select (l => l.Substring (Prefix.Length)).ToArray ());
                }
 
                protected override void CloneTo (CloneContext clonectx, Expression t)
@@ -114,8 +118,8 @@ namespace Mono.CSharp {
                                return null;
 
                        TypeSpec expr_type = expr_resolved.Type;
-                       if (expr_type.IsPointer || expr_type == TypeManager.void_type || expr_type == InternalType.Null || expr_type == InternalType.AnonymousMethod) {
-                               Unary.Error_OperatorCannotBeApplied (ec, loc, ".", 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);
                                return null;
                        }
 
@@ -134,19 +138,11 @@ namespace Mono.CSharp {
                                else
                                        namespaced_partial = nexpr.Name + "." + partial_name;
 
-#if false
-                               Console.WriteLine ("Workign with: namespaced partial {0}", namespaced_partial);
-                               foreach (var x in ec.TypeContainer.NamespaceEntry.CompletionGetTypesStartingWith (ec.TypeContainer, namespaced_partial)){
-                                       Console.WriteLine ("    {0}", x);
-                               }
-#endif
-
-                               CompletionSimpleName.AppendResults (
-                                       results,
-                                       partial_name, 
-                                       ec.CurrentMemberDefinition.Parent.NamespaceEntry.CompletionGetTypesStartingWith (namespaced_partial));
+                               ec.CurrentMemberDefinition.GetCompletionStartingWith (namespaced_partial, results);
+                               if (partial_name != null)
+                                       results = results.Select (l => l.Substring (partial_name.Length)).ToList ();
                        } else {
-                               var r = MemberCache.GetCompletitionMembers (expr_type, partial_name).Select (l => l.Name);
+                               var r = MemberCache.GetCompletitionMembers (ec, expr_type, partial_name).Select (l => l.Name);
                                AppendResults (results, partial_name, r);
                        }
 
@@ -175,7 +171,7 @@ namespace Mono.CSharp {
                
                protected override Expression DoResolve (ResolveContext ec)
                {
-                       var members = MemberCache.GetCompletitionMembers (ec.CurrentInitializerVariable.Type, partial_name);
+                       var members = MemberCache.GetCompletitionMembers (ec, ec.CurrentInitializerVariable.Type, partial_name);
 
 // TODO: Does this mean exact match only ?
 //                     if (partial_name != null && results.Count > 0 && result [0] == "")