Added code completion for attributes.

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

src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpCompletionBinding.cs

@@ -10,6 +10,7 @@ using System.Collections;
 using System.Collections.Generic;
 using ICSharpCode.Core;
 using ICSharpCode.TextEditor.Gui.CompletionWindow;
+using ICSharpCode.TextEditor.Document;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor;
@@ -28,8 +29,10 @@ namespace CSharpBinding
 		{
 			if (!CheckExtension(editor))
 				return false;
+			CSharpBinding.Parser.ExpressionFinder ef = new CSharpBinding.Parser.ExpressionFinder();
+			int cursor = editor.ActiveTextAreaControl.Caret.Offset;
+			ExpressionContext context;
 			if (ch == '(') {
-				ExpressionContext context;
 				switch (editor.GetWordBeforeCaret().Trim()) {
 					case "for":
 					case "lock":
@@ -52,15 +55,27 @@ namespace CSharpBinding
 						break;
 				}
 				if (context != null) {
-					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(context), ' ');
+					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(context), ch);
+					return true;
+				} else if (EnableMethodInsight) {
+					editor.ShowInsightWindow(new MethodInsightDataProvider());
+					return true;
+				}
+				return false;
+			} else if (ch == '[') {
+				LineSegment line = editor.Document.GetLineSegmentForOffset(cursor);
+				if (TextUtilities.FindPrevWordStart(editor.Document, cursor) <= line.Offset) {
+					// [ is first character on the line
+					// -> Attribute completion
+					editor.ShowCompletionWindow(new AttributesDataProvider(), ch);
 					return true;
 				}
 			} else if (ch == ',') {
 				// Show MethodInsightWindow or IndexerInsightWindow
-				CSharpBinding.Parser.ExpressionFinder ef = new CSharpBinding.Parser.ExpressionFinder();
 				string documentText = editor.Text;
-				int cursor = editor.ActiveTextAreaControl.Caret.Offset;
+				int oldCursor = cursor;
 				string textWithoutComments = ef.FilterComments(documentText, ref cursor);
+				int commentLength = oldCursor - cursor;
 				if (textWithoutComments != null) {
 					Stack<ResolveResult> parameters = new Stack<ResolveResult>();
 					char c = '\0';
@@ -69,16 +84,16 @@ namespace CSharpBinding
 						       ((c = textWithoutComments[cursor]) == ',' ||
 						        char.IsWhiteSpace(c)));
 						if (c == '(') {
-							ShowInsight(editor, new MethodInsightDataProvider(cursor, true), parameters, ch);
+							ShowInsight(editor, new MethodInsightDataProvider(cursor + commentLength, true), parameters, ch);
 							return true;
 						} else if (c == '[') {
-							ShowInsight(editor, new IndexerInsightDataProvider(cursor, true), parameters, ch);
+							ShowInsight(editor, new IndexerInsightDataProvider(cursor + commentLength, true), parameters, ch);
 							return true;
 						}
 						string expr = ef.FindExpressionInternal(textWithoutComments, cursor);
 						if (expr == null || expr.Length == 0)
 							break;
-						parameters.Push(ParserService.Resolve(expr,
+						parameters.Push(ParserService.Resolve(new ExpressionResult(expr),
 						                                      editor.ActiveTextAreaControl.Caret.Line,
 						                                      editor.ActiveTextAreaControl.Caret.Column,
 						                                      editor.FileName,
@@ -125,7 +140,7 @@ namespace CSharpBinding
 			IClass c = expected.GetUnderlyingClass();
 			if (c == null) return;
 			if (c.ClassType == ClassType.Enum) {
-				CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider(ExpressionContext.Default);
+				CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider();
 				cdp.ForceNewExpression = true;
 				CachedCompletionDataProvider cache = new CachedCompletionDataProvider(cdp);
 				cache.GenerateCompletionData(editor.FileName, editor.ActiveTextAreaControl.TextArea, charTyped);
@@ -161,7 +176,7 @@ namespace CSharpBinding
 					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Type), ' ');
 					return true;
 				case "new":
-					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.ConstructableType), ' ');
+					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.ObjectCreation), ' ');
 					return true;
 				default:
 					return base.HandleKeyword(editor, word);

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/ExpressionFinder.cs

@@ -9,18 +9,61 @@ namespace CSharpBinding.Parser
 	/// </summary>
 	public class ExpressionFinder : IExpressionFinder
 	{
-		ExpressionResult CreateResult(string expression)
+		#region Capture Context
+		ExpressionResult CreateResult(string expression, string inText, int offset)
 		{
-			if (expression != null && expression.StartsWith("using "))
+			if (expression == null)
+				return new ExpressionResult(null);
+			if (expression.StartsWith("using "))
 				return new ExpressionResult(expression.Substring(6).TrimStart(), ExpressionContext.Namespace, null);
-			else
-				return new ExpressionResult(expression);
+			if (IsInAttribute(inText, offset))
+				return new ExpressionResult(expression, ExpressionContext.Attribute);
+			return new ExpressionResult(expression);
 		}
 		
+		bool IsInAttribute(string txt, int offset)
+		{
+			// Get line start:
+			int lineStart = offset;
+			while (--lineStart > 0 && txt[lineStart] != '\n');
+			
+			bool inAttribute = false;
+			int parens = 0;
+			for (int i = lineStart + 1; i < offset; i++) {
+				char ch = txt[i];
+				if (char.IsWhiteSpace(ch))
+					continue;
+				if (!inAttribute) {
+					// outside attribute
+					if (ch == '[')
+						inAttribute = true;
+					else
+						return false;
+				} else if (parens == 0) {
+					// inside attribute, outside parameter list
+					if (ch == ']')
+						inAttribute = false;
+					else if (ch == '(')
+						parens = 1;
+					else if (!char.IsLetterOrDigit(ch) && ch != ',')
+						return false;
+				} else {
+					// inside attribute, inside parameter list
+					if (ch == '(')
+						parens++;
+					else if (ch == ')')
+						parens--;
+				}
+			}
+			return inAttribute && parens == 0;
+		}
+		#endregion
+		
+		#region Find Expression
 		public ExpressionResult FindExpression(string inText, int offset)
 		{
 			inText = FilterComments(inText, ref offset);
-			return CreateResult(FindExpressionInternal(inText, offset));
+			return CreateResult(FindExpressionInternal(inText, offset), inText, offset);
 		}
 		
 		public string FindExpressionInternal(string inText, int offset)
@@ -55,14 +98,16 @@ namespace CSharpBinding.Parser
 				return ((state == ACCEPTNOMORE) ? offset : lastAccept) + 1;
 			}
 		}
