private void AnalyzeMethod(SyntaxNodeAnalysisContext context)
{
var invocation = (InvocationExpressionSyntax)context.Node;
if (!SyntaxNodeUtils.IsInsideOrchestrator(invocation) && !SyntaxNodeUtils.IsMarkedDeterministic(invocation))
{
return;
}
var methodSymbol = context.SemanticModel.GetSymbolInfo(invocation, context.CancellationToken).Symbol as IMethodSymbol;
if (methodSymbol == null)
{
return;
}
var syntaxReference = methodSymbol.DeclaringSyntaxReferences.FirstOrDefault();
if (syntaxReference == null)
{
return;
}
var declaration = syntaxReference.GetSyntax(context.CancellationToken);
if (SyntaxNodeUtils.IsMarkedDeterministic(declaration))
{
return;
}
else
{
var diagnostic = Diagnostic.Create(Rule, invocation.GetLocation(), invocation);
context.ReportDiagnostic(diagnostic);
}
}
private static void AnalyzeIdentifierEnvironmentVariable(SyntaxNodeAnalysisContext context)
{
var identifierName = context.Node as IdentifierNameSyntax;
if (identifierName != null)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "GetEnvironmentVariable" || identifierText == "GetEnvironmentVariables" || identifierText == "ExpandEnvironmentVariables")
{
var memberAccessExpression = identifierName.Parent;
var invocationExpression = memberAccessExpression.Parent;
var memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol;
if (!memberSymbol?.ToString().StartsWith("System.Environment") ?? true)
{
return;
}
else if (!SyntaxNodeUtils.IsInsideOrchestrator(identifierName) && !SyntaxNodeUtils.IsMarkedDeterministic(identifierName))
{
return;
}
else
{
var diagnostic = Diagnostic.Create(Rule, invocationExpression.GetLocation(), memberAccessExpression);
context.ReportDiagnostic(diagnostic);
}
}
}
}
private static void AnalyzeIdentifierIO(SyntaxNodeAnalysisContext context)
{
var identifierName = context.Node as IdentifierNameSyntax;
if (identifierName != null)
{
var identifierText = identifierName.Identifier.ValueText;
var identifierNameSymbol = context.SemanticModel.GetSymbolInfo(identifierName, context.CancellationToken).Symbol;
var typeInfo = context.SemanticModel.GetTypeInfo(identifierName);
if (typeInfo.Type != null)
{
var type = typeInfo.Type.ToString();
if (IsIOClass(type))
{
if (!SyntaxNodeUtils.IsInsideOrchestrator(identifierName) && !SyntaxNodeUtils.IsMarkedDeterministic(identifierName))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, identifierName.Identifier.GetLocation(), type);
context.ReportDiagnostic(diagnostic);
}
}
}
}
private static void AnalyzeIdentifierThread(SyntaxNodeAnalysisContext context)
{
var identifierName = context.Node as IdentifierNameSyntax;
if (identifierName != null)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "Start")
{
var memberAccessExpression = identifierName.Parent;
var memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol;
if (memberSymbol == null || !memberSymbol.ToString().StartsWith("System.Threading.Thread"))
{
return;
}
if (!SyntaxNodeUtils.IsInsideOrchestrator(identifierName) && !SyntaxNodeUtils.IsMarkedDeterministic(identifierName))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, memberAccessExpression.GetLocation(), memberAccessExpression);
context.ReportDiagnostic(diagnostic);
}
}
}
private void AnalyzeIdentifierTaskContinueWith(SyntaxNodeAnalysisContext context)
{
var identifierName = context.Node as IdentifierNameSyntax;
if (identifierName != null)
{
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "ContinueWith")
{
var memberAccessExpression = identifierName.Parent;
var memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol;
if (!memberSymbol?.ToString().StartsWith("System.Threading.Tasks.Task") ?? true)
{
return;
}
else if (HasExecuteSynchronously(identifierName))
{
return;
}
else if (!SyntaxNodeUtils.IsInsideOrchestrator(identifierName) && !SyntaxNodeUtils.IsMarkedDeterministic(identifierName))
{
return;
}
else
{
var diagnostic = Diagnostic.Create(Rule, memberAccessExpression.GetLocation(), memberAccessExpression);
context.ReportDiagnostic(diagnostic);
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var expression = root.FindNode(diagnosticSpan, false, true);
if (!TryGetInvocationExpression(expression, out SyntaxNode invocationExpression))
{
return;
}
SemanticModel semanticModel = await context.Document.GetSemanticModelAsync();
var durableVersion = SyntaxNodeUtils.GetDurableVersion(semanticModel);
if (SyntaxNodeUtils.IsInsideOrchestrator(invocationExpression) && durableVersion.Equals(DurableVersion.V2))
{
if (TryGetDurableOrchestrationContextVariableName(invocationExpression, out string variableName))
{
var newExpression = "";
if (TryGetMillisecondsParameter(invocationExpression, out string milliseconds))
{
if (TryGetCancellationTokenParameter(invocationExpression, semanticModel, out string cancellationToken))
{
newExpression = "await " + variableName + ".CreateTimer(" + variableName + ".CurrentUtcDateTime.AddMilliseconds(" + milliseconds + "), " + cancellationToken + ")";
}
else
{
newExpression = "await " + variableName + ".CreateTimer(" + variableName + ".CurrentUtcDateTime.AddMilliseconds(" + milliseconds + "), CancellationToken.None)";
}
}
else if (TryGetTimespanParameter(invocationExpression, semanticModel, out string timeSpan))
{
if (TryGetCancellationTokenParameter(invocationExpression, semanticModel, out string cancellationToken))
{
newExpression = "await " + variableName + ".CreateTimer(" + variableName + ".CurrentUtcDateTime.Add(" + timeSpan + "), " + cancellationToken + ")";
}
else
{
newExpression = "await " + variableName + ".CreateTimer(" + variableName + ".CurrentUtcDateTime.Add(" + timeSpan + "), CancellationToken.None)";
}
}
context.RegisterCodeFix(
CodeAction.Create(FixTimerInOrchestrator.ToString(), c => ReplaceWithIdentifierAsync(context.Document, expression, c, newExpression), nameof(TimerCodeFixProvider)),
diagnostic);
}
}
else if (SyntaxNodeUtils.IsMarkedDeterministic(invocationExpression))
{
context.RegisterCodeFix(
CodeAction.Create(FixDeterministicAttribute.ToString(), c => RemoveDeterministicAttributeAsync(context.Document, expression, c), nameof(TimerCodeFixProvider)), diagnostic);
}
}
private void AnalyzeMethod(SyntaxNodeAnalysisContext context)
{
if (context.Node is MethodDeclarationSyntax declaration &&
SyntaxNodeUtils.IsInsideOrchestrator(declaration) &&
SyntaxNodeUtils.IsInsideFunction(context.SemanticModel, declaration))
{
if (this.semanticModel == null)
{
this.semanticModel = context.SemanticModel;
}
this.orchestratorMethodDeclarations.Add(declaration);
}
}
private void AnalyzeMethod(SyntaxNodeAnalysisContext context)
{
var declaration = (MethodDeclarationSyntax)context.Node;
if (!SyntaxNodeUtils.IsInsideOrchestrator(declaration) ||
!SyntaxNodeUtils.IsInsideFunction(declaration))
{
return;
}
if (this.semanticModel == null)
{
this.semanticModel = context.SemanticModel;
}
this.orchestratorMethodDeclarations.Add(declaration);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var expression = root.FindNode(diagnosticSpan);
if (SyntaxNodeUtils.IsInsideOrchestrator(expression))
{
if (CodeFixProviderUtils.TryGetDurableOrchestrationContextVariableName(expression, out string variableName))
{
context.RegisterCodeFix(
CodeAction.Create(FixDateTimeInOrchestrator.ToString(), c => CodeFixProviderUtils.ReplaceWithIdentifierAsync(context.Document, expression, c, variableName + ".CurrentUtcDateTime"), nameof(DateTimeCodeFixProvider)), diagnostic);
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var expression = root.FindNode(diagnosticSpan) as InvocationExpressionSyntax;
if (expression == null)
{
return;
}
if (SyntaxNodeUtils.IsInsideOrchestrator(expression))
{
if (CodeFixProviderUtils.TryGetDurableOrchestrationContextVariableName(expression, out string variableName))
{
context.RegisterCodeFix(
CodeAction.Create(FixGuidInOrchestrator.ToString(), c => ReplaceWithInvocationExpressionAsync(context.Document, expression, c, variableName + ".NewGuid()"), nameof(GuidCodeFixProvider)),
diagnostic);
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var expression = root.FindNode(diagnosticSpan);
if (SyntaxNodeUtils.IsInsideOrchestrator(expression))
{
if (TryGetDurableOrchestrationContextVariableName(expression, out string variableName))
{
context.RegisterCodeFix(
CodeAction.Create(FixGuidInOrchestrator.ToString(), c => ReplaceWithIdentifierAsync(context.Document, expression, c, variableName + ".NewGuid()"), nameof(GuidCodeFixProvider)),
diagnostic);
}
}
else if (SyntaxNodeUtils.IsMarkedDeterministic(expression))
{
context.RegisterCodeFix(
CodeAction.Create(FixDeterministicAttribute.ToString(), c => RemoveDeterministicAttributeAsync(context.Document, expression, c), nameof(GuidCodeFixProvider)), diagnostic);
}
}
private static void AnalyzeIdentifierThread(SyntaxNodeAnalysisContext context)
{
var identifierName = context.Node as IdentifierNameSyntax;
if (identifierName != null)
{
var semanticModel = context.SemanticModel;
version = SyntaxNodeUtils.GetDurableVersion(semanticModel);
var identifierText = identifierName.Identifier.ValueText;
if (identifierText == "Sleep")
{
var memberAccessExpression = identifierName.Parent;
var memberSymbol = context.SemanticModel.GetSymbolInfo(memberAccessExpression).Symbol;
if (memberSymbol == null || !memberSymbol.ToString().StartsWith("System.Threading.Thread"))
{
return;
}
if (!SyntaxNodeUtils.IsInsideOrchestrator(identifierName) && !SyntaxNodeUtils.IsMarkedDeterministic(identifierName))
{
return;
}
if (TryGetRuleFromVersion(out DiagnosticDescriptor rule))
{
var expression = GetAwaitOrInvocationExpression(memberAccessExpression);
var diagnostic = Diagnostic.Create(rule, expression.GetLocation(), expression);
context.ReportDiagnostic(diagnostic);
}
}
}
}
