Add attribute completion to BooBinding.

BOO-436, Smarter Boo integration (Macros, Attributes, Modules, and Imported Classes)

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

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/BooProject.cs

@@ -50,6 +50,8 @@ namespace Grunwald.BooBinding
 			return new BooLanguageBinding().CanCompile(fileName);
 		}
 		
+		internal static IProjectContent BooCompilerPC;
+		
 		public override ParseProjectContent CreateProjectContent()
 		{
 			ParseProjectContent pc = base.CreateProjectContent();
@@ -57,6 +59,8 @@ namespace Grunwald.BooBinding
 			pc.ReferencedContents.Add(ProjectContentRegistry.GetProjectContentForReference(systemItem));
 			ReferenceProjectItem booLangItem = new ReferenceProjectItem(this, typeof(Boo.Lang.Builtins).Assembly.Location);
 			pc.ReferencedContents.Add(ProjectContentRegistry.GetProjectContentForReference(booLangItem));
+			ReferenceProjectItem booCompilerItem = new ReferenceProjectItem(this, typeof(Boo.Lang.Compiler.AbstractAstAttribute).Assembly.Location);
+			BooCompilerPC = ProjectContentRegistry.GetProjectContentForReference(booCompilerItem);
 			ReferenceProjectItem booUsefulItem = new ReferenceProjectItem(this, typeof(Boo.Lang.Useful.Attributes.SingletonAttribute).Assembly.Location);
 			pc.ReferencedContents.Add(ProjectContentRegistry.GetProjectContentForReference(booUsefulItem));
 			pc.DefaultImports = new DefaultUsing(pc);

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs

@@ -179,8 +179,40 @@ namespace Grunwald.BooBinding.CodeCompletion
 			}
 			
 			AST.Expression expr = Boo.Lang.Parser.BooParser.ParseExpression("expression", expressionResult.Expression);
+			if (expr == null)
+				return null;
 			if (expr is AST.IntegerLiteralExpression)
 				return null; // no CC for "5."
+			
+			if (expressionResult.Context == ExpressionFinder.BooAttributeContext.Instance) {
+				AST.MethodInvocationExpression mie = expr as AST.MethodInvocationExpression;
+				if (mie != null)
+					expr = mie.Target;
+				string name = expr.ToCodeString();
+				IReturnType rt = pc.SearchType(name, 0, callingClass, cu, caretLine, caretColumn);
+				if (rt != null && rt.GetUnderlyingClass() != null)
+					return new TypeResolveResult(callingClass, callingMember, rt);
+				rt = pc.SearchType(name + "Attribute", 0, callingClass, cu, caretLine, caretColumn);
+				if (rt != null && rt.GetUnderlyingClass() != null)
+					return new TypeResolveResult(callingClass, callingMember, rt);
+				if (BooProject.BooCompilerPC != null) {
+					IClass c = BooProject.BooCompilerPC.GetClass("Boo.Lang." + char.ToUpper(name[0]) + name.Substring(1) + "Attribute");
+					if (c != null)
+						return new TypeResolveResult(callingClass, callingMember, c);
+				}
+				return null;
+			} else {
+				if (expr.NodeType == AST.NodeType.ReferenceExpression) {
+					// this could be a macro
+					if (BooProject.BooCompilerPC != null) {
+						string name = ((AST.ReferenceExpression)expr).Name;
+						IClass c = BooProject.BooCompilerPC.GetClass("Boo.Lang." + char.ToUpper(name[0]) + name.Substring(1) + "Macro");
+						if (c != null)
+							return new TypeResolveResult(callingClass, callingMember, c);
+					}
+				}
+			}
+			
 			ResolveVisitor visitor = new ResolveVisitor(this);
 			visitor.Visit(expr);
 			return visitor.ResolveResult;
@@ -201,7 +233,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		#endregion
 		
 		#region CtrlSpace
