private static SyntaxNode GetContainingMember(SyntaxNode oldNode)
{
foreach (var node in oldNode.Ancestors())
{
switch (node.Kind())
{
case SyntaxKind.ParenthesizedLambdaExpression:
case SyntaxKind.SimpleLambdaExpression:
case SyntaxKind.AnonymousMethodExpression:
if ((node as AnonymousFunctionExpressionSyntax)?.AsyncKeyword.Kind() != SyntaxKind.AsyncKeyword)
{
return node;
}
break;
case SyntaxKind.MethodDeclaration:
if ((node as MethodDeclarationSyntax)?.Modifiers.Any(SyntaxKind.AsyncKeyword) == false)
{
return node;
}
break;
default:
continue;
}
}
return null;
}
private static SyntaxToken GetIdentifierOrKeywordAtPosition(SyntaxNode root, SourceLocation position)
{
var syntaxToken = root.FindTokenOnLeft(position);
return syntaxToken.Kind.IsIdentifierOrKeyword() && syntaxToken.SourceRange.ContainsOrTouches(position)
? syntaxToken
: null;
}
public PathSyntaxReference(SyntaxNode node)
{
_tree = node.SyntaxTree;
_kind = node.Kind();
_textSpan = node.Span;
_pathFromRoot = ComputePathFromRoot(node);
}
private void ReplayVarUsage(LocalFunctionSymbol localFunc,
SyntaxNode syntax,
bool isWrite)
{
LocalFuncUsages usages = GetOrCreateLocalFuncUsages(localFunc);
var state = isWrite ? usages.WrittenVars : usages.ReadVars;
// Start at slot 1 (slot 0 just indicates reachability)
for (int slot = 1; slot < state.Capacity; slot++)
{
if (state[slot])
{
if (isWrite)
{
SetSlotAssigned(slot);
}
else
{
var symbol = variableBySlot[slot].Symbol;
CheckAssigned(symbol, syntax, slot);
}
}
}
usages.LocalFuncVisited = true;
}
private ImmutableArray<int> ComputePathFromRoot(SyntaxNode node)
{
var path = new List<int>();
var root = _tree.GetRoot();
while (node != root)
{
for (; node.Parent != null; node = node.Parent)
{
var index = GetChildIndex(node);
path.Add(index);
}
// if we were part of structure trivia, continue searching until we get to the true root
if (node.IsStructuredTrivia)
{
var trivia = node.ParentTrivia;
var triviaIndex = GetTriviaIndex(trivia);
path.Add(triviaIndex);
var tokenIndex = GetChildIndex(trivia.Token);
path.Add(tokenIndex);
node = trivia.Token.Parent;
continue;
}
else if (node != root)
{
throw new InvalidOperationException(CSharpWorkspaceResources.Node_does_not_descend_from_root);
}
}
path.Reverse();
return path.ToImmutableArray();
}
public void AnalyzeCodeBlock(SyntaxNode codeBlock, ISymbol ownerSymbol, SemanticModel semanticModel, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (IsEmptyFinalizer(codeBlock, semanticModel))
{
addDiagnostic(ownerSymbol.CreateDiagnostic(Rule));
}
}
public static SyntaxNode FindPartner(SyntaxNode leftRoot, SyntaxNode rightRoot, SyntaxNode leftNode)
{
// Finding a partner of a zero-width node is complicated and not supported atm:
Debug.Assert(leftNode.FullSpan.Length > 0);
Debug.Assert(leftNode.SyntaxTree == leftRoot.SyntaxTree);
SyntaxNode originalLeftNode = leftNode;
int leftPosition = leftNode.SpanStart;
leftNode = leftRoot;
SyntaxNode rightNode = rightRoot;
while (leftNode != originalLeftNode)
{
Debug.Assert(leftNode.RawKind == rightNode.RawKind);
var leftChild = leftNode.ChildThatContainsPosition(leftPosition, out var childIndex);
// Can only happen when searching for zero-width node.
Debug.Assert(!leftChild.IsToken);
rightNode = rightNode.ChildNodesAndTokens()[childIndex].AsNode();
leftNode = leftChild.AsNode();
}
return rightNode;
}
private string GetOutsideTypeQualifiedName(SyntaxNode node)
{
// Get the name space name enclosing this node.
string namespaceName = node.AncestorsAndSelf().
// ancestors whose kind is name space node.
Where(n => n.Kind == SyntaxKind.NamespaceDeclaration).
// conver to the syntax and get the name.
Select(n => (NamespaceDeclarationSyntax)n).First().Name.PlainName;
// Get the class name enclosing this node.
var classesNames = node.AncestorsAndSelf().
// ancestors whose kind is class node.
Where(n => n.Kind == SyntaxKind.ClassDeclaration).
// convert each one to the kind class node syntax.
Select(n => (ClassDeclarationSyntax)n).
// order all the class decs by their length, in decending order.
OrderByDescending(n => n.Span.Length).
// select their names.
Select(n => n.Identifier.ValueText);
// Combine all the names to get the scope string.
var qualifiedName = namespaceName + "." + StringUtil.ConcatenateAll(".", classesNames);
logger.Info(qualifiedName);
return qualifiedName;
}
public CommentsAnalyzerTests()
{
this.code = FileUtil.ReadAllText(path);
this.root = ASTUtil.GetSyntaxTreeFromSource(code).GetRoot();
this.retriever = RetrieverFactory.GetCommentsRetriever();
this.logger = NLoggerUtil.GetNLogger(typeof (CommentsAnalyzerTests));
}
private void AddEdits(
SyntaxNode root,
SyntaxEditor editor,
Diagnostic diagnostic,
CancellationToken cancellationToken)
{
var localDeclarationLocation = diagnostic.AdditionalLocations[0];
var ifStatementLocation = diagnostic.AdditionalLocations[1];
var conditionLocation = diagnostic.AdditionalLocations[2];
var asExpressionLocation = diagnostic.AdditionalLocations[3];
var localDeclaration = (LocalDeclarationStatementSyntax)localDeclarationLocation.FindNode(cancellationToken);
var ifStatement = (IfStatementSyntax)ifStatementLocation.FindNode(cancellationToken);
var condition = (BinaryExpressionSyntax)conditionLocation.FindNode(cancellationToken);
var asExpression = (BinaryExpressionSyntax)asExpressionLocation.FindNode(cancellationToken);
var updatedCondition = SyntaxFactory.IsPatternExpression(
asExpression.Left, SyntaxFactory.DeclarationPattern(
((TypeSyntax)asExpression.Right).WithoutTrivia(),
localDeclaration.Declaration.Variables[0].Identifier.WithoutTrivia()));
var trivia = localDeclaration.GetLeadingTrivia().Concat(localDeclaration.GetTrailingTrivia())
.Where(t => t.IsSingleOrMultiLineComment())
.SelectMany(t => ImmutableArray.Create(t, SyntaxFactory.ElasticCarriageReturnLineFeed))
.ToImmutableArray();
var updatedIfStatement = ifStatement.ReplaceNode(condition, updatedCondition)
.WithPrependedLeadingTrivia(trivia)
.WithAdditionalAnnotations(Formatter.Annotation);
editor.RemoveNode(localDeclaration);
editor.ReplaceNode(ifStatement, updatedIfStatement);
}
public static bool AreSemanticallyEquivalent(
SemanticModel semanticModel1,
SemanticModel semanticModel2,
SyntaxNode node1,
SyntaxNode node2,
Func<SyntaxNode, bool> predicate = null)
{
// First check for syntactic equivalency. If two nodes aren't structurally equivalent,
// then they're not semantically equivalent.
if (node1 == null && node2 == null)
{
return true;
}
if (node1 == null || node2 == null)
{
return false;
}
if (!node1.IsEquivalentTo(node2, topLevel: false))
{
return false;
}
// From this point on we can assume the tree structure is the same. So no need to check
// kinds, child counts or token contents.
return AreSemanticallyEquivalentWorker(
semanticModel1, semanticModel2, node1, node2, predicate);
}
public override SignatureHelpState GetCurrentArgumentState(SyntaxNode root, int position, ISyntaxFactsService syntaxFacts, TextSpan currentSpan, CancellationToken cancellationToken)
{
if (GetOuterMostTupleExpressionInSpan(root, position, syntaxFacts, currentSpan, cancellationToken, out var expression))
{
return CommonSignatureHelpUtilities.GetSignatureHelpState(expression, position,
getOpenToken: s_getOpenToken,
getCloseToken: s_getCloseToken,
getArgumentsWithSeparators: s_getArgumentsWithSeparators,
getArgumentNames: s_getArgumentNames);
}
if (GetOuterMostParenthesizedExpressionInSpan(root, position, syntaxFacts, currentSpan, cancellationToken, out var parenthesizedExpression))
{
if (currentSpan.Start == parenthesizedExpression.SpanStart)
{
return new SignatureHelpState(
argumentIndex: 0,
argumentCount: 0,
argumentName: string.Empty,
argumentNames: null);
}
}
return null;
}
private BoundNode BindGlobalDeclaration(SyntaxNode declaration, Symbol parent)
{
switch (declaration.Kind)
{
case SyntaxKind.VariableDeclarationStatement:
return BindVariableDeclarationStatement((VariableDeclarationStatementSyntax) declaration, parent);
case SyntaxKind.FunctionDeclaration:
return BindFunctionDeclaration((FunctionDeclarationSyntax) declaration, parent);
case SyntaxKind.FunctionDefinition:
return BindFunctionDefinition((FunctionDefinitionSyntax) declaration, parent);
case SyntaxKind.ConstantBufferDeclaration:
return BindConstantBufferDeclaration((ConstantBufferSyntax) declaration);
case SyntaxKind.TypeDeclarationStatement:
return BindTypeDeclaration((TypeDeclarationStatementSyntax) declaration, parent);
case SyntaxKind.Namespace:
return BindNamespace((NamespaceSyntax) declaration);
case SyntaxKind.TechniqueDeclaration:
return BindTechniqueDeclaration((TechniqueSyntax) declaration);
case SyntaxKind.TypedefStatement:
return BindTypedefStatement((TypedefStatementSyntax) declaration);
case SyntaxKind.EmptyStatement:
return BindEmptyStatement((EmptyStatementSyntax) declaration);
default:
throw new ArgumentOutOfRangeException(declaration.Kind.ToString());
}
}
public override void DefaultVisit(SyntaxNode node)
{
foreach (var child in node.ChildNodes())
{
child.Accept(this);
}
}
public override void DefaultVisit(SyntaxNode node)
{
foreach (var child in node.ChildNodes())
{
Visit(child);
}
}
public ICodeBlockEndedAnalyzer OnCodeBlockStarted(SyntaxNode codeBlock, ISymbol ownerSymbol, SemanticModel semanticModel, Action<Diagnostic> addDiagnostic, CancellationToken cancellationToken)
{
var methodSymbol = ownerSymbol as IMethodSymbol;
if (methodSymbol == null ||
methodSymbol.ReturnsVoid ||
methodSymbol.ReturnType.Kind == SymbolKind.ArrayType ||
methodSymbol.Parameters.Length > 0 ||
!(methodSymbol.DeclaredAccessibility == Accessibility.Public || methodSymbol.DeclaredAccessibility == Accessibility.Protected) ||
methodSymbol.IsAccessorMethod() ||
!IsPropertyLikeName(methodSymbol.Name))
{
return null;
}
// Fxcop has a few additional checks to reduce the noise for this diagnostic:
// Ensure that the method is non-generic, non-virtual/override, has no overloads and doesn't have special names: 'GetHashCode' or 'GetEnumerator'.
// Also avoid generating this diagnostic if the method body has any invocation expressions.
if (methodSymbol.IsGenericMethod ||
methodSymbol.IsVirtual ||
methodSymbol.IsOverride ||
methodSymbol.ContainingType.GetMembers(methodSymbol.Name).Length > 1 ||
methodSymbol.Name == GetHashCodeName ||
methodSymbol.Name == GetEnumeratorName)
{
return null;
}
return GetCodeBlockEndedAnalyzer();
}
public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
{
nextOperation.Invoke(list);
var queryExpression = node as QueryExpressionSyntax;
if (queryExpression != null)
{
var firstToken = queryExpression.FromClause.Expression.GetFirstToken(includeZeroWidth: true);
var lastToken = queryExpression.FromClause.Expression.GetLastToken(includeZeroWidth: true);
AddIndentBlockOperation(list, queryExpression.FromClause.FromKeyword, firstToken, lastToken);
for (int i = 0; i < queryExpression.Body.Clauses.Count; i++)
{
// if it is nested query expression
var fromClause = queryExpression.Body.Clauses[i] as FromClauseSyntax;
if (fromClause != null)
{
firstToken = fromClause.Expression.GetFirstToken(includeZeroWidth: true);
lastToken = fromClause.Expression.GetLastToken(includeZeroWidth: true);
AddIndentBlockOperation(list, fromClause.FromKeyword, firstToken, lastToken);
}
}
// set alignment line for query expression
var baseToken = queryExpression.GetFirstToken(includeZeroWidth: true);
var endToken = queryExpression.GetLastToken(includeZeroWidth: true);
if (!baseToken.IsMissing && !baseToken.Equals(endToken))
{
var startToken = baseToken.GetNextToken(includeZeroWidth: true);
SetAlignmentBlockOperation(list, baseToken, startToken, endToken);
}
}
}
private void AddFix(string codeFixTitle, CodeFixContext context, SyntaxNode root, SyntaxNode classDecl, SyntaxGenerator generator, params string[] languages)
{
var fix = new MyCodeAction(
codeFixTitle,
c => GetFix(context.Document, root, classDecl, generator, languages));
context.RegisterCodeFix(fix, context.Diagnostics);
}
private IEnumerable<SyntaxNode> EnumerateNonRootChildren(SyntaxNode node)
{
foreach (var child in node.ChildNodes())
{
if (LambdaUtilities.IsLambdaBodyStatementOrExpression(child))
{
continue;
}
if (HasLabel(child))
{
yield return child;
}
else
{
foreach (var descendant in child.DescendantNodes(DescendIntoChildren))
{
if (HasLabel(descendant))
{
yield return descendant;
}
}
}
}
}
internal CorrectAllSignaturesInSolution(ISolution solution, SyntaxNode declaration,
IEnumerable<Tuple<int, int>> mappings)
{
this.solution = solution;
this.declaration = declaration;
this.mappings = mappings;
}
private Task<Document> AddNonSerializedAttribute(Document document, SemanticModel model, SyntaxNode root, SyntaxNode fieldNode, SyntaxGenerator generator)
{
var attr = generator.Attribute(generator.TypeExpression(WellKnownTypes.NonSerializedAttribute(model.Compilation)));
var newNode = generator.AddAttributes(fieldNode, attr);
var newDocument = document.WithSyntaxRoot(root.ReplaceNode(fieldNode, newNode));
return Task.FromResult(newDocument);
}
internal StatementSyntaxComparer(SyntaxNode oldRootChild, SyntaxNode newRootChild)
{
_oldRootChild = oldRootChild;
_newRootChild = newRootChild;
_oldRoot = oldRootChild.Parent;
_newRoot = newRootChild.Parent;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="syntaxNode">SyntaxNode</param>
/// <param name="node">IControlFlowNode</param>
/// <param name="summary">MethodSummary</param>
private Statement(SyntaxNode syntaxNode, IControlFlowNode node,
MethodSummary summary)
{
this.SyntaxNode = syntaxNode;
this.ControlFlowNode = node;
this.Summary = summary;
}
public void AddOrAccess(SyntaxNode instance, IWeakAction<SyntaxNode> evictor)
{
if (!trees.ContainsKey(instance))
{
trees[instance] = evictor;
}
}
private State(SyntaxNode node, INamedTypeSymbol classType, INamedTypeSymbol abstractClassType, IList<Tuple<INamedTypeSymbol, IList<ISymbol>>> unimplementedMembers)
{
this.Location = node;
this.ClassType = classType;
this.AbstractClassType = abstractClassType;
this.UnimplementedMembers = unimplementedMembers;
}
private async Task<Solution> RenameThenRemoveAsyncTokenAsync(Document document, SyntaxNode node, IMethodSymbol methodSymbol, CancellationToken cancellationToken)
{
var name = methodSymbol.Name;
var newName = name.Substring(0, name.Length - AsyncSuffix.Length);
var solution = document.Project.Solution;
var options = solution.Workspace.Options;
// Store the path to this node. That way we can find it post rename.
var syntaxPath = new SyntaxPath(node);
// Rename the method to remove the 'Async' suffix, then remove the 'async' keyword.
var newSolution = await Renamer.RenameSymbolAsync(solution, methodSymbol, newName, options, cancellationToken).ConfigureAwait(false);
var newDocument = newSolution.GetDocument(document.Id);
var newRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SyntaxNode newNode;
if (syntaxPath.TryResolve<SyntaxNode>(newRoot, out newNode))
{
var semanticModel = await newDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var newMethod = (IMethodSymbol)semanticModel.GetDeclaredSymbol(newNode, cancellationToken);
return await RemoveAsyncTokenAsync(newDocument, newMethod, newNode, cancellationToken).ConfigureAwait(false);
}
return newSolution;
}
private SyntaxNode GetNewNode(Document document, SyntaxNode node, CancellationToken cancellationToken)
{
SyntaxNode newNode = null;
var propertyStatement = node as PropertyDeclarationSyntax;
if (propertyStatement != null)
{
newNode = propertyStatement.AddModifiers(SyntaxFactory.Token(SyntaxKind.NewKeyword)) as SyntaxNode;
}
var methodStatement = node as MethodDeclarationSyntax;
if (methodStatement != null)
{
newNode = methodStatement.AddModifiers(SyntaxFactory.Token(SyntaxKind.NewKeyword));
}
var fieldDeclaration = node as FieldDeclarationSyntax;
if (fieldDeclaration != null)
{
newNode = fieldDeclaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.NewKeyword));
}
//Make sure we preserve any trivia from the original node
newNode = newNode.WithTriviaFrom(node);
return newNode.WithAdditionalAnnotations(Formatter.Annotation);
}
internal override Task<IEnumerable<CodeAction>> GetFixesAsync(Document document, SemanticModel model, SyntaxNode root, SyntaxNode nodeToFix, CancellationToken cancellationToken)
{
var actions = ImmutableArray.CreateBuilder<CodeAction>();
// Fix 1: Add a NonSerialized attribute to the field
var fieldNode = GetFieldDeclarationNode(nodeToFix);
if (fieldNode != null)
{
var generator = SyntaxGenerator.GetGenerator(document);
var codeAction = new MyDocumentCodeAction(FxCopFixersResources.AddNonSerializedAttribute,
async ct => await AddNonSerializedAttribute(document, model, root, fieldNode, generator).ConfigureAwait(false));
actions.Add(codeAction);
// Fix 2: If the type of the field is defined in source, then add the serializable attribute to the type.
var fieldSymbol = model.GetDeclaredSymbol(nodeToFix, cancellationToken) as IFieldSymbol;
var type = fieldSymbol.Type;
if (type.Locations.Any(l => l.IsInSource))
{
var typeCodeAction = new MySolutionCodeAction(FxCopFixersResources.AddSerializableAttribute,
async ct => await AddSerializableAttributeToType(document, model, generator, type, cancellationToken).ConfigureAwait(false));
actions.Add(typeCodeAction);
}
}
return Task.FromResult<IEnumerable<CodeAction>>(actions.ToImmutable());
}
// This constructor can be used to have the span and associated node be arbitrarily different.
public SourceLocationWithAssociatedNode(SyntaxTree syntaxTree, TextSpan span, SyntaxNode associatedNode, bool associateInParent)
: base(syntaxTree, span)
{
Debug.Assert(associatedNode != null); //if it's null, construct a SourceLocation instead
this.associatedNode = new WeakReference<SyntaxNode>(associatedNode);
this.associateInParent = associateInParent;
}
public PathSyntaxReference(SyntaxNode node)
{
this.tree = node.SyntaxTree;
this.kind = node.CSharpKind();
this.textSpan = node.Span;
this.pathFromRoot = ComputePathFromRoot(node);
}
protected abstract Task <SyntaxNode> ReplaceNodeAsync(SyntaxNode node, string containerName, CancellationToken cancellationToken);
protected abstract (string description, bool hasExistingImport) GetDescription(Document document, INamespaceOrTypeSymbol symbol, SemanticModel semanticModel, SyntaxNode root, CancellationToken cancellationToken);
protected abstract TNode RewriteCore <TNode>(
TNode node,
SyntaxNode replacementNode,
ISet <TExpressionSyntax> matches)
where TNode : SyntaxNode;
public static bool IsInstance(SyntaxNode node)
{
return(node != null && LightupHelpers.CanWrapNode(node, WrappedType));
}
public void Replace(SyntaxNode oldNode, SyntaxNode newNode)
{
_replace[oldNode] = newNode;
}
private static SyntaxNode GetNegationOfBinaryExpression(
SyntaxNode expressionNode,
SyntaxGenerator generator,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
var syntaxFacts = generator.SyntaxFacts;
syntaxFacts.GetPartsOfBinaryExpression(expressionNode, out var leftOperand, out var operatorToken, out var rightOperand);
var binaryOperation = semanticModel.GetOperation(expressionNode, cancellationToken) as IBinaryOperation;
if (binaryOperation == null)
{
// Apply the logical not operator if it is not a binary operation.
return(generator.LogicalNotExpression(expressionNode));
}
if (!s_negatedBinaryMap.TryGetValue(binaryOperation.OperatorKind, out var negatedKind))
{
return(generator.LogicalNotExpression(expressionNode));
}
else
{
var negateOperands = false;
switch (binaryOperation.OperatorKind)
{
case BinaryOperatorKind.Or:
case BinaryOperatorKind.And:
case BinaryOperatorKind.ConditionalAnd:
case BinaryOperatorKind.ConditionalOr:
negateOperands = true;
break;
}
//Workaround for https://github.com/dotnet/roslyn/issues/23956
//Issue to remove this when above is merged
if (binaryOperation.OperatorKind == BinaryOperatorKind.Or && syntaxFacts.IsConditionalOr(expressionNode))
{
negatedKind = BinaryOperatorKind.ConditionalAnd;
}
else if (binaryOperation.OperatorKind == BinaryOperatorKind.And && syntaxFacts.IsConditionalAnd(expressionNode))
{
negatedKind = BinaryOperatorKind.ConditionalOr;
}
var newLeftOperand = leftOperand;
var newRightOperand = rightOperand;
if (negateOperands)
{
newLeftOperand = generator.Negate(leftOperand, semanticModel, cancellationToken);
newRightOperand = generator.Negate(rightOperand, semanticModel, cancellationToken);
}
var newBinaryExpressionSyntax = NewBinaryOperation(binaryOperation, newLeftOperand, negatedKind, newRightOperand, generator, cancellationToken)
.WithTriviaFrom(expressionNode);
var newToken = syntaxFacts.GetOperatorTokenOfBinaryExpression(newBinaryExpressionSyntax);
var newTokenWithTrivia = newToken.WithTriviaFrom(operatorToken);
return(newBinaryExpressionSyntax.ReplaceToken(newToken, newTokenWithTrivia));
}
}
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationSyntax member)
{
SyntaxNode parent = member.Parent;
if (parent?.IsKind(
SyntaxKind.NamespaceDeclaration,
SyntaxKind.ClassDeclaration,
SyntaxKind.StructDeclaration,
SyntaxKind.InterfaceDeclaration) == true)
{
var parentMember = (MemberDeclarationSyntax)parent;
SyntaxList<MemberDeclarationSyntax> members = parentMember.GetMembers();
if (members.Count > 1)
{
int index = IndexOfMemberToSwap(member, members, context.Span);
if (index != -1)
{
SyntaxTree tree = member.SyntaxTree;
FileLinePositionSpan fileLinePositionSpan = tree.GetLineSpan(context.Span, context.CancellationToken);
int startLine = fileLinePositionSpan.StartLine();
int endLine = fileLinePositionSpan.EndLine();
if (startLine > tree.GetEndLine(members[index].TrimmedSpan(), context.CancellationToken)
&& endLine < tree.GetStartLine(members[index + 1].TrimmedSpan(), context.CancellationToken))
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveMemberDeclarations))
{
context.RegisterRefactoring(
"Remove members above",
cancellationToken =>
{
return ReplaceMembersAsync(
context.Document,
parentMember,
List(members.Skip(index + 1)),
cancellationToken);
});
context.RegisterRefactoring(
"Remove members below",
cancellationToken =>
{
return ReplaceMembersAsync(
context.Document,
parentMember,
List(members.Take(index + 1)),
cancellationToken);
});
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapMemberDeclarations))
{
context.RegisterRefactoring(
"Swap members",
cancellationToken =>
{
return RefactorAsync(
context.Document,
parentMember,
members,
index,
cancellationToken);
});
}
}
}
}
}
}
protected abstract Task <Document> AddImportAsync(SyntaxNode contextNode, IReadOnlyList <string> nameSpaceParts, Document document, bool specialCaseSystem, CancellationToken cancellationToken);
protected abstract bool IsViableExtensionMethod(IMethodSymbol method, SyntaxNode expression, SemanticModel semanticModel, ISyntaxFacts syntaxFacts, CancellationToken cancellationToken);
protected abstract bool IsAddMethodContext(SyntaxNode node, SemanticModel semanticModel);
protected abstract ITypeSymbol GetDeconstructInfo(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken);
protected abstract Task <Document> AddImportAsync(SyntaxNode contextNode, INamespaceOrTypeSymbol symbol, Document document, bool specialCaseSystem, CancellationToken cancellationToken);
protected abstract bool CanAddImportForType(string diagnosticId, SyntaxNode node, out TSimpleNameSyntax nameNode);
protected abstract ITypeSymbol GetQueryClauseInfo(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken);
protected abstract bool CanAddImportForGetAsyncEnumerator(string diagnosticId, ISyntaxFacts syntaxFactsService, SyntaxNode node);
protected abstract ISet <INamespaceSymbol> GetImportNamespacesInScope(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken);
protected abstract bool CanAddImportForMethod(string diagnosticId, ISyntaxFacts syntaxFacts, SyntaxNode node, out TSimpleNameSyntax nameNode);
protected abstract bool CanAddImportForQuery(string diagnosticId, SyntaxNode node);
public override SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options)
{
throw new NotImplementedException();
}
protected abstract bool CanAddImportForDeconstruct(string diagnosticId, SyntaxNode node);
static IEnumerable <IClassificationType> GetClassificationType(SyntaxNode node, SemanticModel semanticModel)
{
node = node.Kind() == SyntaxKind.Argument ? (node as ArgumentSyntax).Expression : node;
//System.Diagnostics.Debug.WriteLine(node.GetType().Name + node.Span.ToString());
var symbol = semanticModel.GetSymbolInfo(node).Symbol;
if (symbol == null)
{
symbol = semanticModel.GetDeclaredSymbol(node);
if (symbol != null)
{
switch (symbol.Kind)
{
case SymbolKind.NamedType:
yield return(symbol.ContainingType != null ? _Classifications.NestedDeclaration : _Classifications.Declaration);
break;
case SymbolKind.Event:
case SymbolKind.Method:
yield return(_Classifications.NestedDeclaration);
break;
case SymbolKind.Property:
if (symbol.ContainingType.IsAnonymousType == false)
{
yield return(_Classifications.NestedDeclaration);
}
break;
case SymbolKind.Field:
if (node.IsKind(SyntaxKind.TupleElement) && (node as TupleElementSyntax).Identifier.IsKind(SyntaxKind.None))
{
symbol = semanticModel.GetTypeInfo((node as TupleElementSyntax).Type).Type;
}
break;
}
}
else
{
// NOTE: handle alias in using directive
if ((node.Parent as NameEqualsSyntax)?.Parent is UsingDirectiveSyntax)
{
yield return(_Classifications.AliasNamespace);
}
else if (node is AttributeArgumentSyntax)
{
symbol = semanticModel.GetSymbolInfo((node as AttributeArgumentSyntax).Expression).Symbol;
if (symbol != null && symbol.Kind == SymbolKind.Field && (symbol as IFieldSymbol)?.IsConst == true)
{
yield return(_Classifications.ConstField);
yield return(_Classifications.StaticMember);
}
}
symbol = node.Parent is MemberAccessExpressionSyntax?semanticModel.GetSymbolInfo(node.Parent).CandidateSymbols.FirstOrDefault()
: node.Parent.IsKind(SyntaxKind.Argument) ? semanticModel.GetSymbolInfo((node.Parent as ArgumentSyntax).Expression).CandidateSymbols.FirstOrDefault()
: node.IsKind(SyntaxKind.SimpleBaseType) ? semanticModel.GetTypeInfo((node as SimpleBaseTypeSyntax).Type).Type
: node.IsKind(SyntaxKind.TypeConstraint) ? semanticModel.GetTypeInfo((node as TypeConstraintSyntax).Type).Type
: null;
if (symbol == null)
{
yield break;
}
}
}
switch (symbol.Kind)
{
case SymbolKind.Alias:
case SymbolKind.ArrayType:
case SymbolKind.Assembly:
case SymbolKind.DynamicType:
case SymbolKind.ErrorType:
case SymbolKind.NetModule:
case SymbolKind.PointerType:
case SymbolKind.RangeVariable:
case SymbolKind.Preprocessing:
//case SymbolKind.Discard:
yield break;
case SymbolKind.Label:
yield return(_Classifications.Label);
yield break;
case SymbolKind.TypeParameter:
yield return(_Classifications.TypeParameter);
yield break;
case SymbolKind.Field:
var fieldSymbol = symbol as IFieldSymbol;
yield return(fieldSymbol.IsConst ? _Classifications.ConstField : fieldSymbol.IsReadOnly ? _Classifications.ReadonlyField : _Classifications.Field);
break;
case SymbolKind.Property:
yield return(_Classifications.Property);
break;
case SymbolKind.Event:
yield return(_Classifications.Event);
break;
case SymbolKind.Local:
var localSymbol = symbol as ILocalSymbol;
yield return(localSymbol.IsConst ? _Classifications.ConstField : _Classifications.LocalVariable);
break;
case SymbolKind.Namespace:
yield return(_Classifications.Namespace);
yield break;
case SymbolKind.Parameter:
yield return(_Classifications.Parameter);
break;
case SymbolKind.Method:
var methodSymbol = symbol as IMethodSymbol;
switch (methodSymbol.MethodKind)
{
case MethodKind.Constructor:
yield return
(node is AttributeSyntax || node.Parent is AttributeSyntax || node.Parent?.Parent is AttributeSyntax
? _Classifications.AttributeName
: _Classifications.ConstructorMethod);
break;
case MethodKind.Destructor:
case MethodKind.StaticConstructor:
yield return(_Classifications.ConstructorMethod);
break;
default:
yield return(methodSymbol.IsExtensionMethod ? _Classifications.ExtensionMethod
: methodSymbol.IsExtern ? _Classifications.ExternMethod
: _Classifications.Method);
break;
}
break;
case SymbolKind.NamedType:
break;
default:
yield break;
}
if (SymbolMarkManager.HasBookmark)
{
var markerStyle = SymbolMarkManager.GetSymbolMarkerStyle(symbol);
if (markerStyle != null)
{
yield return(markerStyle);
}
}
if (TextEditorHelper.IdentifySymbolSource && symbol.IsMemberOrType() && symbol.ContainingAssembly != null)
{
yield return(symbol.ContainingAssembly.GetSourceType() == AssemblySource.Metadata
? _Classifications.MetadataSymbol
: _Classifications.UserSymbol);
}
if (symbol.IsStatic)
{
if (symbol.Kind != SymbolKind.Namespace)
{
yield return(_Classifications.StaticMember);
}
}
else if (symbol.IsSealed)
{
if (symbol.Kind == SymbolKind.NamedType && (symbol as ITypeSymbol).TypeKind != TypeKind.Class)
{
yield break;
}
yield return(_Classifications.SealedMember);
}
else if (symbol.IsOverride)
{
yield return(_Classifications.OverrideMember);
}
else if (symbol.IsVirtual)
{
yield return(_Classifications.VirtualMember);
}
else if (symbol.IsAbstract)
{
yield return(_Classifications.AbstractMember);
}
}
protected abstract bool CanAddImport(SyntaxNode node, CancellationToken cancellationToken);
public static SyntaxNode Simplify(this SyntaxNode node) =>
SyntaxNodeSimplifier.Simplify(node);
public override SyntaxReference GetReference(SyntaxNode node)
{
return(new Reference(this, underlyingTree.GetReference(node)));
}
internal BaseMethodWrapperSymbol(NamedTypeSymbol containingType, MethodSymbol methodBeingWrapped, SyntaxNode syntax, string name)
: base(containingType, methodBeingWrapped, syntax.SyntaxTree.GetReference(syntax), syntax.GetLocation(), name, DeclarationModifiers.Private)
{
Debug.Assert(containingType.ContainingModule is SourceModuleSymbol);
Debug.Assert(ReferenceEquals(methodBeingWrapped, methodBeingWrapped.ConstructedFrom));
Debug.Assert(!methodBeingWrapped.IsStatic);
TypeMap typeMap = null;
ImmutableArray <TypeParameterSymbol> typeParameters;
var substitutedType = methodBeingWrapped.ContainingType as SubstitutedNamedTypeSymbol;
typeMap = ((object)substitutedType == null ? TypeMap.Empty : substitutedType.TypeSubstitution);
if (!methodBeingWrapped.IsGenericMethod)
{
typeParameters = ImmutableArray <TypeParameterSymbol> .Empty;
}
else
{
typeMap = typeMap.WithAlphaRename(methodBeingWrapped, this, out typeParameters);
}
AssignTypeMapAndTypeParameters(typeMap, typeParameters);
}
static IClassificationType ClassifySyntaxNode(SyntaxNode node)
{
switch (node.Kind())
{
case SyntaxKind.MethodDeclaration:
case SyntaxKind.AnonymousMethodExpression:
case SyntaxKind.SimpleLambdaExpression:
case SyntaxKind.ParenthesizedLambdaExpression:
case SyntaxKind.LocalFunctionStatement:
return(_Classifications.Method);
case SyntaxKind.InvocationExpression:
return((((node as InvocationExpressionSyntax).Expression as IdentifierNameSyntax)?.Identifier.ValueText == "nameof") ? null : _Classifications.Method);
case SyntaxKind.ConstructorDeclaration:
case SyntaxKind.AnonymousObjectCreationExpression:
case SyntaxKind.ObjectInitializerExpression:
case SyntaxKind.ObjectCreationExpression:
case SyntaxKind.CollectionInitializerExpression:
case SyntaxKind.ArrayInitializerExpression:
case SyntaxKind.ThisConstructorInitializer:
return(_Classifications.ConstructorMethod);
case SyntaxKind.PropertyDeclaration: return(_Classifications.Property);
case SyntaxKind.ClassDeclaration: return(_Classifications.ClassName);
case SyntaxKind.InterfaceDeclaration: return(_Classifications.InterfaceName);
case SyntaxKind.EnumDeclaration: return(_Classifications.EnumName);
case SyntaxKind.StructDeclaration: return(_Classifications.StructName);
case SyntaxKind.Attribute: return(_Classifications.AttributeName);
case SyntaxKind.NamespaceDeclaration:
return(_Classifications.Namespace);
case SyntaxKind.IfStatement:
case SyntaxKind.ElseClause:
case SyntaxKind.SwitchStatement:
case SyntaxKind.SwitchSection:
return(_GeneralClassifications.BranchingKeyword);
case SyntaxKind.ForStatement:
case SyntaxKind.ForEachStatement:
case SyntaxKind.WhileStatement:
case SyntaxKind.DoStatement:
return(_GeneralClassifications.LoopKeyword);
case SyntaxKind.UsingStatement:
case SyntaxKind.LockStatement:
case SyntaxKind.FixedStatement:
case SyntaxKind.UnsafeStatement:
case SyntaxKind.TryStatement:
case SyntaxKind.CatchClause:
case SyntaxKind.CatchFilterClause:
case SyntaxKind.FinallyClause:
return(_Classifications.ResourceKeyword);
}
return(null);
}
public static bool IsEquivalentWhenNormalized(this SyntaxNode node, SyntaxNode other) =>
SyntaxNodeComparer.IsEquivalentToNormalized(node, other);
private async Task <Document> ProcessNode(Document document, SyntaxNode node, string containerName, CancellationToken cancellationToken)
{
var newRoot = await this.ReplaceNodeAsync(node, containerName, cancellationToken).ConfigureAwait(false);
return(document.WithSyntaxRoot(newRoot));
}
protected abstract BoundExpression FramePointer(SyntaxNode syntax, NamedTypeSymbol frameClass);
protected abstract bool CanFullyQualify(Diagnostic diagnostic, ref SyntaxNode node);