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); }