-		IClass GetPrimitiveClass(string systemType, string newName)
+		static IClass GetPrimitiveClass(IProjectContent pc, string systemType, string newName)
 		{
 			IClass c = pc.GetClass(systemType);
 			if (c == null) {
@@ -220,13 +252,31 @@ namespace Grunwald.BooBinding.CodeCompletion
 			return c2;
 		}
 		
-		public ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent)
+		public ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent, ExpressionContext context)
 		{
 			if (!Initialize(fileName, caretLine, caretColumn))
 				return null;
 			
 			ArrayList result = GetImportedNamespaceContents();
 			
+			if (BooProject.BooCompilerPC != null) {
+				if (context == ExpressionFinder.BooAttributeContext.Instance) {
+					foreach (object o in BooProject.BooCompilerPC.GetNamespaceContents("Boo.Lang")) {
+						IClass c = o as IClass;
+						if (c != null && c.Name.EndsWith("Attribute") && !c.IsAbstract) {
+							result.Add(GetPrimitiveClass(BooProject.BooCompilerPC, c.FullyQualifiedName, c.Name.Substring(0, c.Name.Length - 9).ToLowerInvariant()));
+						}
+					}
+				} else {
+					foreach (object o in BooProject.BooCompilerPC.GetNamespaceContents("Boo.Lang")) {
+						IClass c = o as IClass;
+						if (c != null && c.Name.EndsWith("Macro") && !c.IsAbstract) {
+							result.Add(GetPrimitiveClass(BooProject.BooCompilerPC, c.FullyQualifiedName, c.Name.Substring(0, c.Name.Length - 5).ToLowerInvariant()));
+						}
+					}
+				}
+			}
+			
 			NRResolver.AddContentsFromCalling(result, callingClass, callingMember);
 			
 			ArrayList knownVariableNames = new ArrayList();
@@ -255,7 +305,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			ArrayList list = new ArrayList();
 			IClass c;
 			foreach (KeyValuePair<string, string> pair in BooAmbience.TypeConversionTable) {
-				c = GetPrimitiveClass(pair.Key, pair.Value);
+				c = GetPrimitiveClass(pc, pair.Key, pair.Value);
 				if (c != null) list.Add(c);
 			}
 			NRResolver.AddImportedNamespaceContents(list, cu, callingClass);

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/CompletionBinding.cs

@@ -25,6 +25,24 @@ namespace Grunwald.BooBinding.CodeCompletion
 			this.EnableXmlCommentCompletion = false;
 		}
 		
