public override void VisitExpressionStatement(ExpressionStatementSyntax node)
{
// hack: Console.WriteLine
var s = node.Expression.GetText().ToString().Trim();
if (s.StartsWith("Console.WriteLine"))
{
var ise = node.Expression as InvocationExpressionSyntax;
var args = ise.ArgumentList;
cb.AppendWithIndent("cout << ")
.Append(args.GetText().ToString().Trim('(', ')').Replace(" + ", " << ").Replace("+", " << "))
.AppendLine(" << endl;");
}
else if (s.StartsWith("Environment.Exit"))
{
var ise = node.Expression as InvocationExpressionSyntax;
var args = ise.ArgumentList;
cb.AppendWithIndent("exit(")
.Append(args.GetText().ToString().Trim('(', ')'))
.AppendLine(");");
}
else
{
base.VisitExpressionStatement(node);
}
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
var extension = null as SyntacticalExtension<SyntaxNode>;
var expr = node.Expression;
InvocationExpressionSyntax call = null;
if (expr is InvocationExpressionSyntax)
call = expr as InvocationExpressionSyntax;
else if (expr is AssignmentExpressionSyntax)
{
var assignment = expr as AssignmentExpressionSyntax;
call = assignment.Right as InvocationExpressionSyntax;
}
if (call != null)
extension = codeExtension(call);
if (extension != null)
{
if (extension.Kind != ExtensionKind.Code)
{
//td: error, incorrect extension (i.e. a code extension being used inside a type)
return node;
}
_lookahead = CheckCodeExtension(node, extension);
return null;
}
return node;
}
/// <summary>
/// Rewrites the statement with a raise statement.
/// </summary>
/// <param name="node">ExpressionStatementSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
{
var invocation = node.Expression as InvocationExpressionSyntax;
var arguments = new List<ArgumentSyntax>();
arguments.Add(invocation.ArgumentList.Arguments[0]);
string payload = "";
for (int i = 1; i < invocation.ArgumentList.Arguments.Count; i++)
{
if (i == invocation.ArgumentList.Arguments.Count - 1)
{
payload += invocation.ArgumentList.Arguments[i].ToString();
}
else
{
payload += invocation.ArgumentList.Arguments[i].ToString() + ", ";
}
}
arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
"new " + arguments[0].ToString() + "(" + payload + ")"));
invocation = invocation.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(arguments)));
var text = "{ " +
node.WithExpression(invocation.WithExpression(SyntaxFactory.IdentifierName("this.Raise"))).ToString() +
"return; }";
var rewritten = SyntaxFactory.ParseStatement(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
/// <summary>
/// Normalizes the <paramref name="statement" /> if it is an invocation of a state machine method.
/// </summary>
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
{
var invocationExpression = statement.Expression as InvocationExpressionSyntax;
if (invocationExpression == null)
return base.VisitExpressionStatement(statement);
var methodSymbol = invocationExpression.GetReferencedSymbol(SemanticModel);
if (!methodSymbol.IsStatic)
return base.VisitExpressionStatement(statement);
if (methodSymbol.Name != "InitialState" && methodSymbol.Name != "InitialStates" && methodSymbol.Name != "Transition")
return base.VisitExpressionStatement(statement);
var isComponentMethod = methodSymbol.ContainingType.Equals(Compilation.GetComponentClassSymbol());
if (!isComponentMethod)
return base.VisitExpressionStatement(statement);
// MetadataBuilders.GetBuilder(this)
var metadataBuilderSymbol = Syntax.TypeExpression(Compilation.GetTypeSymbol(typeof(MetadataBuilders)));
var getBuilderMethod = Syntax.MemberAccessExpression(metadataBuilderSymbol, "GetBuilder");
var builder = Syntax.InvocationExpression(getBuilderMethod, Syntax.ThisExpression());
if (methodSymbol.Name == "Transition")
return SyntaxFactory.Block(NormalizeTransitions(builder, invocationExpression)).NormalizeWhitespace().EnsureLineCount(statement);
// .WithInitialStates(states)
var withInitialStates = Syntax.MemberAccessExpression(builder, "WithInitialStates");
var arguments = invocationExpression.ArgumentList.Arguments;
return Syntax.ExpressionStatement(Syntax.InvocationExpression(withInitialStates, arguments)).EnsureLineCount(statement);
}
/// <summary>
/// Normalizes the <paramref name="statement" /> if it is an invocation of a <c>SetInitialValues</c> method.
/// </summary>
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
{
var invocationExpression = statement.Expression as InvocationExpressionSyntax;
if (invocationExpression == null)
return base.VisitExpressionStatement(statement);
var methodSymbol = invocationExpression.GetReferencedSymbol(SemanticModel);
if (methodSymbol.Name != "SetInitialValues" || !methodSymbol.IsStatic)
return base.VisitExpressionStatement(statement);
var isComponentMethod = methodSymbol.ContainingType.Equals(Compilation.GetComponentClassSymbol());
var isFaultMethod = methodSymbol.ContainingType.Equals(Compilation.GetFaultClassSymbol());
var isOccurrenceMethod = methodSymbol.ContainingType.Equals(Compilation.GetOccurrencePatternClassSymbol());
if (!isComponentMethod && !isFaultMethod && !isOccurrenceMethod)
return base.VisitExpressionStatement(statement);
// MetadataBuilders.GetBuilder(this)
var metadataBuilderSymbol = Syntax.TypeExpression(Compilation.GetTypeSymbol(typeof(MetadataBuilders)));
var getBuilderMethod = Syntax.MemberAccessExpression(metadataBuilderSymbol, "GetBuilder");
var builder = Syntax.InvocationExpression(getBuilderMethod, Syntax.ThisExpression());
// ReflectionHelpers.GetField(typeof(...), typeof(...), "...")
var fieldSymbol = invocationExpression.ArgumentList.Arguments[0].Expression.GetReferencedSymbol<IFieldSymbol>(SemanticModel);
var fieldInfo = fieldSymbol.GetFieldInfoExpression(Syntax);
// .WithInitialValues()
var withInitialValues = Syntax.MemberAccessExpression(builder, Syntax.GenericName("WithInitialValues", fieldSymbol.Type));
var arguments = new List<ArgumentSyntax>(invocationExpression.ArgumentList.Arguments.Skip(1));
arguments.Insert(0, (ArgumentSyntax)Syntax.Argument(fieldInfo));
return Syntax.ExpressionStatement(Syntax.InvocationExpression(withInitialValues, arguments)).EnsureLineCount(statement);
}
/// <summary>
/// Normalizes the <paramref name="statement" />.
/// </summary>
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
{
var transformed = TransformExpression(statement.Expression);
if (transformed == null)
return statement;
return transformed.EnsureLineCount(statement);
}
/// <summary>
/// Rewrites the raise statement.
/// </summary>
/// <param name="node">ExpressionStatementSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
{
var text = "{ " + node.ToString() + "return; }";
var rewritten = SyntaxFactory.ParseStatement(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
public override SyntaxList <StatementSyntax> VisitExpressionStatement(CSS.ExpressionStatementSyntax node)
{
var exprNode = node.Expression.Accept(nodesVisitor);
if (!(exprNode is StatementSyntax))
{
exprNode = SyntaxFactory.ExpressionStatement((ExpressionSyntax)exprNode);
}
return(SyntaxFactory.SingletonList((StatementSyntax)exprNode));
}
private static async Task<Document> UseExistenceOperatorAsyncWithAssignmentAsync(Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken, ExpressionStatementSyntax expressionIf)
{
var memberAccessAssignment = (AssignmentExpressionSyntax)expressionIf.Expression;
var newMemberAccess = ((MemberAccessExpressionSyntax)memberAccessAssignment.Right).ToConditionalAccessExpression();
var newExpressionStatement = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, memberAccessAssignment.Left, newMemberAccess))
.WithLeadingTrivia(ifStatement.GetLeadingTrivia())
.WithTrailingTrivia(ifStatement.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
var root = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = root.ReplaceNode(ifStatement, newExpressionStatement);
var newDocument = document.WithSyntaxRoot(newRoot);
return newDocument;
}
private static void CheckForCondition(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocationNode,
ExpressionStatementSyntax expressionStatementParent, DiagnosticDescriptor descriptor)
{
// Make sure the invocation's containing type is not the same as the class that contains it
if ((invocationNode.DescendantNodesAndTokens().Any(_ => _.IsKind(SyntaxKind.DotToken)) &&
!invocationNode.DescendantNodesAndTokens().Any(_ => _.IsKind(SyntaxKind.ThisExpression) || _.IsKind(SyntaxKind.BaseExpression))) &&
(!expressionStatementParent?.DescendantNodesAndTokens()?.Any(_ => _.IsKind(SyntaxKind.EqualsToken)) ?? false) &&
!(invocationNode.DescendantNodes()?.Any(_ => new ContainsInvocationExpressionWalker(_).HasIssue) ?? false) &&
!FindSaveAssignmentIssueAnalyzer.IsReturnValue(invocationNode))
{
context.ReportDiagnostic(Diagnostic.Create(descriptor, invocationNode.GetLocation()));
}
}
private static SyntaxNode CreateRootAddingDisposeToEndOfMethod(SyntaxNode root, ExpressionStatementSyntax statement, ILocalSymbol identitySymbol)
{
var method = statement.FirstAncestorOrSelf<MethodDeclarationSyntax>();
var newDispose = ImplementsDisposableExplicitly(identitySymbol.Type)
? SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ParenthesizedExpression(SyntaxFactory.CastExpression(SyntaxFactory.ParseName("System.IDisposable").WithAdditionalAnnotations(Simplifier.Annotation), SyntaxFactory.IdentifierName(identitySymbol.Name))),
SyntaxFactory.IdentifierName("Dispose"))))
: SyntaxFactory.ParseStatement($"{identitySymbol.Name}.Dispose();");
newDispose = newDispose.WithAdditionalAnnotations(Formatter.Annotation);
var last = method.Body.Statements.Last();
var newRoot = root.InsertNodesAfter(method.Body.Statements.Last(), new[] { newDispose });
return newRoot;
}
public override void VisitExpressionStatement(ExpressionStatementSyntax node)
{
if (node.DescendantNodes().OfType<IdentifierNameSyntax>().Any(a => "WaitAll".Equals(a.ToString()))
&& node.Parent.ChildNodes().Any(a => a.ToString().Contains("StartNew"))
&& !node.Parent.ChildNodes().Any(a => a is ForStatementSyntax)
&& !node.Parent.ChildNodes().Any(a => a is ForEachStatementSyntax))
{
if (Id.ToLower().Contains("test"))
Helper.WriteInstance(InvokeTestFile, Id, node.Parent.ToString());
else
Helper.WriteInstance(InvokeFile, Id, node.Parent.ToString());
}
base.VisitExpressionStatement(node);
}
private async Task<Document> AssignMethodReturnToReceiverAsync(CodeFixContext context, Document document, ExpressionStatementSyntax statement, string receiverName, CancellationToken c)
{
var rValueExpr = statement.ToString();
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
var memberAccess = root.FindNode(context.Span)?.FirstAncestorOrSelf<MemberAccessExpressionSyntax>();
var declaration = SyntaxFactory
.ParseStatement($"{receiverName} = {rValueExpr}");
var formattedDeclaration = declaration.WithTriviaFrom(statement);
// Replace the old statement with the block:
var newRoot = root.ReplaceNode((SyntaxNode)statement, formattedDeclaration);
var newDocument = document.WithSyntaxRoot(newRoot);
return newDocument;
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
SyntaxNode retVal = null;
if (node.Expression.Kind() == SyntaxKind.AddAssignmentExpression ||
node.Expression.Kind() == SyntaxKind.SubtractAssignmentExpression ||
node.Expression.Kind() == SyntaxKind.MultiplyAssignmentExpression ||
node.Expression.Kind() == SyntaxKind.DivideAssignmentExpression)
{
var add = node.Expression as BinaryExpressionSyntax;
var printValueStmt = add.Left.GetText();
retVal = base.VisitExpressionStatement(node);
}
return base.VisitExpressionStatement(node);
}
/// <summary>
/// Normalizes the <paramref name="statement" />.
/// </summary>
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
{
if (!statement.Expression.IsKind(SyntaxKind.InvocationExpression))
return statement;
var expression = (InvocationExpressionSyntax)statement.Expression;
var methodSymbol = expression.GetReferencedSymbol<IMethodSymbol>(SemanticModel);
if (!methodSymbol.IsBindMethod(SemanticModel))
return statement;
var requiredPortReferenceExpression = (InvocationExpressionSyntax)expression.ArgumentList.Arguments[0].Expression;
var providedPortReferenceExpression = (InvocationExpressionSyntax)expression.ArgumentList.Arguments[1].Expression;
var requiredPorts = requiredPortReferenceExpression.ResolvePortReferences(SemanticModel);
var providedPorts = providedPortReferenceExpression.ResolvePortReferences(SemanticModel);
requiredPorts.RemoveWhere(symbol => !symbol.IsRequiredPort(SemanticModel));
providedPorts.RemoveWhere(symbol => symbol.IsRequiredPort(SemanticModel));
if (methodSymbol.Arity == 1)
{
var delegateType = (INamedTypeSymbol)methodSymbol.TypeArguments[0];
MethodSymbolFilter.Filter(requiredPorts, delegateType);
MethodSymbolFilter.Filter(providedPorts, delegateType);
}
else
MethodSymbolFilter.Filter(requiredPorts, providedPorts);
// The analyzer guarantees that there is exactly one port in each set now, but just to be sure...
Assert.That(requiredPorts.Count == 1, "Expected exactly one required port at this point.");
Assert.That(providedPorts.Count == 1, "Expected exactly one provided port at this point.");
var requiredPortExpression = requiredPortReferenceExpression.ArgumentList.Arguments[0].Expression;
var providedPortExpression = providedPortReferenceExpression.ArgumentList.Arguments[0].Expression;
var requiredPortReference = CreatePortReference(requiredPorts.Single(), requiredPortExpression);
var providedPortReference = CreatePortReference(providedPorts.Single(), providedPortExpression);
var binderType = Syntax.TypeExpression(SemanticModel.GetTypeSymbol(typeof(PortBinding)));
var binderInstance = Syntax.ObjectCreationExpression(binderType, requiredPortReference, providedPortReference);
var bindMemberAccess = Syntax.MemberAccessExpression(binderInstance, nameof(PortBinding.Bind));
var invocation = (ExpressionSyntax)Syntax.InvocationExpression(bindMemberAccess);
return statement.WithExpression(invocation).NormalizeWhitespace().WithTrivia(statement).PrependLineDirective(statement.GetLineNumber());
}
/// <summary>
/// Rewrites the statement with a raise statement.
/// </summary>
/// <param name="node">ExpressionStatementSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
{
var invocation = node.Expression as InvocationExpressionSyntax;
var arguments = new List<ArgumentSyntax>(invocation.ArgumentList.Arguments);
arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
"new " + arguments[0].ToString() + "()"));
invocation = invocation.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(arguments)));
var text = "{ " +
node.WithExpression(invocation.WithExpression(SyntaxFactory.IdentifierName("this.Raise"))).ToString() +
"return; }";
var rewritten = SyntaxFactory.ParseStatement(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
public override void VisitExpressionStatement(ExpressionStatementSyntax node)
{
if (this.InsideAutoIncludeMethodBlock)
{
var line = node.SyntaxTree.GetLineSpan(node.Span).StartLinePosition.Line;
var allchildren = node.DescendantNodesAndTokens(descendIntoTrivia: true);
if (allchildren.Any(a => a.Kind() == SyntaxKind.MultiLineDocumentationCommentTrivia))
{
var walker = new CodeWithDocumentationWalker(ClassDepth, line);
walker.Visit(node.WithAdditionalAnnotations());
this.Blocks.AddRange(walker.Blocks);
return;
}
base.VisitExpressionStatement(node);
this.Blocks.Add(new CodeBlock(node.WithoutLeadingTrivia().ToFullString(), line));
}
else base.VisitExpressionStatement(node);
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
var aes = node.Expression as AssignmentExpressionSyntax;
if (aes != null)
{
if (aes.Left is IdentifierNameSyntax && ((IdentifierNameSyntax)aes.Left).Identifier.Text == DocumentWeaver.RESULTMARKER)
{
foundAssignment = aes.Right;
//to delete this statement
return null;
}
}
var ies = node.Expression as InvocationExpressionSyntax;
if (ies != null)
{
var newNode = VisitInvocationExpression(ies);
if (newNode == null) return null;
}
return base.VisitExpressionStatement(node);
}
private static async Task<Document> MakeMock(Document document, ExpressionStatementSyntax creation,
CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var creationExpressionSyntax = creation.Expression.ChildNodes().OfType<ObjectCreationExpressionSyntax>().First();
var symbolInfo = semanticModel.GetSymbolInfo(creationExpressionSyntax);
var invokedSymbol = (IMethodSymbol)symbolInfo.CandidateSymbols.FirstOrDefault(x => x is IMethodSymbol
/*&& ((IMethodSymbol)x).Parameters.All(y => y.Type.IsAbstract)*/);
var constructorParameters = invokedSymbol.Parameters.Select(x => new ConstructorParameters
{
ArgumentName = x.Name,
TypeName = GetTypeNameFromType((INamedTypeSymbol)x.Type)
}).ToArray();
var changes = constructorParameters.MakeConstructorInjections();
var changedDocument = await ChangesMaker.ApplyConstuctorInjections(document, creation, cancellationToken, changes, creationExpressionSyntax);
return changedDocument;
}
public BoundExpressionStatement BindExpressionStatement(ExpressionStatementSyntax node, DiagnosticBag diagnostics)
{
return BindExpressionStatement(node, node.Expression, node.AllowsAnyExpression, diagnostics);
}
public override SyntaxList <VB.Syntax.StatementSyntax> VisitExpressionStatement(CS.Syntax.ExpressionStatementSyntax node)
{
return(List(
nodeVisitor.VisitStatement(node.Expression)));
}
public static void WriteStatement(OutputWriter writer, ExpressionStatementSyntax statement)
{
writer.WriteIndent();
Write(writer, statement.Expression);
writer.Write(";\r\n");
}
private bool TryGenerateExpressionStatement(ExpressionStatementSyntax expressionStatement)
{
using (ExpressionStatementTag(GetLineNumber(expressionStatement)))
{
return TryGenerateExpression(expressionStatement.Expression);
}
}
public override void VisitExpressionStatement(ExpressionStatementSyntax node)
{
Clear();
base.VisitExpressionStatement(node);
}
public override void VisitExpressionStatement(ExpressionStatementSyntax node)
{
Visit(node.Expression, _enclosing);
}
private static bool IsCorrectDispose(ExpressionStatementSyntax expressionStatement, SemanticModel semanticModel, ILocalSymbol identitySymbol)
{
if (expressionStatement == null) return false;
var invocation = expressionStatement.Expression as InvocationExpressionSyntax;
if (invocation?.ArgumentList.Arguments.Any() ?? true) return false;
var memberAccess = invocation.Expression as MemberAccessExpressionSyntax;
if (memberAccess == null) return false;
ISymbol memberSymbol;
if (memberAccess.Expression.IsKind(SyntaxKind.IdentifierName))
{
memberSymbol = semanticModel.GetSymbolInfo(memberAccess.Expression).Symbol;
}
else if (memberAccess.Expression.IsKind(SyntaxKind.ParenthesizedExpression))
{
var parenthesizedExpression = (ParenthesizedExpressionSyntax)memberAccess.Expression;
var cast = parenthesizedExpression.Expression as CastExpressionSyntax;
if (cast == null) return false;
var catTypeSymbol = semanticModel.GetTypeInfo(cast.Type).Type;
if (catTypeSymbol.SpecialType != SpecialType.System_IDisposable) return false;
memberSymbol = semanticModel.GetSymbolInfo(cast.Expression).Symbol;
}
else return false;
if (memberSymbol == null || !memberSymbol.Equals(identitySymbol)) return false;
var memberAccessed = memberAccess.Name as IdentifierNameSyntax;
if (memberAccessed == null) return false;
if (memberAccessed.Identifier.Text != "Dispose" || memberAccessed.Arity != 0) return false;
var methodSymbol = semanticModel.GetSymbolInfo(memberAccessed).Symbol as IMethodSymbol;
if (methodSymbol == null) return false;
if (methodSymbol.ToString() == "System.IDisposable.Dispose()") return true;
var disposeMethod = (IMethodSymbol)semanticModel.Compilation.GetSpecialType(SpecialType.System_IDisposable).GetMembers("Dispose").Single();
var isDispose = methodSymbol.Equals(methodSymbol.ContainingType.FindImplementationForInterfaceMember(disposeMethod));
return isDispose;
}
public static glsl.ExpressionStatementSyntax Translate(this cs.ExpressionStatementSyntax node)
{
var expression = new glsl.ExpressionStatementSyntax();
return(expression.Update(node.Expression.Translate(), node.SemicolonToken));
}
private bool TryCheckSingleIfStatementForm(
SyntaxNodeAnalysisContext syntaxContext,
IfStatementSyntax ifStatement,
BinaryExpressionSyntax condition,
ExpressionStatementSyntax expressionStatement,
InvocationExpressionSyntax invocationExpression)
{
var cancellationToken = syntaxContext.CancellationToken;
// Look for the form: "if (someExpr != null) someExpr()"
if (condition.Left.IsKind(SyntaxKind.NullLiteralExpression) ||
condition.Right.IsKind(SyntaxKind.NullLiteralExpression))
{
var expr = condition.Left.IsKind(SyntaxKind.NullLiteralExpression)
? condition.Right
: condition.Left;
cancellationToken.ThrowIfCancellationRequested();
if (SyntaxFactory.AreEquivalent(expr, invocationExpression.Expression, topLevel: false))
{
cancellationToken.ThrowIfCancellationRequested();
// Looks good!
var tree = syntaxContext.SemanticModel.SyntaxTree;
var additionalLocations = new List<Location>
{
Location.Create(tree, ifStatement.Span),
Location.Create(tree, expressionStatement.Span)
};
var properties = ImmutableDictionary<string, string>.Empty.Add(Constants.Kind, Constants.SingleIfStatementForm);
syntaxContext.ReportDiagnostic(Diagnostic.Create(s_descriptor,
Location.Create(tree, TextSpan.FromBounds(ifStatement.SpanStart, expressionStatement.SpanStart)),
additionalLocations, properties));
if (expressionStatement.Span.End != ifStatement.Span.End)
{
syntaxContext.ReportDiagnostic(Diagnostic.Create(s_descriptor,
Location.Create(tree, TextSpan.FromBounds(expressionStatement.Span.End, ifStatement.Span.End)),
additionalLocations, properties));
}
return true;
}
}
return false;
}
private static bool IsAssignedToField(ExpressionStatementSyntax expressionStatement, SemanticModel semanticModel, ILocalSymbol identitySymbol)
{
if (expressionStatement == null) return false;
if (!expressionStatement.Expression.IsKind(SyntaxKind.SimpleAssignmentExpression)) return false;
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
var assignmentTarget = semanticModel.GetSymbolInfo(assignment.Left).Symbol;
if (assignmentTarget?.Kind != SymbolKind.Field) return false;
var assignmentSource = semanticModel.GetSymbolInfo(assignment.Right).Symbol;
return (identitySymbol.Equals(assignmentSource));
}
private bool TryCheckVariableAndIfStatementForm(
SyntaxNodeAnalysisContext syntaxContext,
IfStatementSyntax ifStatement,
BinaryExpressionSyntax condition,
ExpressionStatementSyntax expressionStatement,
InvocationExpressionSyntax invocationExpression)
{
var cancellationToken = syntaxContext.CancellationToken;
cancellationToken.ThrowIfCancellationRequested();
// look for the form "if (a != null)" or "if (null != a)"
if (!ifStatement.Parent.IsKind(SyntaxKind.Block))
{
return false;
}
if (!IsNullCheckExpression(condition.Left, condition.Right) &&
!IsNullCheckExpression(condition.Right, condition.Left))
{
return false;
}
var expression = invocationExpression.Expression;
if (!expression.IsKind(SyntaxKind.IdentifierName))
{
return false;
}
var conditionName = condition.Left is IdentifierNameSyntax
? (IdentifierNameSyntax)condition.Left
: (IdentifierNameSyntax)condition.Right;
var invocationName = (IdentifierNameSyntax)expression;
if (!Equals(conditionName.Identifier.ValueText, invocationName.Identifier.ValueText))
{
return false;
}
// Now make sure the previous statement is "var a = ..."
var parentBlock = (BlockSyntax)ifStatement.Parent;
var ifIndex = parentBlock.Statements.IndexOf(ifStatement);
if (ifIndex == 0)
{
return false;
}
var previousStatement = parentBlock.Statements[ifIndex - 1];
if (!previousStatement.IsKind(SyntaxKind.LocalDeclarationStatement))
{
return false;
}
var localDeclarationStatement = (LocalDeclarationStatementSyntax)previousStatement;
var variableDeclaration = localDeclarationStatement.Declaration;
if (variableDeclaration.Variables.Count != 1)
{
return false;
}
var declarator = variableDeclaration.Variables[0];
if (declarator.Initializer == null)
{
return false;
}
cancellationToken.ThrowIfCancellationRequested();
if (!Equals(declarator.Identifier.ValueText, conditionName.Identifier.ValueText))
{
return false;
}
// Syntactically this looks good. Now make sure that the local is a delegate type.
var semanticModel = syntaxContext.SemanticModel;
var localSymbol = (ILocalSymbol)semanticModel.GetDeclaredSymbol(declarator, cancellationToken);
// Ok, we made a local just to check it for null and invoke it. Looks like something
// we can suggest an improvement for!
// But first make sure we're only using the local only within the body of this if statement.
var analysis = semanticModel.AnalyzeDataFlow(localDeclarationStatement, ifStatement);
if (analysis.ReadOutside.Contains(localSymbol) || analysis.WrittenOutside.Contains(localSymbol))
{
return false;
}
// Looks good!
var tree = semanticModel.SyntaxTree;
var additionalLocations = new List<Location>
{
Location.Create(tree, localDeclarationStatement.Span),
Location.Create(tree, ifStatement.Span),
Location.Create(tree, expressionStatement.Span)
};
var properties = ImmutableDictionary<string, string>.Empty.Add(Constants.Kind, Constants.VariableAndIfStatementForm);
syntaxContext.ReportDiagnostic(Diagnostic.Create(s_descriptor,
Location.Create(tree, TextSpan.FromBounds(localDeclarationStatement.SpanStart, expressionStatement.SpanStart)),
additionalLocations, properties));
if (expressionStatement.Span.End != ifStatement.Span.End)
{
syntaxContext.ReportDiagnostic(Diagnostic.Create(s_descriptor,
Location.Create(tree, TextSpan.FromBounds(expressionStatement.Span.End, ifStatement.Span.End)),
additionalLocations, properties));
}
return true;
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
var expression = this.Visit(node.Expression);
if (expression is IfStatementSyntax)
{
return expression;
}
else
{
var semicolonToken = this.VisitToken(node.SemicolonToken);
return node.Update((ExpressionSyntax)expression, semicolonToken);
}
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
this.Visit(node.Expression);
return node;
}
private IEnumerable<ITypeSymbol> InferTypeInExpressionStatement(ExpressionStatementSyntax expressionStatement, SyntaxToken? previousToken = null)
{
// If we're position based, then that means we're after the semicolon. In this case
// we don't have any sort of type to infer.
if (previousToken.HasValue)
{
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Void));
}
public override SyntaxList <StatementSyntax> VisitExpressionStatement(CSS.ExpressionStatementSyntax node)
{
return(SyntaxFactory.SingletonList(ConvertSingleExpression(node.Expression)));
}