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