public SyntaxNode ConvertToSingleLine(SyntaxNode node)
 {
     return(node.ConvertToSingleLine());
 }
        /// <summary>
        /// Gets the DisplayName for the given node.
        /// </summary>
        public string GetDisplayName(SemanticModel semanticModel, SyntaxNode node)
        {
            if (node == null)
            {
                return(FeaturesResources.paren_Unknown_paren);
            }

            if (CSharpSyntaxFactsService.Instance.IsGlobalAttribute(node))
            {
                return("assembly: " + node.ConvertToSingleLine());
            }

            // Don't discriminate between getters and setters for indexers
            if (node.Parent.IsKind(SyntaxKind.AccessorList) &&
                node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration))
            {
                return(GetDisplayName(semanticModel, node.Parent.Parent));
            }

            switch (node.Kind())
            {
            case SyntaxKind.ConstructorDeclaration:
            {
                // The constructor's name will be the name of the class, not ctor like we want
                var symbol         = semanticModel.GetDeclaredSymbol(node);
                var displayName    = symbol.ToDisplayString(Format);
                var openParenIndex = displayName.IndexOf('(');
                var lastDotBeforeOpenParenIndex = displayName.LastIndexOf('.', openParenIndex, openParenIndex);

                var constructorName = symbol.IsStatic ? "cctor" : "ctor";

                return(displayName.Substring(0, lastDotBeforeOpenParenIndex + 1) +
                       constructorName +
                       displayName.Substring(openParenIndex));
            }

            case SyntaxKind.IndexerDeclaration:
            {
                // The name will be "namespace.class.this[type] - we want "namespace.class[type] Indexer"
                var symbol           = semanticModel.GetDeclaredSymbol(node);
                var displayName      = symbol.ToDisplayString(Format);
                var openBracketIndex = displayName.IndexOf('[');
                var lastDotBeforeOpenBracketIndex = displayName.LastIndexOf('.', openBracketIndex, openBracketIndex);

                return(displayName.Substring(0, lastDotBeforeOpenBracketIndex) +
                       displayName.Substring(openBracketIndex) +
                       " Indexer");
            }

            case SyntaxKind.OperatorDeclaration:
            {
                // The name will be "namespace.class.operator +(type)" - we want namespace.class.+(type) Operator
                var symbol                  = semanticModel.GetDeclaredSymbol(node);
                var displayName             = symbol.ToDisplayString(Format);
                var spaceIndex              = displayName.IndexOf(' ');
                var lastDotBeforeSpaceIndex = displayName.LastIndexOf('.', spaceIndex, spaceIndex);

                return(displayName.Substring(0, lastDotBeforeSpaceIndex + 1) +
                       displayName.Substring(spaceIndex + 1) +
                       " Operator");
            }

            case SyntaxKind.ConversionOperatorDeclaration:
            {
                // The name will be "namespace.class.operator +(type)" - we want namespace.class.+(type) Operator
                var symbol                  = semanticModel.GetDeclaredSymbol(node);
                var displayName             = symbol.ToDisplayString(Format);
                var firstSpaceIndex         = displayName.IndexOf(' ');
                var secondSpaceIndex        = displayName.IndexOf(' ', firstSpaceIndex + 1);
                var lastDotBeforeSpaceIndex = displayName.LastIndexOf('.', firstSpaceIndex, firstSpaceIndex);

                return(displayName.Substring(0, lastDotBeforeSpaceIndex + 1) +
                       displayName.Substring(secondSpaceIndex + 1) +
                       " Operator");
            }

            case SyntaxKind.UsingDirective:
            {
                // We want to see usings formatted as simply "Using", prefaced by the namespace they are in
                var enclosingScopeString = GetEnclosingScopeString(node, semanticModel, Format);
                return(string.IsNullOrEmpty(enclosingScopeString) ? "Using" : enclosingScopeString + " Using");
            }

            case SyntaxKind.ExternAliasDirective:
            {
                // We want to see aliases formatted as "Alias", prefaced by their enclosing scope, if any
                var enclosingScopeString = GetEnclosingScopeString(node, semanticModel, Format);
                return(string.IsNullOrEmpty(enclosingScopeString) ? "Alias" : enclosingScopeString + " Alias");
            }

            default:
            {
                var symbol = semanticModel.GetDeclaredSymbol(node);
                return(symbol != null?symbol.ToDisplayString(Format) : FeaturesResources.paren_Unknown_paren);
            }
            }
        }
 public SyntaxNode ConvertToSingleLine(SyntaxNode node)
 {
     return node.ConvertToSingleLine();
 }
 public SyntaxNode ConvertToSingleLine(SyntaxNode node, bool useElasticTrivia = false)
 {
     return node.ConvertToSingleLine(useElasticTrivia);
 }
        /// <summary>
        /// Gets the DisplayName for the given node.
        /// </summary>
        public string GetDisplayName(SemanticModel semanticModel, SyntaxNode node)
        {
            if (node == null)
            {
                return FeaturesResources.paren_Unknown_paren;
            }

            if (CSharpSyntaxFactsService.Instance.IsGlobalAttribute(node))
            {
                return "assembly: " + node.ConvertToSingleLine();
            }

            // Don't discriminate between getters and setters for indexers
            if (node.Parent.IsKind(SyntaxKind.AccessorList) &&
                node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration))
            {
                return GetDisplayName(semanticModel, node.Parent.Parent);
            }

            switch (node.Kind())
            {
                case SyntaxKind.ConstructorDeclaration:
                {
                    // The constructor's name will be the name of the class, not ctor like we want
                    var symbol = semanticModel.GetDeclaredSymbol(node);
                    var displayName = symbol.ToDisplayString(Format);
                    var openParenIndex = displayName.IndexOf('(');
                    var lastDotBeforeOpenParenIndex = displayName.LastIndexOf('.', openParenIndex, openParenIndex);

                    var constructorName = symbol.IsStatic ? "cctor" : "ctor";

                    return displayName.Substring(0, lastDotBeforeOpenParenIndex + 1) +
                           constructorName +
                           displayName.Substring(openParenIndex);
                }

                case SyntaxKind.IndexerDeclaration:
                {
                    // The name will be "namespace.class.this[type] - we want "namespace.class[type] Indexer"
                    var symbol = semanticModel.GetDeclaredSymbol(node);
                    var displayName = symbol.ToDisplayString(Format);
                    var openBracketIndex = displayName.IndexOf('[');
                    var lastDotBeforeOpenBracketIndex = displayName.LastIndexOf('.', openBracketIndex, openBracketIndex);

                    return displayName.Substring(0, lastDotBeforeOpenBracketIndex) +
                           displayName.Substring(openBracketIndex) +
                           " Indexer";
                }

                case SyntaxKind.OperatorDeclaration:
                {
                    // The name will be "namespace.class.operator +(type)" - we want namespace.class.+(type) Operator
                    var symbol = semanticModel.GetDeclaredSymbol(node);
                    var displayName = symbol.ToDisplayString(Format);
                    var spaceIndex = displayName.IndexOf(' ');
                    var lastDotBeforeSpaceIndex = displayName.LastIndexOf('.', spaceIndex, spaceIndex);

                    return displayName.Substring(0, lastDotBeforeSpaceIndex + 1) +
                           displayName.Substring(spaceIndex + 1) +
                           " Operator";
                }

                case SyntaxKind.ConversionOperatorDeclaration:
                {
                    // The name will be "namespace.class.operator +(type)" - we want namespace.class.+(type) Operator
                    var symbol = semanticModel.GetDeclaredSymbol(node);
                    var displayName = symbol.ToDisplayString(Format);
                    var firstSpaceIndex = displayName.IndexOf(' ');
                    var secondSpaceIndex = displayName.IndexOf(' ', firstSpaceIndex + 1);
                    var lastDotBeforeSpaceIndex = displayName.LastIndexOf('.', firstSpaceIndex, firstSpaceIndex);

                    return displayName.Substring(0, lastDotBeforeSpaceIndex + 1) +
                           displayName.Substring(secondSpaceIndex + 1) +
                           " Operator";
                }

                case SyntaxKind.UsingDirective:
                {
                    // We want to see usings formatted as simply "Using", prefaced by the namespace they are in
                    var enclosingScopeString = GetEnclosingScopeString(node, semanticModel, Format);
                    return string.IsNullOrEmpty(enclosingScopeString) ? "Using" : enclosingScopeString + " Using";
                }

                case SyntaxKind.ExternAliasDirective:
                {
                    // We want to see aliases formatted as "Alias", prefaced by their enclosing scope, if any
                    var enclosingScopeString = GetEnclosingScopeString(node, semanticModel, Format);
                    return string.IsNullOrEmpty(enclosingScopeString) ? "Alias" : enclosingScopeString + " Alias";
                }

                default:
                {
                    var symbol = semanticModel.GetDeclaredSymbol(node);
                    return symbol != null ? symbol.ToDisplayString(Format) : FeaturesResources.paren_Unknown_paren;
                }
            }
        }