TypeSystemAstBuilder: do not specify accessibility on accessors unless necessary.

Ported some SD4 unit tests to NR5.

ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs

@@ -3822,7 +3822,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		public IEnumerable<Statement> ParseStatements (TextReader reader, int lineModifier = 0)
 		{
-			string code = "void M() { " + Environment.NewLine + reader.ReadToEnd () + "}";
+			// the dummy method is async so that 'await' expressions are parsed as expected
+			string code = "async void M() { " + Environment.NewLine + reader.ReadToEnd () + "}";
 			var members = ParseTypeMembers (new StringReader (code), lineModifier - 1);
 			var method = members.FirstOrDefault () as MethodDeclaration;
 			if (method != null && method.Body != null) {

ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs

@@ -593,12 +593,13 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			}
 		}
 		
-		Accessor ConvertAccessor(IMethod accessor)
+		Accessor ConvertAccessor(IMethod accessor, Accessibility ownerAccessibility)
 		{
 			if (accessor == null)
 				return Accessor.Null;
 			Accessor decl = new Accessor();
-			decl.Modifiers = ModifierFromAccessibility(accessor.Accessibility);
+			if (accessor.Accessibility != ownerAccessibility)
+				decl.Modifiers = ModifierFromAccessibility(accessor.Accessibility);
 			decl.Body = GenerateBodyBlock();
 			return decl;
 		}
@@ -609,8 +610,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			decl.Modifiers = GetMemberModifiers(property);
 			decl.ReturnType = ConvertType(property.ReturnType);
 			decl.Name = property.Name;
-			decl.Getter = ConvertAccessor(property.Getter);
-			decl.Setter = ConvertAccessor(property.Setter);
+			decl.Getter = ConvertAccessor(property.Getter, property.Accessibility);
+			decl.Setter = ConvertAccessor(property.Setter, property.Accessibility);
 			return decl;
 		}
 		
@@ -622,8 +623,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			foreach (IParameter p in indexer.Parameters) {
 				decl.Parameters.Add(ConvertParameter(p));
 			}
-			decl.Getter = ConvertAccessor(indexer.Getter);
-			decl.Setter = ConvertAccessor(indexer.Setter);
+			decl.Getter = ConvertAccessor(indexer.Getter, indexer.Accessibility);
+			decl.Setter = ConvertAccessor(indexer.Setter, indexer.Accessibility);
 			return decl;
 		}
 		
@@ -634,8 +635,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				decl.Modifiers = GetMemberModifiers(ev);
 				decl.ReturnType = ConvertType(ev.ReturnType);
 				decl.Name = ev.Name;
-				decl.AddAccessor    = ConvertAccessor(ev.AddAccessor);
-				decl.RemoveAccessor = ConvertAccessor(ev.RemoveAccessor);
+				decl.AddAccessor    = ConvertAccessor(ev.AddAccessor, ev.Accessibility);
+				decl.RemoveAccessor = ConvertAccessor(ev.RemoveAccessor, ev.Accessibility);
 				return decl;
 			} else {
 				EventDeclaration decl = new EventDeclaration();

ICSharpCode.NRefactory.Tests/CSharp/CodeActions/ImplementInterfaceExplicitTests.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // ImplementInterfaceExplicitTests.cs
 //  
 // Author:
@@ -49,6 +49,33 @@ class Foo : IDisposable
 	}
 	#endregion
 }
+");
+		}
+		
+		[Test]
+		public void NestedInterfaceInGenericClass()
+		{
+			Test<ImplementInterfaceExplicitAction>(@"using System;
+class TestClass<T> {
+	public interface INestedInterface { T Prop { get; } }
+}
+class TargetClass : TestClass<string>.$INestedInterface
+{
+}
+", @"using System;
+class TestClass<T> {
+	public interface INestedInterface { T Prop { get; } }
+}
+class TargetClass : TestClass<string>.INestedInterface
+{
+	#region INestedInterface implementation
+	string TestClass<string>.INestedInterface.Prop {
+		get {
+			throw new NotImplementedException ();
+		}
+	}
+	#endregion
+}
 ");
 		}
 	}

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PrimitiveExpressionTests.cs

