public bool IsImport(SyntaxNode node, out string importFullName) { importFullName = string.Empty; if (node.GetAncestor<IfDirectiveTriviaSyntax>() != null || node.GetAncestor<ElifDirectiveTriviaSyntax>() != null) { return false; } var usingDirective = node.GetAncestor<UsingDirectiveSyntax>(); importFullName = usingDirective == null ? null : usingDirective.Name.ToString(); return usingDirective != null; }
public bool IsType(SyntaxNode node) { if (node.GetAncestor<UsingDirectiveSyntax>() != null || node.Parent is NameMemberCrefSyntax || node.Parent is XmlCrefAttributeSyntax || node.Parent is XmlNameAttributeSyntax || node.Parent is MemberBindingExpressionSyntax || node.Parent is ConditionalAccessExpressionSyntax) { return false; } if (node.Parent is MemberAccessExpressionSyntax) { if (!node.Parent.ChildNodes().First().Equals(node)) { return false; } } return true; }
public override SyntaxNode GetEffectiveParentForAttribute(SyntaxNode node) { if (node.HasAncestor<BaseFieldDeclarationSyntax>()) { return node.GetAncestor<BaseFieldDeclarationSyntax>().Declaration.Variables.FirstOrDefault(); } else if (node.HasAncestor<ParameterSyntax>()) { return node.GetAncestor<ParameterSyntax>(); } else { return node.Parent; } }
public override SyntaxNode GetNodeWithAttributes(SyntaxNode node) { return node is VariableDeclaratorSyntax ? node.GetAncestor<MemberDeclarationSyntax>() : node; }
internal override bool IsAddMethodContext(SyntaxNode node, SemanticModel semanticModel) { if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression)) { var objectCreationExpressionSyntax = node.GetAncestor<ObjectCreationExpressionSyntax>(); if (objectCreationExpressionSyntax == null) { return false; } return true; } return false; }
protected override bool IsViableExtensionMethod(IMethodSymbol method, SyntaxNode expression, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken) { var leftExpression = syntaxFacts.GetExpressionOfMemberAccessExpression(expression) ?? syntaxFacts.GetExpressionOfConditionalMemberAccessExpression(expression); if (leftExpression == null) { if (expression.IsKind(SyntaxKind.CollectionInitializerExpression)) { leftExpression = expression.GetAncestor<ObjectCreationExpressionSyntax>(); } else { return false; } } var semanticInfo = semanticModel.GetTypeInfo(leftExpression, cancellationToken); var leftExpressionType = semanticInfo.Type; return leftExpressionType != null && method.ReduceExtensionMethod(leftExpressionType) != null; }
private bool UsingsAreContainedInNamespace(SyntaxNode contextNode) { return contextNode.GetAncestor<NamespaceDeclarationSyntax>()?.DescendantNodes().OfType<UsingDirectiveSyntax>().FirstOrDefault() != null; }
protected override bool CanAddImportForMethod(Diagnostic diagnostic, ISyntaxFactsService syntaxFacts, ref SyntaxNode node) { switch (diagnostic.Id) { case CS1061: if (node.IsKind(SyntaxKind.ConditionalAccessExpression)) { node = (node as ConditionalAccessExpressionSyntax).WhenNotNull; } else if (node.IsKind(SyntaxKind.MemberBindingExpression)) { node = (node as MemberBindingExpressionSyntax).Name; } else if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression)) { return true; } break; case CS0122: case CS1501: if (node is SimpleNameSyntax) { break; } else if (node is MemberBindingExpressionSyntax) { node = (node as MemberBindingExpressionSyntax).Name; } break; case CS1929: var memberAccessName = (node.Parent as MemberAccessExpressionSyntax)?.Name; var conditionalAccessName = (((node.Parent as ConditionalAccessExpressionSyntax)?.WhenNotNull as InvocationExpressionSyntax)?.Expression as MemberBindingExpressionSyntax)?.Name; if (memberAccessName == null && conditionalAccessName == null) { return false; } node = memberAccessName ?? conditionalAccessName; break; case CS1503: //// look up its corresponding method name var parent = node.GetAncestor<InvocationExpressionSyntax>(); if (parent == null) { return false; } var method = parent.Expression as MemberAccessExpressionSyntax; if (method != null) { node = method.Name; } break; default: return false; } var simpleName = node as SimpleNameSyntax; if (!simpleName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) && !simpleName.IsParentKind(SyntaxKind.MemberBindingExpression)) { return false; } var memberAccess = simpleName.Parent as MemberAccessExpressionSyntax; var memberBinding = simpleName.Parent as MemberBindingExpressionSyntax; if (memberAccess.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) || memberAccess.IsParentKind(SyntaxKind.ElementAccessExpression) || memberBinding.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) || memberBinding.IsParentKind(SyntaxKind.ElementAccessExpression)) { return false; } if (!syntaxFacts.IsMemberAccessExpressionName(node)) { return false; } return true; }
public bool IsExtension(SyntaxNode node) { return (node.Parent is MemberAccessExpressionSyntax) && node.GetAncestor<UsingDirectiveSyntax>() == null && !node.Parent.ChildNodes().First().Equals(node); }
public bool IsAttribute(SyntaxNode node) { return node.GetAncestor<AttributeSyntax>() != null; }
static CodeAction Handle(Document document, Microsoft.CodeAnalysis.Text.TextSpan span, SyntaxNode root, SyntaxNode node, ExpressionSyntax iterateOver, bool replaceNode) { return CodeActionFactory.Create( span, DiagnosticSeverity.Info, "Iterate via 'foreach'", ct => { ForEachStatementSyntax foreachStmt = BuildForeach(iterateOver); SyntaxNode newRoot; var ancestor = node.GetAncestor<StatementSyntax>(); if (replaceNode) { newRoot = root.ReplaceNode(ancestor, new[] { foreachStmt.WithTrailingTrivia(ancestor.GetTrailingTrivia()) }); } else { newRoot = root.InsertNodesAfter(ancestor, new[] { foreachStmt.WithTrailingTrivia(ancestor.GetTrailingTrivia()) }); } return Task.FromResult(document.WithSyntaxRoot(newRoot)); } ); }
CodeAction GetAction(Document document, SemanticModel model, SyntaxNode root, SyntaxNode node, MethodDeclarationSyntax method) { return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Info, GettextCatalog.GetString("Extract anonymous method"), t2 => { var identifier = SyntaxFactory.IdentifierName(NameGenerator.EnsureUniqueness("Method", model.LookupSymbols(node.SpanStart).Select(s => s.Name))); var surroundingMemberDeclaration = node.GetAncestor<MemberDeclarationSyntax>(); var rootWithTrackedMember = root.TrackNodes(node, surroundingMemberDeclaration); var newRoot = rootWithTrackedMember.ReplaceNode(rootWithTrackedMember.GetCurrentNode(node), identifier); newRoot = newRoot .InsertNodesBefore(newRoot.GetCurrentNode(surroundingMemberDeclaration), new[] { method.WithTrailingTrivia(surroundingMemberDeclaration.GetTrailingTrivia()) }); return Task.FromResult(document.WithSyntaxRoot(newRoot)); }); }