private static TextSpan GetUsingsSpan(CompilationUnitSyntax root, NamespaceDeclarationSyntax namespaceDeclaration)
{
if (namespaceDeclaration != null)
{
var usings = namespaceDeclaration.Usings;
var start = usings.First().SpanStart;
var end = usings.Last().Span.End;
return TextSpan.FromBounds(start, end);
}
else
{
var rootUsings = root.Usings;
if (rootUsings.Any())
{
var start = rootUsings.First().SpanStart;
var end = rootUsings.Last().Span.End;
return TextSpan.FromBounds(start, end);
}
else
{
var start = 0;
var end = root.Members.Any()
? root.Members.First().GetFirstToken().Span.End
: root.Span.End;
return TextSpan.FromBounds(start, end);
}
}
}
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var semanticModel = Context.Instance.Compilation.GetSemanticModel(node.SyntaxTree);
var symbol = semanticModel.GetDeclaredSymbol(node);
var fullName = symbol.GetFullName();
ProcessNamespace(fullName);
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
string ns = node.Name.ToFullString();//Extend: seems no need to further break down.
var template = _template.CreateNamespaceTemplate();
template.Assign(NamespaceTemplate.NAMESPACE, ns);
if (!RegisteredNamespace.Contains(ns))
{
_output.WriteLine(node.Name, template.GetBeginString());
}
foreach (var member in node.Members)
{
var info = _semanticModel.GetDeclaredSymbol(member);
if (info.IsNoCompile())
continue;
this.Visit(member);
}
if (!RegisteredNamespace.Contains(ns))
{
_output.TrivialWriteLine(template.GetEndString());
RegisteredNamespace.Add(ns);
}
return node;
}
public override void VisitNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax node)
{
cancellationToken.ThrowIfCancellationRequested();
AddUsings(node);
AddFolding(node.OpenBraceToken, node.CloseBraceToken, FoldType.Undefined);
base.VisitNamespaceDeclaration(node);
}
//protected override void VisitInvocationExpression(InvocationExpressionSyntax node)
//{
//}
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
foreach (var type in node.DescendantNodes().OfType<ClassDeclarationSyntax>())
{
Visit(type);
}
}
public override VisualBasicSyntaxNode VisitNamespaceDeclaration(CsSyntax.NamespaceDeclarationSyntax node)
{
var convertedNode = (VbSyntax.NamespaceBlockSyntax)DefaultVisitInner(node);
return(convertedNode.WithEndNamespaceStatement(
convertedNode.EndNamespaceStatement.WithSourceMappingFrom(node.CloseBraceToken)
));
}
private static NamespaceDeclarationSyntax AddParameterClassToNamespaceAndUpdateClassToUseNamespace(NamespaceDeclarationSyntax oldNamespace, ClassDeclarationSyntax oldClass, MethodDeclarationSyntax oldMethod)
{
var className = $"NewClass{oldMethod.Identifier.Text}";
var newParameterClass = CreateParameterClass(className, oldMethod);
var newNamespace = oldNamespace.ReplaceNode(oldClass, UpdateClassToUseNewParameterClass(className, oldClass, oldMethod))
.AddMembers(newParameterClass);
return newNamespace;
}
public CommandInterfaceBuilder WithReferences(IEnumerable <string> references)
{
namespaceDeclaration = namespaceDeclaration.AddUsings(
references.Select(
x => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(x))).ToArray()
);
return(this);
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
if (node.Usings.Any() || node.Externs.Any())
{
node = node.WithAdditionalAnnotations(LayoutAnnotations.MultiLineConstructAnnotation);
}
return base.VisitNamespaceDeclaration(node);
}
internal static NamespaceDeclarationSyntax AddMethodTo(
NamespaceDeclarationSyntax destination,
IMethodSymbol method,
CodeGenerationOptions options,
IList<bool> availableIndices)
{
var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.Namespace, options);
var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod);
return destination.WithMembers(members.ToSyntaxList());
}
/// <summary>Called when the visitor visits a NamespaceDeclarationSyntax node.</summary>
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var u = _namespaces.Select(each => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName($" {each}"))
.WithLeadingTrivia(_leadingTrivia)
.WithTrailingTrivia(_trailingTrivia)
).ToArray();
node = node.AddUsings(u);
node = node.WithUsings(Sort(node.Usings));
return base.VisitNamespaceDeclaration(node);
}
public static MemberDeclarationSyntax[] GenerateClasses(NamespaceDeclarationSyntax @namespace)
{
var isInterfaceToClass = @namespace.GetLeadingTrivia().Any(trivia => trivia.ToString().Trim() == "//Meta(interface-to-class)");
if (!isInterfaceToClass)
return Array<MemberDeclarationSyntax>.Empty;
var resultMembers = new List<MemberDeclarationSyntax>();
foreach (var @interface in @namespace.Members.OfType<InterfaceDeclarationSyntax>())
{
resultMembers.Add(ToClass(@interface));
}
return resultMembers.ToArray();
}
public static NamespaceDeclarationSyntax AddNamedTypeTo(
ICodeGenerationService service,
NamespaceDeclarationSyntax destination,
INamedTypeSymbol namedType,
CodeGenerationOptions options,
IList<bool> availableIndices)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.Namespace, options);
var members = Insert(destination.Members, declaration, options, availableIndices);
return ConditionallyAddFormattingAnnotationTo(
destination.WithMembers(members),
members);
}
private static NamespaceDeclarationSyntax NewNameSpaceFactory(NamespaceDeclarationSyntax OldNameSpace, ClassDeclarationSyntax OldClass, MethodDeclarationSyntax OldMethod)
{
var newNameSpace = OldNameSpace;
var className = $"NewClass{OldMethod.Identifier.Text}";
var memberNameSpaceOld = (from member in OldNameSpace.Members
where member == OldClass
select member).FirstOrDefault();
newNameSpace = OldNameSpace.ReplaceNode(memberNameSpaceOld, NewClassFactory(className, OldClass, OldMethod));
var newParameterClass = NewClassParameterFactory(className, NewPropertyClassFactory(OldMethod));
newNameSpace = newNameSpace
.WithMembers(newNameSpace.Members.Add(newParameterClass))
.WithAdditionalAnnotations(Formatter.Annotation);
return newNameSpace;
}
public static NamespaceDeclarationSyntax AddNamespaceTo(
ICodeGenerationService service,
NamespaceDeclarationSyntax destination,
INamespaceSymbol @namespace,
CodeGenerationOptions options,
IList<bool> availableIndices)
{
var declaration = GenerateNamespaceDeclaration(service, @namespace, options);
if (!(declaration is NamespaceDeclarationSyntax))
{
throw new ArgumentException(CSharpWorkspaceResources.NamespaceCanNotBeAddedIn);
}
var members = Insert(destination.Members, (NamespaceDeclarationSyntax)declaration, options, availableIndices);
return destination.WithMembers(members);
}
public override VisualBasicSyntaxNode VisitNamespaceDeclaration(CSS.NamespaceDeclarationSyntax node)
{
var members = node.Members.Select(m => (StatementSyntax)m.Accept(this));
IList <string> names;
if (!node.Name.TryGetNameParts(out names))
{
throw new NotSupportedException();
}
return(SyntaxFactory.NamespaceBlock(
SyntaxFactory.NamespaceStatement((NameSyntax)node.Name.Accept(this)),
SyntaxFactory.List(members)
));
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var result = (NamespaceDeclarationSyntax)base.VisitNamespaceDeclaration(node);
if (!_namespacesToImport.TryGetValue(node, out var namespaces))
{
return result;
}
if (!result.CanAddUsingDirectives(_cancellationToken))
{
return result;
}
var directives = CreateDirectives(namespaces);
return result.AddUsingDirectives(directives, _placeSystemNamespaceFirst, Formatter.Annotation);
}
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var parts = node.Name.ToString().Split('.');
cb.AppendIndent();
foreach (var part in parts)
{
cb.Append("namespace ").Append(part).Append(" { ");
}
cb.AppendLine();
base.VisitNamespaceDeclaration(node);
cb.AppendIndent();
foreach (var part in parts)
cb.Append("} /* " + part + "*/ ");
cb.AppendLine();
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
var identifierName = SyntaxFactory.IdentifierName(_typeNamespace);
var newNamespace = SyntaxFactory.NamespaceDeclaration(identifierName);
var newNode = node.Update(
node.NamespaceKeyword,
newNamespace.Name,
node.OpenBraceToken,
node.Externs,
node.Usings,
node.Members,
node.CloseBraceToken,
node.SemicolonToken);
return base.VisitNamespaceDeclaration(newNode);
}
private IList<INamespaceSymbol> GetExistingNamespaces(
SemanticModel semanticModel, NamespaceDeclarationSyntax namespaceDeclaration, CancellationToken cancellationToken)
{
var q = from u in namespaceDeclaration.Usings
let symbol = semanticModel.GetSymbolInfo(u.Name, cancellationToken).Symbol as INamespaceSymbol
where symbol != null && !symbol.IsGlobalNamespace
select symbol;
var usingImports = q.ToList();
var namespaceSymbol = semanticModel.GetDeclaredSymbol(namespaceDeclaration, cancellationToken) as INamespaceSymbol;
var namespaceImports = GetContainingNamespacesAndThis(namespaceSymbol).ToList();
var outerNamespaces = this.GetExistingNamespaces(semanticModel, namespaceDeclaration.Parent, cancellationToken);
return outerNamespaces.Concat(namespaceImports).Concat(usingImports)
.Distinct()
.OrderBy(INamespaceSymbolExtensions.CompareNamespaces)
.ToList();
}
private async Task<Solution> FixBadNamespace(Document document, NamespaceDeclarationSyntax namespaceDecl, CancellationToken cancellationToken)
{
try
{
var newName = GetNamespaceName(document.Project, document.Folders);
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
INamespaceSymbol nsSymbol = semanticModel.GetDeclaredSymbol(namespaceDecl, cancellationToken);
Solution originalSolution = document.Project.Solution;
OptionSet optionSet = originalSolution.Workspace.Options;
var newSolution = await Renamer.RenameSymbolAsync(originalSolution, nsSymbol, newName, optionSet, cancellationToken).ConfigureAwait(false);
return newSolution;
}
catch (OperationCanceledException ocex)
{
Debug.WriteLine(ocex.Message);
return document.Project.Solution;
}
}
public CommandInterfaceBuilder WithClass(TypeDeclarationSyntax classDefinition)
{
namespaceDeclaration = namespaceDeclaration.AddMembers((ClassDeclarationSyntax)classDefinition);
return(this);
}
private static int GetNamespaceId(SyntaxList<MemberDeclarationSyntax> members, NamespaceDeclarationSyntax target, ref int index)
{
foreach (var member in members)
{
var childNamespace = member as NamespaceDeclarationSyntax;
if (childNamespace == null)
{
continue;
}
if (childNamespace == target)
{
return index;
}
index++;
var result = GetNamespaceId(childNamespace, target, ref index);
if (result > 0)
{
return result;
}
}
return -1;
}
private static int GetNamespaceId(SyntaxNode container, NamespaceDeclarationSyntax target, ref int index)
{
var compilation = container as CompilationUnitSyntax;
if (compilation != null)
{
return GetNamespaceId(compilation.Members, target, ref index);
}
var @namespace = container as NamespaceDeclarationSyntax;
if (@namespace != null)
{
return GetNamespaceId(@namespace.Members, target, ref index);
}
return Contract.FailWithReturn<int>("shouldn't reach here");
}
internal static bool IsInNamespaceDeclaration(int position, NamespaceDeclarationSyntax namespaceDecl)
{
Debug.Assert(namespaceDecl != null);
return(IsBetweenTokens(position, namespaceDecl.NamespaceKeyword, namespaceDecl.CloseBraceToken));
}
private SyntaxNode RegisterNamespaceDeclarationCodeFix(SyntaxNode syntaxRoot, NamespaceDeclarationSyntax node, IndentationOptions indentationOptions)
{
return this.ReformatElement(syntaxRoot, node, node.OpenBraceToken, node.CloseBraceToken, indentationOptions);
}
private NamespaceSymbol GetDeclaredNamespace(NamespaceDeclarationSyntax declarationSyntax)
{
Debug.Assert(declarationSyntax != null);
NamespaceOrTypeSymbol container;
if (declarationSyntax.Parent.Kind() == SyntaxKind.CompilationUnit)
{
container = _compilation.Assembly.GlobalNamespace;
}
else
{
container = GetDeclaredNamespaceOrType(declarationSyntax.Parent);
}
Debug.Assert((object)container != null);
// We should get a namespace symbol since we match the symbol location with a namespace declaration syntax location.
var symbol = (NamespaceSymbol)GetDeclaredMember(container, declarationSyntax.Span, declarationSyntax.Name);
Debug.Assert((object)symbol != null);
// Map to compilation-scoped namespace (Roslyn bug 9538)
symbol = _compilation.GetCompilationNamespace(symbol);
Debug.Assert((object)symbol != null);
return symbol;
}
/// <summary>
/// Given a namespace declaration syntax node, get the corresponding namespace symbol for the declaration
/// assembly.
/// </summary>
/// <param name="declarationSyntax">The syntax node that declares a namespace.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The namespace symbol that was declared by the namespace declaration.</returns>
public override INamespaceSymbol GetDeclaredSymbol(NamespaceDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
CheckSyntaxNode(declarationSyntax);
return GetDeclaredNamespace(declarationSyntax);
}
/// <summary>
/// Initializes a new instance of the <see cref="NamespaceDeclaration"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
/// <param name="semanticModel"></param>
public NamespaceDeclaration(NamespaceDeclarationSyntax syntaxNode, SemanticModel semanticModel)
: base(syntaxNode, semanticModel)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="NamespaceDeclaration"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
public NamespaceDeclaration(NamespaceDeclarationSyntax syntaxNode)
: this(syntaxNode, null)
{
}
/// <summary> /// Given a namespace declaration syntax node, get the corresponding namespace symbol for /// the declaration assembly. /// </summary> /// <param name="declarationSyntax">The syntax node that declares a namespace.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The namespace symbol that was declared by the namespace declaration.</returns> public abstract INamespaceSymbol GetDeclaredSymbol(NamespaceDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
private VirtualTreePoint GetStartPoint(SourceText text, NamespaceDeclarationSyntax node, EnvDTE.vsCMPart part)
{
int startPosition;
switch (part)
{
case EnvDTE.vsCMPart.vsCMPartName:
case EnvDTE.vsCMPart.vsCMPartAttributes:
case EnvDTE.vsCMPart.vsCMPartHeader:
case EnvDTE.vsCMPart.vsCMPartWhole:
case EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter:
case EnvDTE.vsCMPart.vsCMPartHeaderWithAttributes:
throw Exceptions.ThrowENotImpl();
case EnvDTE.vsCMPart.vsCMPartAttributesWithDelimiter:
throw Exceptions.ThrowEFail();
case EnvDTE.vsCMPart.vsCMPartWholeWithAttributes:
startPosition = node.GetFirstToken().SpanStart;
break;
case EnvDTE.vsCMPart.vsCMPartNavigate:
startPosition = node.Name.SpanStart;
break;
case EnvDTE.vsCMPart.vsCMPartBody:
if (node.OpenBraceToken.IsMissing || node.CloseBraceToken.IsMissing)
{
throw Exceptions.ThrowEFail();
}
return GetBodyStartPoint(text, node.OpenBraceToken);
default:
throw Exceptions.ThrowEInvalidArg();
}
return new VirtualTreePoint(node.SyntaxTree, text, startPosition);
}
private static SyntaxNode HandleNamespaceDeclaration(MemberOrderHelper memberOrder, NamespaceDeclarationSyntax namespaceDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
return OrderMember(memberOrder, namespaceDeclaration.Members, checks, syntaxRoot, indentationOptions);
}
public CommandInterfaceBuilder WithInterface(TypeDeclarationSyntax interfaceDeclaration)
{
namespaceDeclaration = namespaceDeclaration.AddMembers((InterfaceDeclarationSyntax)interfaceDeclaration);
return(this);
}
public override INamespaceSymbol GetDeclaredSymbol(NamespaceDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
// Can't defined namespace inside a member.
return null;
}
private bool CompareNamespaceDeclarations(
NamespaceDeclarationSyntax oldNamespace,
NamespaceDeclarationSyntax newNamespace,
SyntaxNode newNodeParent,
CodeModelEventQueue eventQueue)
{
Debug.Assert(oldNamespace != null && newNamespace != null);
// Check if the namespace nodes are identical w.r.t Name
if (!CompareNames(oldNamespace.Name, newNamespace.Name))
{
var change = CompareRenamedDeclarations(
CompareNamespacesOrTypes,
GetValidMembers(oldNamespace),
GetValidMembers(newNamespace),
oldNamespace,
newNamespace,
newNodeParent,
eventQueue);
if (change == DeclarationChange.NameOnly)
{
EnqueueChangeEvent(newNamespace, newNodeParent, CodeModelEventType.Rename, eventQueue);
}
return false;
}
return CompareChildren(
CompareNamespacesOrTypes,
GetValidMembers(oldNamespace),
GetValidMembers(newNamespace),
newNamespace,
CodeModelEventType.Unknown,
eventQueue);
}
private void ClassifyUpdate(NamespaceDeclarationSyntax oldNode, NamespaceDeclarationSyntax newNode)
{
Debug.Assert(!SyntaxFactory.AreEquivalent(oldNode.Name, newNode.Name));
ReportError(RudeEditKind.Renamed);
}
public CommandInterfaceBuilder WithNamespace(string name)
{
namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(name));
return(this);
}