@@ -236,6 +236,14 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 			Assert.AreEqual("0", pe.LiteralValue);
 		}
 		
+		[Test]
+		public void InvalidUnicodeEscapeSequence()
+		{
+			string code = @"""\u{0}""";
+			var pe = ParseUtilCSharp.ParseExpression<PrimitiveExpression>(code, expectErrors: true);
+			Assert.AreEqual(code, pe.LiteralValue);
+		}
+		
 		[Test]
 		[Ignore("Mono parser crash")]
 		public void LargeVerbatimString()

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/UnaryOperatorExpressionTests.cs

@@ -134,5 +134,22 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 			UnaryOperatorExpression adrOf = (UnaryOperatorExpression)ce.Expression;
 			Assert.AreEqual(UnaryOperatorType.AddressOf, adrOf.Operator);
 		}
+		
+		[Test]
+		public void AwaitStaticMethodCall()
+		{
+			var uoe = ParseUtilCSharp.ParseExpression<UnaryOperatorExpression>("await Task.WhenAll(a, b)");
+			Assert.AreEqual(UnaryOperatorType.Await, uoe.Operator);
+			Assert.IsInstanceOf<InvocationExpression>(uoe.Expression);
+		}
+		
+		[Test]
+		public void AwaitStaticMethodCallStatement()
+		{
+			var es = ParseUtilCSharp.ParseStatement<ExpressionStatement>("await Task.WhenAll(a, b);");
+			UnaryOperatorExpression uoe = (UnaryOperatorExpression)es.Expression;
+			Assert.AreEqual(UnaryOperatorType.Await, uoe.Operator);
+			Assert.IsInstanceOf<InvocationExpression>(uoe.Expression);
+		}
 	}
 }

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/MethodDeclarationTests.cs

@@ -332,6 +332,19 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
 			Assert.IsTrue(md.IsExtensionMethod);
 		}
 		
+		[Test]
+		public void ExtensionMethodWithAttributeTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"public static int ToInt32([Attr] this string s) { return int.Parse(s); }"
+			);
+			Assert.AreEqual("ToInt32", md.Name);
+			Assert.IsTrue(md.IsExtensionMethod);
+			Assert.AreEqual("s", md.Parameters.Single().Name);
+			Assert.AreEqual(KnownTypeCode.String, ((PrimitiveType)md.Parameters.Single().Type).KnownTypeCode);
+			Assert.AreEqual(1, md.Parameters.Single().Attributes.Count);
+		}
+		
 		[Test]
 		public void VoidExtensionMethodTest()
 		{

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

@@ -587,5 +587,53 @@ class TestClass {
 			Assert.AreSame(resolvedParameter, parameterInResolveResult);
 			Assert.AreSame(resolvedParameter, referencedParameter);
 		}
+		
+		[Test]
+		public void MultipleOverloadsWithImplicitLambda()
+		{
+			string program = @"class MainClass {
+	void Main() {
+		$M(x=>x.ToUpper())$;
+	}
+	delegate R Func<T, R>(T arg);
+	int M(Func<int, int> f){ }
+	string M(Func<string, string> f){ }
+}";
+			var mrr = Resolve<CSharpInvocationResolveResult>(program);
+			Assert.IsFalse(mrr.IsError);
+			Assert.AreEqual("System.String", mrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void MultipleOverloadsWithImplicitLambda2()
+		{
+			string program = @"class MainClass {
+	void Main() {
+		$M(x=>x.Length)$;
+	}
+	delegate R Func<T, R>(T arg);
+	int M(Func<int, int> f){ }
+	string M(Func<string, int> f){ }
+}";
+			var mrr = Resolve<CSharpInvocationResolveResult>(program);
+			Assert.IsFalse(mrr.IsError);
+			Assert.AreEqual("System.String", mrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void MultipleOverloadsWithImplicitLambda3()
+		{
+			string program = @"class MainClass {
+	void Main() {
+		$M(x=>x+x)$;
+	}
+	delegate R Func<T, R>(T arg);
+	string M(Func<string, int> f){ }
+	int M(Func<int, int> f){ }
+}";
+			var mrr = Resolve<CSharpInvocationResolveResult>(program);
+			Assert.IsFalse(mrr.IsError);
+			Assert.AreEqual("System.Int32", mrr.Type.ReflectionName);
+		}
 	}
 }

