Worked on Xaml language binding.

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

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

@@ -81,7 +81,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		public ExpressionResult FindExpression(string inText, int offset)
 		{
 			if (inText == null || offset >= inText.Length)
-				return new ExpressionResult(null);
+				return ExpressionResult.Empty;
 			// OK, first try a kind of "quick find"
 			int i = offset + 1;
 			const string forbidden = "\"\'/#)]}";
@@ -110,7 +110,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			
 			inText = SimplifyCode(inText, offset);
 			if (inText == null) {
-				return new ExpressionResult(null);
+				return ExpressionResult.Empty;
 			}
 			// inText now has no comments or string literals, but the same meaning in
 			// terms of the type system
@@ -133,7 +133,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 					while (bracketStack.Count > 0 && bracketStack.Pop() > bracket);
 				}
 			}
-			return new ExpressionResult(null);
+			return ExpressionResult.Empty;
 		}
 		
 		bool CheckString(string text, int offset, string forbidden, string finish)
@@ -150,7 +150,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		
 		ExpressionResult GetExpression(string inText, int start, int end)
 		{
-			if (start == end) return new ExpressionResult(null);
+			if (start == end) return ExpressionResult.Empty;
 			StringBuilder b = new StringBuilder();
 			bool wasSpace = true;
 			int i = start;
@@ -273,7 +273,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 					while (bracketStack.Count > 0 && bracketStack.Pop() > bracket);
 				}
 			}
-			return new ExpressionResult(null);
+			return ExpressionResult.Empty;
 		}
 		#endregion
 		

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