+		public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
+		{
+			if (ch == '[') {
+				int cursor = editor.ActiveTextAreaControl.Caret.Offset;
+				for (int i = cursor - 1; i > 0; i--) {
+					char c = editor.Document.GetCharAt(i);
+					if (c == '\n' || c == '(' || c == ',') {
+						// -> Attribute completion
+						editor.ShowCompletionWindow(new AttributesDataProvider(ExpressionFinder.BooAttributeContext.Instance), ch);
+						return true;
+					}
+					if (!char.IsWhiteSpace(c))
+						break;
+				}
+			}
+			return base.HandleKeyPress(editor, ch);
+		}
+		
 		bool IsInComment(SharpDevelopTextAreaControl editor)
 		{
 			ExpressionFinder ef = new ExpressionFinder(editor.FileName);

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ExpressionFinder.cs

@@ -13,6 +13,7 @@ using ICSharpCode.SharpDevelop.Dom;
 
 namespace Grunwald.BooBinding.CodeCompletion
 {
+	// TODO: We could need some unit tests for this.
 	public class ExpressionFinder : IExpressionFinder
 	{
 		string fileName;
@@ -33,7 +34,28 @@ namespace Grunwald.BooBinding.CodeCompletion
 		/// </example>
 		public string RemoveLastPart(string expression)
 		{
-			throw new NotImplementedException();
+			int state = 0;
+			int pos = 0;
+			int lastFinishPos = 0;
+			int brackets = 0;
+			while (state >= 0) {
+				state = FindNextCodeCharacter(state, expression, ref pos);
+				if (pos >= expression.Length)
+					break;
+				char c = expression[pos];
+				if (c == '[' || c == '(' || c == '{') {
+					if (brackets == 0)
+						lastFinishPos = pos;
+					brackets += 1;
+				}
+				if (brackets == 0 && c == '.') {
+					lastFinishPos = pos;
+				}
+				if (brackets > 0 && (c == ']' || c == ')' || c == '}')) {
+					brackets -= 1;
+				}
+			}
+			return expression.Substring(0, lastFinishPos);
 		}
 		#endregion
 		
@@ -71,7 +93,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 					break;
 				}
 				if (forbidden.IndexOf(c) >= 0) {
-					LoggingService.Debug("Quickfind failed: got " + c);
+					//LoggingService.Debug("Quickfind failed: got " + c);
 					break;
 				}
 				if (char.IsWhiteSpace(c)) {
@@ -101,6 +123,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 				i -= 1;
 				char c = inText[i];
 				if (bracketStack.Count == 0 && (finish.IndexOf(c) >= 0 || Char.IsWhiteSpace(c))) {
+					// SUCCESS!
 					return GetExpression(inText, i + 1, inText.Length);
 				}
 				int bracket = _closingBrackets.IndexOf(c);
@@ -144,9 +167,63 @@ namespace Grunwald.BooBinding.CodeCompletion
 				}
 				i += 1;
 			}
-			return new ExpressionResult(b.ToString());
+			ExpressionResult result = new ExpressionResult(b.ToString());
+			// Now try to find the context of the expression
+			while (--start > 0 && char.IsWhiteSpace(inText, start));
+			if (start > 2 && char.IsWhiteSpace(inText, start - 2)
+			    && inText[start - 1] == 'a' && inText[start] == 's') {
+				result.Context = ExpressionContext.Type;
+			} else {
+				bool wasSquareBracket = false;
+				int brackets = 0;
+				while (start > 0) {
+					char c = inText[start];
+					if (c == '\n') break;
+					if (brackets == 0) {
+						if (c == '(' || c == ',')
+							break;
+						if (!char.IsWhiteSpace(inText, start))
+							wasSquareBracket = inText[start] == '[';
+					} else {
+						if (c == '[' || c == '(')
+							brackets -= 1;
+					}
+					if (c == ')' || c == ']')
+						brackets += 1;
+					start -= 1;
+				}
+				if (wasSquareBracket) {
+					result.Context = BooAttributeContext.Instance;
+				}
+			}
+			
+			return result;
+		}
+		
+		internal class BooAttributeContext : ExpressionContext
+		{
+			public static BooAttributeContext Instance = new BooAttributeContext();
+			
+			public override bool ShowEntry(object o)
+			{
+				IClass c = o as IClass;
+				if (c != null && c.IsAbstract)
+					return false;
+				if (ExpressionContext.Attribute.ShowEntry(o))
+					return true;
+				if (c == null)
+					return false;
+				if (BooProject.BooCompilerPC != null) {
+					return c.IsTypeInInheritanceTree(BooProject.BooCompilerPC.GetClass("Boo.Lang.Compiler.AbstractAstAttribute"));
+				} else {
+					foreach (IReturnType baseType in c.BaseTypes) {
+						if (baseType.FullyQualifiedName == "Boo.Lang.Compiler.AbstractAstAttribute")
+							return true;
+					}
+					return false;
+				}
+			}
 		}
-		// TODO: We could need some unit tests for this.
 		#endregion
 		
 		#region Find Full Expression

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs

@@ -39,10 +39,15 @@ namespace Grunwald.BooBinding.CodeCompletion
 		#endregion
 		
 		#region Make Result
+		void ClearResult()
+		{
+			resolveResult = null;
+		}
+		
 		void MakeResult(IReturnType type)
 		{
 			if (type == null)
-				resolveResult = null;
+				ClearResult();
 			else
 				resolveResult = new ResolveResult(callingClass, resolver.CallingMember, type);
 		}
