public static Doc Print(ImplicitObjectCreationExpressionSyntax node)
{
// TODO 1 more tests for this?
return(Doc.Concat(
Token.Print(node.NewKeyword),
ArgumentList.Print(node.ArgumentList),
node.Initializer != null ? Node.Print(node.Initializer) : Doc.Null
));
}
private Doc PrintImplicitObjectCreationExpressionSyntax(
ImplicitObjectCreationExpressionSyntax node)
{
// TODO 1 more tests for this?
return(Concat(
this.PrintSyntaxToken(node.NewKeyword),
this.PrintArgumentListSyntax(node.ArgumentList),
this.Print(node.Initializer)
));
}
public static Doc Print(ImplicitObjectCreationExpressionSyntax node)
{
return(Doc.Concat(
Token.Print(node.NewKeyword),
ArgumentList.Print(node.ArgumentList),
node.Initializer != null
? Doc.Concat(Doc.Line, Node.Print(node.Initializer))
: Doc.Null
));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(
root,
context.Span,
out SyntaxNode node,
predicate: f => f.IsKind(SyntaxKind.ObjectCreationExpression, SyntaxKind.ImplicitObjectCreationExpression, SyntaxKind.VariableDeclaration)))
{
return;
}
Document document = context.Document;
Diagnostic diagnostic = context.Diagnostics[0];
if (node is ObjectCreationExpressionSyntax objectCreation)
{
CodeAction codeAction = CodeAction.Create(
"Use implicit object creation",
ct =>
{
ImplicitObjectCreationExpressionSyntax implicitObjectCreation = ImplicitObjectCreationExpression(
objectCreation.NewKeyword.WithTrailingTrivia(objectCreation.NewKeyword.TrailingTrivia.EmptyIfWhitespace()),
objectCreation.ArgumentList ?? ArgumentList().WithTrailingTrivia(objectCreation.Type.GetTrailingTrivia()),
objectCreation.Initializer);
if (objectCreation.IsParentKind(SyntaxKind.EqualsValueClause) &&
objectCreation.Parent.IsParentKind(SyntaxKind.VariableDeclarator) &&
objectCreation.Parent.Parent.Parent is VariableDeclarationSyntax variableDeclaration &&
variableDeclaration.Type.IsVar)
{
VariableDeclarationSyntax newVariableDeclaration = variableDeclaration
.ReplaceNode(objectCreation, implicitObjectCreation)
.WithType(objectCreation.Type.WithTriviaFrom(variableDeclaration.Type));
return(document.ReplaceNodeAsync(variableDeclaration, newVariableDeclaration, ct));
}
else
{
return(document.ReplaceNodeAsync(objectCreation, implicitObjectCreation, ct));
}
},
/// <inheritdoc/>
public override SyntaxNode VisitImplicitObjectCreationExpression(ImplicitObjectCreationExpressionSyntax node)
{
var updatedNode = (ImplicitObjectCreationExpressionSyntax)base.VisitImplicitObjectCreationExpression(node) !;
if (SemanticModel.For(node).GetTypeInfo(node).Type is ITypeSymbol {
IsUnmanagedType : false
} type)
{
Context.ReportDiagnostic(InvalidObjectCreationExpression, node, type);
}
TypeSyntax explicitType = IdentifierName("").ReplaceAndTrackType(node, SemanticModel.For(node), DiscoveredTypes);
// Mutate the syntax like with explicit object creation expressions
if (updatedNode.ArgumentList !.Arguments.Count == 0)
{
return(CastExpression(explicitType, LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))));
}
// Add explicit casts like with the explicit object creation expressions above
if (SemanticModel.For(node).GetTypeInfo(node).Type is ITypeSymbol matrixType &&
HlslKnownTypes.IsMatrixType(matrixType.GetFullMetadataName()))
{
for (int i = 0; i < node.ArgumentList.Arguments.Count; i++)
{
IArgumentOperation argumentOperation = (IArgumentOperation)SemanticModel.For(node).GetOperation(node.ArgumentList.Arguments[i]) !;
INamedTypeSymbol elementType = (INamedTypeSymbol)argumentOperation.Parameter !.Type;
updatedNode = updatedNode.ReplaceNode(
updatedNode.ArgumentList.Arguments[i].Expression,
CastExpression(IdentifierName(HlslKnownTypes.GetMappedName(elementType)), updatedNode.ArgumentList.Arguments[i].Expression));
}
}
return(InvocationExpression(explicitType, updatedNode.ArgumentList));
}
public override void VisitImplicitObjectCreationExpression(ImplicitObjectCreationExpressionSyntax node) => base.VisitImplicitObjectCreationExpression(node);
private static void ReportDiagnostic(SyntaxNodeAnalysisContext context, ImplicitObjectCreationExpressionSyntax implicitObjectCreation)
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticRules.UseImplicitOrExplicitObjectCreation, implicitObjectCreation, "explicit");
}
public override void VisitImplicitObjectCreationExpression(ImplicitObjectCreationExpressionSyntax node)
{
Log(node, "Unsupported Syntax !");
}
