- added tests

- fixed build
- ran FxCop on XamlBinding and fixed some problems

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

src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/MarkupExtensionTests.cs

@@ -22,7 +22,7 @@ namespace ICSharpCode.XamlBinding.Tests
 			MarkupExtensionToken token = null;
 			var tokens = new List<MarkupExtensionToken>();
 			
-			while ((token = tokenizer.NextToken()).Kind != MarkupExtensionTokenKind.EOF)
+			while ((token = tokenizer.NextToken()).Kind != MarkupExtensionTokenKind.EndOfFile)
 				tokens.Add(token);
 			
 			Assert.AreEqual(new List<MarkupExtensionToken> {
@@ -40,7 +40,7 @@ namespace ICSharpCode.XamlBinding.Tests
 			
 			AttributeValue value = MarkupExtensionParser.ParseValue(markup);
 			
-			Assert.AreEqual("x:Type", value.ExtensionValue.Type);
+			Assert.AreEqual("x:Type", value.ExtensionValue.ExtensionType);
 			Assert.AreEqual(1, value.ExtensionValue.PositionalArguments.Count);
 			Assert.AreEqual("CheckBox", value.ExtensionValue.PositionalArguments[0].StringValue);
 		}

src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/XmlTests.cs

@@ -67,5 +67,14 @@ namespace ICSharpCode.XamlBinding.Tests
 			
 			Assert.AreEqual(true, XmlParser.IsInsideAttributeValue(xaml, offset));
 		}
+		
+		[Test]
+		public void InMarkupExtensionNamedParameterTest()
+		{
+			string xaml = "<Test val1=\"{Binding Value, Path=Control}\" />";
+			int offset = "<Test val1=\"{Binding Value, Path=".Length;
+			
+			Assert.AreEqual(true, XmlParser.IsInsideAttributeValue(xaml, offset));
+		}
 	}
 }

src/AddIns/BackendBindings/XamlBinding/XamlBinding/CompletionDataHelper.cs

@@ -297,23 +297,22 @@ namespace ICSharpCode.XamlBinding
 			}
 		}
 		
