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;
