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