From f1a1ab32ad112a3d336628da992f3ca680ab6600 Mon Sep 17 00:00:00 2001 From: Daniel Grunwald Date: Fri, 9 Dec 2011 02:32:44 +0100 Subject: [PATCH] Added ResolverTest to consistency check and fixed some crashing bugs in the resolver. --- .../Resolver/CSharpOperators.cs | 14 +++- .../Resolver/CSharpResolver.cs | 20 +++-- .../TypeSystem/TypeSystemConvertVisitor.cs | 2 +- .../.gitignore | 3 + ...arpCode.NRefactory.ConsistencyCheck.csproj | 1 + .../Program.cs | 29 ++++--- .../ResolverTest.cs | 83 +++++++++++++++++++ .../RoundtripTest.cs | 4 + .../CSharp/Resolver/NameLookupTests.cs | 13 +++ .../TypeSystem/TypeSystemTests.cs | 1 + .../TypeSystem/CecilLoader.cs | 5 +- .../AbstractResolvedTypeParameter.cs | 24 +++++- .../AbstractUnresolvedMember.cs | 4 +- .../DefaultResolvedTypeDefinition.cs | 76 +++++++++-------- .../Implementation/DefaultUnresolvedMethod.cs | 2 +- 15 files changed, 215 insertions(+), 66 deletions(-) create mode 100644 ICSharpCode.NRefactory.ConsistencyCheck/.gitignore create mode 100644 ICSharpCode.NRefactory.ConsistencyCheck/ResolverTest.cs diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs index 768639a108..28285c89ba 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs @@ -289,6 +289,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver public override object Invoke(CSharpResolver resolver, object input) { + if (input == null) + return null; return func((T)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T)), input)); } @@ -456,6 +458,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver public override object Invoke(CSharpResolver resolver, object lhs, object rhs) { + if (lhs == null || rhs == null) + return null; Func func = resolver.CheckForOverflow ? checkedFunc : uncheckedFunc; return func((T1)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T1)), lhs), (T2)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T2)), rhs)); @@ -692,6 +696,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver public override object Invoke(CSharpResolver resolver, object lhs, object rhs) { + if (lhs == null && rhs == null) + return !Negate; // ==: true; !=: false + if (lhs == null || rhs == null) + return Negate; // ==: false; !=: true lhs = resolver.CSharpPrimitiveCast(Type, lhs); rhs = resolver.CSharpPrimitiveCast(Type, rhs); bool equal; @@ -734,10 +742,6 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver public override object Invoke(CSharpResolver resolver, object lhs, object rhs) { - if (lhs == null && rhs == null) - return !baseMethod.Negate; // ==: true; !=: false - if (lhs == null || rhs == null) - return baseMethod.Negate; // ==: false; !=: true return baseMethod.Invoke(resolver, lhs, rhs); } @@ -809,6 +813,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver public override object Invoke(CSharpResolver resolver, object lhs, object rhs) { + if (lhs == null || rhs == null) + return null; return func((T1)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T1)), lhs), (T2)resolver.CSharpPrimitiveCast(Type.GetTypeCode(typeof(T2)), rhs)); } diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs index ad7e7debb3..c1a7c3fa74 100644 --- a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs +++ b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs @@ -393,7 +393,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver break; case UnaryOperatorType.BitNot: if (type.Kind == TypeKind.Enum) { - if (expression.IsCompileTimeConstant && !isNullable) { + if (expression.IsCompileTimeConstant && !isNullable && expression.ConstantValue != null) { // evaluate as (E)(~(U)x); var U = compilation.FindType(expression.ConstantValue.GetType()); var unpackedEnum = new ConstantResolveResult(U, expression.ConstantValue); @@ -1325,7 +1325,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver ResolveResult LookInCurrentType(string identifier, IList typeArguments, SimpleNameLookupMode lookupMode, bool parameterizeResultType) { int k = typeArguments.Count; - MemberLookup lookup = CreateMemberLookup(); + MemberLookup lookup; + if (lookupMode == SimpleNameLookupMode.BaseTypeReference && this.CurrentTypeDefinition != null) { + // When looking up a base type reference, treat us as being outside the current type definition + // for accessibility purposes. + // This avoids a stack overflow when referencing a protected class nested inside the base class + // of a parent class. (NameLookupTests.InnerClassInheritingFromProtectedBaseInnerClassShouldNotCauseStackOverflow) + lookup = new MemberLookup(this.CurrentTypeDefinition.DeclaringTypeDefinition, this.Compilation.MainAssembly, false); + } else { + lookup = CreateMemberLookup(); + } // look in current type definitions for (ITypeDefinition t = this.CurrentTypeDefinition; t != null; t = t.DeclaringTypeDefinition) { if (k == 0) { @@ -1376,7 +1385,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver ITypeDefinition def = n.GetTypeDefinition(identifier, k); if (def != null) { IType result = def; - if (parameterizeResultType) { + if (parameterizeResultType && k > 0) { result = new ParameterizedType(def, typeArguments); } if (u.HasAlias(identifier)) @@ -1521,9 +1530,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver /// public MemberLookup CreateMemberLookup() { + ITypeDefinition currentTypeDefinition = this.CurrentTypeDefinition; bool isInEnumMemberInitializer = this.CurrentMember != null && this.CurrentMember.EntityType == EntityType.Field - && this.CurrentTypeDefinition != null && this.CurrentTypeDefinition.Kind == TypeKind.Enum; - return new MemberLookup(this.CurrentTypeDefinition, this.Compilation.MainAssembly, isInEnumMemberInitializer); + && currentTypeDefinition != null && currentTypeDefinition.Kind == TypeKind.Enum; + return new MemberLookup(currentTypeDefinition, this.Compilation.MainAssembly, isInEnumMemberInitializer); } #endregion diff --git a/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs b/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs index 38f284b45c..984c5ea408 100644 --- a/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs +++ b/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs @@ -547,7 +547,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem } else { ctor.BodyRegion = MakeRegion(constructorDeclaration.Body); } - ctor.ReturnType = currentTypeDefinition; + ctor.ReturnType = KnownTypeReference.Void; ConvertAttributes(ctor.Attributes, constructorDeclaration.Attributes); ConvertParameters(ctor.Parameters, constructorDeclaration.Parameters); diff --git a/ICSharpCode.NRefactory.ConsistencyCheck/.gitignore b/ICSharpCode.NRefactory.ConsistencyCheck/.gitignore new file mode 100644 index 0000000000..9ce745d95d --- /dev/null +++ b/ICSharpCode.NRefactory.ConsistencyCheck/.gitignore @@ -0,0 +1,3 @@ + +bin/ +obj/ \ No newline at end of file diff --git a/ICSharpCode.NRefactory.ConsistencyCheck/ICSharpCode.NRefactory.ConsistencyCheck.csproj b/ICSharpCode.NRefactory.ConsistencyCheck/ICSharpCode.NRefactory.ConsistencyCheck.csproj index 86a7c85332..a3ee9235cd 100644 --- a/ICSharpCode.NRefactory.ConsistencyCheck/ICSharpCode.NRefactory.ConsistencyCheck.csproj +++ b/ICSharpCode.NRefactory.ConsistencyCheck/ICSharpCode.NRefactory.ConsistencyCheck.csproj @@ -50,6 +50,7 @@ + diff --git a/ICSharpCode.NRefactory.ConsistencyCheck/Program.cs b/ICSharpCode.NRefactory.ConsistencyCheck/Program.cs index b4b5d0fd05..9401d6f136 100644 --- a/ICSharpCode.NRefactory.ConsistencyCheck/Program.cs +++ b/ICSharpCode.NRefactory.ConsistencyCheck/Program.cs @@ -36,29 +36,36 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck public const string TempPath = @"C:\temp"; + static Solution solution; + public static void Main(string[] args) { - Solution sln; using (new Timer("Loading solution... ")) { - sln = new Solution(Path.GetFullPath("../../../NRefactory.sln")); + solution = new Solution(Path.GetFullPath("../../../NRefactory.sln")); } Console.WriteLine("Loaded {0} lines of code ({1:f1} MB) in {2} files in {3} projects.", - sln.AllFiles.Sum(f => f.LinesOfCode), - sln.AllFiles.Sum(f => f.Content.TextLength) / 1024.0 / 1024.0, - sln.AllFiles.Count(), - sln.Projects.Count); + solution.AllFiles.Sum(f => f.LinesOfCode), + solution.AllFiles.Sum(f => f.Content.TextLength) / 1024.0 / 1024.0, + solution.AllFiles.Count(), + solution.Projects.Count); - using (new Timer("Roundtripping tests... ")) { - foreach (var file in sln.AllFiles) { - RoundtripTest.RunTest(file); - } - } + //RunTestOnAllFiles("Roundtripping test", RoundtripTest.RunTest); + RunTestOnAllFiles("Resolver test", ResolverTest.RunTest); Console.Write("Press any key to continue . . . "); Console.ReadKey(true); } + static void RunTestOnAllFiles(string title, Action runTest) + { + using (new Timer(title + "... ")) { + foreach (var file in solution.AllFiles) { + runTest(file); + } + } + } + static ConcurrentDictionary assemblyDict = new ConcurrentDictionary(Platform.FileNameComparer); public static IUnresolvedAssembly LoadAssembly(string assemblyFileName) diff --git a/ICSharpCode.NRefactory.ConsistencyCheck/ResolverTest.cs b/ICSharpCode.NRefactory.ConsistencyCheck/ResolverTest.cs new file mode 100644 index 0000000000..3ff1429ef4 --- /dev/null +++ b/ICSharpCode.NRefactory.ConsistencyCheck/ResolverTest.cs @@ -0,0 +1,83 @@ +/* + * Created by SharpDevelop. + * User: Daniel + * Date: 12/9/2011 + * Time: 01:26 + * + * To change this template use Tools | Options | Coding | Edit Standard Headers. + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using ICSharpCode.NRefactory.CSharp; +using ICSharpCode.NRefactory.CSharp.Resolver; +using ICSharpCode.NRefactory.Semantics; +using ICSharpCode.NRefactory.TypeSystem; + +namespace ICSharpCode.NRefactory.ConsistencyCheck +{ + /// + /// Description of ResolverTest. + /// + public class ResolverTest + { + public static void RunTest(CSharpFile file) + { + CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile); + var navigator = new ValidatingResolveAllNavigator(file.FileName); + resolver.ApplyNavigator(navigator, CancellationToken.None); + navigator.Validate(file.CompilationUnit); + } + + sealed class ValidatingResolveAllNavigator : IResolveVisitorNavigator + { + string fileName; + + public ValidatingResolveAllNavigator(string fileName) + { + this.fileName = fileName; + } + + HashSet resolvedNodes = new HashSet(); + HashSet nodesWithConversions = new HashSet(); + + public ResolveVisitorNavigationMode Scan(AstNode node) + { + return ResolveVisitorNavigationMode.Resolve; + } + + public void Resolved(AstNode node, ResolveResult result) + { + if (!resolvedNodes.Add(node)) + throw new InvalidOperationException("Duplicate Resolved() call"); + if (CSharpAstResolver.IsUnresolvableNode(node)) + throw new InvalidOperationException("Resolved unresolvable node"); + + if (result.IsError) { + Console.WriteLine("Compiler error at " + fileName + ":" + node.StartLocation + ": " + result); + } + } + + public void ProcessConversion(Expression expression, ResolveResult result, Conversion conversion, IType targetType) + { + if (!nodesWithConversions.Add(expression)) + throw new InvalidOperationException("Duplicate ProcessConversion() call"); + if (conversion == Conversion.None) { + Console.WriteLine("Compiler error at " + fileName + ":" + expression.StartLocation + ": Cannot convert from " + result + " to " + targetType); + } + } + + public void Validate(CompilationUnit cu) + { + foreach (AstNode node in cu.DescendantsAndSelf.Except(resolvedNodes)) { + if (node.NodeType != NodeType.Token) { + if (!CSharpAstResolver.IsUnresolvableNode(node)) { + Console.WriteLine("Forgot to resolve " + node); + } + } + } + } + } + } +} diff --git a/ICSharpCode.NRefactory.ConsistencyCheck/RoundtripTest.cs b/ICSharpCode.NRefactory.ConsistencyCheck/RoundtripTest.cs index 9a52ac3147..68befc6a84 100644 --- a/ICSharpCode.NRefactory.ConsistencyCheck/RoundtripTest.cs +++ b/ICSharpCode.NRefactory.ConsistencyCheck/RoundtripTest.cs @@ -25,6 +25,10 @@ using ICSharpCode.NRefactory.PatternMatching; namespace ICSharpCode.NRefactory.ConsistencyCheck { + /// + /// Tests parser + output visitor by roundtripping code. + /// Everything but whitespace must be preserved. + /// public class RoundtripTest { public static void RunTest(CSharpFile file) diff --git a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/NameLookupTests.cs b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/NameLookupTests.cs index ff53b3e434..f8b904f4f1 100644 --- a/ICSharpCode.NRefactory.Tests/CSharp/Resolver/NameLookupTests.cs +++ b/ICSharpCode.NRefactory.Tests/CSharp/Resolver/NameLookupTests.cs @@ -900,6 +900,19 @@ class B Assert.AreEqual("Test.Base", result.Type.FullName); } + [Test] + public void InnerClassInheritingFromProtectedBaseInnerClassShouldNotCauseStackOverflow() + { + string program = @"class Base { + protected class NestedBase {} +} +class Derived : Base { + class NestedDerived : $NestedBase$ { } +}"; + var result = Resolve(program); + Assert.AreEqual("Base.NestedBase", result.Type.FullName); + } + [Test] public void EnumMembersHaveUnderlyingTypeWithinInitializers_MemberFromSameEnum() { diff --git a/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs b/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs index 06f8b3f840..20463d9f95 100644 --- a/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs +++ b/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs @@ -314,6 +314,7 @@ namespace ICSharpCode.NRefactory.TypeSystem var ctors = compilation.FindType(typeof(MyStructWithCtor)).GetConstructors(); Assert.AreEqual(2, ctors.Count()); Assert.IsFalse(ctors.Any(c => c.IsStatic)); + Assert.IsTrue(ctors.All(c => c.ReturnType.Kind == TypeKind.Void)); } [Test] diff --git a/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs b/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs index 5549bf7a1f..fc35f040c1 100644 --- a/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs +++ b/ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs @@ -1645,10 +1645,7 @@ namespace ICSharpCode.NRefactory.TypeSystem } } - if (method.IsConstructor) - m.ReturnType = parentType; - else - m.ReturnType = ReadTypeReference(method.ReturnType, typeAttributes: method.MethodReturnType); + m.ReturnType = ReadTypeReference(method.ReturnType, typeAttributes: method.MethodReturnType); if (HasAnyAttributes(method)) AddAttributes(method, m.Attributes, m.ReturnTypeAttributes); diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs index 3712d3aca2..9e51490efa 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs @@ -232,14 +232,30 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation return EmptyList.Instance; } + static readonly IUnresolvedMethod dummyConstructor = CreateDummyConstructor(); + + static IUnresolvedMethod CreateDummyConstructor() + { + var m = new DefaultUnresolvedMethod { + EntityType = EntityType.Constructor, + Name = ".ctor", + Accessibility = Accessibility.Public, + IsSynthetic = true, + ReturnType = KnownTypeReference.Void + }; + m.Freeze(); + return m; + } + public IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) { if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) { if (this.HasDefaultConstructorConstraint || this.HasValueTypeConstraint) { - throw new NotImplementedException(); - //DefaultMethod m = DefaultMethod.CreateDefaultConstructor(GetDummyClassForTypeParameter(constraints)); - //if (filter(m)) - // return new [] { m }; + if (filter == null || filter(dummyConstructor)) { + var resolvedCtor = (IMethod)dummyConstructor.CreateResolved(compilation.TypeResolveContext); + IMethod m = new SpecializedMethod(this, resolvedCtor, EmptyList.Instance); + return new [] { m }; + } } return EmptyList.Instance; } else { diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs index 3daa732ebb..e36582ad54 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedMember.cs @@ -28,7 +28,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation [Serializable] public abstract class AbstractUnresolvedMember : AbstractUnresolvedEntity, IUnresolvedMember { - ITypeReference returnType; + ITypeReference returnType = SpecialType.UnknownType; IList interfaceImplementations; public override void ApplyInterningProvider(IInterningProvider provider) @@ -67,6 +67,8 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation public ITypeReference ReturnType { get { return returnType; } set { + if (value == null) + throw new ArgumentNullException(); ThrowIfFrozen(); returnType = value; } diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs index 91dcceef34..c400f82c47 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs @@ -290,45 +290,51 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation LazyInit.ReadBarrier(); return result; } else { - result = new List(); - bool hasNonInterface = false; - if (this.Kind != TypeKind.Enum) { - foreach (var part in parts) { - var context = part.CreateResolveContext(parentContext).WithCurrentTypeDefinition(this); - foreach (var baseTypeRef in part.BaseTypes) { - IType baseType = baseTypeRef.Resolve(context); - if (!(baseType.Kind == TypeKind.Unknown || result.Contains(baseType))) { - result.Add(baseType); - if (baseType.Kind != TypeKind.Interface) - hasNonInterface = true; - } - } - } - } - if (!hasNonInterface && !(this.Name == "Object" && this.Namespace == "System" && this.TypeParameterCount == 0)) { - KnownTypeCode primitiveBaseType; - switch (this.Kind) { - case TypeKind.Enum: - primitiveBaseType = KnownTypeCode.Enum; - break; - case TypeKind.Struct: - case TypeKind.Void: - primitiveBaseType = KnownTypeCode.ValueType; - break; - case TypeKind.Delegate: - primitiveBaseType = KnownTypeCode.Delegate; - break; - default: - primitiveBaseType = KnownTypeCode.Object; - break; + result = CalculateDirectBaseTypes(); + return LazyInit.GetOrSet(ref this.directBaseTypes, result); + } + } + } + + IList CalculateDirectBaseTypes() + { + List result = new List(); + bool hasNonInterface = false; + if (this.Kind != TypeKind.Enum) { + foreach (var part in parts) { + var context = part.CreateResolveContext(parentContext).WithCurrentTypeDefinition(this); + foreach (var baseTypeRef in part.BaseTypes) { + IType baseType = baseTypeRef.Resolve(context); + if (!(baseType.Kind == TypeKind.Unknown || result.Contains(baseType))) { + result.Add(baseType); + if (baseType.Kind != TypeKind.Interface) + hasNonInterface = true; } - IType t = parentContext.Compilation.FindType(primitiveBaseType); - if (t.Kind != TypeKind.Unknown) - result.Add(t); } - return LazyInit.GetOrSet(ref this.directBaseTypes, result); } } + if (!hasNonInterface && !(this.Name == "Object" && this.Namespace == "System" && this.TypeParameterCount == 0)) { + KnownTypeCode primitiveBaseType; + switch (this.Kind) { + case TypeKind.Enum: + primitiveBaseType = KnownTypeCode.Enum; + break; + case TypeKind.Struct: + case TypeKind.Void: + primitiveBaseType = KnownTypeCode.ValueType; + break; + case TypeKind.Delegate: + primitiveBaseType = KnownTypeCode.Delegate; + break; + default: + primitiveBaseType = KnownTypeCode.Object; + break; + } + IType t = parentContext.Compilation.FindType(primitiveBaseType); + if (t.Kind != TypeKind.Unknown) + result.Add(t); + } + return result; } #endregion diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs index c374988cfb..5e2a8e4900 100644 --- a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs +++ b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs @@ -142,7 +142,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation Accessibility = typeDefinition.IsAbstract ? Accessibility.Protected : Accessibility.Public, IsSynthetic = true, Region = region, - ReturnType = typeDefinition + ReturnType = KnownTypeReference.Void }; } }