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