diff options
Diffstat (limited to 'ICSharpCode.Decompiler/Ast/Transforms/ConvertConstructorCallIntoInitializer.cs')
-rw-r--r-- | ICSharpCode.Decompiler/Ast/Transforms/ConvertConstructorCallIntoInitializer.cs | 183 |
1 files changed, 183 insertions, 0 deletions
diff --git a/ICSharpCode.Decompiler/Ast/Transforms/ConvertConstructorCallIntoInitializer.cs b/ICSharpCode.Decompiler/Ast/Transforms/ConvertConstructorCallIntoInitializer.cs new file mode 100644 index 00000000..36811c18 --- /dev/null +++ b/ICSharpCode.Decompiler/Ast/Transforms/ConvertConstructorCallIntoInitializer.cs @@ -0,0 +1,183 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using ICSharpCode.NRefactory.CSharp; +using ICSharpCode.NRefactory.PatternMatching; +using Mono.Cecil; + +namespace ICSharpCode.Decompiler.Ast.Transforms +{ + /// <summary> + /// If the first element of a constructor is a chained constructor call, convert it into a constructor initializer. + /// </summary> + public class ConvertConstructorCallIntoInitializer : DepthFirstAstVisitor<object, object>, IAstTransform + { + public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) + { + ExpressionStatement stmt = constructorDeclaration.Body.Statements.FirstOrDefault() as ExpressionStatement; + if (stmt == null) + return null; + InvocationExpression invocation = stmt.Expression as InvocationExpression; + if (invocation == null) + return null; + MemberReferenceExpression mre = invocation.Target as MemberReferenceExpression; + if (mre != null && mre.MemberName == ".ctor") { + ConstructorInitializer ci = new ConstructorInitializer(); + if (mre.Target is ThisReferenceExpression) + ci.ConstructorInitializerType = ConstructorInitializerType.This; + else if (mre.Target is BaseReferenceExpression) + ci.ConstructorInitializerType = ConstructorInitializerType.Base; + else + return null; + // Move arguments from invocation to initializer: + invocation.Arguments.MoveTo(ci.Arguments); + // Add the initializer: (unless it is the default 'base()') + if (!(ci.ConstructorInitializerType == ConstructorInitializerType.Base && ci.Arguments.Count == 0)) + constructorDeclaration.Initializer = ci.WithAnnotation(invocation.Annotation<MethodReference>()); + // Remove the statement: + stmt.Remove(); + } + return null; + } + + static readonly ExpressionStatement fieldInitializerPattern = new ExpressionStatement { + Expression = new AssignmentExpression { + Left = new NamedNode("fieldAccess", new MemberReferenceExpression { + Target = new ThisReferenceExpression(), + MemberName = Pattern.AnyString + }), + Operator = AssignmentOperatorType.Assign, + Right = new AnyNode("initializer") + } + }; + + static readonly AstNode thisCallPattern = new ExpressionStatement(new ThisReferenceExpression().Invoke(".ctor", new Repeat(new AnyNode()))); + + public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) + { + // Handle initializers on instance fields + HandleInstanceFieldInitializers(typeDeclaration.Members); + + // Now convert base constructor calls to initializers: + base.VisitTypeDeclaration(typeDeclaration, data); + + // Remove single empty constructor: + RemoveSingleEmptyConstructor(typeDeclaration); + + // Handle initializers on static fields: + HandleStaticFieldInitializers(typeDeclaration.Members); + return null; + } + + void HandleInstanceFieldInitializers(IEnumerable<AstNode> members) + { + var instanceCtors = members.OfType<ConstructorDeclaration>().Where(c => (c.Modifiers & Modifiers.Static) == 0).ToArray(); + var instanceCtorsNotChainingWithThis = instanceCtors.Where(ctor => !thisCallPattern.IsMatch(ctor.Body.Statements.FirstOrDefault())).ToArray(); + if (instanceCtorsNotChainingWithThis.Length > 0) { + MethodDefinition ctorMethodDef = instanceCtorsNotChainingWithThis[0].Annotation<MethodDefinition>(); + if (ctorMethodDef != null && ctorMethodDef.DeclaringType.IsValueType) + return; + + // Recognize field initializers: + // Convert first statement in all ctors (if all ctors have the same statement) into a field initializer. + bool allSame; + do { + Match m = fieldInitializerPattern.Match(instanceCtorsNotChainingWithThis[0].Body.FirstOrDefault()); + if (!m.Success) + break; + + FieldDefinition fieldDef = m.Get<AstNode>("fieldAccess").Single().Annotation<FieldReference>().ResolveWithinSameModule(); + if (fieldDef == null) + break; + AstNode fieldOrEventDecl = members.FirstOrDefault(f => f.Annotation<FieldDefinition>() == fieldDef); + if (fieldOrEventDecl == null) + break; + Expression initializer = m.Get<Expression>("initializer").Single(); + // 'this'/'base' cannot be used in field initializers + if (initializer.DescendantsAndSelf.Any(n => n is ThisReferenceExpression || n is BaseReferenceExpression)) + break; + + allSame = true; + for (int i = 1; i < instanceCtorsNotChainingWithThis.Length; i++) { + if (!instanceCtors[0].Body.First().IsMatch(instanceCtorsNotChainingWithThis[i].Body.FirstOrDefault())) + allSame = false; + } + if (allSame) { + foreach (var ctor in instanceCtorsNotChainingWithThis) + ctor.Body.First().Remove(); + fieldOrEventDecl.GetChildrenByRole(Roles.Variable).Single().Initializer = initializer.Detach(); + } + } while (allSame); + } + } + + void RemoveSingleEmptyConstructor(TypeDeclaration typeDeclaration) + { + var instanceCtors = typeDeclaration.Members.OfType<ConstructorDeclaration>().Where(c => (c.Modifiers & Modifiers.Static) == 0).ToArray(); + if (instanceCtors.Length == 1) { + ConstructorDeclaration emptyCtor = new ConstructorDeclaration(); + emptyCtor.Modifiers = ((typeDeclaration.Modifiers & Modifiers.Abstract) == Modifiers.Abstract ? Modifiers.Protected : Modifiers.Public); + emptyCtor.Body = new BlockStatement(); + if (emptyCtor.IsMatch(instanceCtors[0])) + instanceCtors[0].Remove(); + } + } + + void HandleStaticFieldInitializers(IEnumerable<AstNode> members) + { + // Convert static constructor into field initializers if the class is BeforeFieldInit + var staticCtor = members.OfType<ConstructorDeclaration>().FirstOrDefault(c => (c.Modifiers & Modifiers.Static) == Modifiers.Static); + if (staticCtor != null) { + MethodDefinition ctorMethodDef = staticCtor.Annotation<MethodDefinition>(); + if (ctorMethodDef != null && ctorMethodDef.DeclaringType.IsBeforeFieldInit) { + while (true) { + ExpressionStatement es = staticCtor.Body.Statements.FirstOrDefault() as ExpressionStatement; + if (es == null) + break; + AssignmentExpression assignment = es.Expression as AssignmentExpression; + if (assignment == null || assignment.Operator != AssignmentOperatorType.Assign) + break; + FieldDefinition fieldDef = assignment.Left.Annotation<FieldReference>().ResolveWithinSameModule(); + if (fieldDef == null || !fieldDef.IsStatic) + break; + FieldDeclaration fieldDecl = members.OfType<FieldDeclaration>().FirstOrDefault(f => f.Annotation<FieldDefinition>() == fieldDef); + if (fieldDecl == null) + break; + fieldDecl.Variables.Single().Initializer = assignment.Right.Detach(); + es.Remove(); + } + if (staticCtor.Body.Statements.Count == 0) + staticCtor.Remove(); + } + } + } + + void IAstTransform.Run(AstNode node) + { + // If we're viewing some set of members (fields are direct children of CompilationUnit), + // we also need to handle those: + HandleInstanceFieldInitializers(node.Children); + HandleStaticFieldInitializers(node.Children); + + node.AcceptVisitor(this, null); + } + } +} |