public static void Write(this ConstructorInitializerSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var symbol = (IMethodSymbol)context.SemanticModel.GetSymbolInfo(syntax).Symbol;
if (syntax.Kind() == SyntaxKind.BaseConstructorInitializer)
{
textWriter.Write("(element % _M.DOT_LVL(typeObject.Level - 1))._C_0_");
context.SignatureWriter.WriteSignature(symbol.Parameters.Select(p => p.Type).ToArray(), textWriter);
}
else if (syntax.Kind() == SyntaxKind.ThisConstructorInitializer)
{
textWriter.Write("(element % _M.DOT_LVL(typeObject.Level))");
var signatureWriter = textWriter.CreateTextWriterAtSameIndent();
var hasGenericComponents = context.SignatureWriter.WriteSignature(symbol.Parameters.Select(p => p.Type).ToArray(), signatureWriter);
if (hasGenericComponents)
{
textWriter.Write("['_C_0_'..(");
textWriter.AppendTextWriter(signatureWriter);
textWriter.Write(")]");
}
else
{
textWriter.Write("._C_0_");
textWriter.AppendTextWriter(signatureWriter);
}
}
syntax.ArgumentList.Write(textWriter, context);
textWriter.WriteLine(";");
}
> GetConstructorInitializerParameterLists(
SemanticModel semanticModel,
int position,
ConstructorInitializerSyntax constructorInitializer,
CancellationToken cancellationToken
)
{
var within = semanticModel.GetEnclosingNamedType(position, cancellationToken);
if (
within != null
&& (within.TypeKind == TypeKind.Struct || within.TypeKind == TypeKind.Class)
)
{
var type =
constructorInitializer.Kind() == SyntaxKind.BaseConstructorInitializer
? within.BaseType
: within;
if (type != null)
{
return type.InstanceConstructors
.Where(c => c.IsAccessibleWithin(within))
.Select(c => c.Parameters);
}
}
return null;
}
private static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context)
{
var constructor = (ConstructorDeclarationSyntax)context.Node;
ConstructorInitializerSyntax initializer = constructor.Initializer;
if (initializer?.Kind() == SyntaxKind.BaseConstructorInitializer &&
initializer.ArgumentList?.Arguments.Count == 0 &&
initializer
.DescendantTrivia(initializer.Span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
DiagnosticHelpers.ReportDiagnostic(context,
DiagnosticDescriptors.RemoveRedundantBaseConstructorCall,
initializer);
}
}
/// <summary>
/// Returns true if the method is a constructor and has a this() constructor initializer.
/// </summary>
internal static bool HasThisConstructorInitializer(this MethodSymbol method)
{
if ((object)method != null && method.MethodKind == MethodKind.Constructor)
{
SourceMemberMethodSymbol sourceMethod = method as SourceMemberMethodSymbol;
if ((object)sourceMethod != null)
{
ConstructorDeclarationSyntax constructorSyntax = sourceMethod.SyntaxNode as ConstructorDeclarationSyntax;
if (constructorSyntax != null)
{
ConstructorInitializerSyntax initializerSyntax = constructorSyntax.Initializer;
if (initializerSyntax != null)
{
return(initializerSyntax.Kind() == SyntaxKind.ThisConstructorInitializer);
}
}
}
}
return(false);
}
internal static DocumentationCommentData GenerateFromBase(ConstructorDeclarationSyntax constructorDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken))
{
ConstructorInitializerSyntax initializer = constructorDeclaration.Initializer;
if (initializer?.Kind() == SyntaxKind.BaseConstructorInitializer)
{
ISymbol baseConstructor = semanticModel.GetSymbol(initializer, cancellationToken);
if (baseConstructor?.IsErrorType() == false)
{
SyntaxTrivia trivia = GetDocumentationCommentTrivia(baseConstructor, semanticModel, constructorDeclaration.SpanStart, cancellationToken);
if (trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia))
{
return(new DocumentationCommentData(trivia, DocumentationCommentOrigin.BaseMember));
}
}
}
return(default(DocumentationCommentData));
}
private static Task <Document> RefactorAsync(
Document document,
VariableDeclaratorSyntax variableDeclarator,
TypeDeclarationSyntax typeDeclaration,
CancellationToken cancellationToken)
{
SyntaxList <MemberDeclarationSyntax> members = typeDeclaration.Members;
string name = variableDeclarator.Identifier.ValueText;
string camelCaseName = StringUtility.ToCamelCase(name);
HashSet <string> reservedNames = null;
for (int i = 0; i < members.Count; i++)
{
if (!(members[i] is ConstructorDeclarationSyntax constructorDeclaration))
{
continue;
}
if (constructorDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword))
{
continue;
}
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
if (parameterList == null)
{
continue;
}
BlockSyntax body = constructorDeclaration.Body;
if (body == null)
{
continue;
}
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
reservedNames?.Clear();
string parameterName = GetParameterName(camelCaseName, parameters, ref reservedNames);
ParameterSyntax parameter = Parameter(((VariableDeclarationSyntax)variableDeclarator.Parent).Type.WithoutTrivia(), parameterName);
parameterList = parameterList.WithParameters(parameters.Add(parameter)).WithFormatterAnnotation();
ConstructorInitializerSyntax initializer = constructorDeclaration.Initializer;
if (initializer?.Kind() == SyntaxKind.ThisConstructorInitializer)
{
ArgumentListSyntax argumentList = initializer.ArgumentList;
if (argumentList != null)
{
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList.Arguments;
initializer = initializer.WithArgumentList(
argumentList.WithArguments(
arguments.Add(Argument(IdentifierName(parameterName))))).WithFormatterAnnotation();
}
}
body = body.WithStatements(
body.Statements.Add(
SimpleAssignmentStatement(
SimpleMemberAccessExpression(ThisExpression(), IdentifierName(name)).WithSimplifierAnnotation(),
IdentifierName(parameterName)).WithFormatterAnnotation()));
constructorDeclaration = constructorDeclaration.Update(
constructorDeclaration.AttributeLists,
constructorDeclaration.Modifiers,
constructorDeclaration.Identifier,
parameterList,
initializer,
body,
constructorDeclaration.SemicolonToken);
members = members.ReplaceAt(i, constructorDeclaration);
}
TypeDeclarationSyntax newNode = typeDeclaration.WithMembers(members);
return(document.ReplaceNodeAsync(typeDeclaration, newNode, cancellationToken));
}
private static Task <Document> RefactorAsync(
Document document,
ImmutableArray <FieldInfo> fieldInfos,
TypeDeclarationSyntax typeDeclaration,
CancellationToken cancellationToken)
{
SyntaxList <MemberDeclarationSyntax> members = typeDeclaration.Members;
HashSet <string> reservedNames = null;
for (int i = 0; i < members.Count; i++)
{
if (!(members[i] is ConstructorDeclarationSyntax constructorDeclaration))
{
continue;
}
if (constructorDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword))
{
continue;
}
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
if (parameterList == null)
{
continue;
}
BlockSyntax body = constructorDeclaration.Body;
if (body == null)
{
continue;
}
SeparatedSyntaxList <ParameterSyntax> parameters = parameterList.Parameters;
reservedNames?.Clear();
ConstructorInitializerSyntax initializer = constructorDeclaration.Initializer;
ArgumentListSyntax argumentList = initializer?.ArgumentList;
SeparatedSyntaxList <ArgumentSyntax> arguments = argumentList?.Arguments ?? default;
bool addToInitializer = initializer?.Kind() == SyntaxKind.ThisConstructorInitializer &&
argumentList != null;
SyntaxList <StatementSyntax> statements = body.Statements;
foreach (FieldInfo fieldInfo in fieldInfos)
{
string parameterName = GetParameterName(fieldInfo.NameCamelCase, parameters, ref reservedNames);
parameters = parameters.Add(Parameter(fieldInfo.Type.WithoutTrivia(), parameterName));
if (addToInitializer)
{
arguments = arguments.Add(Argument(IdentifierName(parameterName)));
}
statements = statements.Add(
SimpleAssignmentStatement(
SimpleMemberAccessExpression(ThisExpression(), IdentifierName(fieldInfo.Name)).WithSimplifierAnnotation(),
IdentifierName(parameterName)).WithFormatterAnnotation());
}
parameterList = parameterList.WithParameters(parameters).WithFormatterAnnotation();
if (addToInitializer)
{
initializer = initializer
.WithArgumentList(argumentList.WithArguments(arguments))
.WithFormatterAnnotation();
}
body = body.WithStatements(statements);
constructorDeclaration = constructorDeclaration.Update(
constructorDeclaration.AttributeLists,
constructorDeclaration.Modifiers,
constructorDeclaration.Identifier,
parameterList,
initializer,
body,
constructorDeclaration.SemicolonToken);
members = members.ReplaceAt(i, constructorDeclaration);
}
TypeDeclarationSyntax newNode = typeDeclaration.WithMembers(members);
return(document.ReplaceNodeAsync(typeDeclaration, newNode, cancellationToken));
}
