private static void AppendName(StringBuilder builder, NameSyntax name)
{
if (name.Kind() == SyntaxKind.QualifiedName)
{
AppendName(builder, ((QualifiedNameSyntax)name).Left);
}
switch (name.Kind())
{
case SyntaxKind.IdentifierName:
AppendDotIfNeeded(builder);
builder.Append(((IdentifierNameSyntax)name).Identifier.ValueText);
break;
case SyntaxKind.GenericName:
var genericName = (GenericNameSyntax)name;
AppendDotIfNeeded(builder);
builder.Append(genericName.Identifier.ValueText);
AppendArity(builder, genericName.Arity);
break;
case SyntaxKind.AliasQualifiedName:
var aliasQualifiedName = (AliasQualifiedNameSyntax)name;
AppendName(builder, aliasQualifiedName.Alias);
builder.Append("::");
AppendName(builder, aliasQualifiedName.Name);
break;
case SyntaxKind.QualifiedName:
AppendName(builder, ((QualifiedNameSyntax)name).Right);
break;
}
}
public static SyntaxToken GetNameToken(this NameSyntax nameSyntax)
{
while (true)
{
if (nameSyntax.Kind() == SyntaxKind.IdentifierName)
{
return(((IdentifierNameSyntax)nameSyntax).Identifier);
}
else if (nameSyntax.Kind() == SyntaxKind.QualifiedName)
{
nameSyntax = ((QualifiedNameSyntax)nameSyntax).Right;
}
else if (nameSyntax.Kind() == SyntaxKind.GenericName)
{
return(((GenericNameSyntax)nameSyntax).Identifier);
}
else if (nameSyntax.Kind() == SyntaxKind.AliasQualifiedName)
{
nameSyntax = ((AliasQualifiedNameSyntax)nameSyntax).Name;
}
else
{
throw new NotSupportedException();
}
}
}
private bool CompareNames(NameSyntax oldName, NameSyntax newName)
{
if (oldName.Kind() != newName.Kind())
{
return(false);
}
switch (oldName.Kind())
{
case SyntaxKind.IdentifierName:
var oldIdentifierName = (IdentifierNameSyntax)oldName;
var newIdentifierName = (IdentifierNameSyntax)newName;
return(StringComparer.Ordinal.Equals(oldIdentifierName.Identifier.ToString(), newIdentifierName.Identifier.ToString()));
case SyntaxKind.QualifiedName:
var oldQualifiedName = (QualifiedNameSyntax)oldName;
var newQualifiedName = (QualifiedNameSyntax)newName;
return(CompareNames(oldQualifiedName.Left, newQualifiedName.Left) &&
CompareNames(oldQualifiedName.Right, oldQualifiedName.Right));
case SyntaxKind.GenericName:
var oldGenericName = (GenericNameSyntax)oldName;
var newGenericName = (GenericNameSyntax)newName;
if (!StringComparer.Ordinal.Equals(oldGenericName.Identifier.ToString(), newGenericName.Identifier.ToString()))
{
return(false);
}
if (oldGenericName.Arity != newGenericName.Arity)
{
return(false);
}
for (int i = 0; i < oldGenericName.Arity; i++)
{
if (!CompareTypes(oldGenericName.TypeArgumentList.Arguments[i], newGenericName.TypeArgumentList.Arguments[i]))
{
return(false);
}
}
return(true);
case SyntaxKind.AliasQualifiedName:
var oldAliasQualifiedName = (AliasQualifiedNameSyntax)oldName;
var newAliasQualifiedName = (AliasQualifiedNameSyntax)newName;
return(CompareNames(oldAliasQualifiedName.Alias, newAliasQualifiedName.Alias) &&
CompareNames(oldAliasQualifiedName.Name, newAliasQualifiedName.Name));
}
Debug.Fail("Unknown kind: " + oldName.Kind());
return(false);
}
private void DecomposeNameParts(NameSyntax name, List <SimpleNameSyntax> result)
{
switch (name.Kind())
{
case SyntaxKind.QualifiedName:
var dottedName = (QualifiedNameSyntax)name;
DecomposeNameParts(dottedName.Left, result);
DecomposeNameParts(dottedName.Right, result);
break;
case SyntaxKind.AliasQualifiedName:
var aliasedName = (AliasQualifiedNameSyntax)name;
result.Add(aliasedName.Alias);
DecomposeNameParts(aliasedName.Name, result);
break;
case SyntaxKind.IdentifierName:
result.Add((IdentifierNameSyntax)name);
break;
case SyntaxKind.GenericName:
result.Add((GenericNameSyntax)name);
break;
}
}
internal NamespaceSymbol GetNestedNamespace(NameSyntax name)
{
switch (name.Kind())
{
case SyntaxKind.GenericName: // DeclarationTreeBuilder.VisitNamespace uses the PlainName, even for generic names
case SyntaxKind.IdentifierName:
return(this.GetNestedNamespace(((SimpleNameSyntax)name).Identifier.ValueText));
case SyntaxKind.QualifiedName:
var qn = (QualifiedNameSyntax)name;
var leftNs = this.GetNestedNamespace(qn.Left);
if ((object)leftNs != null)
{
return(leftNs.GetNestedNamespace(qn.Right));
}
break;
case SyntaxKind.AliasQualifiedName:
// This is an error scenario, but we should still handle it.
// We recover in the same way as DeclarationTreeBuilder.VisitNamespaceDeclaration.
return(this.GetNestedNamespace(name.GetUnqualifiedName().Identifier.ValueText));
}
return(null);
}
private static bool ContainsGeneric(NameSyntax name)
{
switch (name.Kind())
{
case SyntaxKind.GenericName:
return(true);
case SyntaxKind.AliasQualifiedName:
return(ContainsGeneric(((AliasQualifiedNameSyntax)name).Name));
case SyntaxKind.QualifiedName:
var qualifiedName = (QualifiedNameSyntax)name;
return(ContainsGeneric(qualifiedName.Left) || ContainsGeneric(qualifiedName.Right));
}
return(false);
}
internal TemplateSymbol GetNestedTemplate(NameSyntax name)
{
switch (name.Kind())
{
case SyntaxKind.GenericName:
case SyntaxKind.IdentifierName:
return(this.GetNestedTemplate(((SimpleNameSyntax)name).Identifier.ValueText));
case SyntaxKind.QualifiedName:
throw new System.NotImplementedException("NamespaceSymbol - GetNestedTemplate of QualifiedName");
case SyntaxKind.AliasQualifiedName:
throw new System.NotImplementedException("NamespaceSymbol - GetNestedTemplate of AliasQualifiedName");
}
return(null);
}
public static string GetName(this NameSyntax name)
{
if (name == null)
{
return(null);
}
switch (name.Kind())
{
case SyntaxKind.IdentifierName:
case SyntaxKind.GenericName: return(((SimpleNameSyntax)name).Identifier.Text);
case SyntaxKind.QualifiedName: return(((QualifiedNameSyntax)name).Right.Identifier.Text);
case SyntaxKind.AliasQualifiedName: return(((AliasQualifiedNameSyntax)name).Name.Identifier.Text);
}
return(name.ToString());
}
private SyntaxNode EditSyntaxNode(SyntaxNode node, CSharpCompilation compilation, CancellationToken cancellationToken)
{
bool HasBreakingAttribute(SyntaxList <AttributeListSyntax> attrLists)
{
for (int i = 0; i < attrLists.Count; i++)
{
SeparatedSyntaxList <AttributeSyntax> attrs = attrLists[i].Attributes;
for (int j = 0; j < attrs.Count; j++)
{
NameSyntax attrName = attrs[i].Name;
string attrNameString;
switch (attrName.Kind())
{
case SyntaxKind.IdentifierName:
attrNameString = ((IdentifierNameSyntax)attrName).Identifier.Text;
break;
case SyntaxKind.QualifiedName:
attrNameString = ((QualifiedNameSyntax)attrName).Right.Identifier.Text;
break;
default:
continue;
}
if (Array.IndexOf(possibleNames, attrNameString) != -1)
{
return(true);
}
}
}
return(false);
}
if (node is MethodDeclarationSyntax method && HasBreakingAttribute(method.AttributeLists))
{
var statements = method.Body.Statements.Insert(0, BreakStatement.NormalizeWhitespace());
return(method.WithBody(method.Body.WithStatements(statements)));
}
return(node);
}
private static void ComputeDeclarations(
SemanticModel model,
SyntaxNode node,
Func <SyntaxNode, int?, bool> shouldSkip,
bool getSymbol,
List <DeclarationInfo> builder,
int?levelsToCompute,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (shouldSkip(node, levelsToCompute))
{
return;
}
var newLevel = DecrementLevel(levelsToCompute);
switch (node.Kind())
{
case SyntaxKind.NamespaceDeclaration:
{
var ns = (NamespaceDeclarationSyntax)node;
foreach (var decl in ns.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
var declInfo = GetDeclarationInfo(model, node, getSymbol, cancellationToken);
builder.Add(declInfo);
NameSyntax name = ns.Name;
INamespaceSymbol nsSymbol = declInfo.DeclaredSymbol as INamespaceSymbol;
while (name.Kind() == SyntaxKind.QualifiedName)
{
name = ((QualifiedNameSyntax)name).Left;
var declaredSymbol = getSymbol ? nsSymbol?.ContainingNamespace : null;
builder.Add(new DeclarationInfo(name, ImmutableArray <SyntaxNode> .Empty, declaredSymbol));
nsSymbol = declaredSymbol;
}
return;
}
case SyntaxKind.ConceptDeclaration: //@t-mawind ?
case SyntaxKind.InstanceDeclaration: //@t-mawind ?
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.InterfaceDeclaration:
{
var t = (TypeDeclarationSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EnumDeclaration:
{
var t = (EnumDeclarationSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EnumMemberDeclaration:
{
var t = (EnumMemberDeclarationSyntax)node;
builder.Add(GetDeclarationInfo(model, node, getSymbol, t.EqualsValue, cancellationToken));
return;
}
case SyntaxKind.DelegateDeclaration:
{
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EventDeclaration:
{
var t = (EventDeclarationSyntax)node;
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EventFieldDeclaration:
case SyntaxKind.FieldDeclaration:
{
var t = (BaseFieldDeclarationSyntax)node;
foreach (var decl in t.Declaration.Variables)
{
builder.Add(GetDeclarationInfo(model, decl, getSymbol, decl.Initializer, cancellationToken));
}
return;
}
case SyntaxKind.ArrowExpressionClause:
{
// Arrow expression clause declares getter symbol for properties and indexers.
var parentProperty = node.Parent as BasePropertyDeclarationSyntax;
if (parentProperty != null)
{
builder.Add(GetExpressionBodyDeclarationInfo(parentProperty, (ArrowExpressionClauseSyntax)node, model, getSymbol, cancellationToken));
}
return;
}
case SyntaxKind.PropertyDeclaration:
{
var t = (PropertyDeclarationSyntax)node;
if (t.AccessorList != null)
{
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
}
if (t.ExpressionBody != null)
{
ComputeDeclarations(model, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken, t.Initializer));
return;
}
case SyntaxKind.IndexerDeclaration:
{
var t = (IndexerDeclarationSyntax)node;
if (t.AccessorList != null)
{
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
}
if (t.ExpressionBody != null)
{
ComputeDeclarations(model, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
}
var codeBlocks = t.ParameterList != null?t.ParameterList.Parameters.Select(p => p.Default) : SpecializedCollections.EmptyEnumerable <SyntaxNode>();
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.AddAccessorDeclaration:
case SyntaxKind.RemoveAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
case SyntaxKind.GetAccessorDeclaration:
{
var t = (AccessorDeclarationSyntax)node;
var blocks = ArrayBuilder <SyntaxNode> .GetInstance();
blocks.AddIfNotNull(t.Body);
blocks.AddIfNotNull(t.ExpressionBody);
builder.Add(GetDeclarationInfo(model, node, getSymbol, blocks, cancellationToken));
blocks.Free();
return;
}
case SyntaxKind.ConstructorDeclaration:
case SyntaxKind.ConversionOperatorDeclaration:
case SyntaxKind.DestructorDeclaration:
case SyntaxKind.MethodDeclaration:
case SyntaxKind.OperatorDeclaration:
{
var t = (BaseMethodDeclarationSyntax)node;
var codeBlocks = t.ParameterList != null?t.ParameterList.Parameters.Select(p => p.Default) : SpecializedCollections.EmptyEnumerable <SyntaxNode>();
codeBlocks = codeBlocks.Concat(t.Body);
var ctorDecl = t as ConstructorDeclarationSyntax;
if (ctorDecl != null && ctorDecl.Initializer != null)
{
codeBlocks = codeBlocks.Concat(ctorDecl.Initializer);
}
var expressionBody = GetExpressionBodySyntax(t);
if (expressionBody != null)
{
codeBlocks = codeBlocks.Concat(expressionBody);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.CompilationUnit:
{
var t = (CompilationUnitSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
return;
}
default:
return;
}
}
private static void ComputeDeclarations(
SemanticModel model,
ISymbol associatedSymbol,
SyntaxNode node,
Func <SyntaxNode, int?, bool> shouldSkip,
bool getSymbol,
ArrayBuilder <DeclarationInfo> builder,
int?levelsToCompute,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (shouldSkip(node, levelsToCompute))
{
return;
}
var newLevel = DecrementLevel(levelsToCompute);
switch (node.Kind())
{
case SyntaxKind.NamespaceDeclaration:
{
var ns = (NamespaceDeclarationSyntax)node;
foreach (var decl in ns.Members)
{
ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
var declInfo = GetDeclarationInfo(model, node, getSymbol, cancellationToken);
builder.Add(declInfo);
NameSyntax name = ns.Name;
INamespaceSymbol nsSymbol = declInfo.DeclaredSymbol as INamespaceSymbol;
while (name.Kind() == SyntaxKind.QualifiedName)
{
name = ((QualifiedNameSyntax)name).Left;
var declaredSymbol = getSymbol ? nsSymbol?.ContainingNamespace : null;
builder.Add(new DeclarationInfo(name, ImmutableArray <SyntaxNode> .Empty, declaredSymbol));
nsSymbol = declaredSymbol;
}
return;
}
case SyntaxKind.RecordDeclaration:
{
if (associatedSymbol is IMethodSymbol ctor)
{
var recordDeclaration = (RecordDeclarationSyntax)node;
Debug.Assert(ctor.MethodKind == MethodKind.Constructor && recordDeclaration.ParameterList is object);
var codeBlocks = GetParameterListInitializersAndAttributes(recordDeclaration.ParameterList);
if (recordDeclaration.BaseList?.Types.FirstOrDefault() is PrimaryConstructorBaseTypeSyntax initializer)
{
codeBlocks = codeBlocks.Concat(initializer);
}
builder.Add(GetDeclarationInfo(node, associatedSymbol, codeBlocks));
return;
}
goto case SyntaxKind.ClassDeclaration;
}
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.InterfaceDeclaration:
{
var t = (TypeDeclarationSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
var attributes = GetAttributes(t.AttributeLists).Concat(GetTypeParameterListAttributes(t.TypeParameterList));
builder.Add(GetDeclarationInfo(model, node, getSymbol, attributes, cancellationToken));
return;
}
case SyntaxKind.EnumDeclaration:
{
var t = (EnumDeclarationSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
var attributes = GetAttributes(t.AttributeLists);
builder.Add(GetDeclarationInfo(model, node, getSymbol, attributes, cancellationToken));
return;
}
case SyntaxKind.EnumMemberDeclaration:
{
var t = (EnumMemberDeclarationSyntax)node;
var attributes = GetAttributes(t.AttributeLists);
var codeBlocks = SpecializedCollections.SingletonEnumerable(t.EqualsValue).Concat(attributes);
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.DelegateDeclaration:
{
var t = (DelegateDeclarationSyntax)node;
var attributes = GetAttributes(t.AttributeLists)
.Concat(GetParameterListInitializersAndAttributes(t.ParameterList))
.Concat(GetTypeParameterListAttributes(t.TypeParameterList));
builder.Add(GetDeclarationInfo(model, node, getSymbol, attributes, cancellationToken));
return;
}
case SyntaxKind.EventDeclaration:
{
var t = (EventDeclarationSyntax)node;
if (t.AccessorList != null)
{
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
}
var attributes = GetAttributes(t.AttributeLists);
builder.Add(GetDeclarationInfo(model, node, getSymbol, attributes, cancellationToken));
return;
}
case SyntaxKind.EventFieldDeclaration:
case SyntaxKind.FieldDeclaration:
{
var t = (BaseFieldDeclarationSyntax)node;
var attributes = GetAttributes(t.AttributeLists);
foreach (var decl in t.Declaration.Variables)
{
var codeBlocks = SpecializedCollections.SingletonEnumerable(decl.Initializer).Concat(attributes);
builder.Add(GetDeclarationInfo(model, decl, getSymbol, codeBlocks, cancellationToken));
}
return;
}
case SyntaxKind.ArrowExpressionClause:
{
// Arrow expression clause declares getter symbol for properties and indexers.
if (node.Parent is BasePropertyDeclarationSyntax parentProperty)
{
builder.Add(GetExpressionBodyDeclarationInfo(parentProperty, (ArrowExpressionClauseSyntax)node, model, getSymbol, cancellationToken));
}
return;
}
case SyntaxKind.PropertyDeclaration:
{
var t = (PropertyDeclarationSyntax)node;
if (t.AccessorList != null)
{
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
}
if (t.ExpressionBody != null)
{
ComputeDeclarations(model, associatedSymbol: null, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
}
var attributes = GetAttributes(t.AttributeLists);
var codeBlocks = SpecializedCollections.SingletonEnumerable(t.Initializer).Concat(attributes);
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.IndexerDeclaration:
{
var t = (IndexerDeclarationSyntax)node;
if (t.AccessorList != null)
{
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
}
if (t.ExpressionBody != null)
{
ComputeDeclarations(model, associatedSymbol: null, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
}
var codeBlocks = GetParameterListInitializersAndAttributes(t.ParameterList);
var attributes = GetAttributes(t.AttributeLists);
codeBlocks = codeBlocks.Concat(attributes);
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.AddAccessorDeclaration:
case SyntaxKind.RemoveAccessorDeclaration:
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
case SyntaxKind.InitAccessorDeclaration:
{
var t = (AccessorDeclarationSyntax)node;
var blocks = ArrayBuilder <SyntaxNode> .GetInstance();
blocks.AddIfNotNull(t.Body);
blocks.AddIfNotNull(t.ExpressionBody);
blocks.AddRange(GetAttributes(t.AttributeLists));
builder.Add(GetDeclarationInfo(model, node, getSymbol, blocks, cancellationToken));
blocks.Free();
return;
}
case SyntaxKind.ConstructorDeclaration:
case SyntaxKind.ConversionOperatorDeclaration:
case SyntaxKind.DestructorDeclaration:
case SyntaxKind.MethodDeclaration:
case SyntaxKind.OperatorDeclaration:
{
var t = (BaseMethodDeclarationSyntax)node;
var codeBlocks = GetParameterListInitializersAndAttributes(t.ParameterList);
codeBlocks = codeBlocks.Concat(t.Body);
if (t is ConstructorDeclarationSyntax ctorDecl && ctorDecl.Initializer != null)
{
codeBlocks = codeBlocks.Concat(ctorDecl.Initializer);
}
var expressionBody = GetExpressionBodySyntax(t);
if (expressionBody != null)
{
codeBlocks = codeBlocks.Concat(expressionBody);
}
codeBlocks = codeBlocks.Concat(GetAttributes(t.AttributeLists));
if (node is MethodDeclarationSyntax methodDecl && methodDecl.TypeParameterList != null)
{
codeBlocks = codeBlocks.Concat(GetTypeParameterListAttributes(methodDecl.TypeParameterList));
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.CompilationUnit:
{
var t = (CompilationUnitSyntax)node;
if (associatedSymbol is IMethodSymbol)
{
builder.Add(GetDeclarationInfo(model, node, getSymbol, new[] { t }, cancellationToken));
}
else
{
foreach (var decl in t.Members)
{
ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
if (t.AttributeLists.Any())
{
var attributes = GetAttributes(t.AttributeLists);
builder.Add(GetDeclarationInfo(model, node, getSymbol: false, attributes, cancellationToken));
}
}
return;
}
default:
return;
}
}
private UsingDirectiveSyntax QualifyUsingDirective(UsingDirectiveSyntax usingDirective)
{
NameSyntax originalName = usingDirective.Name;
NameSyntax rewrittenName;
switch (originalName.Kind())
{
case SyntaxKind.QualifiedName:
case SyntaxKind.IdentifierName:
case SyntaxKind.GenericName:
if (originalName.Parent.IsKind(SyntaxKind.UsingDirective) ||
originalName.Parent.IsKind(SyntaxKind.TypeArgumentList))
{
var symbol = this.semanticModel.GetSymbolInfo(originalName, cancellationToken: CancellationToken.None).Symbol;
if (symbol == null)
{
rewrittenName = originalName;
break;
}
if (symbol is INamespaceSymbol)
{
// TODO: Preserve inner trivia
string fullName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
NameSyntax replacement = SyntaxFactory.ParseName(fullName);
if (!originalName.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>().Any())
{
replacement = replacement.ReplaceNodes(
replacement.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>(),
(originalNode2, rewrittenNode2) => rewrittenNode2.Name);
}
rewrittenName = replacement.WithTriviaFrom(originalName);
break;
}
else if (symbol is INamedTypeSymbol)
{
// TODO: Preserve inner trivia
// TODO: simplify after qualification
string fullName;
if (SpecialTypeHelper.IsPredefinedType(((INamedTypeSymbol)symbol).OriginalDefinition.SpecialType))
{
fullName = "global::System." + symbol.Name;
}
else
{
fullName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
}
NameSyntax replacement = SyntaxFactory.ParseName(fullName);
if (!originalName.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>().Any())
{
replacement = replacement.ReplaceNodes(
replacement.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>(),
(originalNode2, rewrittenNode2) => rewrittenNode2.Name);
}
rewrittenName = replacement.WithTriviaFrom(originalName);
break;
}
else
{
rewrittenName = originalName;
break;
}
}
else
{
rewrittenName = originalName;
break;
}
case SyntaxKind.AliasQualifiedName:
case SyntaxKind.PredefinedType:
default:
rewrittenName = originalName;
break;
}
if (rewrittenName == originalName)
{
return(usingDirective);
}
return(usingDirective.ReplaceNode(originalName, rewrittenName));
}
private static void ComputeDeclarations(
SemanticModel model,
SyntaxNode node,
Func <SyntaxNode, int?, bool> shouldSkip,
bool getSymbol,
ArrayBuilder <DeclarationInfo> builder,
int?levelsToCompute,
CancellationToken cancellationToken)
{
if (shouldSkip(node, levelsToCompute))
{
return;
}
var newLevel = DecrementLevel(levelsToCompute);
switch (node.Kind())
{
case SyntaxKind.NamespaceDeclaration:
{
var ns = (NamespaceDeclarationSyntax)node;
foreach (var decl in ns.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
NameSyntax name = ns.Name;
while (name.Kind() == SyntaxKind.QualifiedName)
{
name = ((QualifiedNameSyntax)name).Left;
var declaredSymbol = getSymbol ? model.GetSymbolInfo(name, cancellationToken).Symbol : null;
builder.Add(new DeclarationInfo(name, ImmutableArray <SyntaxNode> .Empty, declaredSymbol));
}
return;
}
case SyntaxKind.ClassDeclaration:
case SyntaxKind.StructDeclaration:
case SyntaxKind.InterfaceDeclaration:
{
var t = (TypeDeclarationSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EnumDeclaration:
{
var t = (EnumDeclarationSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EnumMemberDeclaration:
{
var t = (EnumMemberDeclarationSyntax)node;
builder.Add(GetDeclarationInfo(model, node, getSymbol, t.EqualsValue, cancellationToken));
return;
}
case SyntaxKind.DelegateDeclaration:
{
var t = (DelegateDeclarationSyntax)node;
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EventDeclaration:
{
var t = (EventDeclarationSyntax)node;
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken));
return;
}
case SyntaxKind.EventFieldDeclaration:
case SyntaxKind.FieldDeclaration:
{
var t = (BaseFieldDeclarationSyntax)node;
foreach (var decl in t.Declaration.Variables)
{
builder.Add(GetDeclarationInfo(model, decl, getSymbol, decl.Initializer, cancellationToken));
}
return;
}
case SyntaxKind.PropertyDeclaration:
{
var t = (PropertyDeclarationSyntax)node;
if (t.AccessorList != null)
{
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, cancellationToken, t.Initializer, t.ExpressionBody));
return;
}
case SyntaxKind.IndexerDeclaration:
{
var t = (IndexerDeclarationSyntax)node;
if (t.AccessorList != null)
{
foreach (var decl in t.AccessorList.Accessors)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
}
var codeBlocks = t.ParameterList != null?t.ParameterList.Parameters.Select(p => p.Default) : SpecializedCollections.EmptyEnumerable <SyntaxNode>();
if (t.ExpressionBody != null)
{
codeBlocks = codeBlocks.Concat(t.ExpressionBody);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.AddAccessorDeclaration:
case SyntaxKind.RemoveAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
case SyntaxKind.GetAccessorDeclaration:
{
var t = (AccessorDeclarationSyntax)node;
builder.Add(GetDeclarationInfo(model, node, getSymbol, t.Body, cancellationToken));
return;
}
case SyntaxKind.ConstructorDeclaration:
case SyntaxKind.ConversionOperatorDeclaration:
case SyntaxKind.DestructorDeclaration:
case SyntaxKind.MethodDeclaration:
case SyntaxKind.OperatorDeclaration:
{
var t = (BaseMethodDeclarationSyntax)node;
var codeBlocks = t.ParameterList != null?t.ParameterList.Parameters.Select(p => p.Default) : SpecializedCollections.EmptyEnumerable <SyntaxNode>();
codeBlocks = codeBlocks.Concat(t.Body);
var ctorDecl = t as ConstructorDeclarationSyntax;
if (ctorDecl != null && ctorDecl.Initializer != null)
{
codeBlocks = codeBlocks.Concat(ctorDecl.Initializer);
}
var expressionBody = GetExpressionBodySyntax(t);
if (expressionBody != null)
{
codeBlocks = codeBlocks.Concat(expressionBody);
}
builder.Add(GetDeclarationInfo(model, node, getSymbol, codeBlocks, cancellationToken));
return;
}
case SyntaxKind.CompilationUnit:
{
var t = (CompilationUnitSyntax)node;
foreach (var decl in t.Members)
{
ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
}
return;
}
default:
return;
}
}
public static IEnumerable <SimpleNameSyntax> GetSimpleNames(this NameSyntax nameSyntax)
{
switch (nameSyntax)
{
case SimpleNameSyntax simpleNameSyntax:
yield return(simpleNameSyntax);
break;
case QualifiedNameSyntax qualifiedNameSyntax:
foreach (var simpleName in qualifiedNameSyntax.Left.GetSimpleNames())
{
yield return(simpleName);
}
foreach (var simpleName in qualifiedNameSyntax.Right.GetSimpleNames())
{
yield return(simpleName);
}
break;
case AliasQualifiedNameSyntax aliasQualifiedNameSyntax:
foreach (var simpleName in aliasQualifiedNameSyntax.Alias.GetSimpleNames())
{
yield return(simpleName);
}
break;
default:
throw new ArgumentOutOfRangeException($"Unknown name syntax: {nameSyntax} ({nameSyntax.Kind()})", nameof(nameSyntax));
}
}
