public static void ComputeRefactorings(RefactoringContext context, LiteralExpressionSyntax literalExpression) { switch (literalExpression.Kind()) { case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: { if (context.IsRefactoringEnabled(RefactoringIdentifiers.NegateBooleanLiteral) && literalExpression.Span.Contains(context.Span)) { context.RegisterRefactoring( "Negate boolean literal", cancellationToken => NegateBooleanLiteralRefactoring.RefactorAsync(context.Document, literalExpression, cancellationToken)); } break; } case SyntaxKind.StringLiteralExpression: { StringLiteralExpressionRefactoring.ComputeRefactorings(context, literalExpression); break; } } }
private string ParseLiteral(LiteralExpressionSyntax syntax) { switch (syntax.Kind()) { case SyntaxKind.DefaultLiteralExpression: return("undefined"); case SyntaxKind.NullLiteralExpression: return("null"); case SyntaxKind.CharacterLiteralExpression: return($"{(int)syntax.Token.ValueText[0]} /* {syntax.Token.ValueText} */"); case SyntaxKind.NumericLiteralExpression: case SyntaxKind.StringLiteralExpression: return(syntax.Token.Text); case SyntaxKind.FalseLiteralExpression: return("false"); case SyntaxKind.TrueLiteralExpression: return("true"); } return(ParseUnknown(syntax)); }
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken); LiteralExpressionSyntax literalExpression = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <LiteralExpressionSyntax>(); if (literalExpression == null) { return; } switch (literalExpression.Kind()) { case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: { context.RegisterRefactoring( "Negate boolean literal", cancellationToken => NegateBooleanLiteralTypeAsync(context.Document, literalExpression, cancellationToken)); break; } } }
/// <summary> /// Gets the type from the liternal expression node /// </summary> /// <param name="node">the node</param> /// <returns>The type from the literal expression</returns> private IType FromLiteralExpression(LiteralExpressionSyntax node) { SyntaxKind kind = node.Kind(); INamedTypeSymbol symb; switch (kind) { case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: symb = _context.Compilation.GetTypeByMetadataName(typeof(bool).FullName); break; case SyntaxKind.StringLiteralExpression: symb = _context.Compilation.GetTypeByMetadataName(typeof(string).FullName); break; case SyntaxKind.NumericLiteralExpression: symb = _context.Compilation.GetTypeByMetadataName(typeof(int).FullName); break; default: return(null); } return(FromSymbol(symb)); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind() == SyntaxKind.DefaultLiteralExpression) { AnalyzeNode(node); } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); LiteralExpressionSyntax literalExpression = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <LiteralExpressionSyntax>(); Debug.Assert(literalExpression != null, $"{nameof(literalExpression)} is null"); if (literalExpression == null) { return; } Debug.Assert(literalExpression.IsBooleanLiteralExpression(), literalExpression.Kind().ToString()); if (!literalExpression.IsBooleanLiteralExpression()) { return; } SyntaxNode parent = literalExpression.Parent; switch (parent?.Kind()) { case SyntaxKind.ForStatement: { RegisterCodeFix( context, cancellationToken => { return(RemoveRedundantBooleanLiteralRefactoring.RefactorAsync( context.Document, (ForStatementSyntax)parent, cancellationToken)); }); break; } case SyntaxKind.LogicalAndExpression: case SyntaxKind.LogicalOrExpression: case SyntaxKind.EqualsExpression: case SyntaxKind.NotEqualsExpression: { RegisterCodeFix( context, cancellationToken => { return(RemoveRedundantBooleanLiteralRefactoring.RefactorAsync( context.Document, (BinaryExpressionSyntax)parent, cancellationToken)); }); break; } } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, LiteralExpressionSyntax literalExpression) { switch (literalExpression.Kind()) { case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: { if (context.IsRefactoringEnabled(RefactoringIdentifiers.NegateBooleanLiteral) && literalExpression.Span.Contains(context.Span)) { context.RegisterRefactoring( "Negate boolean literal", cancellationToken => NegateBooleanLiteralRefactoring.RefactorAsync(context.Document, literalExpression, cancellationToken)); } break; } case SyntaxKind.StringLiteralExpression: { if (context.Span.IsContainedInSpanOrBetweenSpans(literalExpression)) { await StringLiteralExpressionRefactoring.ComputeRefactoringsAsync(context, literalExpression).ConfigureAwait(false); } break; } } }
private LiteralExpressionNode ParseLiteralExpression(LiteralExpressionSyntax literalExpression) { var value = literalExpression.Token.Text; var kLiteralExpression = KSyntaxFactory.LiteralExpression((KSyntaxKind)literalExpression.Kind(), KSyntaxFactory.Literal(value)); return(kLiteralExpression); }
internal static StringLiteralExpressionInfo Create(LiteralExpressionSyntax literalExpression) { if (literalExpression?.Kind() != SyntaxKind.StringLiteralExpression) { return(Default); } return(new StringLiteralExpressionInfo(literalExpression)); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind().Equals(SyntaxKind.NumericLiteralExpression)) { return(base.VisitLiteralExpression(node.ReplaceNode(node, node.WithToken(SyntaxFactory.ParseToken(node.Token.ValueText))))); } return(base.VisitLiteralExpression(node)); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (!node.Kind().Equals(SyntaxKind.NumericLiteralExpression) || !int.TryParse(node.Token.ValueText, out int result)) { return(base.VisitLiteralExpression(node)); } return(SyntaxFactory.ParseExpression(IntToBitExpression.Replace(result))); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.NullLiteralExpression: AddCilInstruction(ilVar, OpCodes.Ldnull); break; case SyntaxKind.StringLiteralExpression: AddCilInstruction(ilVar, OpCodes.Ldstr, node.ToFullString()); break; case SyntaxKind.CharacterLiteralExpression: case SyntaxKind.NumericLiteralExpression: AddLocalVariableAndHandleCallOnValueTypeLiterals(node, "assembly.MainModule.TypeSystem.Int32", node.ToString()); break; case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: AddLocalVariableAndHandleCallOnValueTypeLiterals(node, "assembly.MainModule.TypeSystem.Boolean", bool.Parse(node.ToString()) ? 1 : 0); break; default: throw new ArgumentException($"Literal ( {node}) of type {node.Kind()} not supported yet."); } void AddLocalVariableAndHandleCallOnValueTypeLiterals(LiteralExpressionSyntax literalNode, string cecilTypeSystemReference, object literalValue) { AddCilInstruction(ilVar, LoadOpCodeFor(literalNode), literalValue); var localVarParent = (CSharpSyntaxNode)literalNode.Parent; if (localVarParent.Accept(new UsageVisitor()) == UsageKind.CallTarget) { var tempLocalName = MethodExtensions.LocalVariableNameFor("tmp_", "tmp_".UniqueId().ToString()); AddCecilExpression("var {0} = new VariableDefinition({1});", tempLocalName, cecilTypeSystemReference); AddCecilExpression("{0}.Body.Variables.Add({1});", Context.DefinitionVariables.GetLastOf(MemberKind.Method).VariableName, tempLocalName); AddCilInstruction(ilVar, OpCodes.Stloc, $"{tempLocalName}"); AddCilInstruction(ilVar, OpCodes.Ldloca_S, $"{tempLocalName}"); } } }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { SyntaxKind kind = node.Kind(); if (kind == SyntaxKind.StringLiteralExpression) { TryCapture(node); } base.VisitLiteralExpression(node); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind() == SyntaxKind.StringLiteralExpression) { cb.Append("std::string(").Append(node.ToString()).Append(")"); } else { cb.Append(node.ToString()); } }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.NumericLiteralExpression: Context.Append((int)node.Token.Value); //handling UInt256 break; default: throw new NotImplementedException(); } }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.StringLiteralExpression: return RewriteStringLiteralExpression(node); case SyntaxKind.CharacterLiteralExpression: return RewriteCharacterLiteralExpression(node); } return node; }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { node = (LiteralExpressionSyntax)base.VisitLiteralExpression(node); var token = node.Token; if ((transformKind == TransformKind.TrueToFalse) && (node.Kind() == SyntaxKind.TrueLiteralExpression)) { var newToken = SyntaxFactory.Token(token.LeadingTrivia, SyntaxKind.FalseKeyword, token.TrailingTrivia); return(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression, newToken)); } if ((transformKind == TransformKind.FalseToTrue) && (node.Kind() == SyntaxKind.FalseLiteralExpression)) { var newToken = SyntaxFactory.Token(token.LeadingTrivia, SyntaxKind.TrueKeyword, token.TrailingTrivia); return(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, newToken)); } return(node); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.StringLiteralExpression: return(RewriteStringLiteralExpression(node)); case SyntaxKind.CharacterLiteralExpression: return(RewriteCharacterLiteralExpression(node)); } return(node); }
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 BoundNode VisitLiteralExpression(LiteralExpressionSyntax node) { IConstantValue constantValue; TypeSymbol constantType; switch (node.Kind()) { case SyntaxKind.NumericLiteralExpression: Type type = node.Token.Value.GetType(); constantType = Context.GetTypeSymbol(type); constantValue = (IConstantValue)Activator.CreateInstance(typeof(ConstantValue <>).MakeGenericType(type), node.Token.Value); break; case SyntaxKind.StringLiteralExpression: constantType = Context.GetTypeSymbol(SpecialType.System_String); constantValue = new ConstantValue <string>((string)node.Token.Value); break; case SyntaxKind.CharacterLiteralExpression: constantType = Context.GetTypeSymbol(SpecialType.System_Char); constantValue = new ConstantValue <char>((char)node.Token.Value); break; case SyntaxKind.TrueLiteralExpression: constantType = Context.GetTypeSymbol(SpecialType.System_Boolean); constantValue = new ConstantValue <bool>(true); break; case SyntaxKind.FalseLiteralExpression: constantType = Context.GetTypeSymbol(SpecialType.System_Boolean); constantValue = new ConstantValue <bool>(false); break; case SyntaxKind.NullLiteralExpression: constantType = Context.GetTypeSymbol(SpecialType.System_Object); constantValue = new ConstantValue <object>(null); break; case SyntaxKind.DefaultLiteralExpression: constantType = GetTypeSymbol(node); constantValue = GetDefaultValue(constantType); break; default: return(base.VisitLiteralExpression(node)); } return(new BoundConstantExpression(constantValue, constantType, node)); }
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 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; }
public static string StringValue(this LiteralExpressionSyntax node) { if (node.Kind() != SyntaxKind.StringLiteralExpression) { throw new ArgumentException("node is not string literal"); } var str = node.Token.ToString(); if (str.StartsWith("@")) { str = str.Substring(1); } str = str.Substring(1, str.Length - 2); return(str); }
public override string VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.StringLiteralExpression: return($"\"{node.Token.ValueText}\""); case SyntaxKind.NumericLiteralExpression: case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: return(node.Token.ValueText); } return(base.VisitLiteralExpression(node)); }
public static string LiteralExpression(LiteralExpressionSyntax expression) { var r = ""; switch (expression.Kind()) { //Swift doesn't use the same 'c' character literal syntax, instead you create a String and type annotate it as a Character case SyntaxKind.CharacterLiteralExpression: //this is sketch, probably shouldn't use char literals o.o r = '"' + expression.Token.ValueText.Replace("\\'", "'").Replace("\"", "\\\"") + '"'; break; case SyntaxKind.NullKeyword: case SyntaxKind.NullLiteralExpression: switch (Builder.Instance.Language) { case Languages.Swift: r = "nil"; break; case Languages.Kotlin: r = "null"; break; case Languages.TypeScript: r = "null"; break; case Languages.Php: r = "null"; break; } break; case SyntaxKind.StringLiteralExpression: r = Builder.Instance.LanguageConvertLiteralExpressionString(expression.ToString()); break; default: r = expression.ToString(); break; } r = expression.ToFullString().Replace(expression.ToString(), r); return(r); }
public override int VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind() != SyntaxKind.NumericLiteralExpression) { throw new InvalidOperationException($"Invalid literal type: {node}"); } var value = node.ToString(); if (value.StartsWith("0x")) { return(Convert.ToInt32(value.Substring(2), 16)); } return(int.Parse(value)); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.FalseLiteralExpression: _output.Write(node, "false"); break; case SyntaxKind.TrueLiteralExpression: _output.Write(node, "true"); break; case SyntaxKind.NullLiteralExpression: _output.Write(node, "null"); break; case SyntaxKind.NumericLiteralExpression: string num = node.GetText().ToString().Trim(); //Note:Keep everything, e.g. prefix 0, in C#, it has no meaning, but it means octet in js if (!char.IsNumber(num[num.Length - 1])) //Note:Remove postfix, since C# has l,m etc as postfix. { num = num.Substring(0, num.Length - 1); } _output.Write(node, num); break; case SyntaxKind.StringLiteralExpression: string str = node.Token.ValueText.Bracketing(StringPair.DoubleQuote); if (str[0] == '@') { str = str.Substring(1); this.AppendCompileIssue(node, IssueType.Warning, IssueId.StringPrefixIgnore); } _output.Write(node, str); break; case SyntaxKind.CharacterLiteralExpression: _output.Write(node, node.Token.ValueText.Bracketing(StringPair.SingleQuote)); break; default: this.AppendCompileIssue(node, IssueType.Error, IssueId.UnknownExpressionType, node.Kind()); break; } return(node); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.NumericLiteralExpression: var v = decimal.Parse(node.ToString(), CultureInfo.InvariantCulture); if (_TupleValues == null) { Values.Push(new BidAsk(v)); } else { _TupleValues.Push(v); } break; } }
public static IEnvironmentVariableInterpolation Match(SemanticModel model, LiteralExpressionSyntax node, bool constant) { if (node.Kind() != SyntaxKind.StringLiteralExpression) { return(null); } var filePath = ScriptFilePath(model, node); if (constant && Constant.Qualifies(node)) { return(new Constant(node, filePath)); } return(RuntimeWithinLiteral.Qualifies(node) ? new RuntimeWithinLiteral(node, filePath) : null); }
// Where we handle creating constants and such public override void VisitLiteralExpression(LiteralExpressionSyntax node) { UpdateSyntaxNode(node); SymbolDefinition expressionConstant = null; switch (node.Kind()) { case SyntaxKind.NumericLiteralExpression: // The Roslyn AST figures out the type automagically for you based on how the token is declared :D // Can probably flatten out the other ones into this too expressionConstant = visitorContext.topTable.CreateConstSymbol(node.Token.Value.GetType(), node.Token.Value); break; case SyntaxKind.StringLiteralExpression: expressionConstant = visitorContext.topTable.CreateConstSymbol(typeof(string), node.Token.Value); break; case SyntaxKind.CharacterLiteralExpression: expressionConstant = visitorContext.topTable.CreateConstSymbol(typeof(char), node.Token.Value); break; case SyntaxKind.TrueLiteralExpression: expressionConstant = visitorContext.topTable.CreateConstSymbol(typeof(bool), true); break; case SyntaxKind.FalseLiteralExpression: expressionConstant = visitorContext.topTable.CreateConstSymbol(typeof(bool), false); break; case SyntaxKind.NullLiteralExpression: expressionConstant = visitorContext.topTable.CreateConstSymbol(typeof(object), null); break; default: base.VisitLiteralExpression(node); return; } if (expressionConstant != null && visitorContext.topCaptureScope != null) { visitorContext.topCaptureScope.SetToLocalSymbol(expressionConstant); } }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, LiteralExpressionSyntax literalExpression) { switch (literalExpression.Kind()) { case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: { if (context.IsRefactoringEnabled(RefactoringDescriptors.InvertBooleanLiteral) && literalExpression.Span.Contains(context.Span)) { context.RegisterRefactoring( "Invert boolean literal", ct => InvertBooleanLiteralRefactoring.RefactorAsync(context.Document, literalExpression, ct), RefactoringDescriptors.InvertBooleanLiteral); } break; } case SyntaxKind.StringLiteralExpression: { if (context.Span.IsContainedInSpanOrBetweenSpans(literalExpression)) { await StringLiteralExpressionRefactoring.ComputeRefactoringsAsync(context, literalExpression).ConfigureAwait(false); } break; } case SyntaxKind.NumericLiteralExpression: { if (context.IsRefactoringEnabled(RefactoringDescriptors.ConvertHexadecimalLiteralToDecimalLiteral) && context.Span.IsBetweenSpans(literalExpression)) { ConvertHexadecimalLiteralToDecimalLiteralRefactoring.ComputeRefactoring(context, literalExpression); } break; } } }
public override Tristate VisitLiteralExpression(LiteralExpressionSyntax node) { Tristate state; if (_symbolStates.TryGetValue(node.ToString(), out state)) { return(state); } switch (node.Kind()) { case SyntaxKind.TrueLiteralExpression: return(Tristate.True); case SyntaxKind.FalseLiteralExpression: return(Tristate.False); default: throw new InvalidPreprocessorExpressionException("Expected true or false literal expression"); } }
private static SyntaxNode RewriteStringLiteralExpression(LiteralExpressionSyntax node) { Debug.Assert(node.Kind() == SyntaxKind.StringLiteralExpression); if (node.Token.IsVerbatimStringLiteral()) { // We do not correctly rewrite verbatim string literals yet. Once Issue 39 is // fixed we can remove this early out. return node; } 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; }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { node = (LiteralExpressionSyntax)base.VisitLiteralExpression(node); var token = node.Token; if ((transformKind == TransformKind.TrueToFalse) && (node.Kind() == SyntaxKind.TrueLiteralExpression)) { var newToken = SyntaxFactory.Token(token.LeadingTrivia, SyntaxKind.FalseKeyword, token.TrailingTrivia); return SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression, newToken); } if ((transformKind == TransformKind.FalseToTrue) && (node.Kind() == SyntaxKind.FalseLiteralExpression)) { var newToken = SyntaxFactory.Token(token.LeadingTrivia, SyntaxKind.TrueKeyword, token.TrailingTrivia); return SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, newToken); } return node; }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind() == SyntaxKind.StringLiteralExpression) cb.Append("std::string(").Append(node.ToString()).Append(")"); else cb.Append(node.ToString()); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.FalseLiteralExpression: _output.Write(node, "false"); break; case SyntaxKind.TrueLiteralExpression: _output.Write(node, "true"); break; case SyntaxKind.NullLiteralExpression: _output.Write(node, "null"); break; case SyntaxKind.NumericLiteralExpression: string num = node.GetText().ToString().Trim();//Note:Keep everything, e.g. prefix 0, in C#, it has no meaning, but it means octet in js if (!char.IsNumber(num[num.Length - 1]))//Note:Remove postfix, since C# has l,m etc as postfix. { num = num.Substring(0, num.Length - 1); } _output.Write(node, num); break; case SyntaxKind.StringLiteralExpression: string str = node.Token.ValueText.Bracketing(StringPair.DoubleQuote); if (str[0] == '@') { str = str.Substring(1); this.AppendCompileIssue(node, IssueType.Warning, IssueId.StringPrefixIgnore); } _output.Write(node, str); break; case SyntaxKind.CharacterLiteralExpression: _output.Write(node, node.Token.ValueText.Bracketing(StringPair.SingleQuote)); break; default: this.AppendCompileIssue(node, IssueType.Error, IssueId.UnknownExpressionType, node.Kind()); break; } return node; }