@@ -61,7 +66,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			} else if (member != null) {
 				resolveResult = new MemberResolveResult(callingClass, resolver.CallingMember, member);
 			} else {
-				resolveResult = null;
+				ClearResult();
 			}
 		}
 		
@@ -102,7 +107,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			}
 			// was not resolved or was resolved as local, member etc.
 			ResolveResult oldResult = resolveResult;
-			resolveResult = null;
+			ClearResult();
 			// Try to resolve as type:
 			IReturnType t = projectContent.SearchType(identifier, 0, callingClass, cu, resolver.CaretLine, resolver.CaretColumn);
 			if (t != null) {
@@ -138,7 +143,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		bool ResolveIdentifier(string identifier)
 		{
 			IField local;
-			resolveResult = null;
+			ClearResult();
 			if (resolver.CallingMember != null) {
 				local = resolver.FindLocalVariable(identifier, false);
 				if (local != null) {
@@ -204,7 +209,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		#region Resolve Member
 		public override void OnMemberReferenceExpression(MemberReferenceExpression node)
 		{
-			resolveResult = null;
+			ClearResult();
 			node.Target.Accept(this);
 			if (resolveResult is NamespaceResolveResult) {
 				string namespaceName = (resolveResult as NamespaceResolveResult).Name;
@@ -279,7 +284,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		#region Resolve Method Invocation
 		public override void OnMethodInvocationExpression(MethodInvocationExpression node)
 		{
-			resolveResult = null;
+			ClearResult();
 			node.Target.Accept(this);
 			if (resolveResult == null)
 				return;
@@ -320,7 +325,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 					}
 					ResolveInvocation(methods, node.Arguments);
 				} else {
-					resolveResult = null;
+					ClearResult();
 				}
 			} else if (resolveResult.ResolvedType != null) {
 				// maybe event or callable call or call on System.Type -> constructor by reflection
@@ -335,19 +340,19 @@ namespace Grunwald.BooBinding.CodeCompletion
 					} else if (c.FullyQualifiedName == "System.Type") {
 						resolveResult.ResolvedType = ReflectionReturnType.Object;
 					} else {
-						resolveResult = null;
+						ClearResult();
 					}
 				} else {
-					resolveResult = null;
+					ClearResult();
 				}
 			} else {
-				resolveResult = null;
+				ClearResult();
 			}
 		}
 		
 		void ResolveInvocation(List<IMethod> methods, ExpressionCollection arguments)
 		{
-			resolveResult = null;
+			ClearResult();
 			if (methods.Count == 0) {
 				return;
 			}
@@ -356,7 +361,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			for (int i = 0; i < types.Length; ++i) {
 				arguments[i].Accept(this);
 				types[i] = (resolveResult != null) ? resolveResult.ResolvedType : null;
-				resolveResult = null;
+				ClearResult();
 			}
 			MakeResult(MemberLookupHelper.FindOverload(methods, new IReturnType[0], types));
 		}
@@ -365,7 +370,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		#region Resolve Slice Expression
 		public override void OnSlicingExpression(SlicingExpression node)
 		{
-			resolveResult = null;
+			ClearResult();
 		}
 		#endregion
 		
@@ -391,7 +396,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 				default:
 					if (node.Left == null) {
 						if (node.Right == null) {
-							resolveResult = null;
+							ClearResult();
 						} else {
 							node.Right.Accept(this);
 						}
@@ -489,7 +494,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		public override void OnSelfLiteralExpression(SelfLiteralExpression node)
 		{
 			if (callingClass == null)
-				resolveResult = null;
+				ClearResult();
 			else
 				MakeResult(callingClass.DefaultReturnType);
 		}
@@ -497,7 +502,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		public override void OnSuperLiteralExpression(SuperLiteralExpression node)
 		{
 			if (callingClass == null)
-				resolveResult = null;
+				ClearResult();
 			else
 				MakeResult(callingClass.BaseType);
 		}

src/Main/Base/Project/Src/Dom/ExpressionContext.cs

@@ -74,7 +74,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// even when the keyword "new" is not part of the expression.</remarks>
 		public static ExpressionContext ObjectCreation = new TypeExpressionContext(null, true, true);
 		
-		/// <summary>Context expects a non-abstract type deriving from System.Attribute.</summary>
+		/// <summary>Context expects a type deriving from System.Attribute.</summary>
 		/// <example>[*expr*()]</example>
 		/// <remarks>When using this context, a resolver should try resolving typenames with an
 		/// appended "Attribute" suffix and treat "invocations" of the attribute type as

src/Main/Base/Project/Src/Dom/IResolver.cs

@@ -28,6 +28,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 		                      string fileName,
 		                      string fileContent);
 		
-		ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent);
+		ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent, ExpressionContext context);
 	}
 }

