public override void VisitLiteralExpression(LiteralExpressionSyntax node)
{
var token = node.Token.ToString();
var nl = OurLine.NewLine(LineKind.Decl, "LiteralExpression");
OurLine.AddEssentialInfo(ref nl, "token:" + token);
nl.Source = node.ToFullString();
nl.ParentKind = node.Parent.RawKind;
nl.RawKind = node.RawKind;
LogCommand(nl);
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 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 string VisitLiteralExpression(LiteralExpressionSyntax node)
{
string literal = node.ToFullString().Trim();
return(_backend.CorrectLiteral(literal));
}
public void Test_EmbeddedConstantIsUsedWhenDisconnected([Values] TestingMode mode)
{
const float outerValue = 42f;
const float innerValue = 347f;
// make sure that we really test values that are not default
Assume.That(outerValue, Is.Not.EqualTo(default(float)));
Assume.That(innerValue, Is.Not.EqualTo(default(float)));
var stencil = GraphModel.Stencil;
FunctionModel a = GraphModel.CreateFunction("A", Vector2.zero);
// Debug.Log(...)
MethodInfo logMethod = typeof(Debug).GetMethod(nameof(Debug.Log), new[] { typeof(object) });
Assume.That(logMethod, Is.Not.Null);
FunctionCallNodeModel log = a.CreateStackedNode <FunctionCallNodeModel>("Log", 0, SpawnFlags.Default, n => n.MethodInfo = logMethod);
var logParameterPort = log.GetParameterPorts().Single();
// Math.Abs(...)
MethodInfo absMethod = typeof(Mathf).GetMethod(nameof(Mathf.Abs), new[] { typeof(float) });
Assume.That(absMethod, Is.Not.Null);
FunctionCallNodeModel abs = GraphModel.CreateNode <FunctionCallNodeModel>("Abs", Vector2.zero, SpawnFlags.Default, n => n.MethodInfo = absMethod);
var absParameterPort = abs.GetParameterPorts().Single();
((FloatConstantModel)abs.InputConstantsById[absParameterPort.UniqueId]).value = innerValue;
GraphModel.CreateEdge(logParameterPort, abs.OutputPort);
// float
IConstantNodeModel outerFloat = GraphModel.CreateConstantNode("float42", typeof(float).GenerateTypeHandle(stencil), Vector2.zero);
Assume.That(outerFloat, Is.Not.Null);
((FloatConstantModel)outerFloat).value = outerValue;
string innerFloatString = SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(innerValue)).ToFullString();
string outerFloatString = SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(outerValue)).ToFullString();
TestPrereqActionPostreq(mode,
() =>
{
// outer float disconnected, check that we use the inner value
SyntaxNode astRoot = CompileCurrentGraphModel();
LiteralExpressionSyntax literalInsideLogAbs = GetLiteralInsideLogAbs(astRoot);
Assert.That(literalInsideLogAbs.ToFullString(), Is.EqualTo(innerFloatString));
return(new CreateEdgeAction(absParameterPort, outerFloat.OutputPort));
},
() =>
{
// outer float connected, check that we use the outer value
SyntaxNode astRoot = CompileCurrentGraphModel();
LiteralExpressionSyntax literalInsideLogAbs = GetLiteralInsideLogAbs(astRoot);
Assert.That(literalInsideLogAbs.ToFullString(), Is.EqualTo(outerFloatString));
});
}