private static string GetParameterNameThatMatchStringLiteral(LiteralExpressionSyntax stringLiteral)
 {
     var ancestorThatMightHaveParameters = stringLiteral.FirstAncestorOfType(typeof(AttributeListSyntax), typeof(MethodDeclarationSyntax), typeof(ConstructorDeclarationSyntax), typeof(IndexerDeclarationSyntax));
     var parameterName = string.Empty;
     if (ancestorThatMightHaveParameters != null)
     {
         var parameters = new SeparatedSyntaxList<ParameterSyntax>();
         switch (ancestorThatMightHaveParameters.Kind())
         {
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.ConstructorDeclaration:
                 var method = (BaseMethodDeclarationSyntax)ancestorThatMightHaveParameters;
                 parameters = method.ParameterList.Parameters;
                 break;
             case SyntaxKind.IndexerDeclaration:
                 var indexer = (IndexerDeclarationSyntax)ancestorThatMightHaveParameters;
                 parameters = indexer.ParameterList.Parameters;
                 break;
             case SyntaxKind.AttributeList:
                 break;
         }
         parameterName = GetParameterWithIdentifierEqualToStringLiteral(stringLiteral, parameters)?.Identifier.Text;
     }
     return parameterName;
 }

 private static SyntaxNode CreateNewLiteral(LiteralExpressionSyntax literal, SyntaxNode root)
 {
     SyntaxNode newRoot;
     if (literal.Token.ValueText != literal.Token.Text)
     {
         var newTokenText = literal.Token.ValueText;
         var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
         newRoot = root.ReplaceNode(literal, newLiteral);
     }
     else
     {
         var value = (dynamic)literal.Token.Value;
         if (literal.Parent != null && literal.Parent.IsKind(SyntaxKind.UnaryMinusExpression))
         {
             var newTokenText = (string)("0x" + (value * -1).ToString("X"));
             var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText))
                 .WithLeadingTrivia(literal.Parent.GetLeadingTrivia())
                 .WithTrailingTrivia(literal.Parent.GetTrailingTrivia());
             newRoot = root.ReplaceNode(literal.Parent, newLiteral);
         }
         else
         {
             var newTokenText = (string)("0x" + value.ToString("X"));
             var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
             newRoot = root.ReplaceNode(literal, newLiteral);
         }
     }
     return newRoot;
 }

		private async Task<Document> FormatXmlAsync(Document document, LiteralExpressionSyntax sleSyntax, CancellationToken cancellationToken)
		{
			var root = await document.GetSyntaxRootAsync(cancellationToken);
			var tree = root.SyntaxTree;

			//Get the character position of the LiteralExpressionSyntax
			FileLinePositionSpan position = tree.GetLineSpan(sleSyntax.Span);
			int cSpace = position.StartLinePosition.Character;

			//Figure out the preceeding trivia since we can't get the column position from GetLineSpan
			var parentTrivia = sleSyntax.GetLeadingTrivia().ToFullString();

			var xml = sleSyntax.GetFirstToken().ValueText;
			var newXmlText = FormatXml(xml);

			//Process each line of the formatted XML and prepend the parent trivia & spaces
			string[] xmlLines = newXmlText.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
			for (int i = 1; i < xmlLines.Length; i++)
			{
				xmlLines[i] = parentTrivia + new String(' ', (cSpace + 2)) + xmlLines[i];
			}

			newXmlText = String.Join("\r\n", xmlLines);
			var newXmlValue = "@\"" + newXmlText + "\"";

			var newNode = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
				SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.StringLiteralToken, newXmlValue, newXmlText, SyntaxTriviaList.Empty));
			var newRoot = root.ReplaceNode(sleSyntax, newNode);
			return document.WithSyntaxRoot(newRoot);
		}

        public StringInterpolation(SemanticModel model, LiteralExpressionSyntax node, bool constant)
        {
            this.model = model;
            this.node = node;
            this.constant = constant;

            literal  = node.Token.ValueText;
        }

        private static Task<Solution> UseStringDotEmptyAsync(Document document, SyntaxNode root, LiteralExpressionSyntax literalDeclaration)
        {
            var stringDotEmptyInvocation = SyntaxFactory.ParseExpression("string.Empty");
            var newRoot = root.ReplaceNode(literalDeclaration, stringDotEmptyInvocation);

            var newDocument = document.WithSyntaxRoot(newRoot);
            return Task.FromResult(newDocument.Project.Solution);
        }

        public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
        {
            if (node.IsKind(SyntaxKind.StringLiteralExpression)
                && node.ToString().IndexOf('\n') >= 0)
            {
                node = node.WithAdditionalAnnotations(LayoutAnnotations.MultiLineConstructAnnotation);
            }

            return base.VisitLiteralExpression(node);
        }

 private static ExpressionSyntax ToVerbatimStringLiteral(LiteralExpressionSyntax expression)
 {
     var str = (string)expression.Token.Value;
     return LiteralExpression(SyntaxKind.StringLiteralExpression,
         Literal(
             TriviaList(),
             StringToVerbatimText(str),
             str,
             TriviaList()));
 }

 private static async Task<string> GetIdentifierAsync(Document document, LiteralExpressionSyntax stringLiteral, SyntaxNode root, Diagnostic diagnostic, CancellationToken cancellationToken)
 {
     var diagnosticSpan = diagnostic.Location.SourceSpan;
     var parameter = FindParameterThatStringLiteralRefers(root, diagnosticSpan.Start, stringLiteral);
     if (parameter != null)
         return parameter.Identifier.Text;
     var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
     var symbol = semanticModel.LookupSymbols(stringLiteral.Token.SpanStart, null, stringLiteral.Token.ValueText).First();
     return symbol.ToDisplayParts().Last(NameOfAnalyzer.IncludeOnlyPartsThatAreName).ToString();
 }

 static bool IsBoolean(LiteralExpressionSyntax expr, out bool value)
 {
     value = false;
     if (expr != null && (expr.Token.Value is bool))
     {
         value = (bool)expr.Token.Value;
         return true;
     }
     return false;
 }

        public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
        {
            var interpolation = result.Find(node);
            if (interpolation == null)
                return base.VisitLiteralExpression(node);

            var interpolated = interpolation.Interpolate();
            foreach (var variable in interpolation.Captured)
                Captured.Add(variable);

            return interpolated;
        }

            public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
            {
                switch (node.Kind())
                {
                    case SyntaxKind.StringLiteralExpression:
                        return RewriteStringLiteralExpression(node);
                    case SyntaxKind.CharacterLiteralExpression:
                        return RewriteCharacterLiteralExpression(node);
                }

                return node;
            }

        private static bool OutSideOfDeclarationSideWithSameName(LiteralExpressionSyntax stringLiteral)
        {
            var variableDeclaration = stringLiteral.FirstAncestorOfType<VariableDeclaratorSyntax>();
            if (variableDeclaration != null)
            {
                return !string.Equals(variableDeclaration.Identifier.ValueText, stringLiteral.Token.ValueText, StringComparison.Ordinal);
            }

            var propertyDeclaration = stringLiteral.FirstAncestorOfType<PropertyDeclarationSyntax>();
            var outSideOfAccessors = null == stringLiteral.FirstAncestorOfType<AccessorListSyntax>();
            if (!outSideOfAccessors) return true;
            return !string.Equals(propertyDeclaration?.Identifier.ValueText, stringLiteral.Token.ValueText, StringComparison.Ordinal);
        }

 private static void CheckJsonValue(SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalParameter,
     string json)
 {
     try
     {
         parseMethodInfo.Value.Invoke(null, new[] { json });
     }
     catch (Exception ex)
     {
         var diag = Diagnostic.Create(Rule, literalParameter.GetLocation(), ex.InnerException.Message);
         context.ReportDiagnostic(diag);
     }
 }

        private static string GetProgramElementNameThatMatchStringLiteral(LiteralExpressionSyntax stringLiteral, SemanticModel semanticModel)
        {
            var programElementName = GetParameterNameThatMatchStringLiteral(stringLiteral);

            if (!Found(programElementName))
            {
                var literalValueText = stringLiteral.Token.ValueText;
                var symbol = semanticModel.LookupSymbols(stringLiteral.Token.SpanStart, null, literalValueText).FirstOrDefault();

                programElementName = symbol?.ToDisplayParts().LastOrDefault(IncludeOnlyPartsThatAreName).ToString();
            }

            return programElementName;
        }

        private async Task<Document> ReplaceWithNameOf(Document document, LiteralExpressionSyntax literalExpression, CancellationToken cancellationToken)
        {
            var stringText = literalExpression.Token.ValueText;

            var nameOfExpression = InvocationExpression(
                expression: IdentifierName("nameof"),
                argumentList: ArgumentList(
                    arguments: SingletonSeparatedList(Argument(IdentifierName(stringText)))));

            var root = await document.GetSyntaxRootAsync(cancellationToken);
            var newRoot = root.ReplaceNode(literalExpression, nameOfExpression);

            return document.WithSyntaxRoot(newRoot);
        }

 public override void VisitLiteralExpression(LiteralExpressionSyntax node)
 {
     switch (node.Kind())
     {
         case SyntaxKind.TrueLiteralExpression:
             VisitSymbol("true");
             break;
         case SyntaxKind.FalseLiteralExpression:
             VisitSymbol("false");
             break;
         default:
             throw new InvalidPreprocessorExpressionException("Expected true or false literal expression");
     }
 }

            public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
            {
                if (node.Kind != SyntaxKind.StringLiteralExpression)
                    return node;

                var variables = InterpolationUtils.EnumerateVariables(node.GetText().ToString()).Distinct().ToArray();
                var arguments = string.Join(", ", variables);
                var formatString = node.GetText().ToString();

                for (int i = 0; i < variables.Length; i++) {
                    formatString = formatString.Replace("$" + variables[0], "{" + i + "}");
                }

                return Syntax.ParseExpression(string.Format("string.Format({0}, {1})", formatString, arguments));
            }

            private static SyntaxNode RewriteCharacterLiteralExpression(LiteralExpressionSyntax node)
            {
                Debug.Assert(node.Kind() == SyntaxKind.CharacterLiteralExpression);

                if (HasNonAsciiCharacters(node.Token.Text))
                {
                    string convertedText = EscapeNonAsciiCharacters(node.Token.Text);

                    SyntaxToken t = SyntaxFactory.Literal(node.Token.LeadingTrivia, convertedText, node.Token.ValueText, node.Token.TrailingTrivia);

                    node = node.WithToken(t);
                }

                return node;
            }

        private static SyntaxToken GetNewLiteral(LiteralExpressionSyntax literal, SemanticModel semanticModel)
        {
            var type = semanticModel.GetTypeInfo(literal).Type;
            var text = literal.Token.Text;
            var reversedText = text.Reverse();
            var reversedTextEnding = new string(reversedText.TakeWhile(char.IsLetter).ToArray());
            var reversedTextBeginning = new string(reversedText.SkipWhile(char.IsLetter).ToArray());
            var newText = new string((reversedTextEnding.ToUpperInvariant() + reversedTextBeginning).Reverse().ToArray());

            switch (type.SpecialType)
            {
                case SpecialType.System_Int32:
                    return SyntaxFactory.Literal(
                        newText,
                        (int)literal.Token.Value);
                case SpecialType.System_Char:
                    return SyntaxFactory.Literal(
                        newText,
                        (char)literal.Token.Value);
                case SpecialType.System_UInt32:
                    return SyntaxFactory.Literal(
                        newText,
                        (uint)literal.Token.Value);
                case SpecialType.System_Int64:
                    return SyntaxFactory.Literal(
                        newText,
                        (long)literal.Token.Value);
                case SpecialType.System_UInt64:
                    return SyntaxFactory.Literal(
                        newText,
                        (ulong)literal.Token.Value);
                case SpecialType.System_Decimal:
                    return SyntaxFactory.Literal(
                        newText,
                        (decimal)literal.Token.Value);
                case SpecialType.System_Single:
                    return SyntaxFactory.Literal(
                        newText,
                        (float)literal.Token.Value);
                case SpecialType.System_Double:
                    return SyntaxFactory.Literal(
                        newText,
                        (double)literal.Token.Value);
                default:
                    return SyntaxFactory.Token(SyntaxKind.None);
            }
        }

        public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
        {
            if (node.CSharpKind() != SyntaxKind.StringLiteralExpression) return node;

            var pos = node.GetLocation().GetMappedLineSpan();
            var result = OnRewrite(pos.StartLinePosition.Line + 1, pos.StartLinePosition.Character + 1, Source.Lines[pos.StartLinePosition.Line].ToString(), node.Token.ValueText);
            if (result == null) return node;

            var names = result.Split('.');
            ExpressionSyntax newNode = SyntaxFactory.IdentifierName(names.First());
            foreach (var name in names.Skip(1))
            {
                newNode = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, newNode, SyntaxFactory.IdentifierName(name));
            }

            return newNode.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia());
        }