+		#endregion
 		
+		#region FindFullExpression
 		public ExpressionResult FindFullExpression(string inText, int offset)
 		{
 			int offsetWithoutComments = offset;
 			string textWithoutComments = FilterComments(inText, ref offsetWithoutComments);
 			string expressionBeforeOffset = FindExpressionInternal(textWithoutComments, offsetWithoutComments);
 			if (expressionBeforeOffset == null || expressionBeforeOffset.Length == 0)
-				return CreateResult(null);
+				return CreateResult(null, textWithoutComments, offsetWithoutComments);
 			StringBuilder b = new StringBuilder(expressionBeforeOffset);
 			// append characters after expression
 			for (int i = offset + 1; i < inText.Length; ++i) {
@@ -90,7 +135,7 @@ namespace CSharpBinding.Parser
 					break;
 				}
 			}
-			return CreateResult(b.ToString());
+			return CreateResult(b.ToString(), textWithoutComments, offsetWithoutComments);
 		}
 		
 		int FindEndOfTypeParameters(string inText, int offset)
@@ -116,6 +161,7 @@ namespace CSharpBinding.Parser
 			}
 			return -1;
 		}
+		#endregion
 		
 		#region SearchBracketForward
 		// like CSharpFormattingStrategy.SearchBracketForward, but operates on a string.

src/Libraries/ICSharpCode.TextEditor/Project/Src/Document/TextUtilities.cs

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -42,7 +42,7 @@ namespace ICSharpCode.TextEditor.Document
 					sb.Append('\t');
 					// if we had say 3 spaces then a tab and tabIndent was 4 then
 					// we would want to simply replace all of that with 1 tab
-					consecutiveSpaces = 0;					
+					consecutiveSpaces = 0;
 				}
 				else {
 					break;
@@ -142,7 +142,7 @@ namespace ICSharpCode.TextEditor.Document
 						break;
 				}
 			}
-			done:
+		done:
 			//// simple exit fails when : is inside comment line or any other character
 			//// we have to check if we got several ids in resulting line, which usually happens when
 			//// id. is typed on next line after comment one
@@ -153,13 +153,13 @@ namespace ICSharpCode.TextEditor.Document
 			if (pos>=0) {
 				offset+=pos+1;
 				//// whitespaces and tabs, which might be inside, will be skipped by trim below
-			}							
+			}
 			string expression = document.GetText(offset, textArea.Caret.Offset - offset ).Trim();
 			return expression;
 		}
 		
 		