ICSharpCode.NRefactory.Tests/Documentation/CSharpDocumentationTests.cs

@@ -137,5 +137,37 @@ class Base {
 			Assert.AreEqual("Overridden summary", element.Children[0].TextContent);
 			Assert.AreEqual("Base remarks", element.Children[1].TextContent);
 		}
+		
+		[Test]
+		public void DocumentationAboveAttribute()
+		{
+			Init(@"using System;
+/// <summary/>
+[SomeAttribute]
+class Test { }");
+			Assert.AreEqual("<summary/>", typeDefinition.Documentation.ToString());
+		}
+		
+		[Test]
+		public void DocumentationAboveAttribute2()
+		{
+			Init(@"using System;
+/// <summary/>
+[SomeAttribute] // a comment on the attribute
+class Test { }");
+			Assert.AreEqual("<summary/>", typeDefinition.Documentation.ToString());
+		}
+		
+		[Test]
+		public void DocumentationAboveAttributeInRegion()
+		{
+			Init(@"using System;
+/// <summary/>
+#region R
+[SomeAttribute]
+#endregion
+class Test { }");
+			Assert.AreEqual("<summary/>", typeDefinition.Documentation.ToString());
+		}
 	}
 }

ICSharpCode.NRefactory.Tests/Editor/ReadOnlyDocumentTests.cs

@@ -0,0 +1,75 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team
+// 
+// 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.Editor
+{
+	[TestFixture]
+	public class ReadOnlyDocumentTests
+	{
+		[Test]
+		public void EmptyReadOnlyDocument()
+		{
+			IDocument document = new ReadOnlyDocument(string.Empty);
+			Assert.AreEqual(string.Empty, document.Text);
+			Assert.AreEqual(0, document.TextLength);
+			Assert.AreEqual(1, document.LineCount);
+			Assert.AreEqual(0, document.GetOffset(1, 1));
+			Assert.AreEqual(new TextLocation(1, 1), document.GetLocation(0));
+			
+			Assert.AreEqual(0, document.GetLineByNumber(1).Offset);
+			Assert.AreEqual(0, document.GetLineByNumber(1).EndOffset);
+			Assert.AreEqual(0, document.GetLineByNumber(1).Length);
+			Assert.AreEqual(0, document.GetLineByNumber(1).TotalLength);
+			Assert.AreEqual(0, document.GetLineByNumber(1).DelimiterLength);
+			Assert.AreEqual(1, document.GetLineByNumber(1).LineNumber);
+		}
+		
+		[Test]
+		public void SimpleDocument()
+		{
+			string text = "Hello\nWorld!\r\n";
+			IDocument document = new ReadOnlyDocument(text);
+			Assert.AreEqual(text, document.Text);
+			Assert.AreEqual(3, document.LineCount);
+			
+			Assert.AreEqual(0, document.GetLineByNumber(1).Offset);
+			Assert.AreEqual(5, document.GetLineByNumber(1).EndOffset);
+			Assert.AreEqual(5, document.GetLineByNumber(1).Length);
+			Assert.AreEqual(6, document.GetLineByNumber(1).TotalLength);
+			Assert.AreEqual(1, document.GetLineByNumber(1).DelimiterLength);
+			Assert.AreEqual(1, document.GetLineByNumber(1).LineNumber);
+			
+			Assert.AreEqual(6, document.GetLineByNumber(2).Offset);
+			Assert.AreEqual(12, document.GetLineByNumber(2).EndOffset);
+			Assert.AreEqual(6, document.GetLineByNumber(2).Length);
+			Assert.AreEqual(8, document.GetLineByNumber(2).TotalLength);
+			Assert.AreEqual(2, document.GetLineByNumber(2).DelimiterLength);
+			Assert.AreEqual(2, document.GetLineByNumber(2).LineNumber);
+
+			Assert.AreEqual(14, document.GetLineByNumber(3).Offset);
+			Assert.AreEqual(14, document.GetLineByNumber(3).EndOffset);
+			Assert.AreEqual(0, document.GetLineByNumber(3).Length);
+			Assert.AreEqual(0, document.GetLineByNumber(3).TotalLength);
+			Assert.AreEqual(0, document.GetLineByNumber(3).DelimiterLength);
+			Assert.AreEqual(3, document.GetLineByNumber(3).LineNumber);
+		}
+	}
+}

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

@@ -72,7 +72,7 @@
     <Optimize>False</Optimize>
     <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
     <DefineConstants>DEBUG;TRACE;NET45</DefineConstants>
-	<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'net_4_5_Debug|AnyCPU' ">
     <OutputPath>..\ICSharpCode.NRefactory\bin\Debug\</OutputPath>
@@ -93,7 +93,7 @@
     <Optimize>True</Optimize>
     <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
     <DefineConstants>TRACE;NET45</DefineConstants>
-	<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'net_4_5_Release|AnyCPU' ">
     <OutputPath>..\ICSharpCode.NRefactory\bin\Release\</OutputPath>
@@ -223,6 +223,7 @@
     <Compile Include="Documentation\CSharpCrefParserTests.cs" />
     <Compile Include="Documentation\CSharpDocumentationTests.cs" />
     <Compile Include="Documentation\IDStringTests.cs" />
+    <Compile Include="Editor\ReadOnlyDocumentTests.cs" />
     <Compile Include="FormattingTests\TestBraceStlye.cs" />
     <Compile Include="FormattingTests\TestFormattingBugs.cs" />
     <Compile Include="FormattingTests\TestSpacingVisitor.cs" />
@@ -345,6 +346,7 @@
     <Folder Include="CSharp\CodeIssues\" />
     <Folder Include="CSharp\CodeActions\" />
     <Folder Include="CSharp\Parser\Bugs\" />
+    <Folder Include="Editor" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ProjectExtensions>

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.TestCase.cs

@@ -118,6 +118,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.TestCase
 		public MyStructWithCtor(int a) {}
 	}
 	
