Add option to context menu to automatically add a missing using statement.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@3004 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/Main/Base/Project/Src/Services/RefactoringService/RefactoringMenuBuilder.cs

@@ -97,6 +97,9 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			} else if (rr is UnknownIdentifierResolveResult) {
 				item = MakeItemForResolveError((UnknownIdentifierResolveResult)rr, expressionResult.Context, textArea);
 				insertIndex = 0;	// Insert menu item at the topmost position.
+			} else if (rr is UnknownConstructorCallResolveResult) {
+				item = MakeItemForResolveError((UnknownConstructorCallResolveResult)rr, expressionResult.Context, textArea);
+				insertIndex = 0;	// Insert menu item at the topmost position.
 			}
 			if (item != null) {
 				resultItems.Insert(insertIndex, item);
@@ -135,10 +138,12 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 		
 		ToolStripMenuItem MakeItemForResolveError(UnknownIdentifierResolveResult rr, ExpressionContext context, TextArea textArea)
 		{
-			if (context != null && context.IsTypeContext) {
-				return MakeItemForUnknownClass(rr.CallingClass, rr.Identifier, textArea);
-			}
-			return null;
+			return MakeItemForUnknownClass(rr.CallingClass, rr.Identifier, textArea);
+		}
+		
+		ToolStripMenuItem MakeItemForResolveError(UnknownConstructorCallResolveResult rr, ExpressionContext context, TextArea textArea)
+		{
+			return MakeItemForUnknownClass(rr.CallingClass, rr.TypeName, textArea);
 		}
 		
 		ToolStripMenuItem MakeItemForUnknownClass(IClass callingClass, string unknownClassName, TextArea textArea)
@@ -154,6 +159,8 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			foreach (IProjectContent rpc in pc.ReferencedContents) {
 				SearchAllClassesWithName(searchResults, rpc, unknownClassName, pc.Language);
 			}
+			if (searchResults.Count == 0)
+				return null;
 			foreach (IClass c in searchResults) {
 				string newNamespace = c.Namespace;
 				ToolStripMenuItem subItem = new ToolStripMenuItem("using " + newNamespace, ClassBrowserIconService.ImageList.Images[ClassBrowserIconService.NamespaceIndex]);

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -253,6 +253,20 @@ interface IInterface2 {
 			Assert.IsTrue(getType, "GetType not found");
 		}
 		
+		[Test]
+		public void UnknownIdentifierTest()
+		{
+			string program = @"class A {
+	void Method() {
+		
+	}
+}
+";
+			UnknownIdentifierResolveResult result = Resolve<UnknownIdentifierResolveResult>(program, "StringBuilder", 3);
+			Assert.IsFalse(result.IsValid);
+			Assert.AreEqual("StringBuilder", result.Identifier);
+		}
+		
 		[Test]
 		public void InvalidMethodCallTest()
 		{
@@ -290,8 +304,8 @@ class A {
 	}
 }
 ";
-			ResolveResult result = Resolve(program, "new ThisClassDoesNotExist()", 3);
-			Assert.IsNull(result);
+			UnknownConstructorCallResolveResult result = Resolve<UnknownConstructorCallResolveResult>(program, "new ThisClassDoesNotExist()", 3);
+			Assert.AreEqual("ThisClassDoesNotExist", result.TypeName);
 		}
 
 		[Test]

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/NRefactoryResolver.cs

@@ -520,6 +520,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				}
 			}
 			
+			if (result == null && result2 == null)
+				return new UnknownIdentifierResolveResult(CallingClass, CallingMember, expr.Identifier);
+
 			if (result == null)  return result2;
 			if (result2 == null) return result;
 			if (context == ExpressionContext.Type)

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/ResolveVisitor.cs

@@ -208,12 +208,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
 		{
-			ResolveResult result = resolver.ResolveIdentifier(identifierExpression, ExpressionContext.Default);
-			if (result != null)
-				return result;
-			else
-				return new UnknownIdentifierResolveResult(resolver.CallingClass, resolver.CallingMember, identifierExpression.Identifier);
-		}
+			return resolver.ResolveIdentifier(identifierExpression, ExpressionContext.Default);
+					}
 		
 		public override object VisitIndexerExpression(IndexerExpression indexerExpression, object data)
 		{
@@ -430,7 +426,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			} else {
 				IReturnType rt = TypeVisitor.CreateReturnType(objectCreateExpression.CreateType, resolver);
 				if (rt == null)
-					return null;
+					return new UnknownConstructorCallResolveResult(resolver.CallingClass, resolver.CallingMember, objectCreateExpression.CreateType.ToString());
 				
 				return ResolveConstructorOverload(rt, objectCreateExpression.Parameters)
 					?? CreateResolveResult(rt);

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ResolveResult.cs

@@ -157,6 +157,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 	{
 		ResolveResult primaryResult, secondaryResult;
 
+		protected override void FreezeInternal()
+		{
+			base.FreezeInternal();
+			primaryResult.Freeze();
+			secondaryResult.Freeze();
+		}
+		
 		public ResolveResult PrimaryResult {
 			get {
 				return primaryResult;
@@ -183,6 +190,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public MixedResolveResult(ResolveResult primaryResult, ResolveResult secondaryResult)
 			: base(primaryResult.CallingClass, primaryResult.CallingMember, primaryResult.ResolvedType)
 		{
+			if (primaryResult == null)
+				throw new ArgumentNullException("primaryResult");
+			if (secondaryResult == null)
+				throw new ArgumentNullException("secondaryResult");
 			this.primaryResult = primaryResult;
 			this.secondaryResult = secondaryResult;
 		}
@@ -776,6 +787,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 	#endregion
 	
 	#region UnknownIdentifierResolveResult
+	/// <summary>
+	/// Used for unknown identifiers.
+	/// </summary>
 	public class UnknownIdentifierResolveResult : ResolveResult
 	{
 		string identifier;
@@ -800,4 +814,33 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 	}
 	#endregion
+	
+	#region UnknownConstructorCallResolveResult
+	/// <summary>
+	/// Used for constructor calls on unknown types.
+	/// </summary>
+	public class UnknownConstructorCallResolveResult : ResolveResult
+	{
+		string typeName;
+		
+		public UnknownConstructorCallResolveResult(IClass callingClass, IMember callingMember, string typeName)
+			: base(callingClass, callingMember, null)
+		{
+			this.typeName = typeName;
+		}
+		
+		public string TypeName {
+			get { return typeName; }
+		}
+		
+		public override bool IsValid {
+			get { return false; }
+		}
+		
+		public override ResolveResult Clone()
+		{
+			return new UnknownConstructorCallResolveResult(this.CallingClass, this.CallingMember, this.TypeName);
+		}
+	}
+	#endregion
 }