-		public static CharacterType GetCharacterType(char c) 
+		public static CharacterType GetCharacterType(char c)
 		{
 			if(IsLetterDigitOrUnderscore(c))
 				return CharacterType.LetterDigitOrUnderscore;
@@ -228,8 +228,8 @@ namespace ICSharpCode.TextEditor.Document
 		public static int FindPrevWordStart(IDocument document, int offset)
 		{
 			int originalOffset = offset;
-			LineSegment line = document.GetLineSegmentForOffset(offset);
 			if (offset > 0) {
+				LineSegment line = document.GetLineSegmentForOffset(offset);
 				CharacterType t = GetCharacterType(document.GetCharAt(offset - 1));
 				while (offset > line.Offset && GetCharacterType(document.GetCharAt(offset - 1)) == t) {
 					--offset;
@@ -253,13 +253,11 @@ namespace ICSharpCode.TextEditor.Document
 			return document.GetText(line.Offset, line.Length);
 		}
 		
-		//[Obsolete("Use IFormattingStrategy.SearchBracketBackward instead.")]
 		public static int SearchBracketBackward(IDocument document, int offset, char openBracket, char closingBracket)
 		{
 			return document.FormattingStrategy.SearchBracketBackward(document, offset, openBracket, closingBracket);
 		}
 		
-		//[Obsolete("Use IFormattingStrategy.SearchBracketForward instead.")]
 		public static int SearchBracketForward(IDocument document, int offset, char openBracket, char closingBracket)
 		{
 			return document.FormattingStrategy.SearchBracketForward(document, offset, openBracket, closingBracket);

src/Libraries/ICSharpCode.TextEditor/Project/Src/Gui/CompletionWindow/CodeCompletionListView.cs

@@ -132,7 +132,7 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 		public void SelectItemWithStart(char startCh)
 		{
 			for (int i = Math.Min(selectedItem + 1, completionData.Length - 1); i < completionData.Length; ++i) {
-				if (completionData[i].Text[0].ToLower()[0] == startCh) {
+				if (completionData[i].Text.ToLower()[0] == startCh) {
 					SelectIndex(i);
 					return;
 				}
@@ -140,7 +140,7 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 			
 			// now loop from start to current one
 			for (int i = 0; i < selectedItem; ++i) {
-				if (completionData[i].Text[0].ToLower()[0] == startCh) {
+				if (completionData[i].Text.ToLower()[0] == startCh) {
 					SelectIndex(i);
 					return;
 				}
@@ -157,7 +157,7 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 			if (startText == null || startText.Length == 0) return;
 			startText = startText.ToLower();
 			for (int i = 0; i < completionData.Length; ++i) {
-				if (completionData[i].Text[0].ToLower().StartsWith(startText)) {
+				if (completionData[i].Text.ToLower().StartsWith(startText)) {
 					SelectIndex(i);
 					return;
 				}
@@ -195,9 +195,9 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 					
 					// draw text
 					if (curItem == selectedItem) {
-						g.DrawString(completionData[curItem].Text[0], Font, SystemBrushes.HighlightText, xPos, yPos);
+						g.DrawString(completionData[curItem].Text, Font, SystemBrushes.HighlightText, xPos, yPos);
 					} else {
-						g.DrawString(completionData[curItem].Text[0], Font, SystemBrushes.WindowText, xPos, yPos);
+						g.DrawString(completionData[curItem].Text, Font, SystemBrushes.WindowText, xPos, yPos);
 					}
 				}
 				

src/Libraries/ICSharpCode.TextEditor/Project/Src/Gui/CompletionWindow/ICompletionData.cs

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -20,8 +20,9 @@ namespace ICSharpCode.TextEditor.Gui.CompletionWindow
 			get;
 		}
 		
-		string[] Text {
+		string Text {
 			get;
+			set;
 		}
 		
 		string Description {

src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj

@@ -675,6 +675,8 @@
     <Compile Include="Src\TextEditor\Gui\Editor\CompletionWindow\CachedCompletionDataProvider.cs" />
     <Compile Include="Src\Dom\Implementations\CompoundClass.cs" />
     <Compile Include="Src\Project\Items\ImportProjectItem.cs" />
+    <Compile Include="Src\TextEditor\Gui\Editor\CompletionWindow\AttributesDataProvider.cs" />
+    <Compile Include="Src\TextEditor\Gui\Editor\CompletionWindow\CtrlSpaceCompletionDataProvider.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\Libraries\DockPanel_Src\WinFormsUI\WinFormsUI.csproj">

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

@@ -6,6 +6,7 @@
 // </file>
 
 using System;
+using ICSharpCode.Core;
 
 namespace ICSharpCode.SharpDevelop.Dom
 {
@@ -30,7 +31,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		/// <summary>Context expects a non-abstract type that has accessible constructors</summary>
 		/// <example>new *expr*();</example>
-		public static ExpressionContext ConstructableType = new TypeExpressionContext(null, true);
+		public static ExpressionContext ObjectCreation = new TypeExpressionContext(null, true);
+		
+		/// <summary>Context expects a non-abstract type deriving from System.Attribute.</summary>
+		/// <example>[*expr*()]</example>
+		public static ExpressionContext Attribute = new TypeExpressionContext(ProjectContentRegistry.Mscorlib.GetClass("System.Attribute"), true);
 		
 		/// <summary>Context expects a type name which has special base type</summary>
 		/// <param name="baseClass">The class the expression must derive from.</param>

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

@@ -24,7 +24,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// Resolves an expression.
 		/// The caretLineNumber and caretColumn is 1 based.
 		/// </summary>
-		ResolveResult Resolve(string expression,
+		ResolveResult Resolve(ExpressionResult expressionResult,
 		                      int caretLineNumber,
 		                      int caretColumn,
 		                      string fileName,

src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs

@@ -291,11 +291,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 					case ClassType.Module:
 						return null;
 					case ClassType.Enum:
-						return ProjectContentRegistry.GetMscorlibContent().GetClass("System.Enum");
+						return ProjectContentRegistry.Mscorlib.GetClass("System.Enum");
 					case ClassType.Delegate:
-						return ProjectContentRegistry.GetMscorlibContent().GetClass("System.Delegate");
+						return ProjectContentRegistry.Mscorlib.GetClass("System.Delegate");
 					case ClassType.Struct:
-						return ProjectContentRegistry.GetMscorlibContent().GetClass("System.ValueType");
+						return ProjectContentRegistry.Mscorlib.GetClass("System.ValueType");
 				}
 				return null;
 			}
@@ -497,7 +497,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 					
 					IClass baseType;
 					if (baseTypeStruct.parent == null) {
-						baseType = ProjectContentRegistry.GetMscorlibContent().GetClass(baseTypeStruct.name);
+						baseType = ProjectContentRegistry.Mscorlib.GetClass(baseTypeStruct.name);
 					} else {
 						baseType = baseTypeStruct.parent.ProjectContent.SearchType(baseTypeStruct.name, baseTypeStruct.parent, 1, 1);
 					}

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

@@ -528,7 +528,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		IReturnType CreateReturnType(Type type)
 		{
-			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type, false);
+			return ReflectionReturnType.Create(ProjectContentRegistry.Mscorlib, type, false);
 		}
 	}
 }

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

@@ -100,16 +100,17 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 		}
 		
-		public ResolveResult Resolve(string expression,
+		public ResolveResult Resolve(ExpressionResult expressionResult,
 		                             int caretLineNumber,
 		                             int caretColumn,
 		                             string fileName,
 		                             string fileContent)
 		{
+			string expression = expressionResult.Expression;
 			if (expression == null) {
 				expression = "";
 			}
-			expression = expression.TrimStart(null);
+			expression = expression.TrimStart();
 			
 			this.caretLine   = caretLineNumber;
 			this.caretColumn = caretColumn;
@@ -118,6 +119,14 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (parseInfo == null) {
 				return null;
 			}
+			
+			cu = parseInfo.MostRecentCompilationUnit;
+			
+			if (cu != null) {
+				callingClass = cu.GetInnermostClass(caretLine, caretColumn);
+				cu.FileName = fileName;
+			}
+			
 			Expression expr = null;
 			if (language == SupportedLanguages.VBNet) {
 				if (expression == "") {
@@ -137,15 +146,13 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					}
 				}
 			}
-			lookupTableVisitor = new LookupTableVisitor(languageProperties.NameComparer);
-			
-			//NRefactoryASTConvertVisitor cSharpVisitor = new NRefactoryASTConvertVisitor(parseInfo.MostRecentCompilationUnit != null ? parseInfo.MostRecentCompilationUnit.ProjectContent : null);
-			cu = parseInfo.MostRecentCompilationUnit; //(ICompilationUnit)cSharpVisitor.Visit(fileCompilationUnit, null);
 			
-			if (cu != null) {
-				callingClass = cu.GetInnermostClass(caretLine, caretColumn);
-				cu.FileName = fileName;
+			if (expressionResult.Context == ExpressionContext.Attribute) {
+				return ResolveAttribute(expr);
 			}
+			
+			lookupTableVisitor = new LookupTableVisitor(languageProperties.NameComparer);
+			
 			callingMember = GetCurrentMember();
 			if (callingMember != null) {
 				System.IO.TextReader content = ExtractMethod(fileContent, callingMember);
@@ -159,6 +166,56 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			return ResolveInternal(expr);
 		}
 		
+		string GetAttributeName(Expression expr)
+		{
+			if (expr is IdentifierExpression) {
+				return (expr as IdentifierExpression).Identifier;
+			} else if (expr is FieldReferenceExpression) {
+				TypeVisitor typeVisitor = new TypeVisitor(this);
+				FieldReferenceExpression fieldReferenceExpression = (FieldReferenceExpression)expr;
+				IReturnType type = fieldReferenceExpression.TargetObject.AcceptVisitor(typeVisitor, null) as IReturnType;
+				if (type is TypeVisitor.NamespaceReturnType) {
+					return type.FullyQualifiedName + "." + fieldReferenceExpression.FieldName;
+				}
+			}
+			return null;
+		}
+		
+		IClass GetAttribute(string name)
+		{
+			if (name == null)
+				return null;
+			IClass c = SearchType(name);
+			if (c != null) {
+				if (c.IsTypeInInheritanceTree(ProjectContentRegistry.Mscorlib.GetClass("System.Attribute")))
+					return c;
+			}
+			return SearchType(name + "Attribute");
+		}
+		
+		ResolveResult ResolveAttribute(Expression expr)
+		{
+			string attributeName = GetAttributeName(expr);
+			IClass c = GetAttribute(attributeName);
+			if (attributeName != null) {
+				return new TypeResolveResult(callingClass, callingMember, c);
+			} else if (expr is InvocationExpression) {
+				InvocationExpression ie = (InvocationExpression)expr;
+				attributeName = GetAttributeName(ie.TargetObject);
+				c = GetAttribute(attributeName);
+				if (c != null) {
+					ArrayList ctors = new ArrayList();
+					foreach (IMethod m in c.Methods) {
+						if (m.IsConstructor && !m.IsStatic)
+							ctors.Add(m);
+					}
+					TypeVisitor typeVisitor = new TypeVisitor(this);
+					return CreateMemberResolveResult(typeVisitor.FindOverload(ctors, ie.Parameters, null));
+				}
+			}
+			return null;
+		}
+		
 		ResolveResult ResolveInternal(Expression expr)
 		{
 			TypeVisitor typeVisitor = new TypeVisitor(this);
@@ -253,9 +310,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			IClass c;
 			IMember member;
-			TypeVisitor.NamespaceReturnType namespaceRT = type as TypeVisitor.NamespaceReturnType;
-			if (namespaceRT != null) {
-				string combinedName = namespaceRT.FullyQualifiedName + "." + fieldReferenceExpression.FieldName;
+			if (type is TypeVisitor.NamespaceReturnType) {
+				string combinedName = type.FullyQualifiedName + "." + fieldReferenceExpression.FieldName;
 				if (projectContent.NamespaceExists(combinedName)) {
 					return new NamespaceResolveResult(callingClass, callingMember, combinedName);
 				}
@@ -265,7 +321,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				}
 				if (languageProperties.ImportModules) {
 					// go through the members of the modules
-					foreach (object o in projectContent.GetNamespaceContents(namespaceRT.FullyQualifiedName)) {
+					foreach (object o in projectContent.GetNamespaceContents(type.FullyQualifiedName)) {
 						member = o as IMember;
 						if (member != null && IsSameName(member.Name, fieldReferenceExpression.FieldName))
 							return CreateMemberResolveResult(member);

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

@@ -484,7 +484,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (t == null) {
 				if (reference.Type != reference.SystemType) {
 					// keyword-type like void, int, string etc.
-					t = ProjectContentRegistry.GetMscorlibContent().GetClass(reference.SystemType).DefaultReturnType;
+					t = ProjectContentRegistry.Mscorlib.GetClass(reference.SystemType).DefaultReturnType;
 				} else {
 					t = new SearchClassReturnType(callingClass, caretLine, caretColumn, reference.SystemType);
 				}
@@ -543,7 +543,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		static IReturnType CreateReturnType(Type type)
 		{
-			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type, false);
+			return ReflectionReturnType.Create(ProjectContentRegistry.Mscorlib, type, false);
 		}
 	}
 }

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

@@ -103,7 +103,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// </summary>
 		public static IReturnType CreatePrimitive(Type type)
 		{
-			return ProjectContentRegistry.GetMscorlibContent().GetClass(type.FullName).DefaultReturnType;
+			return ProjectContentRegistry.Mscorlib.GetClass(type.FullName).DefaultReturnType;
 		}
 		#endregion
 		

src/Main/Base/Project/Src/Gui/Pads/DefinitionViewPad.cs

@@ -79,8 +79,8 @@ namespace ICSharpCode.SharpDevelop.Gui
 			if (expressionFinder == null) return null;
 			Caret caret = ctl.ActiveTextAreaControl.Caret;
 			string content = (e == null) ? ctl.Text : e.Content;
-			string expr = expressionFinder.FindFullExpression(content, caret.Offset).Expression;
-			if (expr == null) return null;
+			ExpressionResult expr = expressionFinder.FindFullExpression(content, caret.Offset);
+			if (expr.Expression == null) return null;
 			return ParserService.Resolve(expr, caret.Line, caret.Column, fileName, content);
 		}
 		

src/Main/Base/Project/Src/Project/MSBuildProject.cs

@@ -200,7 +200,9 @@ namespace ICSharpCode.SharpDevelop.Project
 					ProjectItem.WriteItemGroup(writer, projectFiles);
 				}
 				
-				ProjectItem.WriteItemGroup(writer, other);
+				if (other.Count > 0) {
+					ProjectItem.WriteItemGroup(writer, other);
+				}
 				
 				foreach (string import in Imports) {
 					writer.WriteStartElement("Import");

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

@@ -347,7 +347,8 @@ namespace ICSharpCode.Core
 						LineSegment seg = doc.GetLineSegment(logicPos.Y);
 						int xPosition = Math.Min(seg.Length - 1, logicPos.X);
 						string textContent = doc.TextContent;
-						string expression = expressionFinder.FindFullExpression(textContent, seg.Offset + xPosition).Expression;
+						ExpressionResult expressionResult = expressionFinder.FindFullExpression(textContent, seg.Offset + xPosition);
+						string expression = expressionResult.Expression;
 						//Console.WriteLine("MouseMove@" + logicPos + ":" + expression);
 						if (expression != null && expression.Length > 0) {
 							if (expression == oldExpression && oldLine == logicPos.Y) {
@@ -359,7 +360,7 @@ namespace ICSharpCode.Core
 								// otherwise textArea will close the tooltip.
 							} else {
 								// Look if it is variable
-								ResolveResult result = ParserService.Resolve(expression, logicPos.Y + 1, xPosition + 1, textArea.MotherTextEditorControl.FileName, textContent);
+								ResolveResult result = ParserService.Resolve(expressionResult, logicPos.Y + 1, xPosition + 1, textArea.MotherTextEditorControl.FileName, textContent);
 								string value = GetText(result);
 								if (value != null) {
 									#if DEBUG

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

@@ -13,7 +13,7 @@ namespace ICSharpCode.Core
 			ParseProjectContent newProjectContent = new ParseProjectContent();
 			newProjectContent.project = project;
 			newProjectContent.Language = project.LanguageProperties;
-			newProjectContent.ReferencedContents.Add(ProjectContentRegistry.GetMscorlibContent());
+			newProjectContent.ReferencedContents.Add(ProjectContentRegistry.Mscorlib);
 			newProjectContent.initializing = true;
 			return newProjectContent;
 		}

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

@@ -188,7 +188,7 @@ namespace ICSharpCode.Core
 		static void ParserUpdateThread()
 		{
 			// preload mscorlib, we're going to need it anyway
-			ProjectContentRegistry.GetMscorlibContent();
+			IProjectContent dummyVar = ProjectContentRegistry.Mscorlib;
 			
 			while (!abortParserUpdateThread) {
 				try {
@@ -422,7 +422,7 @@ namespace ICSharpCode.Core
 			return null;
 		}
 		
-		public static ResolveResult Resolve(string expression,
+		public static ResolveResult Resolve(ExpressionResult expressionResult,
 		                                    int caretLineNumber,
 		                                    int caretColumn,
 		                                    string fileName,
@@ -430,7 +430,7 @@ namespace ICSharpCode.Core
 		{
 			IParser parser = GetParser(fileName);
 			if (parser != null) {
-				return parser.CreateResolver().Resolve(expression, caretLineNumber, caretColumn, fileName, fileContent);
+				return parser.CreateResolver().Resolve(expressionResult, caretLineNumber, caretColumn, fileName, fileContent);
 			}
 			return null;
 		}

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

@@ -20,26 +20,27 @@ namespace ICSharpCode.Core
 		static Dictionary<string, IProjectContent> contents = new Dictionary<string, IProjectContent>(StringComparer.InvariantCultureIgnoreCase);
 		static IProjectContent mscorlibContent;
 		
-		public static IProjectContent GetMscorlibContent()
-		{
-			if (mscorlibContent != null) return mscorlibContent;
-			lock (contents) {
-				if (contents.ContainsKey("mscorlib")) {
-					mscorlibContent = contents["mscorlib"];
-					return contents["mscorlib"];
+		public static IProjectContent Mscorlib {
+			get {
+				if (mscorlibContent != null) return mscorlibContent;
+				lock (contents) {
+					if (contents.ContainsKey("mscorlib")) {
+						mscorlibContent = contents["mscorlib"];
+						return contents["mscorlib"];
+					}
+					#if DEBUG
+					Console.WriteLine("Loading mscorlib...");
+					int time = Environment.TickCount;
+					#endif
+					
+					mscorlibContent = new ReflectionProjectContent(typeof(object).Assembly);
+					contents["mscorlib"] = mscorlibContent;
+					
+					#if DEBUG
+					Console.WriteLine("mscorlib loaded in {0} ms", Environment.TickCount - time);
+					#endif
+					return mscorlibContent;
 				}
-				#if DEBUG
-				Console.WriteLine("Loading mscorlib...");
-				int time = Environment.TickCount;
-				#endif
-				
-				mscorlibContent = new ReflectionProjectContent(typeof(object).Assembly);
-				contents["mscorlib"] = mscorlibContent;
-				
-				#if DEBUG
-				Console.WriteLine("mscorlib loaded in {0} ms", Environment.TickCount - time);
-				#endif
-				return mscorlibContent;
 			}
 		}
 		

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

@@ -114,14 +114,14 @@ namespace ICSharpCode.Core
 				if (expressionFinder == null) {
 					expressionFinder = ParserService.GetExpressionFinder(fileName);
 				}
-				string expr = expressionFinder.FindFullExpression(fileContent, pos + 1).Expression;
-				if (expr != null) {
+				ExpressionResult expr = expressionFinder.FindFullExpression(fileContent, pos + 1);
+				if (expr.Expression != null) {
 					Point position = GetPosition(fileContent, pos);
 					// TODO: Optimize by re-using the same resolver if multiple expressions were
 					// found in this file (the resolver should parse all methods at once)
 					ResolveResult rr = ParserService.Resolve(expr, position.Y, position.X, fileName, fileContent);
 					if (IsReferenceToMember(member, rr)) {
-						list.Add(new Reference(fileName, pos, lowerMemberName.Length, expr, rr));
+						list.Add(new Reference(fileName, pos, lowerMemberName.Length, expr.Expression, rr));
 					}
 				}
 			}

src/Main/Base/Project/Src/TextEditor/Actions.cs

@@ -36,7 +36,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Actions
 		{
 			SharpDevelopTextAreaControl sdtac = (SharpDevelopTextAreaControl)services.MotherTextEditorControl;
 			
-			sdtac.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Default), '\0');
+			sdtac.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(), '\0');
 		}
 	}
 	
@@ -67,8 +67,8 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Actions
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(textEditorControl.FileName);
 			if (expressionFinder == null)
 				return;
-			string expression = expressionFinder.FindFullExpression(textContent, textEditorControl.ActiveTextAreaControl.Caret.Offset).Expression;
-			if (expression == null || expression.Length == 0)
+			ExpressionResult expression = expressionFinder.FindFullExpression(textContent, textEditorControl.ActiveTextAreaControl.Caret.Offset);
+			if (expression.Expression == null || expression.Expression.Length == 0)
 				return;
 			ResolveResult result = ParserService.Resolve(expression, caretLineNumber, caretColumn, textEditorControl.FileName, textContent);
 			if (result != null) {

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

@@ -47,9 +47,9 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			}
 		}
 		protected ArrayList completionData = null;
-		protected ExpressionContext context = ExpressionContext.Default;
+		protected ExpressionContext overrideContext;
 		
-		public ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
+		public virtual ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
 		{
 			completionData = new ArrayList();
 			this.fileName = fileName;
@@ -64,23 +64,23 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			return (ICompletionData[])completionData.ToArray(typeof(ICompletionData));
 		}
 		
-		protected string GetExpression(TextArea textArea)
+		protected ExpressionResult GetExpression(TextArea textArea)
 		{
 			IDocument document = textArea.Document;
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName);
 			if (expressionFinder == null) {
-				return TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset);
+				return new ExpressionResult(TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset));
 			} else {
-				ExpressionResult er = expressionFinder.FindExpression(document.GetText(0, textArea.Caret.Offset), textArea.Caret.Offset - 1);
-				if (er.Context != ExpressionContext.Default)
-					context = er.Context;
-				return er.Expression;
+				ExpressionResult res = expressionFinder.FindExpression(document.GetText(0, textArea.Caret.Offset), textArea.Caret.Offset - 1);
+				if (overrideContext != null)
+					res.Context = overrideContext;
+				return res;
 			}
 		}
 		
 		protected abstract void GenerateCompletionData(TextArea textArea, char charTyped);
 		
-		protected void AddResolveResults(ICollection list)
+		protected void AddResolveResults(ICollection list, ExpressionContext context)
 		{
 			if (list == null) {
 				return;
@@ -123,14 +123,14 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			}
 		}
 		
-		protected void AddResolveResults(ResolveResult results)
+		protected void AddResolveResults(ResolveResult results, ExpressionContext context)
 		{
 			insertedElements.Clear();
 			insertedPropertiesElements.Clear();
 			insertedEventElements.Clear();
 			
 			if (results != null) {
-				AddResolveResults(results.GetCompletionData(ParserService.CurrentProjectContent));
+				AddResolveResults(results.GetCompletionData(ParserService.CurrentProjectContent), context);
 			}
 		}
 	}

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

@@ -0,0 +1,55 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Windows.Forms;
+
+using ICSharpCode.Core;
+using ICSharpCode.TextEditor.Document;
+using ICSharpCode.TextEditor;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.TextEditor.Gui.CompletionWindow;
+
+namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
+{
+	/// <summary>
+	/// Provides code completion for attribute names.
+	/// </summary>
+	public class AttributesDataProvider : CtrlSpaceCompletionDataProvider
+	{
+		public AttributesDataProvider() : base(ExpressionContext.Attribute)
+		{
+			this.ForceNewExpression = true;
+		}
+		
+		bool removeAttributeSuffix = true;
+		
+		public bool RemoveAttributeSuffix {
+			get {
+				return removeAttributeSuffix;
+			}
+			set {
+				removeAttributeSuffix = value;
+			}
+		}
+		
+		public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
+		{
+			ICompletionData[] data = base.GenerateCompletionData(fileName, textArea, charTyped);
+			if (removeAttributeSuffix) {
+				foreach (ICompletionData d in data) {
+					if (d.Text.EndsWith("Attribute")) {
+						d.Text = d.Text.Substring(0, d.Text.Length - 9);
+					}
+				}
+			}
+			return data;
+		}
+	}
+}

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

@@ -26,7 +26,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		string   text;
 		string   description;
 		string   documentation;
-		string   completionString;
 		IClass   c;
 		bool     convertedDocumentation = false;
 		
@@ -58,12 +57,12 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			}
 		}
 		
-		public string[] Text {
+		public string Text {
 			get {
-				return new string[] { text };
+				return text;
 			}
 			set {
-				text = value[0];
+				text = value;
 			}
 		}
 		
@@ -90,7 +89,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			ambience = AmbienceService.CurrentAmbience;
 			description = documentation = String.Empty;
 			text = s;
-			completionString = s;
 			this.imageIndex = imageIndex;
 		}
 		
@@ -102,7 +100,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			imageIndex = ClassBrowserIconService.GetIcon(c);
 			ambience.ConversionFlags = ConversionFlags.None;
 			text = ambience.Convert(c);
-			completionString = text;
 			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedNames | ConversionFlags.ShowReturnType | ConversionFlags.ShowModifiers;
 //			Console.WriteLine("Convert : " + c);
 			description = ambience.Convert(c);
@@ -117,7 +114,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			imageIndex  = ClassBrowserIconService.GetIcon(method);
 			text        = method.Name;
 			description = ambience.Convert(method);
-			completionString = method.Name;
 			documentation = method.Documentation;
 		}
 		
@@ -129,7 +125,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			imageIndex  = ClassBrowserIconService.GetIcon(field);
 			text        = field.Name;
 			description = ambience.Convert(field);
-			completionString = field.Name;
 			documentation = field.Documentation;
 		}
 		
@@ -141,7 +136,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			imageIndex  = ClassBrowserIconService.GetIcon(property);
 			text        = property.Name;
 			description = ambience.Convert(property);
-			completionString = property.Name;
 			documentation = property.Documentation;
 		}
 		
@@ -153,13 +147,12 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			imageIndex  = ClassBrowserIconService.GetIcon(e);
 			text        = e.Name;
 			description = ambience.Convert(e);
-			completionString = e.Name;
 			documentation = e.Documentation;
 		}
 		
 		public void InsertAction(TextEditorControl control)
 		{
-			((SharpDevelopTextAreaControl)control).ActiveTextAreaControl.TextArea.InsertString(completionString);
+			((SharpDevelopTextAreaControl)control).ActiveTextAreaControl.TextArea.InsertString(text);
 		}
 		
 		internal static Regex whitespace = new Regex(@"\s+");

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

@@ -31,9 +31,9 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		public bool DebugMode = false;
 		#endif
 		
-		protected void GenerateCompletionData(TextArea textArea, string expression)
+		protected void GenerateCompletionData(TextArea textArea, ExpressionResult expressionResult)
 		{
-			if (expression == null || expression.Length == 0) {
+			if (expressionResult.Expression == null || expressionResult.Expression.Length == 0) {
 				return;
 			}
 			#if DEBUG
@@ -41,65 +41,12 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				Debugger.Break();
 			}
 			#endif
-			AddResolveResults(ParserService.Resolve(expression,
+			AddResolveResults(ParserService.Resolve(expressionResult,
 			                                        caretLineNumber,
 			                                        caretColumn,
 			                                        fileName,
-			                                        textArea.Document.TextContent));
-		}
-	}
-	
-	public class CtrlSpaceCompletionDataProvider : CodeCompletionDataProvider
-	{
-		public CtrlSpaceCompletionDataProvider(ExpressionContext context)
-		{
-			this.context = context;
-		}
-		
-		bool forceNewExpression;
-		
-		/// <summary>
-		/// Gets/Sets whether the CtrlSpaceCompletionDataProvider creates a new completion
-		/// dropdown instead of completing an old expression.
-		/// Default value is false.
-		/// </summary>
-		public bool ForceNewExpression {
-			get {
-				return forceNewExpression;
-			}
-			set {
-				forceNewExpression = value;
-			}
-		}
-		
-		protected override void GenerateCompletionData(TextArea textArea, char charTyped)
-		{
-			string expression = forceNewExpression ? null : GetExpression(textArea);
-			preSelection = null;
-			if (expression == null || expression.Length == 0) {
-				preSelection = "";
-				if (charTyped != '\0') {
-					preSelection = null;
-				}
-				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent));
-				return;
-			}
-			
-			int idx = expression.LastIndexOf('.');
-			if (idx > 0) {
-				preSelection = expression.Substring(idx + 1);
-				expression = expression.Substring(0, idx);
-				if (charTyped != '\0') {
-					preSelection = null;
-				}
-				GenerateCompletionData(textArea, expression);
-			} else {
-				preSelection = expression;
-				if (charTyped != '\0') {
-					preSelection = null;
-				}
-				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent));
-			}
+			                                        textArea.Document.TextContent),
+			                  expressionResult.Context);
 		}
 	}
 }

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