src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs

@@ -861,7 +861,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			return c2;
 		}
 		
-		public ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent)
+		public ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent, ExpressionContext context)
 		{
 			ArrayList result = new ArrayList();
 			if (language == SupportedLanguage.VBNet) {

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs

@@ -109,7 +109,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			} else {
 				this.ClassType = ClassType.Class;
 				foreach (IAttribute att in this.Attributes) {
-					if (att.Name == "Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute") {
+					if (att.Name == "Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute"
+					    || att.Name == "Boo.Lang.ModuleAttribute")
+					{
 						this.ClassType = ClassType.Module;
 						break;
 					}

src/Main/Base/Project/Src/Services/Debugger/DebuggerService.cs

@@ -346,7 +346,7 @@ namespace ICSharpCode.Core
 								string value = GetText(result, expression);
 								if (value != null) {
 									if (Control.ModifierKeys == Keys.Control) {
-										value = "expr: >" + expression + "<\n" + value;
+										value = "expr: " + expressionResult.ToString() + "\n" + value;
 									}
 									textArea.SetToolTip(value);
 								}

src/Main/Base/Project/Src/Services/ParserService/ParserService.cs

@@ -443,11 +443,11 @@ namespace ICSharpCode.Core
 		
 		////////////////////////////////////
 		
-		public static ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent)
+		public static ArrayList CtrlSpace(int caretLine, int caretColumn, string fileName, string fileContent, ExpressionContext context)
 		{
 			IParser parser = GetParser(fileName);
 			if (parser != null) {
-				return parser.CreateResolver().CtrlSpace(caretLine, caretColumn, fileName, fileContent);
+				return parser.CreateResolver().CtrlSpace(caretLine, caretColumn, fileName, fileContent, context);
 			}
 			return null;
 		}

src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/AttributesDataProvider.cs

@@ -23,7 +23,12 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 	/// </summary>
 	public class AttributesDataProvider : CtrlSpaceCompletionDataProvider
 	{
-		public AttributesDataProvider() : base(ExpressionContext.Attribute)
+		public AttributesDataProvider()
+			: this(ExpressionContext.TypeDerivingFrom(ProjectContentRegistry.Mscorlib.GetClass("System.Attribute"), true))
+		{
+		}
+		
+		public AttributesDataProvider(ExpressionContext context) : base(context)
 		{
 			this.ForceNewExpression = true;
 		}

src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CtrlSpaceCompletionDataProvider.cs

@@ -52,7 +52,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				}
 				ExpressionContext context = overrideContext;
 				if (context == null) context = ExpressionContext.Default;
-				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent), context);
+				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, context), context);
 				return;
 			}
 			
@@ -64,7 +64,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				if (charTyped != '\0') {
 					preSelection = null;
 				}
-				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent), expressionResult.Context);
+				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context), expressionResult.Context);
 				return;
 			}
 			
@@ -81,7 +81,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				if (charTyped != '\0') {
 					preSelection = null;
 				}
-				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent), expressionResult.Context);
+				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context), expressionResult.Context);
 			}
 		}
 	}