Merge remote-tracking branch 'upstream/master' into mansheng

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -336,7 +336,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 							endIndex - startIndex - 2
 						) : null;
 						if (!string.IsNullOrEmpty(tag) && commentTags.IndexOf(tag) >= 0) {
-							document.Insert(offset, "</" + tag + ">");
+							document.Insert(offset, "</" + tag + ">", AnchorMovementType.BeforeInsertion);
 						}
 					}
 					return null;
@@ -1226,7 +1226,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				if (currentMember != null || node is Expression) {
 					AddKeywords(wrapper, statementStartKeywords);
 					AddKeywords(wrapper, expressionLevelKeywords);
-					if (node is TypeDeclaration)
+					if (node == null || node is TypeDeclaration)
 						AddKeywords(wrapper, typeLevelKeywords);
 				} else if (currentType != null) {
 					AddKeywords(wrapper, typeLevelKeywords);
@@ -2853,9 +2853,54 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				"value"
 			}
 			);
-		
+
+		string GetLastClosingXmlCommentTag ()
+		{
+			var line = document.GetLineByNumber(location.Line);
+
+		restart:
+			string lineText = document.GetText(line);
+			if (!lineText.Trim ().StartsWith ("///"))
+				return null;
+			int startIndex = Math.Min(location.Column - 1, lineText.Length - 1) - 1;
+			while (startIndex > 0 && lineText [startIndex] != '<') {
+				--startIndex;
+				if (lineText [startIndex] == '/') {
+					// already closed.
+					startIndex = -1;
+					break;
+				}
+			}
+			if (startIndex < 0 && line.PreviousLine != null) {
+				line = line.PreviousLine;
+				goto restart;
+			}
+
+			if (startIndex >= 0) {
+				int endIndex = startIndex;
+				while (endIndex + 1 < lineText.Length && lineText [endIndex] != '>' && !Char.IsWhiteSpace (lineText [endIndex + 1])) {
+					endIndex++;
+				}
+				string tag = endIndex - startIndex - 1 > 0 ? lineText.Substring(
+					startIndex + 1,
+					endIndex - startIndex - 1
+				) : null;
+				if (!string.IsNullOrEmpty(tag) && commentTags.IndexOf(tag) >= 0) {
+					return tag;
+				}
+			}
+			return null;
+		}
+
 		IEnumerable<ICompletionData> GetXmlDocumentationCompletionData()
 		{
+			var closingTag = GetLastClosingXmlCommentTag ();
+			if (closingTag != null) {
+				yield return factory.CreateLiteralCompletionData(
+					"/" + closingTag + ">"
+				);
+			}
+
 			yield return factory.CreateLiteralCompletionData(
 				"c",
 				"Set text in a code-like font"
@@ -2952,6 +2997,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				"value",
 				"Describe a property"
 			);
+
 		}
 		#endregion
 		

ICSharpCode.NRefactory.CSharp/Resolver/CSharpAstResolver.cs

@@ -275,7 +275,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 				return true;
 			}
-			return (node.NodeType == NodeType.Whitespace || node is ArraySpecifier || node is NamedArgumentExpression);
+			return (node.NodeType == NodeType.Whitespace || node is ArraySpecifier || node is NamedArgumentExpression || node is ArrayInitializerExpression);
 		}
 	}
 }

ICSharpCode.NRefactory.CSharp/Resolver/CSharpConversions.cs

@@ -234,6 +234,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (ExplicitEnumerationConversion(fromType, toType))
 				return Conversion.EnumerationConversion(false, false);
 			Conversion c = ExplicitNullableConversion(fromType, toType);
+			if (c.IsValid)
+				return c;
+			c = UserDefinedExplicitConversion(fromType, toType);
 			if (c.IsValid)
 				return c;
 			if (ExplicitReferenceConversion(fromType, toType))
@@ -247,7 +250,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 			if (ExplicitPointerConversion(fromType, toType))
 				return Conversion.ExplicitPointerConversion;
-			return UserDefinedExplicitConversion(fromType, toType);
+			return Conversion.None;
 		}
 		#endregion
 		

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -850,15 +850,21 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						resolver.CurrentTypeResolveContext, propertyOrIndexerDeclaration.EntityType, name,
 						explicitInterfaceType, parameterTypeReferences: parameterTypeReferences);
 				}
