diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AliasReferenceExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AliasReferenceExpressionTests.cs index 354303119d..8b0298e605 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AliasReferenceExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AliasReferenceExpressionTests.cs @@ -12,7 +12,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class AliasReferenceExpressionTests { [Test, Ignore] - public void CSharpGlobalReferenceExpressionTest() + public void GlobalReferenceExpressionTest() { CSharpParser parser = new CSharpParser(); parser.ParseTypeReference(new StringReader("global::System")); @@ -22,7 +22,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test, Ignore] - public void CSharpGlobalTypeDeclaration() + public void GlobalTypeDeclaration() { VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement("global::System.String a;"); //TypeReference typeRef = lvd.GetTypeForVariable(0); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ArrayObjectCreateExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ArrayObjectCreateExpressionTests.cs index a929079f33..e3173c8cd8 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ArrayObjectCreateExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ArrayObjectCreateExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class ArrayObjectCreateExpressionTests { [Test] - public void CSharpArrayCreateExpressionTest1() + public void ArrayCreateExpressionTest1() { /* ArrayCreateExpression ace = ParseUtilCSharp.ParseExpression("new int[5]"); @@ -23,7 +23,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpImplicitlyTypedArrayCreateExpression() + public void ImplicitlyTypedArrayCreateExpression() { /* ArrayCreateExpression ace = ParseUtilCSharp.ParseExpression("new[] { 1, 10, 100, 1000 }"); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AssignmentExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AssignmentExpressionTests.cs index 6a3f497446..f96e40c57f 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AssignmentExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AssignmentExpressionTests.cs @@ -9,7 +9,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression [TestFixture] public class AssignmentExpressionTests { - void CSharpTestAssignmentExpression(string program, AssignmentOperatorType op) + void TestAssignmentExpression(string program, AssignmentOperatorType op) { AssignmentExpression ae = ParseUtilCSharp.ParseExpression(program); @@ -20,69 +20,69 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpAssignTest() + public void AssignTest() { - CSharpTestAssignmentExpression("a = b", AssignmentOperatorType.Assign); + TestAssignmentExpression("a = b", AssignmentOperatorType.Assign); } [Test] - public void CSharpAddTest() + public void AddTest() { - CSharpTestAssignmentExpression("a += b", AssignmentOperatorType.Add); + TestAssignmentExpression("a += b", AssignmentOperatorType.Add); } [Test] - public void CSharpSubtractTest() + public void SubtractTest() { - CSharpTestAssignmentExpression("a -= b", AssignmentOperatorType.Subtract); + TestAssignmentExpression("a -= b", AssignmentOperatorType.Subtract); } [Test] - public void CSharpMultiplyTest() + public void MultiplyTest() { - CSharpTestAssignmentExpression("a *= b", AssignmentOperatorType.Multiply); + TestAssignmentExpression("a *= b", AssignmentOperatorType.Multiply); } [Test] - public void CSharpDivideTest() + public void DivideTest() { - CSharpTestAssignmentExpression("a /= b", AssignmentOperatorType.Divide); + TestAssignmentExpression("a /= b", AssignmentOperatorType.Divide); } [Test] - public void CSharpModulusTest() + public void ModulusTest() { - CSharpTestAssignmentExpression("a %= b", AssignmentOperatorType.Modulus); + TestAssignmentExpression("a %= b", AssignmentOperatorType.Modulus); } [Test] - public void CSharpShiftLeftTest() + public void ShiftLeftTest() { - CSharpTestAssignmentExpression("a <<= b", AssignmentOperatorType.ShiftLeft); + TestAssignmentExpression("a <<= b", AssignmentOperatorType.ShiftLeft); } [Test] - public void CSharpShiftRightTest() + public void ShiftRightTest() { - CSharpTestAssignmentExpression("a >>= b", AssignmentOperatorType.ShiftRight); + TestAssignmentExpression("a >>= b", AssignmentOperatorType.ShiftRight); } [Test] - public void CSharpBitwiseAndTest() + public void BitwiseAndTest() { - CSharpTestAssignmentExpression("a &= b", AssignmentOperatorType.BitwiseAnd); + TestAssignmentExpression("a &= b", AssignmentOperatorType.BitwiseAnd); } [Test] - public void CSharpBitwiseOrTest() + public void BitwiseOrTest() { - CSharpTestAssignmentExpression("a |= b", AssignmentOperatorType.BitwiseOr); + TestAssignmentExpression("a |= b", AssignmentOperatorType.BitwiseOr); } [Test] - public void CSharpExclusiveOrTest() + public void ExclusiveOrTest() { - CSharpTestAssignmentExpression("a ^= b", AssignmentOperatorType.ExclusiveOr); + TestAssignmentExpression("a ^= b", AssignmentOperatorType.ExclusiveOr); } } } diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BaseReferenceExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BaseReferenceExpressionTests.cs index 35abc69cca..4bde43b92d 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BaseReferenceExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BaseReferenceExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class BaseReferenceExpressionTests { [Test] - public void CSharpBaseReferenceExpressionTest1() + public void BaseReferenceExpressionTest1() { MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression("base.myField"); Assert.IsTrue(fre.Target is BaseReferenceExpression); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BinaryOperatorExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BinaryOperatorExpressionTests.cs index e5de23e1b6..df3b610bd3 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BinaryOperatorExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BinaryOperatorExpressionTests.cs @@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpOperatorPrecedenceTest() + public void OperatorPrecedenceTest() { SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide, false); SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "%", BinaryOperatorType.Modulus, false); @@ -75,7 +75,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } #endregion - void CSharpTestBinaryOperatorExpressionTest(string program, BinaryOperatorType op) + void TestBinaryOperatorExpressionTest(string program, BinaryOperatorType op) { BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression(program); Assert.AreEqual(op, boe.BinaryOperatorType); @@ -86,7 +86,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpSubtractionLeftToRight() + public void SubtractionLeftToRight() { BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression("a - b - c"); Assert.IsTrue(boe.Right is IdentifierExpression); @@ -94,7 +94,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpNullCoalescingRightToLeft() + public void NullCoalescingRightToLeft() { BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression("a ?? b ?? c"); Assert.IsTrue(boe.Left is IdentifierExpression); @@ -102,122 +102,122 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpBitwiseAndTest() + public void BitwiseAndTest() { - CSharpTestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.BitwiseAnd); + TestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.BitwiseAnd); } [Test] - public void CSharpBitwiseOrTest() + public void BitwiseOrTest() { - CSharpTestBinaryOperatorExpressionTest("a | b", BinaryOperatorType.BitwiseOr); + TestBinaryOperatorExpressionTest("a | b", BinaryOperatorType.BitwiseOr); } [Test] - public void CSharpLogicalAndTest() + public void LogicalAndTest() { - CSharpTestBinaryOperatorExpressionTest("a && b", BinaryOperatorType.LogicalAnd); + TestBinaryOperatorExpressionTest("a && b", BinaryOperatorType.LogicalAnd); } [Test] - public void CSharpLogicalOrTest() + public void LogicalOrTest() { - CSharpTestBinaryOperatorExpressionTest("a || b", BinaryOperatorType.LogicalOr); + TestBinaryOperatorExpressionTest("a || b", BinaryOperatorType.LogicalOr); } [Test] - public void CSharpExclusiveOrTest() + public void ExclusiveOrTest() { - CSharpTestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.ExclusiveOr); + TestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.ExclusiveOr); } [Test] - public void CSharpGreaterThanTest() + public void GreaterThanTest() { - CSharpTestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan); + TestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan); } [Test] - public void CSharpGreaterThanOrEqualTest() + public void GreaterThanOrEqualTest() { - CSharpTestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual); + TestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual); } [Test] - public void CSharpEqualityTest() + public void EqualityTest() { - CSharpTestBinaryOperatorExpressionTest("a == b", BinaryOperatorType.Equality); + TestBinaryOperatorExpressionTest("a == b", BinaryOperatorType.Equality); } [Test] - public void CSharpInEqualityTest() + public void InEqualityTest() { - CSharpTestBinaryOperatorExpressionTest("a != b", BinaryOperatorType.InEquality); + TestBinaryOperatorExpressionTest("a != b", BinaryOperatorType.InEquality); } [Test] - public void CSharpLessThanTest() + public void LessThanTest() { - CSharpTestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan); + TestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan); } [Test] - public void CSharpLessThanOrEqualTest() + public void LessThanOrEqualTest() { - CSharpTestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual); + TestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual); } [Test] - public void CSharpAddTest() + public void AddTest() { - CSharpTestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add); + TestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add); } [Test] - public void CSharpSubtractTest() + public void SubtractTest() { - CSharpTestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract); + TestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract); } [Test] - public void CSharpMultiplyTest() + public void MultiplyTest() { - CSharpTestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply); + TestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply); } [Test] - public void CSharpDivideTest() + public void DivideTest() { - CSharpTestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide); + TestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide); } [Test] - public void CSharpModulusTest() + public void ModulusTest() { - CSharpTestBinaryOperatorExpressionTest("a % b", BinaryOperatorType.Modulus); + TestBinaryOperatorExpressionTest("a % b", BinaryOperatorType.Modulus); } [Test] - public void CSharpShiftLeftTest() + public void ShiftLeftTest() { - CSharpTestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft); + TestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft); } [Test] - public void CSharpShiftRightTest() + public void ShiftRightTest() { - CSharpTestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight); + TestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight); } [Test] - public void CSharpNullCoalescingTest() + public void NullCoalescingTest() { - CSharpTestBinaryOperatorExpressionTest("a ?? b", BinaryOperatorType.NullCoalescing); + TestBinaryOperatorExpressionTest("a ?? b", BinaryOperatorType.NullCoalescing); } [Test] - public void CSharpLessThanOrGreaterTest() + public void LessThanOrGreaterTest() { const string expr = "i1 < 0 || i1 > (Count - 1)"; BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression(expr); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CastExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CastExpressionTests.cs index 108b4b3a79..a55d27c3af 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CastExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CastExpressionTests.cs @@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression { /* [Test] - public void CSharpSimpleCastExpression() + public void SimpleCastExpression() { CastExpression ce = ParseUtilCSharp.ParseExpression("(MyObject)o"); Assert.AreEqual("MyObject", ce.CastTo.Type); @@ -20,7 +20,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpArrayCastExpression() + public void ArrayCastExpression() { CastExpression ce = ParseUtilCSharp.ParseExpression("(MyType[])o"); Assert.AreEqual("MyType", ce.CastTo.Type); @@ -93,7 +93,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpCastMemberReferenceOnParenthesizedExpression() + public void CastMemberReferenceOnParenthesizedExpression() { // yes, we really wanted to evaluate .Member on expr and THEN cast the result to MyType CastExpression ce = ParseUtilCSharp.ParseExpression("(MyType)(expr).Member"); @@ -103,7 +103,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpTryCastParenthesizedExpression() + public void TryCastParenthesizedExpression() { CastExpression ce = ParseUtilCSharp.ParseExpression("(o) as string"); Assert.AreEqual("System.String", ce.CastTo.ToString()); @@ -112,7 +112,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpCastNegation() + public void CastNegation() { CastExpression ce = ParseUtilCSharp.ParseExpression("(uint)-negativeValue"); Assert.AreEqual("System.UInt32", ce.CastTo.ToString()); @@ -122,7 +122,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression */ [Test] - public void CSharpSubtractionIsNotCast() + public void SubtractionIsNotCast() { BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression("(BigInt)-negativeValue"); Assert.IsTrue(boe.Left is ParenthesizedExpression); @@ -130,7 +130,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpIntMaxValueToBigInt() + public void IntMaxValueToBigInt() { CastExpression ce = ParseUtilCSharp.ParseExpression("(BigInt)int.MaxValue"); Assert.AreEqual("BigInt", ce.CastTo.ToString()); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CheckedExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CheckedExpressionTests.cs index 0cc0cc4d48..696a28b7a6 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CheckedExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CheckedExpressionTests.cs @@ -10,14 +10,14 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class CheckedExpressionTests { [Test] - public void CSharpCheckedExpressionTest() + public void CheckedExpressionTest() { CheckedExpression ce = ParseUtilCSharp.ParseExpression("checked(a)"); Assert.IsTrue(ce.Expression is IdentifierExpression); } [Test] - public void CSharpUncheckedExpressionTest() + public void UncheckedExpressionTest() { UncheckedExpression ce = ParseUtilCSharp.ParseExpression("unchecked(a)"); Assert.IsTrue(ce.Expression is IdentifierExpression); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ConditionalExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ConditionalExpressionTests.cs index 716cb08b37..819b16582d 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ConditionalExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ConditionalExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class ConditionalExpressionTests { [Test] - public void CSharpConditionalExpressionTest() + public void ConditionalExpressionTest() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a == b ? a() : a.B"); @@ -20,7 +20,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpConditionalIsExpressionTest() + public void ConditionalIsExpressionTest() { // (as is b?) ERROR (conflict with nullables, SD-419) ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a is b ? a() : a.B"); @@ -31,7 +31,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpConditionalIsWithNullableExpressionTest() + public void ConditionalIsWithNullableExpressionTest() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a is b? ? a() : a.B"); @@ -41,7 +41,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpConditionalIsExpressionTest2() + public void ConditionalIsExpressionTest2() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a is b ? (a()) : a.B"); @@ -51,7 +51,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpConditionalExpressionNegativeValue() + public void ConditionalExpressionNegativeValue() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("isNegative ? -1 : 1"); @@ -62,7 +62,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression [Test] - public void CSharpConditionalIsWithNegativeValue() + public void ConditionalIsWithNegativeValue() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a is b ? -1 : 1"); @@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpConditionalIsWithExplicitPositiveValue() + public void ConditionalIsWithExplicitPositiveValue() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a is b ? +1 : 1"); @@ -82,7 +82,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpRepeatedConditionalExpr() + public void RepeatedConditionalExpr() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a ? b : c ? d : e"); @@ -92,7 +92,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpNestedConditionalExpr() + public void NestedConditionalExpr() { ConditionalExpression ce = ParseUtilCSharp.ParseExpression("a ? b ? c : d : e"); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/DefaultValueExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/DefaultValueExpressionTests.cs index 59396bdea7..7d22024fb6 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/DefaultValueExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/DefaultValueExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class DefaultValueExpressionTests { [Test] - public void CSharpSimpleDefaultValue() + public void SimpleDefaultValue() { DefaultValueExpression toe = ParseUtilCSharp.ParseExpression("default(T)"); Assert.AreEqual("T", toe.TypeReference.Identifier.Name); @@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression /* [Test] - public void CSharpFullQualifiedDefaultValue() + public void FullQualifiedDefaultValue() { DefaultValueExpression toe = ParseUtilCSharp.ParseExpression("default(global::MyNamespace.N1.MyType)"); Assert.IsTrue(toe.TypeReference.IsGlobal); @@ -26,7 +26,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpGenericDefaultValue() + public void GenericDefaultValue() { DefaultValueExpression toe = ParseUtilCSharp.ParseExpression("default(MyNamespace.N1.MyType)"); Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); @@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpDefaultValueAsIntializer() + public void DefaultValueAsIntializer() { // This test is failing because we need a resolver for the "default:" / "default(" conflict. LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement("T a = default(T);"); @@ -43,7 +43,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpDefaultValueInReturnStatement() + public void DefaultValueInReturnStatement() { ReturnStatement rs = ParseUtilCSharp.ParseStatement("return default(T);"); DefaultValueExpression dve = (DefaultValueExpression)rs.Expression; diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IdentifierExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IdentifierExpressionTests.cs index 20d5a64439..27ff26b233 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IdentifierExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IdentifierExpressionTests.cs @@ -58,7 +58,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test, Ignore] - public void CSharpGenericMethodReference() + public void GenericMethodReference() { IdentifierExpression ident = ParseUtilCSharp.ParseExpression("M"); Assert.AreEqual("M", ident.Identifier); @@ -67,7 +67,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test, Ignore] - public void CSharpGenericMethodReference2() + public void GenericMethodReference2() { IdentifierExpression ident = ParseUtilCSharp.ParseExpression("TargetMethod"); Assert.AreEqual("TargetMethod", ident.Identifier); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IndexerExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IndexerExpressionTests.cs index d5edafdcc7..1a46dc63ff 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IndexerExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IndexerExpressionTests.cs @@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class IndexerExpressionTests { [Test] - public void CSharpIndexerExpressionTest() + public void IndexerExpressionTest() { IndexerExpression ie = ParseUtilCSharp.ParseExpression("field[1, \"Hello\", 'a']"); Assert.IsTrue(ie.Target is IdentifierExpression); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/InvocationExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/InvocationExpressionTests.cs index 60edfee59d..f3a39b6fd1 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/InvocationExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/InvocationExpressionTests.cs @@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class InvocationExpressionTests { [Test] - public void CSharpSimpleInvocationExpressionTest() + public void SimpleInvocationExpressionTest() { var ie = ParseUtilCSharp.ParseExpression("myMethod()"); Assert.AreEqual(0, ie.Arguments.Count()); @@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression /* TODO port unit tests to new DOM [Test] - public void CSharpGenericInvocationExpressionTest() + public void GenericInvocationExpressionTest() { var expr = ParseUtilCSharp.ParseExpression("myMethod('a')"); Assert.AreEqual(1, expr.Arguments.Count()); @@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpGenericInvocation2ExpressionTest() + public void GenericInvocation2ExpressionTest() { var expr = ParseUtilCSharp.ParseExpression("myMethod()"); Assert.AreEqual(0, expr.Arguments.Count); @@ -48,7 +48,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpAmbiguousGrammarGenericMethodCall() + public void AmbiguousGrammarGenericMethodCall() { InvocationExpression ie = ParseUtilCSharp.ParseExpression("F(G(7))"); Assert.IsTrue(ie.TargetObject is IdentifierExpression); @@ -62,7 +62,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpAmbiguousGrammarNotAGenericMethodCall() + public void AmbiguousGrammarNotAGenericMethodCall() { BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression("F+y"); Assert.AreEqual(BinaryOperatorType.GreaterThan, boe.Op); @@ -71,7 +71,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpInvalidNestedInvocationExpressionTest() + public void InvalidNestedInvocationExpressionTest() { // this test was written because this bug caused the AbstractASTVisitor to crash diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/MemberReferenceExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/MemberReferenceExpressionTests.cs index 83427ad74b..3f9ce69eb6 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/MemberReferenceExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/MemberReferenceExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class MemberReferenceExpressionTests { [Test] - public void CSharpSimpleFieldReferenceExpressionTest() + public void SimpleFieldReferenceExpressionTest() { MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression("myTargetObject.myField"); //Assert.AreEqual("myField", fre.MemberName); @@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression /* TODO port unit tests [Test] - public void CSharpGenericFieldReferenceExpressionTest() + public void GenericFieldReferenceExpressionTest() { MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression("SomeClass.myField"); Assert.AreEqual("myField", fre.MemberName); @@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpFullNamespaceGenericFieldReferenceExpressionTest() + public void FullNamespaceGenericFieldReferenceExpressionTest() { MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression("Namespace.Subnamespace.SomeClass.myField"); Assert.AreEqual("myField", fre.MemberName); @@ -45,7 +45,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpGlobalFullNamespaceGenericFieldReferenceExpressionTest() + public void GlobalFullNamespaceGenericFieldReferenceExpressionTest() { MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression("global::Namespace.Subnamespace.SomeClass.myField"); Assert.AreEqual("myField", fre.MemberName); @@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpNestedGenericFieldReferenceExpressionTest() + public void NestedGenericFieldReferenceExpressionTest() { MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression("MyType.InnerClass.myField"); Assert.AreEqual("myField", fre.MemberName); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ParenthesizedExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ParenthesizedExpressionTests.cs index 1813db4134..c60bcbf1f9 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ParenthesizedExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ParenthesizedExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class ParenthesizedExpressionTests { [Test] - public void CSharpPrimitiveParenthesizedExpression() + public void PrimitiveParenthesizedExpression() { ParenthesizedExpression p = ParseUtilCSharp.ParseExpression("((1))"); Assert.IsTrue(p.Expression is ParenthesizedExpression); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PointerReferenceExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PointerReferenceExpressionTests.cs index d494845c29..f02c795e25 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PointerReferenceExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PointerReferenceExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class PointerReferenceExpressionTests { [Test, Ignore("where did PointerReferenceExpression.MemberName go?")] - public void CSharpPointerReferenceExpressionTest() + public void PointerReferenceExpressionTest() { PointerReferenceExpression pre = ParseUtilCSharp.ParseExpression("myObj.field->b"); Assert.IsTrue(pre.Target is MemberReferenceExpression); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PrimitiveExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PrimitiveExpressionTests.cs index df3a3b87e7..29fb7d5bcb 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PrimitiveExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PrimitiveExpressionTests.cs @@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class PrimitiveExpressionTests { [Test] - public void CSharpHexIntegerTest1() + public void HexIntegerTest1() { InvocationExpression invExpr = ParseUtilCSharp.ParseExpression("0xAFFE.ToString()"); Assert.AreEqual(0, invExpr.Arguments.Count()); @@ -34,13 +34,13 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpDoubleTest1() + public void DoubleTest1() { CheckLiteral(".5e-06", .5e-06); } [Test] - public void CSharpCharTest1() + public void CharTest1() { CheckLiteral("'\\u0356'", '\u0356'); } @@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpStringTest1() + public void StringTest1() { CheckLiteral("\"\\n\\t\\u0005 Hello World !!!\"", "\n\t\u0005 Hello World !!!"); } diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/SizeOfExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/SizeOfExpressionTests.cs index 39523641fb..23d444ecc5 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/SizeOfExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/SizeOfExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class SizeOfExpressionTests { [Test] - public void CSharpSizeOfExpressionTest() + public void SizeOfExpressionTest() { SizeOfExpression soe = ParseUtilCSharp.ParseExpression("sizeof(MyType)"); Assert.AreEqual("MyType", soe.Type.Identifier.Name); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/StackAllocExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/StackAllocExpressionTests.cs index 4ef24f872a..038925a42a 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/StackAllocExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/StackAllocExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class StackAllocExpressionTests { [Test, Ignore] - public void CSharpStackAllocExpressionTest() + public void StackAllocExpressionTest() { var sae = ParseUtilCSharp.ParseExpression("stackalloc int[100]"); throw new NotImplementedException(); // TODO: verify type + length expression diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/TypeOfExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/TypeOfExpressionTests.cs index dd5fef5507..599aae19fb 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/TypeOfExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/TypeOfExpressionTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression public class TypeOfExpressionTests { [Test] - public void CSharpSimpleTypeOfExpressionTest() + public void SimpleTypeOfExpressionTest() { //TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(MyNamespace.N1.MyType)"); //Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); @@ -19,28 +19,28 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression /* TODO [Test] - public void CSharpGlobalTypeOfExpressionTest() + public void GlobalTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(global::System.Console)"); Assert.AreEqual("System.Console", toe.TypeReference.Type); } [Test] - public void CSharpPrimitiveTypeOfExpressionTest() + public void PrimitiveTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(int)"); Assert.AreEqual("System.Int32", toe.TypeReference.Type); } [Test] - public void CSharpVoidTypeOfExpressionTest() + public void VoidTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(void)"); Assert.AreEqual("System.Void", toe.TypeReference.Type); } [Test] - public void CSharpArrayTypeOfExpressionTest() + public void ArrayTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(MyType[])"); Assert.AreEqual("MyType", toe.TypeReference.Type); @@ -48,7 +48,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpGenericTypeOfExpressionTest() + public void GenericTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(MyNamespace.N1.MyType)"); Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type); @@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpNestedGenericTypeOfExpressionTest() + public void NestedGenericTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(MyType.InnerClass.InnerInnerClass)"); InnerClassTypeReference ic = (InnerClassTypeReference)toe.TypeReference; @@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpNullableTypeOfExpressionTest() + public void NullableTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(MyStruct?)"); Assert.AreEqual("System.Nullable", toe.TypeReference.Type); @@ -80,7 +80,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpUnboundTypeOfExpressionTest() + public void UnboundTypeOfExpressionTest() { TypeOfExpression toe = ParseUtilCSharp.ParseExpression("typeof(MyType<,>)"); Assert.AreEqual("MyType", toe.TypeReference.Type); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/UnaryOperatorExpressionTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/UnaryOperatorExpressionTests.cs index 189b1714e4..cf583cd0b7 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/UnaryOperatorExpressionTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/UnaryOperatorExpressionTests.cs @@ -9,7 +9,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression [TestFixture] public class UnaryOperatorExpressionTests { - void CSharpTestUnaryOperatorExpressionTest(string program, UnaryOperatorType op) + void TestUnaryOperatorExpressionTest(string program, UnaryOperatorType op) { UnaryOperatorExpression uoe = ParseUtilCSharp.ParseExpression(program); Assert.AreEqual(op, uoe.UnaryOperatorType); @@ -18,67 +18,67 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression } [Test] - public void CSharpNotTest() + public void NotTest() { - CSharpTestUnaryOperatorExpressionTest("!a", UnaryOperatorType.Not); + TestUnaryOperatorExpressionTest("!a", UnaryOperatorType.Not); } [Test] - public void CSharpBitNotTest() + public void BitNotTest() { - CSharpTestUnaryOperatorExpressionTest("~a", UnaryOperatorType.BitNot); + TestUnaryOperatorExpressionTest("~a", UnaryOperatorType.BitNot); } [Test] - public void CSharpMinusTest() + public void MinusTest() { - CSharpTestUnaryOperatorExpressionTest("-a", UnaryOperatorType.Minus); + TestUnaryOperatorExpressionTest("-a", UnaryOperatorType.Minus); } [Test] - public void CSharpPlusTest() + public void PlusTest() { - CSharpTestUnaryOperatorExpressionTest("+a", UnaryOperatorType.Plus); + TestUnaryOperatorExpressionTest("+a", UnaryOperatorType.Plus); } [Test] - public void CSharpIncrementTest() + public void IncrementTest() { - CSharpTestUnaryOperatorExpressionTest("++a", UnaryOperatorType.Increment); + TestUnaryOperatorExpressionTest("++a", UnaryOperatorType.Increment); } [Test] - public void CSharpDecrementTest() + public void DecrementTest() { - CSharpTestUnaryOperatorExpressionTest("--a", UnaryOperatorType.Decrement); + TestUnaryOperatorExpressionTest("--a", UnaryOperatorType.Decrement); } [Test] - public void CSharpPostIncrementTest() + public void PostIncrementTest() { - CSharpTestUnaryOperatorExpressionTest("a++", UnaryOperatorType.PostIncrement); + TestUnaryOperatorExpressionTest("a++", UnaryOperatorType.PostIncrement); } [Test] - public void CSharpPostDecrementTest() + public void PostDecrementTest() { - CSharpTestUnaryOperatorExpressionTest("a--", UnaryOperatorType.PostDecrement); + TestUnaryOperatorExpressionTest("a--", UnaryOperatorType.PostDecrement); } [Test] - public void CSharpStarTest() + public void StarTest() { - CSharpTestUnaryOperatorExpressionTest("*a", UnaryOperatorType.Dereference); + TestUnaryOperatorExpressionTest("*a", UnaryOperatorType.Dereference); } [Test] - public void CSharpBitWiseAndTest() + public void BitWiseAndTest() { - CSharpTestUnaryOperatorExpressionTest("&a", UnaryOperatorType.AddressOf); + TestUnaryOperatorExpressionTest("&a", UnaryOperatorType.AddressOf); } [Test] - public void CSharpDereferenceAfterCast() + public void DereferenceAfterCast() { UnaryOperatorExpression uoe = ParseUtilCSharp.ParseExpression("*((SomeType*) &w)"); Assert.AreEqual(UnaryOperatorType.Dereference, uoe.UnaryOperatorType); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/DelegateDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/DelegateDeclarationTests.cs index 52dd16414f..51e046976a 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/DelegateDeclarationTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/DelegateDeclarationTests.cs @@ -35,7 +35,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope } [Test, Ignore] - public void CSharpDelegateWithoutNameDeclarationTest() + public void DelegateWithoutNameDeclarationTest() { string program = "public delegate void(int a, int secondParam, MyObj lastParam);\n"; DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal(program, true); @@ -45,7 +45,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope } [Test, Ignore] - public void CSharpGenericDelegateDeclarationTest() + public void GenericDelegateDeclarationTest() { string program = "public delegate T CreateObject() where T : ICloneable;\n"; DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal(program); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/UsingDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/UsingDeclarationTests.cs index b4795d387c..529b55bc7a 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/UsingDeclarationTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/UsingDeclarationTests.cs @@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope { [Test] [Ignore("error reporting not yet implemented")] - public void CSharpWrongUsingTest() + public void WrongUsingTest() { string program = "using\n"; CSharpParser parser = new CSharpParser(); @@ -23,7 +23,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope } [Test] - public void CSharpDeclarationTest() + public void DeclarationTest() { string program = "using System;\n" + "using My.Name.Space;\n"; @@ -44,7 +44,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope } [Test] - public void CSharpUsingAliasDeclarationTest() + public void UsingAliasDeclarationTest() { string program = "using TESTME=System;\n" + "using myAlias=My.Name.Space;\n" + @@ -75,7 +75,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope [Test] [Ignore("'::' not yet implemented")] - public void CSharpUsingWithAliasing() + public void UsingWithAliasing() { string program = "using global::System;\n" + "using myAlias=global::My.Name.Space;\n" + diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseUtil.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseUtil.cs index 1d2805552e..731d4e1951 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseUtil.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseUtil.cs @@ -55,5 +55,21 @@ namespace ICSharpCode.NRefactory.CSharp.Parser Assert.IsTrue(type.IsAssignableFrom(parsedExpression.GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parsedExpression.GetType(), type, parsedExpression)); return (T)parsedExpression; } + + public static T ParseTypeMember(string expr, bool expectErrors = false) where T : AbstractMemberBase + { + Assert.Ignore("ParseTypeMember not yet implemented"); + + CSharpParser parser = new CSharpParser(); + var members = parser.ParseTypeMembers(new StringReader(expr)); + + Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors"); + + Assert.AreEqual(1, members.Count); + AbstractMemberBase m = members[0]; + Type type = typeof(T); + Assert.IsTrue(type.IsAssignableFrom(m.GetType()), String.Format("Parsed member was {0} instead of {1} ({2})", m.GetType(), type, m)); + return (T)m; + } } } diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/BlockStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/BlockStatementTests.cs index ebe4e2cc5c..71519b3907 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/BlockStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/BlockStatementTests.cs @@ -11,14 +11,14 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements public class BlockStatementTests { [Test] - public void CSharpBlockStatementTest() + public void BlockStatementTest() { BlockStatement blockStmt = ParseUtilCSharp.ParseStatement("{}"); Assert.AreEqual(0, blockStmt.Statements.Count()); } [Test] - public void CSharpComplexBlockStatementPositionTest() + public void ComplexBlockStatementPositionTest() { string code = @"{ WebClient wc = new WebClient(); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/EmptyStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/EmptyStatementTests.cs index 3bd72ab9c6..b492b21edd 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/EmptyStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/EmptyStatementTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements public class EmptyStatementTests { [Test] - public void CSharpEmptyStatementTest() + public void EmptyStatementTest() { EmptyStatement emptyStmt = ParseUtilCSharp.ParseStatement(";"); } diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/FixedStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/FixedStatementTests.cs index c9cd89a5c6..08ff938b82 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/FixedStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/FixedStatementTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements public class FixedStatementTests { [Test] - public void CSharpFixedStatementTest() + public void FixedStatementTest() { FixedStatement fixedStmt = ParseUtilCSharp.ParseStatement("fixed (int* ptr = &myIntArr) { }"); // TODO : Extend test. diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/ForStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/ForStatementTests.cs index f09d97c958..e97d4da5ea 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/ForStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/ForStatementTests.cs @@ -11,14 +11,14 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements public class ForStatementTests { [Test] - public void CSharpForeachStatementTest() + public void ForeachStatementTest() { ForeachStatement foreachStmt = ParseUtilCSharp.ParseStatement("foreach (int i in myColl) {} "); // TODO : Extend test. } [Test] - public void CSharpEmptyForStatementTest() + public void EmptyForStatementTest() { ForStatement forStmt = ParseUtilCSharp.ParseStatement("for (;;) ;"); Assert.AreEqual(0, forStmt.Initializers.Count()); @@ -28,7 +28,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements } [Test] - public void CSharpForStatementTest() + public void ForStatementTest() { ForStatement forStmt = ParseUtilCSharp.ParseStatement("for (int i = 5; i < 6; ++i) {} "); // TODO : Extend test. diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/LockStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/LockStatementTests.cs index e415eb96b9..a85dc06c97 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/LockStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/LockStatementTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements public class LockStatementTests { [Test] - public void CSharpLockStatementTest() + public void LockStatementTest() { LockStatement lockStmt = ParseUtilCSharp.ParseStatement("lock (myObj) {}"); // TODO : Extend test. diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/TryCatchStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/TryCatchStatementTests.cs index 09a47fb175..971a3f1984 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/TryCatchStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/TryCatchStatementTests.cs @@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements public class TryCatchStatementTests { [Test] - public void CSharpSimpleTryCatchStatementTest() + public void SimpleTryCatchStatementTest() { TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement("try { } catch { } "); Assert.IsNull(tryCatchStatement.FinallyBlock); @@ -22,7 +22,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements /* TODO port tests [Test] - public void CSharpSimpleTryCatchStatementTest2() + public void SimpleTryCatchStatementTest2() { TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement("try { } catch (Exception e) { } "); Assert.IsTrue(tryCatchStatement.FinallyBlock.IsNull); @@ -32,7 +32,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements } [Test] - public void CSharpSimpleTryCatchFinallyStatementTest() + public void SimpleTryCatchFinallyStatementTest() { TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement("try { } catch (Exception) { } catch { } finally { } "); Assert.IsFalse(tryCatchStatement.FinallyBlock.IsNull); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UnsafeStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UnsafeStatementTests.cs index eb89abdbe4..5746815363 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UnsafeStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UnsafeStatementTests.cs @@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements public class UnsafeStatementTests { [Test] - public void CSharpUnsafeStatementTest() + public void UnsafeStatementTest() { UnsafeStatement unsafeStatement = ParseUtilCSharp.ParseStatement("unsafe { }"); Assert.IsNotNull(unsafeStatement.Block); diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UsingStatementTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UsingStatementTests.cs index 07f7148c3b..785b913557 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UsingStatementTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UsingStatementTests.cs @@ -9,8 +9,8 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements [TestFixture] public class UsingStatementTests { - [Test] - public void CSharpUsingStatementTest() + [Test] + public void UsingStatementTest() { UsingStatement usingStmt = ParseUtilCSharp.ParseStatement("using (MyVar var = new MyVar()) { } "); // TODO : Extend test. diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/ConstructorDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/ConstructorDeclarationTests.cs new file mode 100644 index 0000000000..fde562f23a --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/ConstructorDeclarationTests.cs @@ -0,0 +1,52 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using System.Linq; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture] + public class ConstructorDeclarationTests + { + [Test] + public void ConstructorDeclarationTest1() + { + ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember("MyClass() {}"); + Assert.IsNull(cd.Initializer); + } + + [Test] + public void ConstructorDeclarationTest2() + { + ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember("MyClass() : this(5) {}"); + Assert.AreEqual(ConstructorInitializerType.This, cd.Initializer.ConstructorInitializerType); + Assert.AreEqual(1, cd.Initializer.Arguments.Count()); + } + + [Test] + public void ConstructorDeclarationTest3() + { + ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember("MyClass() : base(1, 2, 3) {}"); + Assert.AreEqual(ConstructorInitializerType.Base, cd.Initializer.ConstructorInitializerType); + Assert.AreEqual(3, cd.Initializer.Arguments.Count()); + } + + [Test] + public void StaticConstructorDeclarationTest1() + { + ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember("static MyClass() {}"); + Assert.IsNull(cd.Initializer); + Assert.AreEqual(Modifiers.Static, cd.Modifiers); + } + + [Test] + public void ExternStaticConstructorDeclarationTest() + { + ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember("extern static MyClass();"); + Assert.IsNull(cd.Initializer); + Assert.AreEqual(Modifiers.Static | Modifiers.Extern, cd.Modifiers); + } + } +} diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/DestructorDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/DestructorDeclarationTests.cs new file mode 100644 index 0000000000..25ba714f74 --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/DestructorDeclarationTests.cs @@ -0,0 +1,32 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture] + public class DestructorDeclarationTests + { + [Test] + public void DestructorDeclarationTest() + { + DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember("~MyClass() {}"); + } + + [Test] + public void ExternDestructorDeclarationTest() + { + DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember("extern ~MyClass();"); + Assert.AreEqual(Modifiers.Extern, dd.Modifiers); + } + + [Test] + public void UnsafeDestructorDeclarationTest() + { + DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember("unsafe ~MyClass() {}"); + Assert.AreEqual(Modifiers.Unsafe, dd.Modifiers); + } + } +} diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/EventDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/EventDeclarationTests.cs new file mode 100644 index 0000000000..213f27c383 --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/EventDeclarationTests.cs @@ -0,0 +1,84 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture, Ignore] + public class EventDeclarationTests + { + [Test] + public void SimpleEventDeclarationTest() + { + EventDeclaration ed = ParseUtilCSharp.ParseTypeMember("event System.EventHandler MyEvent;"); + Assert.AreEqual("MyEvent", ed.Name); + //Assert.AreEqual("System.EventHandler", ed.TypeReference.Type); + Assert.Ignore(); // check type + + Assert.IsNull(ed.AddAccessor); + Assert.IsNull(ed.RemoveAccessor); + } + + /* TODO Port tests + [Test] + public void MultipleEventDeclarationTest() + { + TypeDeclaration t = ParseUtilCSharp.ParseGlobal("class C { public event EventHandler A, B; }"); + Assert.AreEqual(2, t.Children.Count); + + EventDeclaration ed = (EventDeclaration)t.Children[0]; + Assert.AreEqual(Modifiers.Public, ed.Modifier); + Assert.AreEqual("EventHandler", ed.TypeReference.Type); + Assert.AreEqual("A", ed.Name); + + ed = (EventDeclaration)t.Children[1]; + Assert.AreEqual(Modifiers.Public, ed.Modifier); + Assert.AreEqual("EventHandler", ed.TypeReference.Type); + Assert.AreEqual("B", ed.Name); + } + + [Test] + public void EventImplementingInterfaceDeclarationTest() + { + EventDeclaration ed = ParseUtilCSharp.ParseTypeMember("event EventHandler MyInterface.MyEvent;"); + + Assert.AreEqual("MyEvent", ed.Name); + Assert.AreEqual("EventHandler", ed.TypeReference.Type); + + Assert.IsFalse(ed.HasAddRegion); + Assert.IsFalse(ed.HasRemoveRegion); + + Assert.AreEqual("MyInterface", ed.InterfaceImplementations[0].InterfaceType.Type); + Assert.AreEqual("MyEvent", ed.InterfaceImplementations[0].MemberName); + } + + [Test] + public void EventImplementingGenericInterfaceDeclarationTest() + { + EventDeclaration ed = ParseUtilCSharp.ParseTypeMember("event EventHandler MyInterface.MyEvent;"); + + Assert.AreEqual("MyEvent", ed.Name); + Assert.AreEqual("EventHandler", ed.TypeReference.Type); + + Assert.IsFalse(ed.HasAddRegion); + Assert.IsFalse(ed.HasRemoveRegion); + + Assert.AreEqual("MyInterface", ed.InterfaceImplementations[0].InterfaceType.Type); + Assert.AreEqual("System.String", ed.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type); + Assert.AreEqual("MyEvent", ed.InterfaceImplementations[0].MemberName); + } + + [Test] + public void AddRemoveEventDeclarationTest() + { + EventDeclaration ed = ParseUtilCSharp.ParseTypeMember("event System.EventHandler MyEvent { add { } remove { } }"); + Assert.AreEqual("MyEvent", ed.Name); + Assert.AreEqual("System.EventHandler", ed.TypeReference.Type); + + Assert.IsTrue(ed.HasAddRegion); + Assert.IsTrue(ed.HasRemoveRegion); + }*/ + } +} diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/FieldDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/FieldDeclarationTests.cs new file mode 100644 index 0000000000..f91cbed4a1 --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/FieldDeclarationTests.cs @@ -0,0 +1,27 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture, Ignore] + public class FieldDeclarationTests + { + [Test] + public void SimpleFieldDeclarationTest() + { + throw new NotImplementedException(); + /* + FieldDeclaration fd = ParseUtilCSharp.ParseTypeMember("int[,,,] myField;"); + Assert.AreEqual("System.Int32", fd.TypeReference.Type); + Assert.AreEqual(new int[] { 3 } , fd.TypeReference.RankSpecifier); + Assert.AreEqual(1, fd.Fields.Count); + + Assert.AreEqual("myField", ((VariableDeclaration)fd.Fields[0]).Name);*/ + } + + // TODO add more tests + } +} diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/IndexerDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/IndexerDeclarationTests.cs new file mode 100644 index 0000000000..48bc01373d --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/IndexerDeclarationTests.cs @@ -0,0 +1,47 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using System.Linq; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture] + public class IndexerDeclarationTests + { + [Test] + public void IndexerDeclarationTest() + { + IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember("int this[int a, string b] { get { } set { } }"); + Assert.AreEqual(2, id.Parameters.Count()); + Assert.IsNotNull(id.GetAccessor, "No get region found!"); + Assert.IsNotNull(id.SetAccessor, "No set region found!"); + } + + [Test] + public void IndexerImplementingInterfaceTest() + { + IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember("int MyInterface.this[int a, string b] { get { } set { } }"); + Assert.AreEqual(2, id.Parameters.Count()); + Assert.IsNotNull(id.GetAccessor, "No get region found!"); + Assert.IsNotNull(id.SetAccessor, "No set region found!"); + + Assert.AreEqual("MyInterface", id.PrivateImplementationType); + } + + [Test, Ignore] + public void IndexerImplementingGenericInterfaceTest() + { + throw new NotImplementedException(); + /* + IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember("int MyInterface.this[int a, string b] { get { } set { } }"); + Assert.AreEqual(2, id.Parameters.Count); + Assert.IsNotNull(id.GetAccessor, "No get region found!"); + Assert.IsNotNull(id.SetAccessor, "No set region found!"); + + Assert.AreEqual("MyInterface", id.InterfaceImplementations[0].InterfaceType.Type); + Assert.AreEqual("System.String", id.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);*/ + } + } +} diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/MethodDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/MethodDeclarationTests.cs new file mode 100644 index 0000000000..721f6c84e6 --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/MethodDeclarationTests.cs @@ -0,0 +1,300 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using System.Linq; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture] + public class MethodDeclarationTests + { + [Test] + public void SimpleMethodDeclarationTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("void MyMethod() {} "); + Assert.AreEqual("System.Void", md.ReturnType); + Assert.AreEqual(0, md.Parameters.Count()); + Assert.IsFalse(md.IsExtensionMethod); + } + + [Test] + public void AbstractMethodDeclarationTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("abstract void MyMethod();"); + Assert.AreEqual("System.Void", md.ReturnType); + Assert.AreEqual(0, md.Parameters.Count()); + Assert.IsFalse(md.IsExtensionMethod); + Assert.IsNull(md.Body); + Assert.AreEqual(Modifiers.Abstract, md.Modifiers); + } + + [Test] + public void DefiningPartialMethodDeclarationTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("partial void MyMethod();"); + Assert.AreEqual("System.Void", md.ReturnType); + Assert.AreEqual(0, md.Parameters.Count()); + Assert.IsFalse(md.IsExtensionMethod); + Assert.IsNull(md.Body); + Assert.AreEqual(Modifiers.Partial, md.Modifiers); + } + + [Test] + public void ImplementingPartialMethodDeclarationTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("partial void MyMethod() { }"); + Assert.AreEqual("System.Void", md.ReturnType); + Assert.AreEqual(0, md.Parameters.Count()); + Assert.IsFalse(md.IsExtensionMethod); + Assert.IsNotNull(md.Body); + Assert.AreEqual(Modifiers.Partial, md.Modifiers); + } + + [Test] + public void SimpleMethodRegionTest() + { + const string program = @" + void MyMethod() + { + OtherMethod(); + } +"; + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember(program); + Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y"); + Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y"); + Assert.AreEqual(3, md.StartLocation.Column, "StartLocation.X"); + Assert.AreEqual(18, md.EndLocation.Column, "EndLocation.X"); + } + + [Test] + public void MethodWithModifiersRegionTest() + { + const string program = @" + public static void MyMethod() + { + OtherMethod(); + } +"; + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember(program); + Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y"); + Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y"); + Assert.AreEqual(3, md.StartLocation.Column, "StartLocation.X"); + } + + [Test] + public void MethodWithUnnamedParameterDeclarationTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("void MyMethod(int) {} ", true); + Assert.AreEqual("System.Void", md.ReturnType); + Assert.AreEqual(1, md.Parameters.Count()); + //Assert.AreEqual("?", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); + } + + /* TODO: port unit tests + [Test] + public void GenericVoidMethodDeclarationTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("void MyMethod(T a) {} "); + Assert.AreEqual("System.Void", md.ReturnType); + Assert.AreEqual(1, md.Parameters.Count()); + Assert.AreEqual("T", md.Parameters.Single().Type); + Assert.AreEqual("a", md.Parameters.Single().Name); + + Assert.AreEqual(1, md.TypeParameters.Count()); + Assert.AreEqual("T", md.Templates[0].Name); + } + + [Test] + public void GenericMethodDeclarationTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("T MyMethod(T a) {} "); + Assert.AreEqual("T", md.TypeReference.Type); + Assert.AreEqual(1, md.Parameters.Count); + Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); + Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); + + Assert.AreEqual(1, md.Templates.Count); + Assert.AreEqual("T", md.Templates[0].Name); + } + + [Test] + public void GenericMethodDeclarationWithConstraintTest() + { + string program = "T MyMethod(T a) where T : ISomeInterface {} "; + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember(program); + Assert.AreEqual("T", md.TypeReference.Type); + Assert.AreEqual(1, md.Parameters.Count); + Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); + Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); + + Assert.AreEqual(1, md.Templates.Count); + Assert.AreEqual("T", md.Templates[0].Name); + Assert.AreEqual(1, md.Templates[0].Bases.Count); + Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type); + } + + [Test] + public void GenericMethodInInterface() + { + const string program = @"interface MyInterface { + T MyMethod(T a) where T : ISomeInterface; +} +"; + TypeDeclaration td = ParseUtilCSharp.ParseGlobal(program); + MethodDeclaration md = (MethodDeclaration)td.Children[0]; + Assert.AreEqual("T", md.TypeReference.Type); + Assert.AreEqual(1, md.Parameters.Count); + Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); + Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); + + Assert.AreEqual(1, md.Templates.Count); + Assert.AreEqual("T", md.Templates[0].Name); + Assert.AreEqual(1, md.Templates[0].Bases.Count); + Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type); + } + + [Test] + public void GenericVoidMethodInInterface() + { + const string program = @"interface MyInterface { + void MyMethod(T a) where T : ISomeInterface; +} +"; + TypeDeclaration td = ParseUtilCSharp.ParseGlobal(program); + MethodDeclaration md = (MethodDeclaration)td.Children[0]; + Assert.AreEqual("System.Void", md.TypeReference.Type); + Assert.AreEqual(1, md.Parameters.Count); + Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type); + Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName); + + Assert.AreEqual(1, md.Templates.Count); + Assert.AreEqual("T", md.Templates[0].Name); + Assert.AreEqual(1, md.Templates[0].Bases.Count); + Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type); + } + + [Test] + public void ShadowingMethodInInterface() + { + const string program = @"interface MyInterface : IDisposable { + new void Dispose(); +} +"; + TypeDeclaration td = ParseUtilCSharp.ParseGlobal(program); + MethodDeclaration md = (MethodDeclaration)td.Children[0]; + Assert.AreEqual("System.Void", md.TypeReference.Type); + Assert.AreEqual(0, md.Parameters.Count); + Assert.AreEqual(Modifiers.New, md.Modifier); + } + + [Test] + public void MethodImplementingInterfaceTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("int MyInterface.MyMethod() {} "); + Assert.AreEqual("System.Int32", md.TypeReference.Type); + + Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); + } + + [Test] + public void MethodImplementingGenericInterfaceTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("int MyInterface.MyMethod() {} "); + Assert.AreEqual("System.Int32", md.TypeReference.Type); + + Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); + Assert.AreEqual("System.String", md.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type); + } + + [Test] + public void VoidMethodImplementingInterfaceTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("void MyInterface.MyMethod() {} "); + Assert.AreEqual("System.Void", md.TypeReference.Type); + + Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); + } + + [Test] + public void VoidMethodImplementingGenericInterfaceTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember("void MyInterface.MyMethod() {} "); + Assert.AreEqual("System.Void", md.TypeReference.Type); + + Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type); + Assert.AreEqual("System.String", md.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type); + } + + [Test] + public void IncompleteConstraintsTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember( + "void a() where T { }", true // expect errors + ); + Assert.AreEqual("a", md.Name); + Assert.AreEqual(1, md.Templates.Count); + Assert.AreEqual("T", md.Templates[0].Name); + Assert.AreEqual(0, md.Templates[0].Bases.Count); + } + + [Test] + public void ExtensionMethodTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember( + "public static int ToInt32(this string s) { return int.Parse(s); }" + ); + Assert.AreEqual("ToInt32", md.Name); + Assert.IsTrue(md.IsExtensionMethod); + Assert.AreEqual("s", md.Parameters[0].ParameterName); + Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type); + } + + [Test] + public void VoidExtensionMethodTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember( + "public static void Print(this string s) { Console.WriteLine(s); }" + ); + Assert.AreEqual("Print", md.Name); + Assert.IsTrue(md.IsExtensionMethod); + Assert.AreEqual("s", md.Parameters[0].ParameterName); + Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type); + } + + [Test] + public void MethodWithEmptyAssignmentErrorInBody() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember( + "void A\n" + + "{\n" + + "int a = 3;\n" + + " = 4;\n" + + "}", true // expect errors + ); + Assert.AreEqual("A", md.Name); + Assert.AreEqual(new Location(1, 2), md.Body.StartLocation); + Assert.AreEqual(new Location(2, 5), md.Body.EndLocation); + } + + [Test] + public void OptionalParameterTest() + { + MethodDeclaration md = ParseUtilCSharp.ParseTypeMember( + "public void Foo(string bar = null, int baz = 0) { }" + ); + Assert.AreEqual("Foo", md.Name); + + Assert.AreEqual("bar", md.Parameters[0].ParameterName); + Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type); + Assert.AreEqual(ParameterModifiers.In | ParameterModifiers.Optional, md.Parameters[0].ParamModifier); + Assert.IsNull(((PrimitiveExpression)md.Parameters[0].DefaultValue).Value); + + Assert.AreEqual("baz", md.Parameters[1].ParameterName); + Assert.AreEqual("System.Int32", md.Parameters[1].TypeReference.Type); + Assert.AreEqual(ParameterModifiers.In | ParameterModifiers.Optional, md.Parameters[1].ParamModifier); + Assert.AreEqual(0, ((PrimitiveExpression)md.Parameters[1].DefaultValue).Value); + }*/ + } +} diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/OperatorDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/OperatorDeclarationTests.cs new file mode 100644 index 0000000000..fbc3d5db0a --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/OperatorDeclarationTests.cs @@ -0,0 +1,53 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using System.Linq; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture] + public class OperatorDeclarationTests + { + [Test] + public void ImplictOperatorDeclarationTest() + { + OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember("public static implicit operator double(MyObject f) { return 0.5d; }"); + Assert.AreEqual(OperatorType.Implicit, od.OperatorType); + Assert.AreEqual(1, od.Parameters.Count()); + Assert.AreEqual("System.Double", od.ReturnType); + Assert.AreEqual("op_Implicit", od.Name); + } + + [Test] + public void ExplicitOperatorDeclarationTest() + { + OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember("public static explicit operator double(MyObject f) { return 0.5d; }"); + Assert.AreEqual(OperatorType.Explicit, od.OperatorType); + Assert.AreEqual(1, od.Parameters.Count()); + Assert.AreEqual("System.Double", od.ReturnType); + Assert.AreEqual("op_Explicit", od.Name); + } + + [Test] + public void BinaryPlusOperatorDeclarationTest() + { + OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember("public static MyObject operator +(MyObject a, MyObject b) {}"); + Assert.AreEqual(OperatorType.Addition, od.OperatorType); + Assert.AreEqual(2, od.Parameters.Count()); + Assert.AreEqual("MyObject", od.ReturnType); + Assert.AreEqual("op_Addition", od.Name); + } + + [Test] + public void UnaryPlusOperatorDeclarationTest() + { + OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember("public static MyObject operator +(MyObject a) {}"); + Assert.AreEqual(OperatorType.UnaryPlus, od.OperatorType); + Assert.AreEqual(1, od.Parameters.Count()); + Assert.AreEqual("MyObject", od.ReturnType); + Assert.AreEqual("op_UnaryPlus", od.Name); + } + } +} diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/PropertyDeclarationTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/PropertyDeclarationTests.cs new file mode 100644 index 0000000000..66b0a68168 --- /dev/null +++ b/ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/PropertyDeclarationTests.cs @@ -0,0 +1,93 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under MIT X11 license (for details please see \doc\license.txt) + +using System; +using System.IO; +using System.Linq; +using NUnit.Framework; + +namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers +{ + [TestFixture] + public class PropertyDeclarationTests + { + [Test] + public void SimpleGetSetPropertyDeclarationTest() + { + PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember("int MyProperty { get {} set {} } "); + Assert.AreEqual("MyProperty", pd.Name); + Assert.IsNotNull(pd.GetAccessor); + Assert.IsNotNull(pd.SetAccessor); + } + + [Test] + public void GetSetPropertyDeclarationWithAccessorModifiers() + { + PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember("int MyProperty { private get {} protected internal set {} } "); + Assert.AreEqual("MyProperty", pd.Name); + Assert.IsNotNull(pd.GetAccessor); + Assert.IsNotNull(pd.SetAccessor); + } + + [Test] + public void SimpleGetPropertyDeclarationTest() + { + PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember("int MyProperty { get {} } "); + Assert.AreEqual("MyProperty", pd.Name); + Assert.IsNotNull(pd.GetAccessor); + Assert.IsNull(pd.SetAccessor); + } + + [Test] + public void SimpleSetPropertyDeclarationTest() + { + PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember("int MyProperty { set {} } "); + Assert.AreEqual("MyProperty", pd.Name); + Assert.IsNull(pd.GetAccessor); + Assert.IsNotNull(pd.SetAccessor); + } + + [Test] + public void PropertyRegionTest() + { + const string code = "class T {\n\tint Prop {\n\t\tget { return f; }\n\t\tset { f = value; }\n\t}\n}\n"; + int line2Pos = code.IndexOf("\tint Prop"); + int line3Pos = code.IndexOf("\t\tget"); + int line4Pos = code.IndexOf("\t\tset"); + + CSharpParser parser = new CSharpParser(); + CompilationUnit cu = parser.Parse(new StringReader(code)); + PropertyDeclaration pd = (PropertyDeclaration)cu.Children.Single().GetChildByRole(TypeDeclaration.Roles.Member); + Assert.AreEqual(new DomLocation(2, code.IndexOf("{\n\t\tget") - line2Pos + 1), pd.LBrace.StartLocation); + Assert.AreEqual(new DomLocation(5, 3), pd.EndLocation); + Assert.AreEqual(new DomLocation(3, code.IndexOf("{ return") - line3Pos + 1), pd.GetAccessor.Body.StartLocation); + Assert.AreEqual(new DomLocation(3, code.IndexOf("}\n\t\tset") + 1 - line3Pos + 1), pd.GetAccessor.Body.EndLocation); + Assert.AreEqual(new DomLocation(4, code.IndexOf("{ f =") - line4Pos + 1), pd.SetAccessor.Body.StartLocation); + Assert.AreEqual(new DomLocation(4, code.IndexOf("}\n\t}") + 1 - line4Pos + 1), pd.SetAccessor.Body.EndLocation); + } + + [Test] + public void PropertyImplementingInterfaceTest() + { + PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember("int MyInterface.MyProperty { get {} } "); + Assert.AreEqual("MyProperty", pd.Name); + Assert.IsNotNull(pd.GetAccessor); + Assert.IsNull(pd.SetAccessor); + + Assert.AreEqual("MyInterface", pd.PrivateImplementationType); + } + + [Test, Ignore] + public void PropertyImplementingGenericInterfaceTest() + { + PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember("int MyInterface.MyProperty { get {} } "); + Assert.AreEqual("MyProperty", pd.Name); + Assert.IsNotNull(pd.GetAccessor); + Assert.IsNull(pd.SetAccessor); + + throw new NotImplementedException(); + //Assert.AreEqual("MyInterface", pd.InterfaceImplementations[0].InterfaceType.Type); + //Assert.AreEqual("System.String", pd.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type); + } + } +} diff --git a/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj b/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj index 0178799475..451138888a 100644 --- a/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj +++ b/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj @@ -81,6 +81,14 @@ + + + + + + + + @@ -144,6 +152,7 @@ + diff --git a/ICSharpCode.NRefactory/CSharp/Dom/DomLocation.cs b/ICSharpCode.NRefactory/CSharp/Dom/DomLocation.cs index e5ba733781..78ef3d3974 100644 --- a/ICSharpCode.NRefactory/CSharp/Dom/DomLocation.cs +++ b/ICSharpCode.NRefactory/CSharp/Dom/DomLocation.cs @@ -33,32 +33,28 @@ namespace ICSharpCode.NRefactory.CSharp [Serializable] public struct DomLocation : IComparable, IEquatable { + public static readonly DomLocation Empty = new DomLocation(0, 0); + + readonly int line, column; + + public DomLocation (int line, int column) + { + this.line = line; + this.column = column; + } + public bool IsEmpty { get { - return Line < 0; + return Line <= 0; } } public int Line { - get; - set; - } - - public int Column { - get; - set; + get { return line; } } - public static DomLocation Empty { - get { - return new DomLocation (-1, -1); - } - } - - public DomLocation (int line, int column) : this () - { - this.Line = line; - this.Column = column; + public int Column { + get { return column; } } public override bool Equals (object other) @@ -71,7 +67,7 @@ namespace ICSharpCode.NRefactory.CSharp public override int GetHashCode () { unchecked { - return Line + Column * 5000; + return line + column * 5000; } } @@ -91,12 +87,12 @@ namespace ICSharpCode.NRefactory.CSharp public override string ToString () { - return String.Format ("[DomLocation: Line={0}, Column={1}]", Line, Column); + return String.Format ("(Line {0}, Column {1})", Line, Column); } public static DomLocation FromInvariantString (string invariantString) { - if (invariantString.ToUpper () == "EMPTY") + if (string.Equals(invariantString, "EMPTY", StringComparison.OrdinalIgnoreCase)) return DomLocation.Empty; string[] splits = invariantString.Split (',', '/'); if (splits.Length == 2) @@ -108,26 +104,26 @@ namespace ICSharpCode.NRefactory.CSharp { if (IsEmpty) return "Empty"; - return String.Format ("{0}/{1}", Line, Column); + return String.Format ("{0}/{1}", line, column); } public static bool operator==(DomLocation left, DomLocation right) { - return left.Line == right.Line && left.Column == right.Column; + return left.line == right.line && left.column == right.column; } public static bool operator!=(DomLocation left, DomLocation right) { - return left.Line != right.Line || left.Column != right.Column; + return left.line != right.line || left.column != right.column; } public static bool operator<(DomLocation left, DomLocation right) { - return left.Line < right.Line || left.Line == right.Line && left.Column < right.Column; + return left.line < right.line || left.line == right.line && left.column < right.column; } public static bool operator>(DomLocation left, DomLocation right) { - return left.Line > right.Line || left.Line == right.Line && left.Column > right.Column; + return left.line > right.line || left.line == right.line && left.column > right.column; } public static bool operator<=(DomLocation left, DomLocation right) { diff --git a/ICSharpCode.NRefactory/CSharp/Dom/INode.cs b/ICSharpCode.NRefactory/CSharp/Dom/INode.cs index 564ba72398..da6ea19db7 100644 --- a/ICSharpCode.NRefactory/CSharp/Dom/INode.cs +++ b/ICSharpCode.NRefactory/CSharp/Dom/INode.cs @@ -40,6 +40,8 @@ namespace ICSharpCode.NRefactory.CSharp get; } + INode GetChildByRole (int role); + int Role { get; set; diff --git a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/IndexerDeclaration.cs b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/IndexerDeclaration.cs index 57df895147..b0c950755b 100644 --- a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/IndexerDeclaration.cs +++ b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/IndexerDeclaration.cs @@ -33,6 +33,11 @@ namespace ICSharpCode.NRefactory.CSharp { public class IndexerDeclaration : PropertyDeclaration { + // TODO: Parameters or Arguments? + public IEnumerable Parameters { + get { return this.Arguments; } + } + public IEnumerable Arguments { get { return base.GetChildrenByRole (Roles.Argument).Cast (); diff --git a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/MethodDeclaration.cs b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/MethodDeclaration.cs index 87fdda6513..a66cc03b33 100644 --- a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/MethodDeclaration.cs +++ b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/MethodDeclaration.cs @@ -32,6 +32,11 @@ namespace ICSharpCode.NRefactory.CSharp { public class MethodDeclaration : AbstractMember { + // TODO: Parameters or Arguments? + public IEnumerable TypeParameters { + get { return this.TypeArguments; } + } + public IEnumerable TypeArguments { get { return GetChildrenByRole (Roles.TypeArgument).Cast (); } } @@ -42,12 +47,25 @@ namespace ICSharpCode.NRefactory.CSharp } } + public IEnumerable Parameters { + get { + return this.Arguments; + } + } + public IEnumerable Arguments { get { return base.GetChildrenByRole (Roles.Argument).Cast (); } } + public bool IsExtensionMethod { + get { + ParameterDeclaration pd = (ParameterDeclaration)GetChildByRole (Roles.Argument); + return pd != null && pd.ParameterModifier == ParameterModifier.This; + } + } + public CSharpTokenNode LPar { get { return (CSharpTokenNode)GetChildByRole (Roles.LPar); } } diff --git a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/OperatorDeclaration.cs b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/OperatorDeclaration.cs index bd19939784..fb07c9c0fc 100644 --- a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/OperatorDeclaration.cs +++ b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/OperatorDeclaration.cs @@ -1,4 +1,4 @@ -// +// // OperatorDeclaration.cs // // Author: @@ -75,11 +75,6 @@ namespace ICSharpCode.NRefactory.CSharp set; } - public string OverloadOperator { - get; - set; - } - public CSharpTokenNode OperatorKeyword { get { return (CSharpTokenNode)GetChildByRole (OperatorKeywordRole); } } diff --git a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/ParameterDeclarationExpression.cs b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/ParameterDeclarationExpression.cs index 05d5452ecc..f17951cfe4 100644 --- a/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/ParameterDeclarationExpression.cs +++ b/ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/ParameterDeclarationExpression.cs @@ -62,6 +62,10 @@ namespace ICSharpCode.NRefactory.CSharp } } + public INode Type { + get { return GetChildByRole (Roles.ReturnType); } + } + public override S AcceptVisitor (IDomVisitor visitor, T data) { return visitor.VisitParameterDeclaration (this, data); diff --git a/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs b/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs index 102b4e9bc6..9872726752 100644 --- a/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs +++ b/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs @@ -2292,7 +2292,7 @@ namespace ICSharpCode.NRefactory.CSharp } } - public List ParseTypeMembers(TextReader reader) + public List ParseTypeMembers(TextReader reader) { // TODO: add support for type members throw new NotImplementedException();