-		
+		public static IEnumerable<IInsightItem> MemberInsight(MemberResolveResult result)
-		public static IEnumerable<IInsightItem> MemberInsight(MemberResolveResult mrr)
 		{
-			switch (mrr.ResolvedType.FullyQualifiedName) {
+			switch (result.ResolvedType.FullyQualifiedName) {
 				case "System.Windows.Thickness":
-					yield return new MemberInsightItem(mrr.ResolvedMember, "left");
+					yield return new MemberInsightItem(result.ResolvedMember, "left");
-					yield return new MemberInsightItem(mrr.ResolvedMember, "left, top");
+					yield return new MemberInsightItem(result.ResolvedMember, "left, top");
-					yield return new MemberInsightItem(mrr.ResolvedMember, "left, top, right, bottom");
+					yield return new MemberInsightItem(result.ResolvedMember, "left, top, right, bottom");
 					break;
 				case "System.Windows.Size":
-					yield return new MemberInsightItem(mrr.ResolvedMember, "width, height");
+					yield return new MemberInsightItem(result.ResolvedMember, "width, height");
 					break;
 				case "System.Windows.Point":
-					yield return new MemberInsightItem(mrr.ResolvedMember, "x, y");
+					yield return new MemberInsightItem(result.ResolvedMember, "x, y");
 					break;
 				case "System.Windows.Rect":
-					yield return new MemberInsightItem(mrr.ResolvedMember, "x, y, width, height");
+					yield return new MemberInsightItem(result.ResolvedMember, "x, y, width, height");
 					break;
 			}
 		}
@@ -375,7 +374,7 @@ namespace ICSharpCode.XamlBinding
 			AttributeValue selItem = context.AttributeValue.ExtensionValue.PositionalArguments.LastOrDefault();
 			if (context.PressedKey == '.') {
 				if (selItem != null && selItem.IsString) {
-					var rr = ResolveStringValue(selItem.StringValue, list, context.Path, info, editor) as TypeResolveResult;
+					var rr = ResolveStringValue(selItem.StringValue, context.Path, info, editor) as TypeResolveResult;
 					if (rr != null)
 						list.Items.AddRange(MemberCompletion(editor, rr.ResolvedType));
 				}
@@ -383,7 +382,7 @@ namespace ICSharpCode.XamlBinding
 				if (selItem != null && selItem.IsString) {
 					int index = selItem.StringValue.IndexOf('.');
 					string s = (index > -1) ? selItem.StringValue.Substring(0, index) : selItem.StringValue;
-					var rr = ResolveStringValue(s, list, context.Path, info, editor) as TypeResolveResult;
+					var rr = ResolveStringValue(s, context.Path, info, editor) as TypeResolveResult;
 					if (rr != null) {
 						list.Items.AddRange(MemberCompletion(editor, rr.ResolvedType));
 						
@@ -410,7 +409,7 @@ namespace ICSharpCode.XamlBinding
 			}
 		}
 		
-		static ResolveResult ResolveStringValue(string value, XamlCompletionItemList list, XmlElementPath path, ParseInformation info, ITextEditor editor)
+		static ResolveResult ResolveStringValue(string value, XmlElementPath path, ParseInformation info, ITextEditor editor)
 		{
 			var resolver = new XamlResolver();
 			var rr = resolver.Resolve(new ExpressionResult(value, new XamlExpressionContext(path, string.Empty, false)), info, editor.Document.Text);

src/AddIns/BackendBindings/XamlBinding/XamlBinding/Extensions.cs

@@ -15,25 +15,34 @@ namespace ICSharpCode.XamlBinding
 {
 	public static class Extensions
 	{
-		public static string[] Split(this string s, StringSplitOptions options, params char[] delimiters)
+		public static string[] Split(this string thisValue, StringSplitOptions options, params char[] delimiters)
 		{
-			return s.Split(delimiters, options);
+			if (thisValue == null)
+				throw new ArgumentNullException("thisValue");
+			
+			return thisValue.Split(delimiters, options);
 		}
 		
-		public static bool EndsWith(this string s, StringComparison comparison, params char[] characters)
+		public static bool EndsWith(this string thisValue, StringComparison comparison, params char[] characters)
 		{
+			if (thisValue == null)
+				throw new ArgumentNullException("thisValue");
+			
 			foreach (var c in characters) {
-				if (s.EndsWith(c.ToString(), comparison))
+				if (thisValue.EndsWith(c.ToString(), comparison))
 					return true;
 			}
 			
 			return false;
 		}
 		
-		public static QualifiedName LastOrDefault(this QualifiedNameCollection coll)
+		public static QualifiedName LastOrDefault(this QualifiedNameCollection collection)
 		{
-			if (coll.Count > 0)
+			if (collection == null)
-				return coll[coll.Count - 1];
+				throw new ArgumentNullException("collection");
+			
+			if (collection.Count > 0)
+				return collection[collection.Count - 1];
 			
 			return null;
 		}

src/AddIns/BackendBindings/XamlBinding/XamlBinding/MarkupExtensionInfo.cs

@@ -57,7 +57,6 @@ namespace ICSharpCode.XamlBinding
 				throw new ArgumentNullException("value");
 			
 			this.stringValue = value;
-			this.extensionValue = null;
 		}
 		
 		public AttributeValue(MarkupExtensionInfo value)
@@ -65,7 +64,6 @@ namespace ICSharpCode.XamlBinding
 			if (value == null)
 				throw new ArgumentNullException("value");
 			
-			this.stringValue = null;
 			this.extensionValue = value;
 		}
 	}

src/AddIns/BackendBindings/XamlBinding/XamlBinding/MarkupExtensionToken.cs

@@ -11,8 +11,8 @@ namespace ICSharpCode.XamlBinding
 {
 	public sealed class MarkupExtensionToken
 	{
-		public readonly MarkupExtensionTokenKind Kind;
+		public MarkupExtensionTokenKind Kind { get; private set; }
-		public readonly string Value;
+		public string Value { get; private set; }
 		
 		public MarkupExtensionToken(MarkupExtensionTokenKind kind, string value)
 		{

src/AddIns/BackendBindings/XamlBinding/XamlBinding/Utils.cs

@@ -75,9 +75,9 @@ namespace ICSharpCode.XamlBinding
 				do {
 					LoggingService.Debug("name: " + reader.Name + " value: " + reader.Value);
 					int start = reader.Name.IndexOf(':') + 1;
-					string plainName = reader.Name.Substring(start, reader.Name.Length - start).ToLowerInvariant();
+					string plainName = reader.Name.Substring(start, reader.Name.Length - start).ToUpperInvariant();
 					
-					if (plainName == name.ToLowerInvariant())
+					if (plainName == name.ToUpperInvariant())
 						return reader.Value;
 				} while (reader.MoveToNextAttribute());
 			} catch (XmlException) { }
@@ -225,7 +225,7 @@ namespace ICSharpCode.XamlBinding
 			var list = Utils.GetXmlNamespacesForOffset(xaml, offset);
 			var item = list.FirstOrDefault(i => i.Value == CompletionDataHelper.XamlNamespace);
 			
-			if (item.Key.StartsWith("xmlns:"))
+			if (item.Key.StartsWith("xmlns:", StringComparison.OrdinalIgnoreCase))
 				return item.Key.Substring("xmlns:".Length);
 			return string.Empty;
 		}
@@ -241,11 +241,11 @@ namespace ICSharpCode.XamlBinding
 				offset = xaml.Length - 1;
 			
 			string interestingPart = xaml.Substring(0, offset);
-			int end = interestingPart.LastIndexOf("-->");
+			int end = interestingPart.LastIndexOf("-->", StringComparison.OrdinalIgnoreCase);
 			
 			interestingPart = (end > -1) ? interestingPart.Substring(end, interestingPart.Length - end) : interestingPart;
 			
-			return interestingPart.LastIndexOf("<!--") != -1;
+			return interestingPart.LastIndexOf("<!--", StringComparison.OrdinalIgnoreCase) != -1;
 		}
 	}
 }

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlCodeCompletionBinding.cs