-				resolver = resolver.WithCurrentMember(member);
 				
 				for (AstNode node = propertyOrIndexerDeclaration.FirstChild; node != null; node = node.NextSibling) {
-					if (node.Role == PropertyDeclaration.SetterRole && member != null) {
+					if (node.Role == PropertyDeclaration.GetterRole && member is IProperty) {
 						resolver = resolver.PushBlock();
-						resolver = resolver.AddVariable(new DefaultParameter(member.ReturnType, "value"));
+						resolver = resolver.WithCurrentMember(((IProperty)member).Getter);
 						Scan(node);
 						resolver = resolver.PopBlock();
-					} else {
+					}
+					else if (node.Role == PropertyDeclaration.SetterRole && member is IProperty) {
+						resolver = resolver.PushBlock();
+						resolver = resolver.WithCurrentMember(((IProperty)member).Setter);
+						Scan(node);
+						resolver = resolver.PopBlock();
+					}
+					else {
 						Scan(node);
 					}
 				}
@@ -898,16 +904,25 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						                                          explicitInterfaceAstType.ToTypeReference());
 					}
 				}
-				resolver = resolver.WithCurrentMember(member);
-				
-				if (member != null) {
-					resolver = resolver.PushBlock();
-					resolver = resolver.AddVariable(new DefaultParameter(member.ReturnType, "value"));
-					ScanChildren(eventDeclaration);
-				} else {
-					ScanChildren(eventDeclaration);
+
+				for (AstNode node = eventDeclaration.FirstChild; node != null; node = node.NextSibling) {
+					if (node.Role == CustomEventDeclaration.AddAccessorRole && member is IEvent) {
+						resolver = resolver.PushBlock();
+						resolver = resolver.WithCurrentMember(((IEvent)member).AddAccessor);
+						Scan(node);
+						resolver = resolver.PopBlock();
+					}
+					else if (node.Role == CustomEventDeclaration.RemoveAccessorRole && member is IEvent) {
+						resolver = resolver.PushBlock();
+						resolver = resolver.WithCurrentMember(((IEvent)member).RemoveAccessor);
+						Scan(node);
+						resolver = resolver.PopBlock();
+					}
+					else {
+						Scan(node);
+					}
 				}
-				
+
 				if (member != null)
 					return new MemberResolveResult(null, member, false);
 				else

ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/DocumentationContextTests.cs

@@ -0,0 +1,74 @@
+//
+// DocumentationContextTests.cs
+//
+// Author:
+//       Mike Krüger <mkrueger@xamarin.com>
+//
+// Copyright (c) 2012 Xamarin Inc. (http://xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
+{
+	[TestFixture()]
+	public class DocumentationContextTests
+	{
+		[Test()]
+		public void TestClosingTag()
+		{
+			CodeCompletionBugTests.CombinedProviderTest(
+@"using System;
+
+public class Test
+{
+	///<summary>Foo$<$
+	void TestFoo()
+	{
+	}
+}
+", provider => {
+				Assert.IsNotNull(provider.Find("/summary>"));
+			});
+		}
+
+		[Test()]
+		public void TestClosingTagMultiLine()
+		{
+			CodeCompletionBugTests.CombinedProviderTest(
+@"using System;
+
+public class Test
+{
+	///<summary>
+	///Foo
+	///$<$
+	void TestFoo()
+	{
+	}
+}
+", provider => {
+				Assert.IsNotNull(provider.Find("/summary>"));
+			});
+		}
+	}
+}
+

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs

@@ -33,15 +33,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	using C = Conversion;
 	
 	[TestFixture]
-	public unsafe class ConversionsTest
+	public unsafe class ConversionsTest : ResolverTestBase
 	{
-		ICompilation compilation;
 		CSharpConversions conversions;
 		
-		[SetUp]
-		public void SetUp()
+		public override void SetUp()
 		{
-			compilation = new SimpleCompilation(CecilLoaderTests.Mscorlib);
+			base.SetUp();
 			conversions = new CSharpConversions(compilation);
 		}
 		
@@ -512,5 +510,24 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			IType type2 = new ParameterizedType(resolvedA, new [] { new ParameterizedType(resolvedB, new[] { compilation.FindType(KnownTypeCode.String) }) });
 			Assert.IsFalse(conversions.ImplicitConversion(type1, type2).IsValid);
 		}
+
+		[Test]
+		public void ExplicitUserDefinedConversion() {
+			var rr = Resolve<ConversionResolveResult>(@"
+class C1 {}
+class C2 {
+	public static explicit operator C1(C2 c2) {
+		return null;
+	}
+}
+class C {
+	public void M() {
+		var c2 = new C2();
+		C1 c1 = $(C1)c2$;
+	}
+}");
+			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.AreEqual("op_Explicit", rr.Conversion.Method.Name);
+		}
 	}
 }