+	public class MyClassWithCtor
+	{
+		private MyClassWithCtor(int a) {}
+	}
+	
 	[Serializable]
 	public class NonCustomAttributes
 	{
@@ -247,6 +252,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.TestCase
 	public class ClassWithVirtualProperty {
 		public virtual int Prop { get; set; }
 	}
+	
+	public class ClassThatOverridesAndSealsVirtualProperty : ClassWithVirtualProperty {
+		public sealed override int Prop { get; set; }
+	}
 
 	public class ClassThatImplementsProperty : IInterfaceWithProperty {
 		public int Prop { get; set; }
@@ -308,4 +317,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.TestCase
 		new int Prop { get; set; }
 		new event EventHandler Evt;
 	}
+	
+	public static class StaticClass {}
+	public abstract class AbstractClass {}
+	
+	public class IndexerNonDefaultName {
+		[IndexerName("Foo")]
+		public int this[int index] {
+			get { return 0; }
+		}
+	}
 }

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs

@@ -466,6 +466,23 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.AreEqual(2, ctors.Count());
 			Assert.IsFalse(ctors.Any(c => c.IsStatic));
 			Assert.IsTrue(ctors.All(c => c.ReturnType.Kind == TypeKind.Void));
+			Assert.IsTrue(ctors.All(c => c.Accessibility == Accessibility.Public));
+		}
+		
+		[Test]
+		public void NoDefaultConstructorAddedToClass()
+		{
+			var ctors = compilation.FindType(typeof(MyClassWithCtor)).GetConstructors();
+			Assert.AreEqual(Accessibility.Private, ctors.Single().Accessibility);
+			Assert.AreEqual(1, ctors.Single().Parameters.Count);
+		}
+		
+		[Test]
+		public void DefaultConstructorOnAbstractClassIsProtected()
+		{
+			var ctors = compilation.FindType(typeof(AbstractClass)).GetConstructors();
+			Assert.AreEqual(0, ctors.Single().Parameters.Count);
+			Assert.AreEqual(Accessibility.Protected, ctors.Single().Accessibility);
 		}
 		
 		[Test]