@@ -106,9 +106,12 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				}
 			}
 			
-			public string[] Text {
+			public string Text {
 				get {
-					return new string[] { text };
+					return text;
+				}
+				set {
+					text = value;
 				}
 			}
 			

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

@@ -0,0 +1,88 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Diagnostics;
+
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.TextEditor;
+using ICSharpCode.TextEditor.Document;
+using ICSharpCode.TextEditor.Gui.CompletionWindow;
+
+namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
+{
+	public class CtrlSpaceCompletionDataProvider : CodeCompletionDataProvider
+	{
+		public CtrlSpaceCompletionDataProvider()
+		{
+		}
+		
+		public CtrlSpaceCompletionDataProvider(ExpressionContext overrideContext)
+		{
+			this.overrideContext = overrideContext;
+		}
+		
+		bool forceNewExpression;
+		
+		/// <summary>
+		/// Gets/Sets whether the CtrlSpaceCompletionDataProvider creates a new completion
+		/// dropdown instead of completing an old expression.
+		/// Default value is false.
+		/// </summary>
+		public bool ForceNewExpression {
+			get {
+				return forceNewExpression;
+			}
+			set {
+				forceNewExpression = value;
+			}
+		}
+		
+		protected override void GenerateCompletionData(TextArea textArea, char charTyped)
+		{
+			if (forceNewExpression) {
+				preSelection = "";
+				if (charTyped != '\0') {
+					preSelection = null;
+				}
+				ExpressionContext context = overrideContext;
+				if (context == null) context = ExpressionContext.Default;
+				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent), context);
+				return;
+			}
+			
+			ExpressionResult expressionResult = GetExpression(textArea);
+			string expression = expressionResult.Expression;
+			preSelection = null;
+			if (expression == null || expression.Length == 0) {
+				preSelection = "";
+				if (charTyped != '\0') {
+					preSelection = null;
+				}
+				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent), expressionResult.Context);
+				return;
+			}
+			
+			int idx = expression.LastIndexOf('.');
+			if (idx > 0) {
+				preSelection = expression.Substring(idx + 1);
+				expression = expression.Substring(0, idx);
+				if (charTyped != '\0') {
+					preSelection = null;
+				}
+				GenerateCompletionData(textArea, expressionResult);
+			} else {
+				preSelection = expression;
+				if (charTyped != '\0') {
+					preSelection = null;
+				}
+				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent), expressionResult.Context);
+			}
+		}
+	}
+}

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