ICSharpCode.NRefactory.Tests/CSharp/Resolver/MethodTests.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using ICSharpCode.NRefactory.Semantics;
+using ICSharpCode.NRefactory.TypeSystem;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver {
+	[TestFixture]
+	public class MethodTests : ResolverTestBase {
+		[Test]
+		public void ParameterIdentityInNormalMethod()
+		{
+			string code = @"using System;
+class TestClass {
+	$int F(int i, int j) {
+		return i + j;
+	}$
+}";
+			
+			var prep = PrepareResolver(code);
+			var md = (MethodDeclaration)prep.Item2;
+
+			var resolver = prep.Item1;
+			var method = (IMethod)((MemberResolveResult)resolver.Resolve(md)).Member;
+			IVariable i1 = method.Parameters.Single(p => p.Name == "i");
+			IVariable j1 = method.Parameters.Single(p => p.Name == "j");
+
+			var returnExpr = (BinaryOperatorExpression)md.Body.Children.OfType<ReturnStatement>().Single().Expression;
+			var returnRR = (OperatorResolveResult)resolver.Resolve(returnExpr);
+
+			IVariable i2 = ((LocalResolveResult)returnRR.Operands[0]).Variable;
+			IVariable j2 = ((LocalResolveResult)returnRR.Operands[1]).Variable;
+
+			Assert.IsTrue(ReferenceEquals(i1, i2));
+			Assert.IsTrue(ReferenceEquals(i1, i2));
+		}
+
+		[Test]
+		public void ParameterIdentityInPropertySetter()
+		{
+			string code = @"using System;
+class TestClass {
+	int myField;
+	$int Prop {
+		get { return myField; }
+		set { myField = value; }
+	}$
+}";
+			
+			var prep = PrepareResolver(code);
+			var pd = (PropertyDeclaration)prep.Item2;
+
+			var resolver = prep.Item1;
+			var property = (IProperty)((MemberResolveResult)resolver.Resolve(pd)).Member;
+			IVariable value1 = property.Setter.Parameters.Single(p => p.Name == "value");
+
+			var assignExpr = (AssignmentExpression)pd.Setter.Body.Children.OfType<ExpressionStatement>().Single().Expression;
+			var assignRR = (OperatorResolveResult)resolver.Resolve(assignExpr);
+
+			IVariable value2 = ((LocalResolveResult)assignRR.Operands[1]).Variable;
+
+			Assert.IsTrue(ReferenceEquals(value1, value2));
+		}
+
+		[Test]
+		public void ParameterIdentityInIndexerGetter()
+		{
+			string code = @"using System;
+class TestClass {
+	int[,] myField;
+	$int this[int i, int j] {
+		get { return myField[i, j]; }
+		set { myField[i, j] = value; }
+	}$
+}";
+			
+			var prep = PrepareResolver(code);
+			var id = (IndexerDeclaration)prep.Item2;
+
+			var resolver = prep.Item1;
+			var property = (IProperty)((MemberResolveResult)resolver.Resolve(id)).Member;
+			IVariable i1 = property.Getter.Parameters.Single(p => p.Name == "i");
+			IVariable j1 = property.Getter.Parameters.Single(p => p.Name == "j");
+
+			var accessExpr = (IndexerExpression)id.Getter.Body.Children.OfType<ReturnStatement>().Single().Expression;
+			var accessRR = (ArrayAccessResolveResult)resolver.Resolve(accessExpr);
+			IVariable i2 = ((LocalResolveResult)accessRR.Indexes[0]).Variable;
+			IVariable j2 = ((LocalResolveResult)accessRR.Indexes[1]).Variable;
+
+			Assert.IsTrue(ReferenceEquals(i1, i2));
+			Assert.IsTrue(ReferenceEquals(j1, j2));
+		}
+
+		[Test]
+		public void ParameterIdentityInIndexerSetter()
+		{
+			string code = @"using System;
+class TestClass {
+	int[,] myField;
+	$int this[int i, int j] {
+		get { return myField[i, j]; }
+		set { myField[i, j] = value; }
+	}$
+}";
+			
+			var prep = PrepareResolver(code);
+			var id = (IndexerDeclaration)prep.Item2;
+
+			var resolver = prep.Item1;
+			var property = (IProperty)((MemberResolveResult)resolver.Resolve(id)).Member;
+			IVariable i1 = property.Setter.Parameters.Single(p => p.Name == "i");
+			IVariable j1 = property.Setter.Parameters.Single(p => p.Name == "j");
+			IVariable value1 = property.Setter.Parameters.Single(p => p.Name == "value");
+
+			var assignExpr = (AssignmentExpression)id.Setter.Body.Children.OfType<ExpressionStatement>().Single().Expression;
+			var assignRR = (OperatorResolveResult)resolver.Resolve(assignExpr);
+			var accessRR = (ArrayAccessResolveResult)assignRR.Operands[0];
+			IVariable i2 = ((LocalResolveResult)accessRR.Indexes[0]).Variable;
+			IVariable j2 = ((LocalResolveResult)accessRR.Indexes[1]).Variable;
+			IVariable value2 = ((LocalResolveResult)assignRR.Operands[1]).Variable;
+
+			Assert.IsTrue(ReferenceEquals(i1, i2));
+			Assert.IsTrue(ReferenceEquals(j1, j2));
+			Assert.IsTrue(ReferenceEquals(value1, value2));
+		}
+
+		[Test]
+		public void ParameterIdentityInEventAdder()
+		{
+			string code = @"using System;
+class TestClass {
+	EventHandler myField;
+	$event EventHandler Evt {
+		add { myField += value; }
+		remove { myField -= value; }
+	}$
+}";
+			
+			var prep = PrepareResolver(code);
+			var ed = (CustomEventDeclaration)prep.Item2;
+
+			var resolver = prep.Item1;
+			var evt = (IEvent)((MemberResolveResult)resolver.Resolve(ed)).Member;
+			IVariable value1 = evt.AddAccessor.Parameters.Single(p => p.Name == "value");
+
+			var assignExpr = (AssignmentExpression)ed.AddAccessor.Body.Children.OfType<ExpressionStatement>().Single().Expression;
+			var assignRR = (OperatorResolveResult)resolver.Resolve(assignExpr);
+
+			IVariable value2 = ((LocalResolveResult)assignRR.Operands[1]).Variable;
+
+			Assert.IsTrue(ReferenceEquals(value1, value2));
+		}
+
+		[Test]
+		public void ParameterIdentityInEventRemover()
+		{
+			string code = @"using System;
+class TestClass {
+	EventHandler myField;
+	$event EventHandler Evt {
+		add { myField += value; }
+		remove { myField -= value; }
+	}$
+}";
+			
+			var prep = PrepareResolver(code);
+			var ed = (CustomEventDeclaration)prep.Item2;
+
+			var resolver = prep.Item1;
+			var evt = (IEvent)((MemberResolveResult)resolver.Resolve(ed)).Member;
+			IVariable value1 = evt.RemoveAccessor.Parameters.Single(p => p.Name == "value");
+
+			var assignExpr = (AssignmentExpression)ed.RemoveAccessor.Body.Children.OfType<ExpressionStatement>().Single().Expression;
+			var assignRR = (OperatorResolveResult)resolver.Resolve(assignExpr);
+
+			IVariable value2 = ((LocalResolveResult)assignRR.Operands[1]).Variable;
+
+			Assert.IsTrue(ReferenceEquals(value1, value2));
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj

@@ -188,6 +188,7 @@
     <Compile Include="CSharp\Resolver\LinqTests.cs" />
     <Compile Include="CSharp\Resolver\LocalTypeInferenceTests.cs" />
     <Compile Include="CSharp\Resolver\MemberLookupTests.cs" />
+    <Compile Include="CSharp\Resolver\MethodTests.cs" />
     <Compile Include="CSharp\Resolver\NameLookupTests.cs" />
     <Compile Include="CSharp\Resolver\ObjectCreationTests.cs" />
     <Compile Include="CSharp\Resolver\ResolveAtLocationTests.cs" />
@@ -292,6 +293,7 @@
     <Compile Include="CSharp\CodeActions\ImplementInterfaceExplicitTests.cs" />
     <Compile Include="CSharp\CodeActions\ImplementAbstractMembersTest.cs" />
     <Compile Include="CSharp\CodeActions\ExtractFieldTests.cs" />
+    <Compile Include="CSharp\CodeCompletion\DocumentationContextTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\Mono.Cecil\Mono.Cecil.csproj">

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs

@@ -131,7 +131,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 					result = (
 						from part in parts
 						from nestedTypeRef in part.NestedTypes
-						group nestedTypeRef by nestedTypeRef.Name into g
+						group nestedTypeRef by new { nestedTypeRef.Name, nestedTypeRef.TypeParameters.Count } into g
 						select new DefaultResolvedTypeDefinition(new SimpleTypeResolveContext(this), g.ToArray())
 					).ToList<ITypeDefinition>().AsReadOnly();
 					return LazyInit.GetOrSet(ref this.nestedTypes, result);