@@ -637,6 +654,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.AreEqual(Accessibility.Public, m.Accessibility);
 			Assert.IsTrue(m.IsAbstract);
 			Assert.IsFalse(m.IsVirtual);
+			Assert.IsFalse(m.IsSealed);
 		}
 		
 		[Test]
@@ -952,7 +970,28 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.That(prop.Getter.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.NRefactory.TypeSystem.TestCase.IInterfaceWithProperty.get_Prop" }));
 			Assert.That(prop.Setter.ImplementedInterfaceMembers.Select(p => p.ReflectionName).ToList(), Is.EqualTo(new[] { "ICSharpCode.NRefactory.TypeSystem.TestCase.IInterfaceWithProperty.set_Prop" }));
 		}
+		
+		[Test]
+		public void PropertyThatImplementsInterfaceIsNotVirtual()
+		{
+			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsProperty));
+			var prop = type.Properties.Single(p => p.Name == "Prop");
+			Assert.IsFalse(prop.IsVirtual);
+			Assert.IsFalse(prop.IsOverridable);
+			Assert.IsFalse(prop.IsSealed);
+		}
 
+		[Test]
+		public void Property_SealedOverride()
+		{
+			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatOverridesAndSealsVirtualProperty));
+			var prop = type.Properties.Single(p => p.Name == "Prop");
+			Assert.IsFalse(prop.IsVirtual);
+			Assert.IsTrue(prop.IsOverride);
+			Assert.IsTrue(prop.IsSealed);
+			Assert.IsFalse(prop.IsOverridable);
+		}
+		
 		[Test]
 		public void PropertyAccessorsShouldSupportToMemberReference()
 		{
@@ -1104,7 +1143,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		}
 
 		[Test]
-		public void ExplicitlyImplementedEventsShouldBeReportedAsBeingImplemented() 
+		public void ExplicitlyImplementedEventsShouldBeReportedAsBeingImplemented()
 		{
 			ITypeDefinition type = GetTypeDefinition(typeof(ClassThatImplementsEventExplicitly));
 			var evt = type.Events.Single();
@@ -1132,5 +1171,30 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.That(evt.AddAccessor.ImplementedInterfaceMembers, Is.Empty);
 			Assert.That(evt.RemoveAccessor.ImplementedInterfaceMembers, Is.Empty);
 		}
+		
+		[Test]
+		public void StaticClassTest()
+		{
+			ITypeDefinition type = GetTypeDefinition(typeof(StaticClass));
+			Assert.IsTrue(type.IsAbstract);
+			Assert.IsTrue(type.IsSealed);
+			Assert.IsTrue(type.IsStatic);
+		}
+		
+		[Test]
+		public void NoDefaultConstructorOnStaticClassTest()
+		{
+			ITypeDefinition type = GetTypeDefinition(typeof(StaticClass));
+			Assert.AreEqual(0, type.GetConstructors().Count());
+		}
+		
+		[Test]
+		[Ignore("not yet implemented in C# TypeSystemConvertVisitor")]
+		public void IndexerNonDefaultName()
+		{
+			ITypeDefinition type = GetTypeDefinition(typeof(IndexerNonDefaultName));
+			var indexer = type.GetProperties(p => p.IsIndexer).Single();
+			Assert.AreEqual("Foo", indexer.Name);
+		}
 	}
 }