public static ILocalSymbol FirstValidSymbolOccuranceOfVariable(SemanticModel model, CSharpSyntaxNode context, string identifier)
{
var outerForLoop = context.FirstAncestorOrSelf <ForStatementSyntax>();
var outerCatchClause = context.FirstAncestorOrSelf <CatchClauseSyntax>();
var foreachLoop = context.FirstAncestorOrSelf <ForEachStatementSyntax>();
var usings = context.FirstAncestorOrSelf <UsingStatementSyntax>();
if (outerForLoop != null && outerForLoop.Declaration.Variables.Any(x => x.Identifier.ToString() == identifier))
{
context = outerForLoop;
}
else if (outerCatchClause != null && outerCatchClause.Declaration.Identifier.ToString() == identifier)
{
context = outerCatchClause;
}
else if (foreachLoop != null && foreachLoop.Identifier.ToString() == identifier)
{
context = foreachLoop;
}
else if (usings.Declaration.Variables.Any(x => x.Identifier.ToString() == identifier))
{
context = usings;
}
else
{
context = context.FirstAncestorOrSelf <BlockSyntax>();
}
var walker = new VariableUsageFinder(model, context, identifier);
context.Accept(walker);
return((ILocalSymbol)walker.symbols.FirstOrDefault());
}
public static IEnumerable <string> GetUsedIdentifiers(CSharpSyntaxNode scope, SemanticModel model)
{
if (scope == null)
{
throw new ArgumentNullException(nameof(scope));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var typeDeclaration = scope.FirstAncestorOrSelf <TypeDeclarationSyntax>();
var typeSymbol = model.GetDeclaredSymbol(typeDeclaration);
var memberAndTypeNames = model
.LookupSymbols(scope.GetLocation().SourceSpan.Start, typeSymbol)
.Select(symbol => symbol.Name);
var locals = scope.DescendantNodes()
.OfType <VariableDeclarationSyntax>()
.SelectMany(declaration => declaration.Variables)
.Select(v => model.GetDeclaredSymbol(v).Name);
return(memberAndTypeNames.Concat(locals).ToArray());
}
private static string GetDeclarationNamespaceFullName(
CSharpSyntaxNode typeDeclarationSyntax)
{
var namespaceDeclarationSyntax = typeDeclarationSyntax.FirstAncestorOrSelf <NamespaceDeclarationSyntax>();
return(namespaceDeclarationSyntax.Name.ToString());
}
internal static ITypeSymbol?GetTargetType(CSharpSyntaxNode node, SemanticModel semanticModel, int ordinal, CancellationToken cancellationToken)
{
MethodDeclarationSyntax?method = node.FirstAncestorOrSelf <MethodDeclarationSyntax>();
if (method is null ||
semanticModel.GetDeclaredSymbol(method, cancellationToken) is not IMethodSymbol symbol ||
symbol.OverriddenMethod is not IMethodSymbol
)
{
return(null);
}
Compilation compilation = semanticModel.Compilation;
INamedTypeSymbol?attribute = compilation.GetTypeByMetadataName(MemberNames.DefaultParamAttribute);
if (attribute is null)
{
return(null);
}
foreach (IMethodSymbol m in symbol.GetBaseMethods())
{
if (m.TypeParameters[ordinal].GetAttribute(attribute) is AttributeData data)
{
return(data.GetConstructorArgumentTypeValue <ITypeSymbol>(0));
}
}
return(null);
}
private static ArgumentListSyntax GetParameterListNode(CSharpSyntaxNode node)
{
InvocationExpressionSyntax invocationExpression = node.Parent as InvocationExpressionSyntax;
if (invocationExpression != null)
return invocationExpression.ArgumentList;
return node.FirstAncestorOrSelf<ArgumentListSyntax>(parent => true);
}
private async Task <Document> ThrowInvalidOperationExceptionAsync(Document document, CSharpSyntaxNode returningClause, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var returnStatement = returningClause as ReturnStatementSyntax;
SyntaxNode newRoot;
if (returnStatement != null)
{
var throwStatement = ThrowStatement()
.WithExpression(ObjectCreationExpression(IdentifierName(nameof(InvalidOperationException)))
.WithArgumentList(ArgumentList())).WithLeadingTrivia(returnStatement.ReturnKeyword.GetAllTrivia()).WithTrailingTrivia(returnStatement.SemicolonToken.GetAllTrivia());
newRoot = root.ReplaceNode(returningClause, throwStatement);
}
else
{
var simpleLambda = returningClause as SimpleLambdaExpressionSyntax;
if (simpleLambda != null)
{
newRoot = root.ReplaceNode(simpleLambda, simpleLambda.WithArrowToken(simpleLambda.ArrowToken).WithBody(Block(ThrowStatement()
.WithExpression(ObjectCreationExpression(IdentifierName(nameof(InvalidOperationException))).WithArgumentList(ArgumentList())))));
}
else
{
var parenthesizedLambda = returningClause as ParenthesizedLambdaExpressionSyntax;
if (parenthesizedLambda != null)
{
newRoot = root.ReplaceNode(parenthesizedLambda, parenthesizedLambda.WithArrowToken(parenthesizedLambda.ArrowToken).WithBody(Block(ThrowStatement()
.WithExpression(ObjectCreationExpression(IdentifierName(nameof(InvalidOperationException))).WithArgumentList(ArgumentList())))));
}
else
{
var arrow = returningClause as ArrowExpressionClauseSyntax;
var methodOrProperty = returningClause.FirstAncestorOrSelf((MemberDeclarationSyntax md) => md.IsKind(SyntaxKind.PropertyDeclaration) || md.IsKind(SyntaxKind.MethodDeclaration));
var expressionProperty = methodOrProperty as PropertyDeclarationSyntax;
if (expressionProperty != null)
{
var propertyDeclarationSyntax = ExpressionPropertyToGetterWithThrowStatement(expressionProperty);
newRoot = root.ReplaceNode(expressionProperty, propertyDeclarationSyntax);
}
else
{
var expressionMethod = methodOrProperty as MethodDeclarationSyntax;
if (expressionMethod != null)
{
var methodDeclarationSyntax = ExpressionMethodToThrowStatementBody(expressionMethod);
newRoot = root.ReplaceNode(methodOrProperty, methodDeclarationSyntax);
}
else
{
return(document);
}
}
}
}
}
return(document.WithSyntaxRoot(newRoot));
}
private static ArgumentListSyntax GetParameterListNode(CSharpSyntaxNode node)
{
InvocationExpressionSyntax invocationExpression = node.Parent as InvocationExpressionSyntax;
if (invocationExpression != null)
{
return(invocationExpression.ArgumentList);
}
return(node.FirstAncestorOrSelf <ArgumentListSyntax>(parent => true));
}
protected MutationLocationInfo GetWhere(CSharpSyntaxNode syntaxNode)
{
var where = "Unknown";
var locationKind = LocationKind.Method;
var methodDeclaration = syntaxNode.FirstAncestorOrSelf <MethodDeclarationSyntax>();
if (methodDeclaration != null)
{
where = $"{methodDeclaration.Identifier.Value}(M)";
}
var constructorDeclaration = syntaxNode.FirstAncestorOrSelf <ConstructorDeclarationSyntax>();
if (constructorDeclaration != null)
{
where = $"{constructorDeclaration.Identifier.Value}(C)";
locationKind = LocationKind.Constructor;
}
var propertyDeclaration = syntaxNode.FirstAncestorOrSelf <PropertyDeclarationSyntax>();
if (propertyDeclaration != null)
{
where = $"{propertyDeclaration.Identifier.Value}(P)";
locationKind = LocationKind.Property;
}
var location = syntaxNode.GetLocation();
var locationString = "Unknown line";
var pos = location.GetLineSpan();
if (pos.Path != null)
{
locationString = $"@({pos.StartLinePosition.Line + 1}:{pos.StartLinePosition.Character + 1})";
}
return(new MutationLocationInfo {
Where = where, Line = locationString, Kind = locationKind
});
}
private static ParameterListSyntax GetParameterListNode(CSharpSyntaxNode node)
{
MethodDeclarationSyntax methodDeclaration = node.Parent as MethodDeclarationSyntax;
if (methodDeclaration != null)
return methodDeclaration.ParameterList;
ConstructorDeclarationSyntax ctorDeclaration = node.Parent as ConstructorDeclarationSyntax;
if (ctorDeclaration != null)
return ctorDeclaration.ParameterList;
return node.FirstAncestorOrSelf<ParameterListSyntax>(parent => true);
}
public static ILocalSymbol FirstValidSymbolOccuranceOfVariable(SemanticModel model, CSharpSyntaxNode context, string identifier)
{
var outerForLoop = context.FirstAncestorOrSelf<ForStatementSyntax>();
var outerCatchClause = context.FirstAncestorOrSelf<CatchClauseSyntax>();
var foreachLoop = context.FirstAncestorOrSelf<ForEachStatementSyntax>();
var usings = context.FirstAncestorOrSelf<UsingStatementSyntax>();
if (outerForLoop != null && outerForLoop.Declaration.Variables.Any(x => x.Identifier.ToString() == identifier))
context = outerForLoop;
else if (outerCatchClause != null && outerCatchClause.Declaration.Identifier.ToString() == identifier)
context = outerCatchClause;
else if (foreachLoop != null && foreachLoop.Identifier.ToString() == identifier)
context = foreachLoop;
else if (usings.Declaration.Variables.Any(x => x.Identifier.ToString() == identifier))
context = usings;
else
context = context.FirstAncestorOrSelf<BlockSyntax>();
var walker = new VariableUsageFinder(model, context, identifier);
context.Accept(walker);
return (ILocalSymbol)walker.symbols.FirstOrDefault();
}
private static ParameterListSyntax GetParameterListNode(CSharpSyntaxNode node)
{
MethodDeclarationSyntax methodDeclaration = node.Parent as MethodDeclarationSyntax;
if (methodDeclaration != null)
{
return(methodDeclaration.ParameterList);
}
ConstructorDeclarationSyntax ctorDeclaration = node.Parent as ConstructorDeclarationSyntax;
if (ctorDeclaration != null)
{
return(ctorDeclaration.ParameterList);
}
return(node.FirstAncestorOrSelf <ParameterListSyntax>(parent => true));
}
private static CSharpSyntaxNode GetMemberDeclaration(CSharpSyntaxNode node)
{
return node.FirstAncestorOrSelf(s_isMemberDeclarationFunction);
}
/// <summary>
/// TODO separate
/// </summary>
/// <param name="node"></param>
/// <param name="nodeSymbol"></param>
/// <param name="getAndSet"></param>
/// <returns></returns>
private static IMethodSymbol GetCalledAccessor(CSharpSyntaxNode node, ISymbol nodeSymbol, out bool getAndSet)
{
IMethodSymbol calledMethod;
getAndSet = false;
var @ref = ( IPropertySymbol )nodeSymbol;
var isUnaryExprOrAssignmentExpr = false;
calledMethod = null;
if (@ref.IsReadOnly)
{
calledMethod = @ref.GetMethod;
}
else if (@ref.IsWriteOnly)
{
calledMethod = @ref.SetMethod;
}
else
{
var assignmentExpr = node.FirstAncestorOrSelf <AssignmentExpressionSyntax>( );
var binaryExpr = node.FirstAncestorOrSelf <BinaryExpressionSyntax>( );
var postUnaryExpr = node.FirstAncestorOrSelf <PostfixUnaryExpressionSyntax>( );
var prefixUnaryExpr = node.FirstAncestorOrSelf <PrefixUnaryExpressionSyntax>( );
if (assignmentExpr != null && assignmentExpr.Left.Contains(node))
{
var memberAccess = node.GetParent <MemberAccessExpressionSyntax>( );
if (memberAccess != null)
{
if (memberAccess.Expression.Contains(node))
{
calledMethod = @ref.GetMethod;
}
else
{
calledMethod = @ref.SetMethod;
}
}
else
{
calledMethod = @ref.SetMethod;
}
}
else if (binaryExpr != null)
{
//prop -= 5 or prop += 5 or other
switch (binaryExpr.OperatorToken.Kind( ))
{
case SyntaxKind.PlusEqualsToken:
case SyntaxKind.MinusEqualsToken:
case SyntaxKind.CaretEqualsToken:
case SyntaxKind.PercentEqualsToken:
case SyntaxKind.SlashEqualsToken:
case SyntaxKind.AsteriskEqualsToken:
case SyntaxKind.BarEqualsToken:
case SyntaxKind.AmpersandEqualsToken:
case SyntaxKind.GreaterThanGreaterThanEqualsToken:
case SyntaxKind.LessThanLessThanEqualsToken:
isUnaryExprOrAssignmentExpr = true;
break;
case SyntaxKind.EqualsToken:
var memberAccess = node.GetParent <MemberAccessExpressionSyntax>( );
if (memberAccess != null)
{
if (memberAccess.Expression.Contains(node))
{
calledMethod = @ref.GetMethod;
}
else
{
calledMethod = @ref.SetMethod;
}
}
else
{
calledMethod = @ref.SetMethod;
}
break;
default:
calledMethod = @ref.GetMethod;
break;
}
}
else
{
//prop++ or ++prop (prop-- or --prop)
if (postUnaryExpr != null || prefixUnaryExpr != null)
{
isUnaryExprOrAssignmentExpr = true;
}
else
{
calledMethod = @ref.GetMethod;
}
}
if (isUnaryExprOrAssignmentExpr)
{
getAndSet = true;
}
}
return(calledMethod);
}
