public override object TrackedVisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
{
if (constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This)
{
TypeDeclaration typeDeclaration = (TypeDeclaration)AstUtil.GetParentOfType(constructorInitializer, typeof(TypeDeclaration));
List <Expression> args = ReplaceNullArguments(typeDeclaration, constructorInitializer.Arguments, constructorInitializer);
constructorInitializer.Arguments = args;
}
return(base.TrackedVisitConstructorInitializer(constructorInitializer, data));
}
public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
{
if (!(constructorDeclaration.Body.Statements.FirstOrDefault() is ExpressionStatement stmt))
{
return;
}
var currentCtor = (IMethod)constructorDeclaration.GetSymbol();
ConstructorInitializer ci;
switch (stmt.Expression)
{
// Pattern for reference types:
// this..ctor(...);
case InvocationExpression invocation:
if (!(invocation.Target is MemberReferenceExpression mre) || mre.MemberName != ".ctor")
{
return;
}
if (!(invocation.GetSymbol() is IMethod ctor && ctor.IsConstructor))
{
return;
}
ci = new ConstructorInitializer();
var target = mre.Target;
// Ignore casts, those might be added if references are missing.
if (target is CastExpression cast)
{
target = cast.Expression;
}
if (target is ThisReferenceExpression or BaseReferenceExpression)
{
if (ctor.DeclaringTypeDefinition == currentCtor.DeclaringTypeDefinition)
{
ci.ConstructorInitializerType = ConstructorInitializerType.This;
}
else
{
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
}
}
else
{
return;
}
// 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.CopyAnnotationsFrom(invocation);
}
// Remove the statement:
stmt.Remove();
break;
public virtual object Visit(ConstructorInitializer constructorInitializer, object data)
{
Debug.Assert(constructorInitializer != null);
Debug.Assert(constructorInitializer.Arguments != null);
foreach (Expression expr in constructorInitializer.Arguments)
{
Debug.Assert(expr != null);
expr.AcceptVisitor(this, data);
}
return(data);
}
public override void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
base.VisitConstructorInitializer(constructorInitializer);
// Check if existing initializer is valid:
var rr = ctx.Resolve(constructorInitializer) as CSharpInvocationResolveResult;
if (rr != null && (rr.OverloadResolutionErrors & errorsIndicatingWrongNumberOfArguments) != 0)
{
IType targetType = constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.Base ? baseType : currentType;
AddIssue(new CodeIssue(constructorInitializer.Keyword, GetIssueText(targetType, constructorInitializer.Arguments.Count)));
}
}
public override void VisitConstructorInitializer(ConstructorInitializer initializer)
{
var result = ctx.Resolve(initializer);
if (!result.IsError)
{
this.initializerInvoked = true;
}
else
{
this.initializer = initializer;
}
}
private void AddProperConstructor(TypeDeclaration typeDeclaration, string instanceFieldName)
{
TypeReference type = new TypeReference(instanceFieldName);
ParameterDeclarationExpression fieldParameter = new ParameterDeclarationExpression(type, instanceFieldName);
FieldReferenceExpression fieldReference = new FieldReferenceExpression(new ThisReferenceExpression(), instanceFieldName);
IdentifierExpression right = new IdentifierExpression(instanceFieldName);
AssignmentExpression assignment = new AssignmentExpression(fieldReference, AssignmentOperatorType.Assign, right);
ExpressionStatement expressionStatement = new ExpressionStatement(assignment);
string fullName = GetFullName(typeDeclaration);
IList constructors = AstUtil.GetChildrenWithType(typeDeclaration, typeof(ConstructorDeclaration));
if (constructors.Count == 0)
{
string name = typeDeclaration.Name;
List <ParameterDeclarationExpression> parameters = new List <ParameterDeclarationExpression>();
parameters.Add(fieldParameter);
ConstructorDeclaration constructorDeclaration = new ConstructorDeclaration(name, Modifiers.Public, parameters, null);
constructorDeclaration.Body = new BlockStatement();
constructorDeclaration.Body.AddChild(expressionStatement);
constructorDeclaration.Parent = typeDeclaration;
CodeBase.References.Add("Cons:" + fullName, null);
typeDeclaration.Children.Add(constructorDeclaration);
}
else
{
foreach (ConstructorDeclaration constructor in constructors)
{
if (!ContainsParameter(constructor.Parameters, fieldParameter))
{
constructor.Parameters.Add(fieldParameter);
if (constructor.ConstructorInitializer != null)
{
ConstructorInitializer ci = constructor.ConstructorInitializer;
if (ci.ConstructorInitializerType == ConstructorInitializerType.This)
{
ci.Arguments.Add(new IdentifierExpression(fieldParameter.ParameterName));
}
}
constructor.Body.Children.Insert(0, expressionStatement);
}
}
if (!CodeBase.References.Contains("Cons:" + fullName))
{
CodeBase.References.Add("Cons:" + fullName, null);
}
}
}
public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
var stmt = constructorDeclaration.Body.Statements.FirstOrDefault() as ExpressionStatement;
if (stmt == null)
{
return(null);
}
var invocation = stmt.Expression as InvocationExpression;
if (invocation == null)
{
return(null);
}
var mre = invocation.Target as MemberReferenceExpression;
if (mre == null || mre.MemberName != ".ctor")
{
return(null);
}
var initializer = new ConstructorInitializer();
if (mre.Target is ThisReferenceExpression)
{
initializer.ConstructorInitializerType = ConstructorInitializerType.This;
}
else if (mre.Target is BaseReferenceExpression)
{
initializer.ConstructorInitializerType = ConstructorInitializerType.Base;
}
else
{
return(null);
}
// Move arguments from invocation to initializer:
invocation.Arguments.MoveTo(initializer.Arguments);
// Add the initializer: (unless it is the default 'base()')
if (initializer.ConstructorInitializerType != ConstructorInitializerType.Base || initializer.Arguments.Count > 0)
{
initializer.AddAnnotation(invocation.Annotation <MethodReference>());
constructorDeclaration.Initializer = initializer;
}
// Remove the statement:
stmt.Remove();
return(null);
}
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);
var ilRanges = stmt.GetAllRecursiveILRanges();
// Add the initializer: (unless it is the default 'base()')
if (!(ci.ConstructorInitializerType == ConstructorInitializerType.Base && ci.Arguments.Count == 0))
{
constructorDeclaration.Initializer = ci.WithAnnotation(invocation.Annotation <IMethod>());
ci.AddAnnotation(ilRanges);
}
else
{
constructorDeclaration.Body.HiddenStart = NRefactoryExtensions.CreateHidden(ilRanges, constructorDeclaration.Body.HiddenStart);
}
// Remove the statement:
stmt.Remove();
}
return(null);
}
public ArgumentsInfo(IEmitter emitter, ConstructorInitializer initializer)
{
this.Emitter = emitter;
this.Expression = null;
var arguments = initializer.Arguments.ToList();
this.ResolveResult = emitter.Resolver.ResolveNode(initializer, emitter) as InvocationResolveResult;
this.BuildArgumentsList(arguments);
if (this.ResolveResult != null)
{
this.HasTypeArguments = ((IMethod)this.ResolveResult.Member).TypeArguments.Count > 0;
}
}
public virtual async Task <TAggregateRoot> FindAsync(Guid aggregateId)
{
using (var eventStorage = _eventStorageFactory.Storage)
{
if (!await eventStorage.AggregateExistsAsync(aggregateId))
{
throw new AggregateNotFoundException($"Aggregate with id {aggregateId} does not exist.");
}
var events = await eventStorage.GetAggregateEventsAsync(aggregateId);
var aggregate = ConstructorInitializer.Construct <TAggregateRoot>(
new Type[] { aggregateId.GetType(), events.GetType() }, new object[] { aggregateId, events });
return(aggregate);
}
}
/// <summary>
/// Create the syntax for a class constructor.
/// </summary>
/// <param name="className">Name of the class.</param>
/// <param name="body">The generated body of the constructor.</param>
/// <param name="parameters">A list with parameters.</param>
/// <param name="modifiers">A list with modifiers.</param>
/// <param name="attributes">A list with attributes.</param>
/// <param name="constructorInitializer">The constructor initializer</param>
/// <param name="summary">XML documentation summary</param>
/// <returns>The declaration syntax for a constructor.</returns>
public static ConstructorDeclarationSyntax Create(
string className,
BlockSyntax body,
IEnumerable <Parameter> parameters = null,
IEnumerable <Modifiers> modifiers = null,
IEnumerable <Attribute> attributes = null,
ConstructorInitializer constructorInitializer = null,
string summary = null)
{
if (className == null)
{
throw new ArgumentNullException(nameof(className));
}
var constructor = SyntaxFactory.ConstructorDeclaration(SyntaxFactory.Identifier(className))
.WithBody(body);
if (parameters != null)
{
constructor = constructor.WithParameterList(ParameterGenerator.Create(parameters.ToArray()));
}
if (constructorInitializer != null)
{
constructor = constructor.WithInitializer(
SyntaxFactory.ConstructorInitializer(
constructorInitializer.ConstructorInitializerType == ConstructorInitializerTypes.Base ? SyntaxKind.BaseConstructorInitializer : SyntaxKind.ThisConstructorInitializer,
constructorInitializer.Arguments == null ? null : ArgumentGenerator.Create(constructorInitializer.Arguments.ToArray())));
}
if (attributes != null)
{
constructor = constructor.WithAttributeLists(AttributeGenerator.Create(attributes.ToArray()));
}
if (modifiers != null)
{
constructor = constructor.WithModifiers(ModifierGenerator.Create(modifiers.ToArray()));
}
if (!string.IsNullOrEmpty(summary))
{
constructor = constructor.WithSummary(summary, parameters);
}
return(constructor);
}
public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
{
var stmt = constructorDeclaration.Body.Statements.FirstOrDefault() as ExpressionStatement;
if (stmt == null)
{
return;
}
if (!(stmt.Expression is InvocationExpression invocation))
{
return;
}
if (invocation.Target is MemberReferenceExpression mre && mre.MemberName == ".ctor")
{
ConstructorInitializer ci = new ConstructorInitializer();
var target = mre.Target;
// Ignore casts, those might be added if references are missing.
if (target is CastExpression cast)
{
target = cast.Expression;
}
if (target is ThisReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.This;
}
else if (target is BaseReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
}
else
{
return;
}
// 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.CopyAnnotationsFrom(invocation);
}
// Remove the statement:
stmt.Remove();
}
}
public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
// make constructor public if visiblity is not set (unless constructor is static)
if ((constructorDeclaration.Modifier & (Modifiers.Visibility | Modifiers.Static)) == 0)
{
constructorDeclaration.Modifier |= Modifiers.Public;
}
// MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this()
BlockStatement body = constructorDeclaration.Body;
if (body != null && body.Children.Count > 0)
{
ExpressionStatement se = body.Children[0] as ExpressionStatement;
if (se != null)
{
InvocationExpression ie = se.Expression as InvocationExpression;
if (ie != null)
{
MemberReferenceExpression fre = ie.TargetObject as MemberReferenceExpression;
if (fre != null && "New".Equals(fre.MemberName, StringComparison.InvariantCultureIgnoreCase))
{
if (fre.TargetObject is BaseReferenceExpression || fre.TargetObject is ClassReferenceExpression || fre.TargetObject is ThisReferenceExpression)
{
body.Children.RemoveAt(0);
ConstructorInitializer ci = new ConstructorInitializer();
ci.Arguments = ie.Arguments;
if (fre.TargetObject is BaseReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
}
else
{
ci.ConstructorInitializerType = ConstructorInitializerType.This;
}
constructorDeclaration.ConstructorInitializer = ci;
}
}
}
}
}
return(base.VisitConstructorDeclaration(constructorDeclaration, data));
}
public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
{
ExpressionStatement stmt = constructorDeclaration.Body.Statements.FirstOrDefault() as ExpressionStatement;
if (stmt == null)
{
return;
}
InvocationExpression invocation = stmt.Expression as InvocationExpression;
if (invocation == null)
{
return;
}
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;
}
// 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.CopyAnnotationsFrom(invocation);
}
// Remove the statement:
stmt.Remove();
}
}
// The following conversions are implemented:
// MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this()
// The following conversions should be implemented in the future:
// Public Event EventName(param As String) -> automatic delegate declaration
// Function A() \n A = SomeValue \n End Function -> convert to return statement
public override object Visit(ConstructorDeclaration constructorDeclaration, object data)
{
// MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this()
BlockStatement body = constructorDeclaration.Body;
if (body != null && body.Children.Count > 0)
{
StatementExpression se = body.Children[0] as StatementExpression;
if (se != null)
{
InvocationExpression ie = se.Expression as InvocationExpression;
if (ie != null)
{
FieldReferenceExpression fre = ie.TargetObject as FieldReferenceExpression;
if (fre != null && "New".Equals(fre.FieldName, StringComparison.InvariantCultureIgnoreCase))
{
if (fre.TargetObject is BaseReferenceExpression || fre.TargetObject is ClassReferenceExpression)
{
body.Children.RemoveAt(0);
ConstructorInitializer ci = new ConstructorInitializer();
ci.Arguments = ie.Arguments;
if (fre.TargetObject is BaseReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
}
else
{
ci.ConstructorInitializerType = ConstructorInitializerType.This;
}
constructorDeclaration.ConstructorInitializer = ci;
}
}
}
}
}
return(base.Visit(constructorDeclaration, data));
}
public override void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
throw NotSupportedToConsistency();
}
public void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
JsonObject initializer = new JsonObject();
initializer.Comment = "VisitConstructorInitializer";
if (constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This)
{
initializer.AddJsonValue("keyword", GetKeyword(ConstructorInitializer.ThisKeywordRole));
}
else
{
initializer.AddJsonValue("keyword", GetKeyword(ConstructorInitializer.BaseKeywordRole));
}
initializer.AddJsonValue("arguments", GetCommaSeparatedList(constructorInitializer.Arguments));
Push(initializer);
}
public UnifiedElement VisitConstructorInitializer(
ConstructorInitializer constructorInitializer, object data)
{
throw new NotImplementedException("ConstructorInitializer");
}
protected override IEnumerable <string> GenerateCode(List <object> includedMembers)
{
bool gotConstructorOverrides = false;
foreach (IMethod m in includedMembers.OfType <IMethod> ().Where(m => m.SymbolKind == SymbolKind.Constructor))
{
gotConstructorOverrides = true;
var init = new ConstructorInitializer {
ConstructorInitializerType = ConstructorInitializerType.Base
};
var overridenConstructor = new ConstructorDeclaration {
Name = Options.EnclosingType.Name,
Modifiers = Modifiers.Public,
Body = new BlockStatement(),
};
if (m.Parameters.Count > 0)
{
overridenConstructor.Initializer = init;
}
foreach (var par in m.Parameters)
{
overridenConstructor.Parameters.Add(new ParameterDeclaration(Options.CreateShortType(par.Type), par.Name));
init.Arguments.Add(new IdentifierExpression(par.Name));
}
foreach (var member in includedMembers.OfType <IMember> ())
{
if (member.SymbolKind == SymbolKind.Constructor)
{
continue;
}
overridenConstructor.Parameters.Add(new ParameterDeclaration(Options.CreateShortType(member.ReturnType), CreateParameterName(member)));
var memberReference = new MemberReferenceExpression(new ThisReferenceExpression(), member.Name);
var assign = new AssignmentExpression(memberReference, AssignmentOperatorType.Assign, new IdentifierExpression(CreateParameterName(member)));
overridenConstructor.Body.Statements.Add(new ExpressionStatement(assign));
}
yield return(overridenConstructor.ToString(Options.FormattingOptions));
}
if (gotConstructorOverrides)
{
yield break;
}
var constructorDeclaration = new ConstructorDeclaration {
Name = Options.EnclosingType.Name,
Modifiers = Modifiers.Public,
Body = new BlockStatement()
};
foreach (IMember member in includedMembers)
{
constructorDeclaration.Parameters.Add(new ParameterDeclaration(Options.CreateShortType(member.ReturnType), CreateParameterName(member)));
var memberReference = new MemberReferenceExpression(new ThisReferenceExpression(), member.Name);
var assign = new AssignmentExpression(memberReference, AssignmentOperatorType.Assign, new IdentifierExpression(CreateParameterName(member)));
constructorDeclaration.Body.Statements.Add(new ExpressionStatement(assign));
}
yield return(constructorDeclaration.ToString(Options.FormattingOptions));
}
public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
{
throw new global::System.NotImplementedException("ConstructorInitializer");
}
public object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
{
throw new ApplicationException("ConstructorInitializer visited.");
}
public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
{
// make constructor public if visiblity is not set (unless constructor is static)
if ((constructorDeclaration.Modifier & (Modifiers.Visibility | Modifiers.Static)) == 0)
constructorDeclaration.Modifier |= Modifiers.Public;
// MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this()
BlockStatement body = constructorDeclaration.Body;
if (body != null && body.Children.Count > 0) {
ExpressionStatement se = body.Children[0] as ExpressionStatement;
if (se != null) {
InvocationExpression ie = se.Expression as InvocationExpression;
if (ie != null) {
MemberReferenceExpression fre = ie.TargetObject as MemberReferenceExpression;
if (fre != null && "New".Equals(fre.MemberName, StringComparison.InvariantCultureIgnoreCase)) {
if (fre.TargetObject is BaseReferenceExpression || fre.TargetObject is ClassReferenceExpression || fre.TargetObject is ThisReferenceExpression) {
body.Children.RemoveAt(0);
ConstructorInitializer ci = new ConstructorInitializer();
ci.Arguments = ie.Arguments;
if (fre.TargetObject is BaseReferenceExpression)
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
else
ci.ConstructorInitializerType = ConstructorInitializerType.This;
constructorDeclaration.ConstructorInitializer = ci;
}
}
}
}
}
return base.VisitConstructorDeclaration(constructorDeclaration, data);
}
void ConstructorInitializer(
#line 1317 "cs.ATG"
out ConstructorInitializer ci) {
#line 1318 "cs.ATG"
Expression expr; ci = new ConstructorInitializer();
Expect(9);
if (la.kind == 51) {
lexer.NextToken();
#line 1322 "cs.ATG"
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
} else if (la.kind == 111) {
lexer.NextToken();
#line 1323 "cs.ATG"
ci.ConstructorInitializerType = ConstructorInitializerType.This;
} else SynErr(184);
Expect(20);
if (StartOf(26)) {
Argument(
#line 1326 "cs.ATG"
out expr);
#line 1326 "cs.ATG"
SafeAdd(ci, ci.Arguments, expr);
while (la.kind == 14) {
lexer.NextToken();
Argument(
#line 1327 "cs.ATG"
out expr);
#line 1327 "cs.ATG"
SafeAdd(ci, ci.Arguments, expr);
}
}
Expect(21);
}
public void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
throw new NotImplementedException();
}
public override void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
ForceSpacesBefore(constructorInitializer.LParToken, policy.SpaceBeforeMethodCallParentheses);
if (constructorInitializer.Arguments.Any()) {
ForceSpacesAfter(constructorInitializer.LParToken, policy.SpaceWithinMethodCallParentheses);
} else {
ForceSpacesAfter(constructorInitializer.LParToken, policy.SpaceBetweenEmptyMethodCallParentheses);
ForceSpacesBefore(constructorInitializer.RParToken, policy.SpaceBetweenEmptyMethodCallParentheses);
}
FormatArguments(constructorInitializer);
}
public override object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
{
WriteLine("VisitConstructorInitializer");
return(base.VisitConstructorInitializer(constructorInitializer, data));
}
public override void VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
{
if (!(constructorDeclaration.Body.Statements.FirstOrDefault() is ExpressionStatement stmt))
{
return;
}
var currentCtor = (IMethod)constructorDeclaration.GetSymbol();
ConstructorInitializer ci;
switch (stmt.Expression)
{
// Pattern for reference types:
// this..ctor(...);
case InvocationExpression invocation:
if (!(invocation.Target is MemberReferenceExpression mre) || mre.MemberName != ".ctor")
{
return;
}
if (!(invocation.GetSymbol() is IMethod ctor && ctor.IsConstructor))
{
return;
}
ci = new ConstructorInitializer();
var target = mre.Target;
// Ignore casts, those might be added if references are missing.
if (target is CastExpression cast)
{
target = cast.Expression;
}
if (target is ThisReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.This;
}
else if (target is BaseReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.Base;
}
else
{
return;
}
// 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.CopyAnnotationsFrom(invocation);
}
// Remove the statement:
stmt.Remove();
break;
// Pattern for value types:
// this = new TSelf(...);
case AssignmentExpression assignment:
if (!(assignment.Right is ObjectCreateExpression oce && oce.GetSymbol() is IMethod ctor2 && ctor2.DeclaringTypeDefinition == currentCtor.DeclaringTypeDefinition))
{
return;
}
ci = new ConstructorInitializer();
if (assignment.Left is ThisReferenceExpression)
{
ci.ConstructorInitializerType = ConstructorInitializerType.This;
}
else
{
return;
}
// Move arguments from invocation to initializer:
oce.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.CopyAnnotationsFrom(oce);
}
// Remove the statement:
stmt.Remove();
break;
default:
return;
}
if (context.DecompileRun.RecordDecompilers.TryGetValue(currentCtor.DeclaringTypeDefinition, out var record) &&
currentCtor.Equals(record.PrimaryConstructor) &&
ci.ConstructorInitializerType == ConstructorInitializerType.Base)
{
if (constructorDeclaration.Parent is TypeDeclaration {
BaseTypes : { Count : >= 1 }
} typeDecl)
{
var baseType = typeDecl.BaseTypes.First();
var newBaseType = new InvocationAstType();
baseType.ReplaceWith(newBaseType);
newBaseType.BaseType = baseType;
ci.Arguments.MoveTo(newBaseType.Arguments);
}
constructorDeclaration.Remove();
}
}
public virtual void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
StartNode(constructorInitializer);
WriteToken(Roles.Colon, BoxedTextColor.Punctuation);
Space();
DebugStart(constructorInitializer);
if (constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This) {
WriteKeyword(ConstructorInitializer.ThisKeywordRole);
} else {
WriteKeyword(ConstructorInitializer.BaseKeywordRole);
}
Space(policy.SpaceBeforeMethodCallParentheses);
WriteCommaSeparatedListInParenthesis(constructorInitializer.Arguments, policy.SpaceWithinMethodCallParentheses, CodeBracesRangeFlags.Parentheses);
DebugEnd(constructorInitializer);
EndNode(constructorInitializer);
}
/// <inheritdoc/>
public virtual void VisitConstructorInitializer(ConstructorInitializer syntax)
{
VisitNode(syntax);
}
public override void VisitConstructorInitializer(ConstructorInitializer syntax)
{
_underlyingVisitor.VisitConstructorInitializer(syntax);
}
public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
Debug.Assert((constructorInitializer != null));
Debug.Assert((constructorInitializer.Arguments != null));
foreach (Expression o in constructorInitializer.Arguments) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
return null;
}
protected override IEnumerable<string> GenerateCode (List<object> includedMembers)
{
bool gotConstructorOverrides = false;
foreach (IMethod m in includedMembers.OfType<IMethod> ().Where (m => m.SymbolKind == SymbolKind.Constructor)) {
gotConstructorOverrides = true;
var init = new ConstructorInitializer {
ConstructorInitializerType = ConstructorInitializerType.Base
};
var overridenConstructor = new ConstructorDeclaration {
Name = Options.EnclosingType.Name,
Modifiers = Modifiers.Public,
Body = new BlockStatement (),
};
if (m.Parameters.Count > 0)
overridenConstructor.Initializer = init;
foreach (var par in m.Parameters) {
overridenConstructor.Parameters.Add (new ParameterDeclaration (Options.CreateShortType (par.Type), par.Name));
init.Arguments.Add (new IdentifierExpression(par.Name));
}
foreach (var member in includedMembers.OfType<IMember> ()) {
if (member.SymbolKind == SymbolKind.Constructor)
continue;
overridenConstructor.Parameters.Add (new ParameterDeclaration (Options.CreateShortType (member.ReturnType), CreateParameterName (member)));
var memberReference = new MemberReferenceExpression (new ThisReferenceExpression (), member.Name);
var assign = new AssignmentExpression (memberReference, AssignmentOperatorType.Assign, new IdentifierExpression (CreateParameterName (member)));
overridenConstructor.Body.Statements.Add (new ExpressionStatement (assign));
}
yield return overridenConstructor.ToString (Options.FormattingOptions);
}
if (gotConstructorOverrides)
yield break;
var constructorDeclaration = new ConstructorDeclaration {
Name = Options.EnclosingType.Name,
Modifiers = Modifiers.Public,
Body = new BlockStatement ()
};
foreach (IMember member in includedMembers) {
constructorDeclaration.Parameters.Add (new ParameterDeclaration (Options.CreateShortType (member.ReturnType), CreateParameterName (member)));
var memberReference = new MemberReferenceExpression (new ThisReferenceExpression (), member.Name);
var assign = new AssignmentExpression (memberReference, AssignmentOperatorType.Assign, new IdentifierExpression (CreateParameterName (member)));
constructorDeclaration.Body.Statements.Add (new ExpressionStatement (assign));
}
yield return constructorDeclaration.ToString (Options.FormattingOptions);
}
public override object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
{
return(null);
}
public IList<JsStatement> CompileConstructorInitializer(ConstructorInitializer initializer, bool currentIsStaticMethod) {
SetRegion(initializer.GetRegion());
try {
var rr = _resolver.Resolve(initializer);
if (rr is DynamicInvocationResolveResult) {
_errorReporter.Message(Messages._7998, initializer.ConstructorInitializerType == ConstructorInitializerType.Base ? "dynamic invocation of base constructor" : "dynamic constructor chaining");
return new JsStatement[0];
}
else {
var csirr = (CSharpInvocationResolveResult)rr;
return _expressionCompiler.CompileConstructorInitializer((IMethod)csirr.Member, csirr.GetArgumentsForCall(), csirr.GetArgumentToParameterMap(), csirr.InitializerStatements, currentIsStaticMethod);
}
}
catch (Exception ex) {
_errorReporter.InternalError(ex);
return new JsStatement[0];
}
}
public void VisitTypeDeclaration(TypeDeclaration node)
{
nextEnumValue = 0;
VisitChildren(node);
// Automatically generate constructor bodies
var result = resolver.Resolve(node) as TypeResolveResult;
if (result != null) {
foreach (var method in result.Type.GetConstructors()) {
if (!method.IsSynthetic) {
continue;
}
// Add the declaration to the tree so it will be emitted
var declaration = new ConstructorDeclaration();
var body = new BlockStatement();
if (result.Type.BaseClass() != null) {
var initializer = new ConstructorInitializer();
initializer.ConstructorInitializerType = ConstructorInitializerType.Base;
declaration.Initializer = initializer;
}
declaration.Name = result.Type.Name;
declaration.Body = body;
body.InsertChildAfter(null, new NewLineNode(), Roles.NewLine);
InsertFieldInitializersIntoConstructorBody(result.Type, declaration);
node.AddChild(declaration, Roles.TypeMemberRole);
context.constructors[method] = declaration;
}
}
}
public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
throw new global::System.NotImplementedException("ConstructorInitializer");
}
public void VisitConstructorInitializer(ConstructorInitializer node)
{
VisitChildren(node);
}
public JNode VisitConstructorInitializer(ConstructorInitializer node)
{
throw new NotImplementedException();
}
public virtual object TrackedVisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
return base.VisitConstructorInitializer(constructorInitializer, data);
}
public Node VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
return(CreateDummy(constructorInitializer));
}
public virtual void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(constructorInitializer);
}
}
public StringBuilder VisitConstructorInitializer(ConstructorInitializer constructorInitializer, int data)
{
throw new NotSupportedException();
}
public virtual void VisitConstructorInitializer (ConstructorInitializer constructorInitializer)
{
VisitChildren (constructorInitializer);
}
public sealed override object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
BeginVisit(constructorInitializer);
object result = TrackedVisitConstructorInitializer(constructorInitializer, data);
EndVisit(constructorInitializer);
return result;
}
public StringBuilder VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
throw new NotImplementedException();
}
public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
Debug.Assert((constructorInitializer != null));
Debug.Assert((constructorInitializer.Arguments != null));
for (int i = 0; i < constructorInitializer.Arguments.Count; i++) {
Expression o = constructorInitializer.Arguments[i];
Debug.Assert(o != null);
nodeStack.Push(o);
o.AcceptVisitor(this, data);
o = (Expression)nodeStack.Pop();
if (o == null)
constructorInitializer.Arguments.RemoveAt(i--);
else
constructorInitializer.Arguments[i] = o;
}
return null;
}
public void VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
{
StartNode(constructorInitializer);
WriteToken(Roles.Colon);
Space();
if (constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This) {
WriteKeyword(ConstructorInitializer.ThisKeywordRole);
} else {
WriteKeyword(ConstructorInitializer.BaseKeywordRole);
}
Space(policy.SpaceBeforeMethodCallParentheses);
WriteCommaSeparatedListInParenthesis(constructorInitializer.Arguments, policy.SpaceWithinMethodCallParentheses);
EndNode(constructorInitializer);
}
public ConstructorDeclaration(IEnumerable<ParameterDeclaration> parameters, ConstructorInitializer initializer)
: base(parameters)
{
Initializer = initializer;
}