public Rewriter(SyntaxNode initialSource, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) { _endOfLineTrivia = initialSource .SyntaxTree .GetRoot() .DescendantTrivia(descendIntoTrivia: true) .FirstOrDefault(x => x.IsKind(SyntaxKind.EndOfLineTrivia)); }
public static SyntaxNode SimplyAsyncCallsHelper(SyntaxNode initialSource, ICleanupOption options) { return (initialSource .ReplaceNodes ( initialSource .DescendantNodes() .Where(node => node is MethodDeclarationSyntax && node.Parent is ClassDeclarationSyntax) , (node1, node2) => SimplyAsyncCallsHelper((MethodDeclarationSyntax)node1, options) )); }
public static bool Should(this ICleanupOption options, int?optionItem) { if (options == null) { return(true); } if (options.CleanupItemsInteger == null) { return(true); } if (optionItem == null) { return(true); } return((options.CleanupItemsInteger & optionItem) == optionItem); }
public MultiLineExpressionRewriter(SemanticModel semanticModel, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) => this.semanticModel = semanticModel;
public LocalTimeRewriter(SemanticModel semanticModel, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) => this.semanticModel = semanticModel;
public CleanupCSharpSyntaxRewriter(ICleanupOption options) => Options = options;
public Rewriter(MyWalker walker, ProjectItemDetailsType projectItemDetails, ICleanupOption options) : base(options) { this.walker = walker; this.projectItemDetails = projectItemDetails; semanticModel = projectItemDetails.SemanticModel; WorkingDocument = projectItemDetails.ProjectItemDocument; }
public static SyntaxNode SimplifyVariableDeclarationsHelper(ProjectItemDetailsType projectItemDetails, ICleanupOption options) { var initialSourceNode = new Rewriter(projectItemDetails, options).Visit(projectItemDetails.InitialSourceNode); return(initialSourceNode); }
public Rewriter(ICleanupOption Options) : base(Options) { }
public Rewriter(bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) { }
public VariableRenamingBaseRewriter(Document workingDocument, ICleanupOption options) : base(options) { WorkingDocument = workingDocument; }
public SyntaxNode SimplifyClassFieldDeclarationsHelper(SyntaxNode initialSourceNode, bool isReportOnlyMode, ICleanupOption options) { var rewriter = new Rewriter(isReportOnlyMode, options); var modifiedSourceNode = rewriter.Visit(initialSourceNode); if (isReportOnlyMode) { CollectMessages(rewriter.GetReport()); return(initialSourceNode); } return(modifiedSourceNode); }
public Rewriter(Document workingDocument, bool isReportOnlyMode, ICleanupOption options) : base(workingDocument, isReportOnlyMode, options) { }
public Rewriter(ProjectItemDetailsType projectItemDetails, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) { semanticModel = projectItemDetails.SemanticModel; }
public Rewriter(Document workingDocument, ICleanupOption options) : base(workingDocument, options) { }
public Rewriter(SemanticModel semanticModel, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) { SemanticModel = semanticModel; }
public SyntaxNode ConvertMembersToExpressionBodiedHelper(SyntaxNode initialSourceNode, ICleanupOption options) { var rewriter = new Rewriter(IsReportOnlyMode, options); var modifiedSourceNode = rewriter.Visit(initialSourceNode); if (IsReportOnlyMode) { CollectMessages(rewriter.GetReport()); return(initialSourceNode); } return(modifiedSourceNode); }
public ReadOnlyRewriter(SemanticModel semanticModel, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) { this.semanticModel = semanticModel; this.isReportOnlyMode = isReportOnlyMode; }
public Rewriter(ProjectItemDetailsType projectItemDetails, ICleanupOption options) : base(options) { semanticModel = projectItemDetails.SemanticModel; }
public static SyntaxNode ConvertMembersToExpressionBodiedHelper(SyntaxNode initialSourceNode, ICleanupOption Options) { return(new Rewriter(Options).Visit(initialSourceNode)); }
public static SyntaxNode SimplifyClassFieldDeclarationsHelper(SyntaxNode initialSourceNode, ICleanupOption options) { initialSourceNode = new Rewriter(options).Visit(initialSourceNode); return(initialSourceNode); }
public Rewriter(ProjectItemDetailsType projectItemDetails, ICleanupOption options) : base(options) { this.projectItemDetails = projectItemDetails; }
protected VariableRenamingBaseRewriter(Document workingDocument, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) { WorkingDocument = workingDocument; }
public MyWalker(ProjectItemDetailsType projectItemDetails, ICleanupOption options) { this.projectItemDetails = projectItemDetails; semanticModel = projectItemDetails.SemanticModel; }
public static SyntaxNode SimplyAsyncCallsHelper2(SyntaxNode initialSourceNode, ICleanupOption options) { return(new Rewriter(options).Visit(initialSourceNode)); }
public CascadeDeleteRewriter(SemanticModel semanticModel, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) => this.semanticModel = semanticModel;
public static MethodDeclarationSyntax SimplyAsyncCallsHelper(MethodDeclarationSyntax method, ICleanupOption options) { if ((method.Parent is ClassDeclarationSyntax) == false) { return(method); } if (method.Modifiers.Any(x => x.IsKind(SyntaxKind.AsyncKeyword)) == false) { return(method); } if (method.Body == null) { return(method); } if (method.ReturnType.WithoutTrivia().ToFullString() == typeof(Task).Name) { return(method); } if (method.ReturnType.WithoutTrivia().ToFullString() == "void") { return(method); } if (method.Body.Statements.Count != 1) { return(method); } var singleStatement = method.Body.Statements.First(); AwaitExpressionSyntax awaitStatementExpression = null; if (singleStatement is ReturnStatementSyntax retSS) { awaitStatementExpression = retSS.Expression as AwaitExpressionSyntax; } else if (singleStatement is ExpressionStatementSyntax eSS) { awaitStatementExpression = eSS.Expression as AwaitExpressionSyntax; } if (awaitStatementExpression == null) { return(method); } if (awaitStatementExpression.Expression is InvocationExpressionSyntax invSS) { if (invSS.ArgumentList.Arguments.Any(a => a.Expression.IsKind(SyntaxKind.AwaitExpression))) { return(method); } } var newStatement = singleStatement; if (options.Should((int)SimplyAsyncCall.CleanupTypes.Single_Expression)) { if (singleStatement is ReturnStatementSyntax rss) { newStatement = rss.WithExpression(awaitStatementExpression.Expression); } else if (singleStatement is ExpressionStatementSyntax) { var newReturnStatement = SyntaxFactory .ReturnStatement(awaitStatementExpression.Expression) .WithLeadingTrivia(singleStatement.GetLeadingTrivia()) .WithTrailingTrivia(singleStatement.GetTrailingTrivia()); newStatement = newReturnStatement.WithReturnKeyword( newReturnStatement.ReturnKeyword.WithTrailingTrivia(_spaceTrivia)); } } return (method .ReplaceNode(singleStatement, newStatement) .WithModifiers( method.Modifiers.Remove(method.Modifiers.First(x => x.IsKind(SyntaxKind.AsyncKeyword)))) .WithLeadingTrivia(method.GetLeadingTrivia()) .WithTrailingTrivia(method.GetTrailingTrivia())); }
protected CleanupCSharpSyntaxRewriter(bool isReportOnlyMode, ICleanupOption options) { this.isReportOnlyMode = isReportOnlyMode; ChangesReport = new List <ChangesReport>(); Options = options; }
public CsMethodStringRewriter(SemanticModel semanticModel, bool isReportOnlyMode, ICleanupOption options) : base(isReportOnlyMode, options) => this.semanticModel = semanticModel;