private static bool IsNegation(LiteralExpressionSyntax literal, LiteralExpressionSyntax literal2)
{
if (literal.IsKind(SyntaxKind.TrueLiteralExpression))
{
return(literal2.IsKind(SyntaxKind.FalseLiteralExpression));
}
else
{
return(literal2.IsKind(SyntaxKind.TrueLiteralExpression));
}
}
private static bool IsOppositeBooleanLiteral(LiteralExpressionSyntax literal1, LiteralExpressionSyntax literal2)
{
if (literal1.IsKind(SyntaxKind.TrueLiteralExpression))
{
return(literal2.IsKind(SyntaxKind.FalseLiteralExpression));
}
else
{
return(literal2.IsKind(SyntaxKind.TrueLiteralExpression));
}
}
public static bool TryParse(LiteralExpressionSyntax literal, out UrlTemplate template)
{
if (literal.IsKind(SyntaxKind.StringLiteralExpression))
{
var text = literal.Token.ValueText;
var builder = ImmutableArray.CreateBuilder <Component>(text.Count(x => x == '/') + 1);
var start = 0;
while (true)
{
var end = text.IndexOf('/', start);
if (end < 0)
{
builder.Add(new Component(literal, start, text.Length));
break;
}
builder.Add(new Component(literal, start, end));
start = end + 1;
}
template = new UrlTemplate(literal, builder.MoveToImmutable());
return(true);
}
template = default(UrlTemplate);
return(false);
}
static bool TryGetDiagnostic(SyntaxNodeAnalysisContext nodeContext, out Diagnostic diagnostic)
{
diagnostic = default(Diagnostic);
var node = nodeContext.Node as AssignmentExpressionSyntax;
if (node.IsKind(SyntaxKind.OrAssignmentExpression))
{
LiteralExpressionSyntax right = node.Right as LiteralExpressionSyntax;
//if right is true
if ((right != null) && right.IsKind(SyntaxKind.TrueLiteralExpression))
{
diagnostic = Diagnostic.Create(
descriptor,
node.GetLocation()
);
return(true);
}
}
else if (node.IsKind(SyntaxKind.AndAssignmentExpression))
{
LiteralExpressionSyntax right = node.Right as LiteralExpressionSyntax;
//if right is false
if ((right != null) && right.IsKind(SyntaxKind.FalseLiteralExpression))
{
diagnostic = Diagnostic.Create(
descriptor,
node.GetLocation()
);
return(true);
}
}
return(false);
}
internal static void Run(SyntaxNodeAnalysisContext context, LiteralExpressionSyntax literalExpression)
{
if (literalExpression == null)
{
return;
}
if (literalExpression.IsKind(SyntaxKind.StringLiteralExpression) &&
literalExpression.Token.IsKind(SyntaxKind.StringLiteralToken))
{
var sql = literalExpression.Token.ValueText;
if (string.IsNullOrWhiteSpace(sql))
{
return;
}
List <string> errors = SqlParser.Parse(sql);
if (errors.Count == 0)
{
return;
}
string errorText = String.Join("\r\n", errors);
var diagnostic = Diagnostic.Create(Rule, literalExpression.GetLocation(), errorText);
context.ReportDiagnostic(diagnostic);
}
}
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NullLiteralExpression))
{
_hasPossibleNullValue = true;
}
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
var newNode = node;
if (node.IsKind(SyntaxKind.StringLiteralExpression) ||
node.IsKind(SyntaxKind.CharacterLiteralExpression) ||
node.IsKind(SyntaxKind.NumericLiteralExpression))
{
// even if the node is a Numerical Literal token, we replace it as a string literal
if (node.Token.ValueText != "0" && node.Token.ValueText != "1")
{
newNode = node.WithToken(SyntaxFactory.Token(node.Token.LeadingTrivia, SyntaxKind.StringLiteralToken, "LITERAL",
"LITERAL", node.Token.TrailingTrivia));
}
}
return(base.VisitLiteralExpression(newNode));
}
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (!node.IsKind(SyntaxKind.NumericLiteralExpression))
{
throw new NotSupportedException();
}
Result = new ConstantExpressionBuilder(node.Token.Value.GetType(), node.Token.Text);
}
static bool IsNull(ExpressionSyntax candidate)
{
return(candidate switch
{
LiteralExpressionSyntax literal => literal.IsKind(SyntaxKind.NullLiteralExpression),
CastExpressionSyntax cast => IsNull(cast.Expression),
BinaryExpressionSyntax binary when binary.IsKind(SyntaxKind.AsExpression) => IsNull(binary.Left),
_ => false,
});
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.StringLiteralExpression))
{
// StringLiteralToken stringLiteralToken = node.Token;
// Console.WriteLine(node.Token.Value);
_strings.Add((string)node.Token.Value);
}
}
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NumericLiteralExpression))
{
this.literals.Add(node);
}
base.VisitLiteralExpression(node);
}
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);
}
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));
}
public static bool IsZeroNumericLiteral(this LiteralExpressionSyntax literalExpression)
{
if (literalExpression == null)
{
throw new ArgumentNullException(nameof(literalExpression));
}
return(literalExpression.IsKind(SyntaxKind.NumericLiteralExpression) &&
string.Equals(literalExpression.Token.ValueText, "0", StringComparison.Ordinal));
}
public static bool IsVerbatimStringLiteral(this LiteralExpressionSyntax literalExpression)
{
if (literalExpression == null)
{
throw new ArgumentNullException(nameof(literalExpression));
}
return(literalExpression.IsKind(SyntaxKind.StringLiteralExpression) &&
literalExpression.Token.Text.StartsWith("@", StringComparison.Ordinal));
}
public static Task <Document> RefactorAsync(
Document document,
LiteralExpressionSyntax literalExpression,
CancellationToken cancellationToken = default)
{
LiteralExpressionSyntax newNode = BooleanLiteralExpression(!literalExpression.IsKind(SyntaxKind.TrueLiteralExpression))
.WithTriviaFrom(literalExpression);
return(document.ReplaceNodeAsync(literalExpression, newNode, cancellationToken));
}
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
// This has to be a top-level function in order to be a valid null-value
if (FunctionDepth <= 1 && node.IsKind(SyntaxKind.NullLiteralExpression))
{
PossibleNullValues.Add(node);
return;
}
base.VisitLiteralExpression(node);
}
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NullLiteralExpression))
{
TypeExpressionLocation = node.GetLocation();
}
else
{
base.VisitLiteralExpression(node);
}
}
private static LiteralExpressionSyntax GetNewNode(LiteralExpressionSyntax literalExpression)
{
if (literalExpression.IsKind(SyntaxKind.TrueLiteralExpression))
{
return(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
}
else
{
return(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression));
}
}
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NumericLiteralExpression))
{
double result;
if (double.TryParse(node.Token.ValueText, out result))
{
Value = (isValuePositive ? 1 : -1) * result;
}
}
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NullLiteralExpression))
{
if (ShouldApply(node))
{
return(Null);
}
}
return(base.VisitLiteralExpression(node));
}
public override SyntaxNode?VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NumericLiteralExpression))
{
return(base.VisitLiteralExpression(
node.WithToken(
SyntaxFactory.Literal(
node.Token.LeadingTrivia, node.Token.ValueText, node.Token.ValueText, node.Token.TrailingTrivia))));
}
return(base.VisitLiteralExpression(node));
}
public string Generate(LiteralExpressionSyntax literal, SemanticModel semanticModel)
{
if (literal.IsKind(SyntaxKind.NullLiteralExpression))
{
return("null");
}
if (literal.IsKind(SyntaxKind.TrueLiteralExpression))
{
return("true");
}
if (literal.IsKind(SyntaxKind.FalseLiteralExpression))
{
return("false");
}
if (literal.IsKind(SyntaxKind.NumericLiteralExpression))
{
return(literal.ToString());
}
if (literal.IsKind(SyntaxKind.StringLiteralExpression))
{
return(literal.ToString());
}
if (literal.IsKind(SyntaxKind.CharacterLiteralExpression))
{
return(literal.ToString());
}
throw new NotImplementedException();
}
public static async Task <Document> RefactorAsync(
Document document,
LiteralExpressionSyntax literalExpression,
CancellationToken cancellationToken = default(CancellationToken))
{
LiteralExpressionSyntax newNode = (literalExpression.IsKind(SyntaxKind.TrueLiteralExpression))
? FalseLiteralExpression()
: TrueLiteralExpression();
newNode = newNode.WithTriviaFrom(literalExpression);
return(await document.ReplaceNodeAsync(literalExpression, newNode, cancellationToken).ConfigureAwait(false));
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.StringLiteralExpression) &&
node.Parent is ArgumentSyntax argument &&
argument.Parent is ArgumentListSyntax argumentList &&
argumentList.Parent is InvocationExpressionSyntax invocation &&
invocation.TryGetMethodName(out var method) &&
method == "GetString")
{
return(node.WithToken(SyntaxFactory.Literal(this.newKey)));
}
return(base.VisitLiteralExpression(node));
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, LiteralExpressionSyntax literalExpression)
{
if (literalExpression.IsKind(SyntaxKind.StringLiteralExpression) &&
literalExpression.Token.ValueText.Length == 1)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (semanticModel.ContainsDiagnostic(CSharpErrorCodes.CannotImplicitlyConvertType, literalExpression.Span, context.CancellationToken))
{
context.RegisterRefactoring(
"Replace string literal with character literal",
cancellationToken => RefactorAsync(context.Document, literalExpression, cancellationToken));
}
}
}
public void Append(LiteralExpressionSyntax stringLiteral)
{
if (stringLiteral == null)
{
return;
}
if (!stringLiteral.IsKind(SyntaxKind.StringLiteralExpression))
{
throw new ArgumentException("", nameof(stringLiteral));
}
StringLiteralExpressionInfo literalInfo = SyntaxInfo.StringLiteralExpressionInfo(stringLiteral);
bool isVerbatim = literalInfo.IsVerbatim;
if (IsVerbatim == isVerbatim)
{
string text = literalInfo.Text;
int length = text.Length;
if (length == 0)
{
return;
}
int startIndex = StringBuilder.Length;
if (isVerbatim)
{
StringBuilder.Append(text, 2, length - 3);
}
else
{
StringBuilder.Append(text, 1, length - 2);
}
if (IsInterpolated)
{
StringBuilder.Replace("{", "{{", startIndex);
StringBuilder.Replace("}", "}}", startIndex);
}
}
else
{
Append(literalInfo.ValueText);
}
}
private static ReturnStatementSyntax CreateReturnStatement(IfStatementSyntax ifStatement)
{
LiteralExpressionSyntax booleanLiteral = SimplifyIfStatementToReturnStatementAnalyzer.GetBooleanLiteral(ifStatement.Statement);
ExpressionSyntax expression = ifStatement.Condition;
if (booleanLiteral.IsKind(SyntaxKind.FalseLiteralExpression))
{
expression = expression.Negate();
}
return(SyntaxFactory.ReturnStatement(
SyntaxFactory.Token(SyntaxKind.ReturnKeyword).WithTrailingSpace(),
expression,
SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NumericLiteralExpression) &&
node.Token.IsKind(SyntaxKind.NumericLiteralToken) &&
node.Token.Value is double value &&
node.Token.Text.Contains("e"))
{
return(base.VisitLiteralExpression(
node.WithToken(
SyntaxFactory.Literal(
node.Token.Text.Replace("e", "E"),
value))));
}
return(base.VisitLiteralExpression(node));
}
internal static HexNumericLiteralExpressionInfo Create(LiteralExpressionSyntax literalExpression)
{
if (literalExpression == null)
return default;
if (!literalExpression.IsKind(SyntaxKind.NumericLiteralExpression))
return default;
SyntaxToken token = literalExpression.Token;
string text = token.Text;
if (!text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
return default;
return new HexNumericLiteralExpressionInfo(literalExpression, token);
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
this.IsAttributeArgument = node.Parent.IsKind(SyntaxKind.AttributeArgument);
if (node.IsKind(SyntaxKind.StringLiteralExpression) &&
!IsParameterDefaultArgument(node) &&
!this.IsAttributeArgument &&
!IsConstVariableDeclaration(node))
{
if (string.IsNullOrEmpty(node.Token.ValueText))
{
this.addedAnnotations = true;
return SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)),
SyntaxFactory.IdentifierName("Empty"));
}
}
return base.VisitLiteralExpression(node);
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
var pattern = $"[^\\w](?<before>{this.before}[^\\w])";
if (node.IsKind(SyntaxKind.StringLiteralExpression) &&
Regex.IsMatch(node.Token.ValueText, pattern))
{
return(node.Update(
SyntaxFactory.Literal(
Regex.Replace(node.Token.Text, this.before, UpdateMatch),
Regex.Replace(node.Token.ValueText, this.before, UpdateMatch))));
}
return(base.VisitLiteralExpression(node));
string UpdateMatch(Match match)
{
return(match.Value.Replace(this.before !, this.after));
}
}
public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
if (node.IsKind(SyntaxKind.NumericLiteralExpression))
{
double result;
if (double.TryParse(node.Token.ValueText, out result))
{
Value = (isValuePositive ? 1 : -1) * result;
}
}
}