public static async Task <string> Process(IEnumerable <IProcessor> processors, string inputSource)
{
try
{
var workspace = new AdhocWorkspace();
string projName = "NewProject";
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(projectId, versionStamp, projName, projName, LanguageNames.CSharp);
var newProject = workspace.AddProject(projectInfo);
var document = workspace.AddDocument(newProject.Id, "NewFile.cs", SourceText.From(inputSource));
DocumentEditor editor = await DocumentEditor.CreateAsync(document);
foreach (var processor in processors)
{
processor.Process(editor);
}
return((await editor.GetChangedDocument().GetTextAsync()).ToString());
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
return(inputSource);
}
}
private Task <Document> MakeSealed(DocumentEditor editor, SyntaxNode declaration, CancellationToken ct)
{
DeclarationModifiers modifiers = editor.Generator.GetModifiers(declaration);
editor.SetModifiers(declaration, modifiers + DeclarationModifiers.Sealed);
return(Task.FromResult(editor.GetChangedDocument()));
}
protected override async Task <Document> FixAllAsync(FixAllContext fixAllContext, Document document, ImmutableArray <Diagnostic> diagnostics)
{
SyntaxNode?root = await document.GetSyntaxRootAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
if (root == null)
{
return(document);
}
DocumentEditor editor = await DocumentEditor.CreateAsync(document, fixAllContext.CancellationToken).ConfigureAwait(false);
switch (fixAllContext.CodeActionEquivalenceKey)
{
case AddMissingCustomTypeMarshallerMembersKey:
foreach (IGrouping <TextSpan, Diagnostic> diagnosticsBySpan in diagnostics.GroupBy(d => d.Location.SourceSpan))
{
SyntaxNode node = root.FindNode(diagnosticsBySpan.Key);
AddMissingMembers(editor, diagnosticsBySpan, node);
}
break;
default:
break;
}
return(editor.GetChangedDocument());
}
private async Task <Document> MakePublic(Document document, SyntaxNode getMethod, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
editor.SetAccessibility(getMethod, Accessibility.Public);
return(editor.GetChangedDocument());
}
private static async Task <Document> ConvertToArrayEmptyAsync(Document document, SyntaxNode nodeToFix, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SyntaxGenerator generator = editor.Generator;
INamedTypeSymbol?arrayTypeSymbol = semanticModel.Compilation.GetSpecialType(SpecialType.System_Array);
if (arrayTypeSymbol == null)
{
return(document);
}
ITypeSymbol?elementType = GetArrayElementType(nodeToFix, semanticModel, cancellationToken);
if (elementType == null)
{
return(document);
}
SyntaxNode arrayEmptyInvocation = GenerateArrayEmptyInvocation(generator, arrayTypeSymbol, elementType).WithTriviaFrom(nodeToFix);
editor.ReplaceNode(nodeToFix, arrayEmptyInvocation);
return(editor.GetChangedDocument());
}
private static async Task <Document> ImplementIDisposable(Document document, SyntaxNode declaration, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
SyntaxGenerator generator = editor.Generator;
SemanticModel model = editor.SemanticModel;
// Add the interface to the baselist.
SyntaxNode interfaceType = generator.TypeExpression(WellKnownTypes.IDisposable(model.Compilation));
editor.AddInterfaceType(declaration, interfaceType);
// Find a Dispose method. If one exists make that implement IDisposable, else generate a new method.
var typeSymbol = model.GetDeclaredSymbol(declaration) as INamedTypeSymbol;
IMethodSymbol disposeMethod = (typeSymbol?.GetMembers("Dispose"))?.OfType <IMethodSymbol>()?.Where(m => m.Parameters.Length == 0).FirstOrDefault();
if (disposeMethod != null && disposeMethod.DeclaringSyntaxReferences.Length == 1)
{
SyntaxNode memberPartNode = await disposeMethod.DeclaringSyntaxReferences.Single().GetSyntaxAsync(cancellationToken).ConfigureAwait(false);
memberPartNode = generator.GetDeclaration(memberPartNode);
editor.ReplaceNode(memberPartNode, generator.AsPublicInterfaceImplementation(memberPartNode, interfaceType));
}
else
{
SyntaxNode throwStatement = generator.ThrowStatement(generator.ObjectCreationExpression(WellKnownTypes.NotImplementedException(model.Compilation)));
SyntaxNode member = generator.MethodDeclaration(TypesThatOwnDisposableFieldsShouldBeDisposableAnalyzer <SyntaxNode> .Dispose, statements: new[] { throwStatement });
member = generator.AsPublicInterfaceImplementation(member, interfaceType);
editor.AddMember(declaration, member);
}
return(editor.GetChangedDocument());
}
private async Task <Document> ImplementOperatorEquals(Document document, SyntaxNode declaration, INamedTypeSymbol typeSymbol, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
var generator = editor.Generator;
if (!typeSymbol.IsOperatorImplemented(WellKnownMemberNames.EqualityOperatorName))
{
var equalityOperator = GenerateOperatorDeclaration(generator.TypeExpression(SpecialType.System_Boolean),
WellKnownMemberNames.EqualityOperatorName,
new[]
{
generator.ParameterDeclaration("left", generator.TypeExpression(typeSymbol)),
generator.ParameterDeclaration("right", generator.TypeExpression(typeSymbol)),
},
generator.ThrowStatement(generator.ObjectCreationExpression(generator.DottedName("System.NotImplementedException"))));
editor.AddMember(declaration, equalityOperator);
}
if (!typeSymbol.IsOperatorImplemented(WellKnownMemberNames.InequalityOperatorName))
{
var inequalityOperator = GenerateOperatorDeclaration(generator.TypeExpression(SpecialType.System_Boolean),
WellKnownMemberNames.InequalityOperatorName,
new[]
{
generator.ParameterDeclaration("left", generator.TypeExpression(typeSymbol)),
generator.ParameterDeclaration("right", generator.TypeExpression(typeSymbol)),
},
generator.ThrowStatement(generator.ObjectCreationExpression(generator.DottedName("System.NotImplementedException"))));
editor.AddMember(declaration, inequalityOperator);
}
return(editor.GetChangedDocument());
}
private static Task <Document> MakeSealedAsync(DocumentEditor editor, SyntaxNode declaration)
{
DeclarationModifiers modifiers = editor.Generator.GetModifiers(declaration);
editor.SetModifiers(declaration, modifiers + DeclarationModifiers.Sealed);
return(Task.FromResult(editor.GetChangedDocument()));
}
private async Task <Document> MakePublic(Document document, SyntaxNode getMethod, SyntaxNode property, CancellationToken cancellationToken)
{
// Clear the accessibility on the getter.
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
editor.SetAccessibility(getMethod, Accessibility.NotApplicable);
// If the containing property is not public, make it so
Accessibility propertyAccessibility = editor.Generator.GetAccessibility(property);
if (propertyAccessibility != Accessibility.Public)
{
editor.SetAccessibility(property, Accessibility.Public);
// Having just made the property public, if it has a setter with no Accessibility set, then we've just made the setter public.
// Instead restore the setter's original accessibility so that we don't fire a violation with the generated code.
SyntaxNode setter = editor.Generator.GetAccessor(property, DeclarationKind.SetAccessor);
if (setter != null)
{
Accessibility setterAccessibility = editor.Generator.GetAccessibility(setter);
if (setterAccessibility == Accessibility.NotApplicable)
{
editor.SetAccessibility(setter, propertyAccessibility);
}
}
}
return(editor.GetChangedDocument());
}
private async Task <Document> WithAttributeAsync([NotNull] INamedTypeSymbol attribute,
[NotNull] Document document, [NotNull] SyntaxNode syntaxNode, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
// Add NotNull/CanBeNull/ItemNotNull/ItemCanBeNull attribute.
SyntaxNode attributeSyntax =
editor.Generator.Attribute(editor.Generator.TypeExpression(attribute))
.WithAdditionalAnnotations(Simplifier.Annotation, Formatter.Annotation, NamespaceImportAnnotation);
editor.AddAttribute(syntaxNode, attributeSyntax);
Document documentWithAttribute = editor.GetChangedDocument();
// Add namespace import.
Document documentWithImport =
await
ImportAdder.AddImportsAsync(documentWithAttribute, NamespaceImportAnnotation, null,
cancellationToken).ConfigureAwait(false);
// Simplify and reformat all annotated nodes.
Document simplified = await SimplifyAsync(documentWithImport, cancellationToken).ConfigureAwait(false);
SyntaxNode formatted = await FormatAsync(simplified, cancellationToken).ConfigureAwait(false);
return(simplified.WithSyntaxRoot(formatted));
}
private async Task <Document> RemoveSetter(Document document, SyntaxNode setMethod, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
editor.SetAccessibility(setMethod, Accessibility.Internal);
return(editor.GetChangedDocument());
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
Document doc = context.Document;
CancellationToken cancellationToken = context.CancellationToken;
SyntaxNode root = await doc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
if (root.FindNode(context.Span) is SyntaxNode expression)
{
string title = MicrosoftNetCoreAnalyzersResources.PreferTypedStringBuilderAppendOverloadsRemoveToString;
context.RegisterCodeFix(
new MyCodeAction(title,
async ct =>
{
SemanticModel model = await doc.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.GetOperationWalkingUpParentChain(expression, cancellationToken) is IArgumentOperation arg &&
arg.Value is IInvocationOperation invoke &&
invoke.Instance?.Syntax is SyntaxNode replacement)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(doc, ct).ConfigureAwait(false);
editor.ReplaceNode(expression, editor.Generator.Argument(replacement));
return(editor.GetChangedDocument());
}
return(doc);
},
equivalenceKey: title),
context.Diagnostics);
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
Document doc = context.Document;
CancellationToken cancellationToken = context.CancellationToken;
SyntaxNode root = await doc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SemanticModel model = await doc.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
// If we're able to make the desired substitution...
var(targetNode, replacementField) = GetTaskCreationOptionsField(context, root, model, cancellationToken);
if (replacementField != null)
{
// ...then offer it.
string title = MicrosoftNetCoreAnalyzersResources.DoNotCreateTaskCompletionSourceWithWrongArgumentsFix;
context.RegisterCodeFix(
new MyCodeAction(title,
async ct =>
{
// Replace "TaskContinuationOptions.Value" with "TaskCreationOptions.Value"
DocumentEditor editor = await DocumentEditor.CreateAsync(doc, ct).ConfigureAwait(false);
editor.ReplaceNode(targetNode,
editor.Generator.Argument(
editor.Generator.MemberAccessExpression(
editor.Generator.TypeExpressionForStaticMemberAccess(replacementField.ContainingType), replacementField.Name)));
return(editor.GetChangedDocument());
},
equivalenceKey: title),
context.Diagnostics);
}
private async Task <Document> ConvertToStringLengthComparison(CodeFixContext context, FixResolution fixResolution)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(context.Document, context.CancellationToken).ConfigureAwait(false);
SyntaxNode leftOperand = GetLeftOperand(fixResolution.BinaryExpressionSyntax);
SyntaxNode rightOperand = GetRightOperand(fixResolution.BinaryExpressionSyntax);
// Take the below example:
// if (f == String.Empty) ...
// The comparison operand, f, will now become 'f.Length' and a the other operand will become '0'
SyntaxNode zeroLengthSyntax = editor.Generator.LiteralExpression(0);
if (leftOperand == fixResolution.ComparisonOperand)
{
leftOperand = editor.Generator.MemberAccessExpression(leftOperand, "Length");
rightOperand = zeroLengthSyntax.WithTriviaFrom(rightOperand);
}
else
{
leftOperand = zeroLengthSyntax;
rightOperand = editor.Generator.MemberAccessExpression(rightOperand.WithoutTrivia(), "Length");
}
SyntaxNode replacementSyntax = fixResolution.UsesEqualsOperator ?
editor.Generator.ValueEqualsExpression(leftOperand, rightOperand) :
editor.Generator.ValueNotEqualsExpression(leftOperand, rightOperand);
SyntaxNode replacementAnnotatedSyntax = replacementSyntax.WithAdditionalAnnotations(Formatter.Annotation);
editor.ReplaceNode(fixResolution.BinaryExpressionSyntax, replacementAnnotatedSyntax);
return(editor.GetChangedDocument());
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
Document doc = context.Document;
SemanticModel model = await doc.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
SyntaxNode root = await doc.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
if (root.FindNode(context.Span, getInnermostNodeForTie: true) is SyntaxNode node &&
model.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemEnvironment, out var environmentType) &&
model.GetOperation(node, context.CancellationToken) is IPropertyReferenceOperation operation)
{
string title = MicrosoftNetCoreAnalyzersResources.UseEnvironmentProcessIdFix;
context.RegisterCodeFix(
new MyCodeAction(title,
async cancellationToken =>
{
DocumentEditor editor = await DocumentEditor.CreateAsync(doc, cancellationToken).ConfigureAwait(false);
var replacement = editor.Generator.MemberAccessExpression(editor.Generator.TypeExpressionForStaticMemberAccess(environmentType), "ProcessId");
editor.ReplaceNode(node, replacement.WithTriviaFrom(node));
return(editor.GetChangedDocument());
},
equivalenceKey: title),
context.Diagnostics);
}
}
public async Task <Solution> InlineAndRemoveMethodAsync(InvocationExpressionSyntax invocation, ExpressionSyntax expression)
{
if (invocation.SyntaxTree == MethodDeclaration.SyntaxTree)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(Document, CancellationToken).ConfigureAwait(false);
ExpressionSyntax newExpression = RewriteExpression(invocation, expression);
editor.ReplaceNode(invocation, newExpression);
editor.RemoveNode(MethodDeclaration);
return(editor.GetChangedDocument().Solution());
}
else
{
Document newDocument = await InlineMethodAsync(invocation, expression).ConfigureAwait(false);
DocumentId documentId = Document.Solution().GetDocumentId(MethodDeclaration.SyntaxTree);
newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(MethodDeclaration, CancellationToken).ConfigureAwait(false);
return(newDocument.Solution());
}
}
private static async Task <Document> SwapArgumentsOrderAsync(Document document, IObjectCreationOperation creation, int paramPosition, int argumentCount, CancellationToken token)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, token).ConfigureAwait(false);
SyntaxNode parameter = AddNameOfIfLiteral(creation.Arguments[paramPosition].Value, editor.Generator);
SyntaxNode newCreation;
if (argumentCount == 2)
{
if (paramPosition == 0)
{
newCreation = editor.Generator.ObjectCreationExpression(creation.Type, creation.Arguments[1].Syntax, parameter);
}
else
{
newCreation = editor.Generator.ObjectCreationExpression(creation.Type, parameter, creation.Arguments[0].Syntax);
}
}
else
{
Debug.Assert(argumentCount == 3);
if (paramPosition == 0)
{
newCreation = editor.Generator.ObjectCreationExpression(creation.Type, creation.Arguments[1].Syntax, parameter, creation.Arguments[2].Syntax);
}
else
{
newCreation = editor.Generator.ObjectCreationExpression(creation.Type, parameter, creation.Arguments[1].Syntax, creation.Arguments[0].Syntax);
}
}
editor.ReplaceNode(creation.Syntax, newCreation);
return(editor.GetChangedDocument());
}
public virtual async Task <Solution> InlineAndRemoveAsync(
SyntaxNode node,
ExpressionSyntax expression,
CancellationToken cancellationToken = default(CancellationToken))
{
if (node.SyntaxTree == Declaration.SyntaxTree)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(Document, cancellationToken).ConfigureAwait(false);
ExpressionSyntax newExpression = RewriteExpression(node, expression);
editor.ReplaceNode(node, newExpression);
editor.RemoveNode(Declaration);
return(editor.GetChangedDocument().Solution());
}
else
{
Document newDocument = await InlineAsync(node, expression, cancellationToken).ConfigureAwait(false);
DocumentId documentId = Document.Solution().GetDocumentId(Declaration.SyntaxTree);
newDocument = await newDocument.Solution().GetDocument(documentId).RemoveMemberAsync(Declaration, cancellationToken).ConfigureAwait(false);
return(newDocument.Solution());
}
}
private static async Task <Document> RemoveField(Document document, SyntaxNode node, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
node = editor.Generator.GetDeclaration(node);
editor.RemoveNode(node);
return(editor.GetChangedDocument());
}
private static async Task <Document> RemoveFinalizerAsync(Document document, SyntaxNode node, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
// Get the declaration so that we step up to the methodblocksyntax and not the methodstatementsyntax for VB.
node = editor.Generator.GetDeclaration(node);
editor.RemoveNode(node);
return(editor.GetChangedDocument());
}
private static async Task <Document> AddNonSerializedAttribute(Document document, SyntaxNode fieldNode, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
SyntaxNode attr = editor.Generator.Attribute(editor.Generator.TypeExpression(WellKnownTypes.NonSerializedAttribute(editor.SemanticModel.Compilation)));
editor.AddAttribute(fieldNode, attr);
return(editor.GetChangedDocument());
}
private static async Task <Document> GetFixAsync(Document document, SyntaxNode expression, bool argument, CancellationToken cancellationToken)
{
// Rewrite the expression to include a .ConfigureAwait() after it. We reattach trailing trivia to the end.
// This is especially important for VB, as the end-of-line may be in the trivia
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
FixDiagnostic(editor, expression, argument);
return(editor.GetChangedDocument());
}
private static async Task <Document> AddNullMessageToArgumentListAsync(Document document, IObjectCreationOperation creation, CancellationToken token)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, token).ConfigureAwait(false);
SyntaxNode argument = AddNameOfIfLiteral(creation.Arguments[0].Value, editor.Generator);
SyntaxNode newCreation = editor.Generator.ObjectCreationExpression(creation.Type, editor.Generator.Argument(editor.Generator.NullLiteralExpression()), argument);
editor.ReplaceNode(creation.Syntax, newCreation);
return(editor.GetChangedDocument());
}
private static async Task <Document> AddSerializableAttribute(Document document, SyntaxNode node, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
SyntaxNode attr = editor.Generator.Attribute(editor.Generator.TypeExpression(
editor.SemanticModel.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemSerializableAttribute)));
editor.AddAttribute(node, attr);
return(editor.GetChangedDocument());
}
private static async Task <Solution> InlineAndRemoveMethodAsync(
Document document,
ExpressionStatementSyntax expressionStatement,
MethodDeclarationSyntax methodDeclaration,
StatementSyntax[] statements,
ParameterInfo[] parameterInfos,
CancellationToken cancellationToken = default(CancellationToken))
{
if (expressionStatement.SyntaxTree.Equals(methodDeclaration.SyntaxTree))
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
Solution solution = document.Project.Solution;
StatementSyntax[] newStatements = await ReplaceParameterExpressionWithArgumentExpressionAsync(
parameterInfos,
statements,
solution,
cancellationToken).ConfigureAwait(false);
newStatements[0] = newStatements[0].WithLeadingTrivia(expressionStatement.GetLeadingTrivia());
newStatements[statements.Length - 1] = newStatements[statements.Length - 1].WithTrailingTrivia(expressionStatement.GetTrailingTrivia());
if (expressionStatement.Parent.IsKind(SyntaxKind.Block))
{
var block = (BlockSyntax)expressionStatement.Parent;
BlockSyntax newBlock = block.WithStatements(block.Statements.ReplaceRange(expressionStatement, newStatements));
editor.ReplaceNode(block, newBlock);
}
else
{
editor.ReplaceNode(expressionStatement, Block(newStatements));
}
editor.RemoveNode(methodDeclaration);
document = editor.GetChangedDocument();
return(document.Project.Solution);
}
else
{
Solution solution = document.Project.Solution;
document = await InlineMethodAsync(document, expressionStatement, statements, parameterInfos, cancellationToken).ConfigureAwait(false);
DocumentId documentId = solution.GetDocumentId(methodDeclaration.SyntaxTree);
solution = document.Project.Solution;
return(await RemoveMethodAsync(solution.GetDocument(documentId), methodDeclaration, cancellationToken).ConfigureAwait(false));
}
}
private async Task <Document> ConvertToGeneratedDllImport(
Document doc,
MethodDeclarationSyntax methodSyntax,
IMethodSymbol methodSymbol,
AttributeData dllImportAttr,
INamedTypeSymbol generatedDllImportAttrType,
char?entryPointSuffix,
CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(doc, cancellationToken).ConfigureAwait(false);
SyntaxGenerator generator = editor.Generator;
var dllImportSyntax = (AttributeSyntax)dllImportAttr !.ApplicationSyntaxReference !.GetSyntax(cancellationToken);
// Create GeneratedDllImport attribute based on the DllImport attribute
SyntaxNode generatedDllImportSyntax = GetGeneratedDllImportAttribute(
editor,
generator,
dllImportSyntax,
methodSymbol.GetDllImportData() !,
generatedDllImportAttrType,
methodSymbol.Name,
entryPointSuffix,
out SyntaxNode? unmanagedCallConvAttributeMaybe);
// Add annotation about potential behavioural and compatibility changes
generatedDllImportSyntax = generatedDllImportSyntax.WithAdditionalAnnotations(
WarningAnnotation.Create(string.Format(Resources.ConvertToGeneratedDllImportWarning, "[TODO] Documentation link")));
// Replace DllImport with GeneratedDllImport
SyntaxNode generatedDeclaration = generator.ReplaceNode(methodSyntax, dllImportSyntax, generatedDllImportSyntax);
if (!methodSymbol.MethodImplementationFlags.HasFlag(System.Reflection.MethodImplAttributes.PreserveSig))
{
generatedDeclaration = await RemoveNoPreserveSigTransform(editor, generatedDeclaration, methodSymbol, cancellationToken).ConfigureAwait(false);
}
if (unmanagedCallConvAttributeMaybe is not null)
{
generatedDeclaration = generator.AddAttributes(generatedDeclaration, unmanagedCallConvAttributeMaybe);
}
// Replace extern keyword with partial keyword
generatedDeclaration = generator.WithModifiers(
generatedDeclaration,
generator.GetModifiers(methodSyntax)
.WithIsExtern(false)
.WithPartial(true));
// Replace the original method with the updated one
editor.ReplaceNode(methodSyntax, generatedDeclaration);
return(editor.GetChangedDocument());
}
private async Task <Document> ReplaceVarWithExplicitType(Document document, SyntaxNode varNode, ITypeSymbol explicitTypeSymbol, CancellationToken cancellationToken)
{
DocumentEditor documentEditor = await DocumentEditor.CreateAsync(document, cancellationToken);
SyntaxNode explicitTypeNode = documentEditor.Generator.TypeExpression(explicitTypeSymbol)
.WithAdditionalAnnotations(Simplifier.Annotation)
.WithTriviaFrom(varNode);
documentEditor.ReplaceNode(varNode, explicitTypeNode);
return(documentEditor.GetChangedDocument());
}
public static KeyValuePair <SyntaxTree, SyntaxTree> FixDocument(Document document)
{
DocumentEditor curlyBraceEditor = DocumentEditor.CreateAsync(document).Result;
SyntaxFixer fixer = new SyntaxFixer();
SyntaxNode newRoot = fixer.Visit(curlyBraceEditor.OriginalRoot);
curlyBraceEditor.ReplaceNode(curlyBraceEditor.OriginalRoot, newRoot);
Document newDocument = curlyBraceEditor.GetChangedDocument();
return(new KeyValuePair <SyntaxTree, SyntaxTree>(document.GetSyntaxTreeAsync().Result, newDocument.GetSyntaxTreeAsync().Result));
}
private async Task <Document> OverrideObjectGetHashCode(Document document, SyntaxNode typeDeclaration, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
SyntaxGenerator generator = editor.Generator;
SyntaxNode methodDeclaration = generator.GetHashCodeOverrideDeclaration();
editor.AddMember(typeDeclaration, methodDeclaration);
return(editor.GetChangedDocument());
}
public async Task <Document> RemoveNodes(Document document, IEnumerable <SyntaxNode> nodes, CancellationToken cancellationToken)
{
DocumentEditor editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
// Start removing from bottom to top to keep spans of nodes that are removed later.
foreach (var node in nodes.Where(n => n != null).OrderByDescending(n => n.SpanStart))
{
RemoveNode(editor, node);
}
return(editor.GetChangedDocument());
}