@@ -19,7 +19,7 @@ namespace VBNetBinding.Parser
 		ExpressionResult CreateResult(string expression)
 		{
 			if (expression == null)
-				return new ExpressionResult(null);
+				return ExpressionResult.Empty;
 			if (expression.Length > 8 && expression.Substring(0, 8).Equals("Imports ", StringComparison.InvariantCultureIgnoreCase))
 				return new ExpressionResult(expression.Substring(8).TrimStart(), ExpressionContext.Type, null);
 			if (expression.Length > 4 && expression.Substring(0, 4).Equals("New ", StringComparison.InvariantCultureIgnoreCase))

src/AddIns/BackendBindings/XamlBinding/Project/Src/XamlCompilationUnit.cs

@@ -22,13 +22,13 @@ namespace XamlBinding
 		public IReturnType CreateType(string xmlNamespace, string className)
 		{
 			if (xmlNamespace.StartsWith("clr-namespace:")) {
-				return CreateClrNamespaceType(xmlNamespace, className);
+				return CreateClrNamespaceType(this.ProjectContent, xmlNamespace, className);
 			} else {
 				return new XamlClassReturnType(this, xmlNamespace, className);
 			}
 		}
 		
-		IReturnType CreateClrNamespaceType(string xmlNamespace, string className)
+		static IReturnType CreateClrNamespaceType(IProjectContent pc, string xmlNamespace, string className)
 		{
 			string namespaceName = xmlNamespace.Substring("clr-namespace:".Length);
 			int pos = namespaceName.IndexOf(';');
@@ -37,18 +37,27 @@ namespace XamlBinding
 				// can ignore the assembly part after the ;
 				namespaceName = namespaceName.Substring(0, pos);
 			}
-			return new GetClassReturnType(this.ProjectContent, namespaceName + "." + className, 0);
+			return new GetClassReturnType(pc, namespaceName + "." + className, 0);
 		}
 		
 		public IReturnType FindType(string xmlNamespace, string className)
 		{
+			return FindType(this.ProjectContent, xmlNamespace, className);
+		}
+		
+		public static IReturnType FindType(IProjectContent pc, string xmlNamespace, string className)
+		{
+			if (pc == null)
+				throw new ArgumentNullException("pc");
+			if (xmlNamespace == null || className == null)
+				return null;
 			if (xmlNamespace.StartsWith("clr-namespace:")) {
-				return CreateClrNamespaceType(xmlNamespace, className);
+				return CreateClrNamespaceType(pc, xmlNamespace, className);
 			} else {
-				IReturnType type = FindTypeInAssembly(this.ProjectContent, xmlNamespace, className);
+				IReturnType type = FindTypeInAssembly(pc, xmlNamespace, className);
 				if (type != null)
 					return type;
-				foreach (IProjectContent p in this.ProjectContent.ReferencedContents) {
+				foreach (IProjectContent p in pc.ReferencedContents) {
 					type = FindTypeInAssembly(p, xmlNamespace, className);
 					if (type != null)
 						return type;

src/AddIns/BackendBindings/XamlBinding/Project/Src/XamlExpressionContext.cs

@@ -0,0 +1,57 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <author name="Daniel Grunwald"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Text;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.XmlEditor;
+
+namespace XamlBinding
+{
+	/// <summary>
+	/// Represents the context of a location in a XAML document.
+	/// </summary>
+	public sealed class XamlExpressionContext : ExpressionContext
+	{
+		public readonly XmlElementPath ElementPath;
+		public readonly string AttributeName;
+		public readonly bool InAttributeValue;
+		
+		public XamlExpressionContext(XmlElementPath elementPath, string attributeName, bool inAttributeValue)
+		{
+			if (elementPath == null)
+				throw new ArgumentNullException("elementPath");
+			this.ElementPath = elementPath;
+			this.AttributeName = attributeName;
+			this.InAttributeValue = inAttributeValue;
+		}
+		
+		public override bool ShowEntry(object o)
+		{
+			return true;
+		}
+		
+		public override string ToString()
+		{
+			StringBuilder b = new StringBuilder();
+			b.Append("[XamlExpressionContext ");
+			for (int i = 0; i < ElementPath.Elements.Count; i ++) {
+				if (i > 0) b.Append(">");
+				b.Append(ElementPath.Elements[i].Name);
+			}
+			if (!string.IsNullOrEmpty(AttributeName)) {
+				b.Append(" AttributeName=");
+				b.Append(AttributeName);
+				if (InAttributeValue) {
+					b.Append(" InAttributeValue");
+				}
+			}
+			b.Append("]");
+			return b.ToString();
+		}
+	}
+}

src/AddIns/BackendBindings/XamlBinding/Project/Src/XamlExpressionFinder.cs

@@ -0,0 +1,70 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <author name="Daniel Grunwald"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Text;
+using System.Xml;
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.XmlEditor;
+
+namespace XamlBinding
+{
+	/// <summary>
+	/// Description of XamlExpressionFinder.
+	/// </summary>
+	public class XamlExpressionFinder : IExpressionFinder
+	{
+		public static readonly XamlExpressionFinder Instance = new XamlExpressionFinder();
+		
+		bool IsValidChar(char c)
+		{
+			return char.IsLetterOrDigit(c) || c == '_' || c == ':' || c == '.';
+		}
+		
+		public ExpressionResult FindExpression(string text, int offset)
+		{
+			int pos = offset - 1;
+			while (pos > 0 && IsValidChar(text[pos])) {
+				pos--;
+			}
+			pos++;
+			return new ExpressionResult(text.Substring(pos, offset - pos), GetContext(text, offset));
+		}
+		
+		public ExpressionResult FindFullExpression(string text, int offset)
+		{
+			int start = offset - 1;
+			while (start > 0 && IsValidChar(text[start])) {
+				start--;
+			}
+			start++;
+			while (offset < text.Length && IsValidChar(text[offset])) {
+				offset++;
+			}
+			return new ExpressionResult(text.Substring(start, offset - start), GetContext(text, offset));
+		}
+		
+		public string RemoveLastPart(string expression)
+		{
+			return "";
+		}
+		
+		ExpressionContext GetContext(string text, int offset)
+		{
+			XmlElementPath path = XmlParser.GetActiveElementStartPathAtIndex(text, offset);
+			if (path == null || path.Elements.Count == 0)
+				return ExpressionContext.Default;
+			string attributeName = XmlParser.GetAttributeNameAtIndex(text, offset);
+			if (!string.IsNullOrEmpty(attributeName)) {
+				return new XamlExpressionContext(path, attributeName, XmlParser.IsInsideAttributeValue(text, offset));
+			} else {
+				return new XamlExpressionContext(path, null, false);
+			}
+		}
+	}
+}

src/AddIns/BackendBindings/XamlBinding/Project/Src/XamlParser.cs

@@ -51,11 +51,13 @@ namespace XamlBinding
 		public ICompilationUnit Parse(IProjectContent projectContent, string fileName, string fileContent)
 		{
 			XamlCompilationUnit cu = new XamlCompilationUnit(projectContent);
+			cu.FileName = fileName;
 			try {
 				using (XmlTextReader r = new XmlTextReader(new StringReader(fileContent))) {
+					r.WhitespaceHandling = WhitespaceHandling.Significant;
 					r.Read();
 					r.MoveToContent();
-					DomRegion classStart = new DomRegion(r.LineNumber, r.LinePosition);
+					DomRegion classStart = new DomRegion(r.LineNumber, r.LinePosition - 1);
 					string className = r.GetAttribute("Class", XamlNamespace);
 					if (string.IsNullOrEmpty(className)) {
 						LoggingService.Debug("XamlParser: returning empty cu because root element has no Class attribute");
@@ -76,8 +78,7 @@ namespace XamlBinding
 						
 						ParseXamlElement(cu, c, r);
 						if (r.NodeType == XmlNodeType.EndElement) {
-							r.Read();
+							c.Region = new DomRegion(classStart.BeginLine, classStart.BeginColumn, r.LineNumber, r.LinePosition + r.Name.Length);
-							c.Region = new DomRegion(classStart.BeginLine, classStart.BeginColumn, r.LineNumber, r.LinePosition);
 						}
 					}
 				}
@@ -90,41 +91,50 @@ namespace XamlBinding
 		
 		IReturnType TypeFromXmlNode(XamlCompilationUnit cu, XmlReader r)
 		{
-			return cu.CreateType(r.NamespaceURI, r.Name);
+			return cu.CreateType(r.NamespaceURI, r.LocalName);
 		}
 		
 		void ParseXamlElement(XamlCompilationUnit cu, DefaultClass c, XmlTextReader r)
 		{
 			Debug.Assert(r.NodeType == XmlNodeType.Element);
 			string name = r.GetAttribute("Name", XamlNamespace) ?? r.GetAttribute("Name");
+			bool isEmptyElement = r.IsEmptyElement;
+			
 			if (!string.IsNullOrEmpty(name)) {
-				DefaultField field = new DefaultField(
+				IReturnType type = TypeFromXmlNode(cu, r);
-					TypeFromXmlNode(cu, r),
+				if (!r.MoveToAttribute("Name", XamlNamespace)) {
-					name,
+					r.MoveToAttribute("Name");
-					ModifierEnum.Internal,
+				}
-					new DomRegion(r.LineNumber, r.LinePosition),
+				DomRegion position = new DomRegion(r.LineNumber, r.LinePosition, r.LineNumber, r.LinePosition + name.Length);
-					c);
+				c.Fields.Add(new DefaultField(type, name, ModifierEnum.Internal, position, c));
-				c.Fields.Add(field);
 			}
 			
-			if (r.IsEmptyElement)
+			if (isEmptyElement)
 				return;
-			do {
+			while (r.Read()) {
-				r.Read();
 				if (r.NodeType == XmlNodeType.Element) {
 					ParseXamlElement(cu, c, r);
+				} else if (r.NodeType == XmlNodeType.Comment) {
+					foreach (string tag in lexerTags) {
+						if (r.Value.Contains(tag)) {
+							cu.TagComments.Add(new TagComment(r.Value, new DomRegion(r.LineNumber, r.LinePosition, r.LineNumber, r.LinePosition + r.Value.Length)));
+							break;
+						}
+					}
+				} else if (r.NodeType == XmlNodeType.EndElement) {
+					break;
 				}
-			} while (r.NodeType != XmlNodeType.EndElement);
+			}
 		}
 		
 		public IExpressionFinder CreateExpressionFinder(string fileName)
 		{
-			throw new NotImplementedException();
+			return XamlExpressionFinder.Instance;
 		}
 		
 		public IResolver CreateResolver()
 		{
-			throw new NotImplementedException();
+			return new XamlResolver();
 		}
 	}
 }

src/AddIns/BackendBindings/XamlBinding/Project/Src/XamlResolver.cs

@@ -0,0 +1,170 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <author name="Daniel Grunwald"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.IO;
+using System.Xml;
+using System.Collections;
+using System.Collections.Generic;
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace XamlBinding
+{
+	/// <summary>
+	/// Description of XamlResolver.
+	/// </summary>
+	public class XamlResolver : IResolver
+	{
+		IClass callingClass;
+		string resolveExpression;
+		XamlExpressionContext context;
+		ParseInformation parseInfo;
+		int caretLineNumber, caretColumn;
+		
+		bool IsReaderAtTarget(XmlTextReader r)
+		{
+			if (r.LineNumber > caretLineNumber)
+				return true;
+			else if (r.LineNumber == caretLineNumber)
+				return r.LinePosition >= caretColumn;
+			else
+				return false;
+		}
+		
+		public ResolveResult Resolve(ExpressionResult expressionResult, int caretLineNumber, int caretColumn, ParseInformation parseInfo, string fileContent)
+		{
+			this.resolveExpression = expressionResult.Expression;
+			this.parseInfo = parseInfo;
+			this.caretLineNumber = caretLineNumber;
+			this.caretColumn = caretColumn;
+			this.callingClass = parseInfo.BestCompilationUnit.GetInnermostClass(caretLineNumber, caretColumn);
+			this.context = expressionResult.Context as XamlExpressionContext;
+			if (context == null)
+				return null;
+			try {
+				using (XmlTextReader r = new XmlTextReader(new StringReader(fileContent))) {
+					r.WhitespaceHandling = WhitespaceHandling.Significant;
+					// move reader to correct position
+					while (r.Read() && !IsReaderAtTarget(r)) { }
+					
+					if (string.IsNullOrEmpty(context.AttributeName)) {
+						return ResolveElementName(r);
+					} else if (context.InAttributeValue) {
+						MemberResolveResult mrr = ResolveAttribute(r, context.AttributeName);
+						if (mrr != null) {
+							return ResolveAttributeValue(mrr.ResolvedMember, resolveExpression);
+						}
+					} else {
+						// in attribute name
+						return ResolveAttribute(r, resolveExpression);
+					}
+				}
+				return null;
+			} catch (XmlException) {
+				return null;
+			}
+		}
+		
+		ResolveResult ResolveElementName(XmlReader r)
+		{
+			string xmlNamespace;
+			string name;
+			if (resolveExpression.Contains(":")) {
+				string prefix = resolveExpression.Substring(0, resolveExpression.IndexOf(':'));
+				name = resolveExpression.Substring(resolveExpression.IndexOf(':') + 1);
+				xmlNamespace = r.LookupNamespace(prefix);
+			} else {
+				xmlNamespace = r.LookupNamespace("");
+				name = resolveExpression;
+			}
+			if (name.Contains(".")) {
+				string propertyName = name.Substring(name.IndexOf('.') + 1);
+				name = name.Substring(0, name.IndexOf('.'));
+				return ResolveProperty(xmlNamespace, name, propertyName, true);
+			} else {
+				IProjectContent pc = parseInfo.BestCompilationUnit.ProjectContent;
+				IReturnType resolvedType = XamlCompilationUnit.FindType(pc, xmlNamespace, name);
+				IClass resolvedClass = resolvedType != null ? resolvedType.GetUnderlyingClass() : null;
+				if (resolvedClass != null) {
+					return new TypeResolveResult(callingClass, null, resolvedClass);
+				} else {
+					return null;
+				}
+			}
+		}
+		
+		MemberResolveResult ResolveProperty(string xmlNamespace, string className, string propertyName, bool allowAttached)
+		{
+			IProjectContent pc = parseInfo.BestCompilationUnit.ProjectContent;
+			IReturnType resolvedType = XamlCompilationUnit.FindType(pc, xmlNamespace, className);
+			if (resolvedType != null && resolvedType.GetUnderlyingClass() != null) {
+				IMember member = resolvedType.GetProperties().Find(delegate(IProperty p) { return p.Name == propertyName; });
+				if (member == null) {
+					member = resolvedType.GetEvents().Find(delegate(IEvent p) { return p.Name == propertyName; });
+				}
+				if (member == null && allowAttached) {
+					member = resolvedType.GetMethods().Find(
+						delegate(IMethod p) {
+							return p.IsStatic && p.Parameters.Count == 1 && p.Name == "Get" + propertyName;
+						});
+				}
+				if (member != null)
+					return new MemberResolveResult(callingClass, null, member);
+			}
+			return null;
+		}
+		
+		MemberResolveResult ResolveAttribute(XmlReader r, string attributeName)
+		{
+			if (context.ElementPath.Elements.Count == 0) {
+				return null;
+			}
+			string attributeXmlNamespace;
+			if (attributeName.Contains(":")) {
+				attributeXmlNamespace = r.LookupNamespace(attributeName.Substring(0, attributeName.IndexOf(':')));
+				attributeName = attributeName.Substring(attributeName.IndexOf(':') + 1);
+			} else {
+				attributeXmlNamespace = r.LookupNamespace("");
+			}
+			if (attributeName.Contains(".")) {
+				string className = attributeName.Substring(0, attributeName.IndexOf('.'));
+				attributeName = attributeName.Substring(attributeName.IndexOf('.') + 1);
+				return ResolveProperty(attributeXmlNamespace, className, attributeName, true);
+			} else {
+				ICSharpCode.XmlEditor.QualifiedName lastElement = context.ElementPath.Elements[context.ElementPath.Elements.Count - 1];
+				return ResolveProperty(lastElement.Namespace, lastElement.Name, attributeName, false);
+			}
+		}
+		
+		ResolveResult ResolveAttributeValue(IMember propertyOrEvent, string expression)
+		{
+			if (propertyOrEvent == null)
+				return null;
+			if (propertyOrEvent is IEvent) {
+				return new MethodResolveResult(callingClass, null, callingClass.DefaultReturnType, expression);
+			}
+			IReturnType type = propertyOrEvent.ReturnType;
+			if (type == null) return null;
+			IClass c = type.GetUnderlyingClass();
+			if (c == null) return null;
+			
+			if (c.ClassType == ClassType.Enum) {
+				foreach (IField f in c.Fields) {
+					if (f.Name == expression)
+						return new MemberResolveResult(callingClass, null, f);
+				}
+			}
+			return null;
+		}
+		
+		public ArrayList CtrlSpace(int caretLine, int caretColumn, ParseInformation parseInfo, string fileContent, ExpressionContext context)
+		{
+			return new ArrayList();
+		}
+	}
+}

src/AddIns/BackendBindings/XamlBinding/Project/XamlBinding.addin

@@ -11,7 +11,7 @@
 	
 	<Manifest>
 		<Identity name = "ICSharpCode.XamlBinding"/>
-		<!--<Dependency addin = "ICSharpCode.XmlEditor" requirePreload = "true"/>-->
+		<Dependency addin = "ICSharpCode.XmlEditor" requirePreload = "true"/>
 	</Manifest>
 	
 	<Runtime>

src/AddIns/BackendBindings/XamlBinding/Project/XamlBinding.csproj

@@ -49,7 +49,10 @@
     <Compile Include="Configuration\AssemblyInfo.cs" />
     <Compile Include="Src\XamlClassReturnType.cs" />
     <Compile Include="Src\XamlCompilationUnit.cs" />
+    <Compile Include="Src\XamlExpressionContext.cs" />
+    <Compile Include="Src\XamlExpressionFinder.cs" />
     <Compile Include="Src\XamlParser.cs" />
+    <Compile Include="Src\XamlResolver.cs" />
     <ProjectReference Include="..\..\..\..\Libraries\ICSharpCode.TextEditor\Project\ICSharpCode.TextEditor.csproj">
       <Project>{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D}</Project>
       <Name>ICSharpCode.TextEditor</Name>
@@ -75,5 +78,10 @@
       <Name>ICSharpCode.SharpDevelop.Dom</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\DisplayBindings\XmlEditor\Project\XmlEditor.csproj">
+      <Project>{6B717BD1-CD5E-498C-A42E-9E6A4584DC48}</Project>
+      <Name>XmlEditor</Name>
+      <Private>False</Private>
+    </ProjectReference>
   </ItemGroup>
 </Project>

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlParser.cs

@@ -266,7 +266,7 @@ namespace ICSharpCode.XmlEditor
 				// Find end of attribute name.
 				for (; index < xml.Length; ++index) {
 					char ch = xml[index];
-					if (!Char.IsLetterOrDigit(ch)) {
+					if (!IsXmlNameChar(ch)) {
 						if (ch == '\'' || ch == '\"') {
 							ignoreQuote = true;
 							ignoreEqualsSign = true;
@@ -625,7 +625,7 @@ namespace ICSharpCode.XmlEditor
 				
 				char currentChar = xml[currentIndex];
 				
-				if (Char.IsLetterOrDigit(currentChar)) {
+				if (IsXmlNameChar(currentChar)) {
 					if (!ignoreEqualsSign) {
 						ignoreWhitespace = false;
 						reversedAttributeName.Append(currentChar);

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

@@ -183,7 +183,7 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			if (member == null) {
 				textFinder = parentClass.ProjectContent.Language.GetFindClassReferencesTextFinder(parentClass);
 			} else {
-				Debug.Assert(member.DeclaringType == parentClass);
+				Debug.Assert(member.DeclaringType.GetCompoundClass() == parentClass.GetCompoundClass());
 				textFinder = parentClass.ProjectContent.Language.GetFindMemberReferencesTextFinder(member);
 			}
 			

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

@@ -37,6 +37,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// </summary>
 	public struct ExpressionResult
 	{
+		public static readonly ExpressionResult Empty = new ExpressionResult(null);
+		
 		/// <summary>The expression that has been found at the specified offset.</summary>
 		public string Expression;
 		/// <summary>Specifies the context in which the expression was found.</summary>

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/VBNet/ExpressionFinder.cs

@@ -15,7 +15,7 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 		ExpressionResult CreateResult(string expression)
 		{
 			if (expression == null)
-				return new ExpressionResult(null);
+				return ExpressionResult.Empty;
 			if (expression.Length > 8 && expression.Substring(0, 8).Equals("Imports ", StringComparison.InvariantCultureIgnoreCase))
 				return new ExpressionResult(expression.Substring(8).TrimStart(), ExpressionContext.Type, null);
 			if (expression.Length > 4 && expression.Substring(0, 4).Equals("New ", StringComparison.InvariantCultureIgnoreCase))