@@ -31,8 +31,6 @@ namespace ICSharpCode.XamlBinding
 		
 		public CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
 		{
-			XamlResolver resolver = new XamlResolver();
-			XamlParser parser = new XamlParser();
 			ParseInformation info = ParserService.GetParseInformation(editor.FileName);
 			
 			XamlContext context = CompletionDataHelper.ResolveContext(editor, ch);
@@ -108,26 +106,15 @@ namespace ICSharpCode.XamlBinding
 					}
 					break;
 				default:
-					char c = char.IsWhiteSpace(ch) ? ch : editor.Document.GetCharAt(editor.Caret.Offset - 1);
+					editor.Document.Insert(editor.Caret.Offset, ch.ToString());
-					
+					this.CtrlSpace(editor);
-					if (!string.IsNullOrEmpty(context.AttributeName)) {
+					return CodeCompletionKeyPressResult.EatKey;
-						if (DoMarkupExtensionCompletion(editor, info, context))
-							return CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion;
-					} else if (context.Path != null && (c == ' ' || c == '\t')) {
-						list = CompletionDataHelper.CreateListForContext(editor, context);
-						editor.ShowCompletionWindow(list);
-						if (ch == ' ' || ch == '\t')
-							return CodeCompletionKeyPressResult.Completed;
-						else
-							return CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion;
-					}
-					break;
 			}
 			
 			return CodeCompletionKeyPressResult.None;
 		}
 		