@@ -67,9 +67,12 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				}
 			}
 			
-			public string[] Text {
+			public string Text {
 				get {
-					return new string[] { template.Shortcut + "\t" + template.Description };
+					return template.Shortcut + "\t" + template.Description;
+				}
+				set {
+					throw new NotSupportedException();
 				}
 			}
 			

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs

@@ -35,9 +35,9 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		/// </summary>
 		public IndexerInsightDataProvider(int lookupOffset, bool setupOnlyOnce) : base(lookupOffset, setupOnlyOnce) {}
 		
-		protected override void SetupDataProvider(string fileName, IDocument document, string word, int caretLineNumber, int caretColumn)
+		protected override void SetupDataProvider(string fileName, IDocument document, ExpressionResult expressionResult, int caretLineNumber, int caretColumn)
 		{
-			ResolveResult result = ParserService.Resolve(word, caretLineNumber, caretColumn, fileName, document.TextContent);
+			ResolveResult result = ParserService.Resolve(expressionResult, caretLineNumber, caretColumn, fileName, document.TextContent);
 			if (result == null)
 				return;
 			IReturnType type = result.ResolvedType;

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs

@@ -101,25 +101,31 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			
 			
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName);
-			string word = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(textArea, useOffset) : expressionFinder.FindExpression(textArea.Document.TextContent, useOffset - 1).Expression;
-			if (word == null) // word can be null when cursor is in string/comment
+			ExpressionResult expressionResult;
+			if (expressionFinder == null)
+				expressionResult = new ExpressionResult(TextUtilities.GetExpressionBeforeOffset(textArea, useOffset));
+			else
+				expressionResult = expressionFinder.FindExpression(textArea.Document.TextContent, useOffset - 1);
+			if (expressionResult.Expression == null) // expression is null when cursor is in string/comment
 				return;
-			word = word.Trim();
+			expressionResult.Expression = expressionResult.Expression.Trim();
 			
 			// the parser works with 1 based coordinates
 			int caretLineNumber = document.GetLineNumberForOffset(useOffset) + 1;
 			int caretColumn     = useOffset - document.GetLineSegment(caretLineNumber).Offset + 1;
-			SetupDataProvider(fileName, document, word, caretLineNumber, caretColumn);
+			SetupDataProvider(fileName, document, expressionResult, caretLineNumber, caretColumn);
 		}
 		