-		bool DoXmlTagCompletion(ITextEditor editor)
+		static bool DoXmlTagCompletion(ITextEditor editor)
 		{
 			int offset = editor.Caret.Offset;
 			if (offset > 0) {
@@ -162,25 +149,17 @@ namespace ICSharpCode.XamlBinding
 			if (context.Path != null) {
 				if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset)) {
 					var list = CompletionDataHelper.CreateListForContext(editor, context) as XamlCompletionItemList;
-					string starter = editor.GetWordBeforeCaret();
+					string starter = editor.GetWordBeforeCaret().Trim('<');
 					if (!string.IsNullOrEmpty(starter) && !starter.EndsWith(StringComparison.Ordinal, ' ', '\t', '\n', '\r'))
 						list.PreselectionLength = starter.Length;
 					editor.ShowCompletionWindow(list);
 					return true;
 				} else {
-					// DO NOT USE CompletionDataHelper.CreateListForContext here!!! might result in endless recursion!!!!
+					// DO NOT USE CompletionDataHelper.CreateListForContext here!!! might result in endless recursion!!!!					
-					string attribute = XmlParser.GetAttributeNameAtIndex(editor.Document.Text, editor.Caret.Offset);
+					if (!string.IsNullOrEmpty(context.AttributeName)) {						
-					string attribValue = XmlParser.GetAttributeValueAtIndex(editor.Document.Text, editor.Caret.Offset);
-					int offsetFromValueStart = Utils.GetOffsetFromValueStart(editor.Document.Text, editor.Caret.Offset);
-					
-					if (!string.IsNullOrEmpty(attribute)) {
-						string interestingPart = attribValue.Substring(0, offsetFromValueStart);
-						
-						AttributeValue value = MarkupExtensionParser.ParseValue(interestingPart);
-						
 						if (!DoMarkupExtensionCompletion(editor, info, context)) {
 							XamlResolver resolver = new XamlResolver();
-							var mrr = resolver.Resolve(new ExpressionResult(attribute, new XamlExpressionContext(context.Path, attribute, false)),
+							var mrr = resolver.Resolve(new ExpressionResult(context.AttributeName, new XamlExpressionContext(context.Path, context.AttributeName, false)),
 							                           info, editor.Document.Text) as MemberResolveResult;
 							if (mrr != null && mrr.ResolvedType != null) {
 								var c = mrr.ResolvedType.GetUnderlyingClass();
@@ -196,13 +175,13 @@ namespace ICSharpCode.XamlBinding
 			return false;
 		}
 
-		bool DoMarkupExtensionCompletion(ITextEditor editor, ParseInformation info, XamlContext context)
+		static bool DoMarkupExtensionCompletion(ITextEditor editor, ParseInformation info, XamlContext context)
 		{
 			if (context.AttributeValue != null && !context.AttributeValue.IsString) {
 				var completionList = CompletionDataHelper.CreateMarkupExtensionCompletion(context, info, editor);
 				editor.ShowCompletionWindow(completionList);
 				var insightList = CompletionDataHelper.CreateMarkupExtensionInsight(context, info, editor);
-				editor.ShowInsightWindow(insightList);
+				//editor.ShowInsightWindow(insightList);
 				return true;
 			}
 			

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

@@ -73,7 +73,7 @@ namespace ICSharpCode.XamlBinding
 				throw new ArgumentNullException("pc");
 			if (xmlNamespace == null || className == null)
 				return null;
-			if (xmlNamespace.StartsWith("clr-namespace:")) {
+			if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase)) {
 				return CreateClrNamespaceType(pc, xmlNamespace, className);
 			}
 			else {
@@ -111,7 +111,7 @@ namespace ICSharpCode.XamlBinding
 				throw new ArgumentNullException("pc");
 			
 			if (!string.IsNullOrEmpty(xmlNamespace)) {
-				if (xmlNamespace.StartsWith("clr-namespace:"))
+				if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase))
 					return pc.GetNamespaceContents(GetNamespaceNameFromClrNamespace(xmlNamespace)).OfType<IClass>();
 				else {
 					var list = new ArrayList();

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlCompletionItemList.cs

@@ -40,8 +40,10 @@ namespace ICSharpCode.XamlBinding
 				
 				if (cItem.Entity is IProperty || cItem.Entity is IEvent) {
 					if (context.Editor.Document.GetCharAt(context.StartOffset - 1) != '.') {
-						context.Editor.Document.Insert(context.EndOffset, "=\"\"");
+						if (!item.Text.EndsWith("=", StringComparison.OrdinalIgnoreCase)) {
-						context.Editor.Caret.Offset--;
+							context.Editor.Document.Insert(context.EndOffset, "=\"\"");
+							context.Editor.Caret.Offset--;
+						}
 						
 						XamlCodeCompletionBinding.Instance.CtrlSpace(context.Editor);
 					}
@@ -84,7 +86,7 @@ namespace ICSharpCode.XamlBinding
 			}
 		}
 		
-		void CreateEventHandlerCode(CompletionContext context, NewEventCompletionItem completionItem)
+		static void CreateEventHandlerCode(CompletionContext context, NewEventCompletionItem completionItem)
 		{
 			ParseInformation p = ParserService.GetParseInformation(context.Editor.FileName);
 			var unit = p.MostRecentCompilationUnit;
@@ -112,7 +114,7 @@ namespace ICSharpCode.XamlBinding
 					ParametrizedNode node = CodeGenerator.ConvertMember(method, new ClassFinder(part, context.Editor.Caret.Line, context.Editor.Caret.Column));
 					
 					node.Name = completionItem.HandlerName;
-										
+					
 					node.Modifier = Modifiers.None;
 					
 					IViewContent viewContent = FileService.OpenFile(part.CompilationUnit.FileName);

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

@@ -19,9 +19,9 @@ namespace ICSharpCode.XamlBinding
 	{
 		public static readonly XamlExpressionContext Empty = new XamlExpressionContext(new XmlElementPath(), null, false);
 
-		public readonly XmlElementPath ElementPath;
+		public XmlElementPath ElementPath { get; private set; }
-		public readonly string AttributeName;
+		public string AttributeName { get; private set; }
-		public readonly bool InAttributeValue;
+		public bool InAttributeValue { get; private set; }
 
 		public XamlExpressionContext(XmlElementPath elementPath, string attributeName, bool inAttributeValue)
 		{