-		protected virtual void SetupDataProvider(string fileName, IDocument document, string word, int caretLineNumber, int caretColumn)
+		protected virtual void SetupDataProvider(string fileName, IDocument document, ExpressionResult expressionResult, int caretLineNumber, int caretColumn)
 		{
 			bool constructorInsight = false;
-			if (word.ToLower().StartsWith("new ")) {
+			if (expressionResult.Context == ExpressionContext.ObjectCreation) {
+				constructorInsight = true;
+				expressionResult.Context = ExpressionContext.Default;
+			} else if (expressionResult.Context == ExpressionContext.Attribute) {
 				constructorInsight = true;
-				word = word.Substring(4);
 			}
-			ResolveResult results = ParserService.Resolve(word, caretLineNumber, caretColumn, fileName, document.TextContent);
+			ResolveResult results = ParserService.Resolve(expressionResult, caretLineNumber, caretColumn, fileName, document.TextContent);
 			if (constructorInsight) {
 				TypeResolveResult result = results as TypeResolveResult;
 				if (result == null)

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -65,7 +65,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 			AddCompilationUnit(Parse("a.cs", program), "a.cs");
 			
 			NRefactoryResolver resolver = new NRefactoryResolver(ICSharpCode.NRefactory.Parser.SupportedLanguages.CSharp);
-			return resolver.Resolve(expression,
+			return resolver.Resolve(new ExpressionResult(expression),
 			                        line, 0,
 			                        "a.cs",
 			                        program);
@@ -76,13 +76,13 @@ namespace ICSharpCode.SharpDevelop.Tests
 			AddCompilationUnit(ParseVB("a.vb", program), "a.vb");
 			
 			NRefactoryResolver resolver = new NRefactoryResolver(ICSharpCode.NRefactory.Parser.SupportedLanguages.VBNet);
-			return resolver.Resolve(expression,
+			return resolver.Resolve(new ExpressionResult(expression),
 			                        line, 0,
 			                        "a.vb",
 			                        program);
 		}
 		
-		IProjectContent corLib = ProjectContentRegistry.GetMscorlibContent();
+		IProjectContent corLib = ProjectContentRegistry.Mscorlib;
 		#endregion
 		
 		#region Test for old issues (Fidalgo)

src/Main/Base/Test/ReflectionLayerTests.cs

@@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 	[TestFixture]
 	public class ReflectionLayerTests
 	{
-		IProjectContent pc = ProjectContentRegistry.GetMscorlibContent();
+		IProjectContent pc = ProjectContentRegistry.Mscorlib;
 		
 		[Test]
 		public void InheritanceTest()

src/Main/Base/Test/SearchClassTests.cs

@@ -20,7 +20,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 		ICompilationUnit Prepare(LanguageProperties language)
 		{
 			DefaultProjectContent pc = new DefaultProjectContent();
-			pc.ReferencedContents.Add(ProjectContentRegistry.GetMscorlibContent());
+			pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib);
 			pc.Language = language;
 			DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
 			if (language == LanguageProperties.VBNet)