#201 - literal refactoring

Author: Stepami

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Expressions/PrimaryExpressions/Literal.cs

@@ -23,4 +23,20 @@ public Literal(
 
     public override ValueDto ToValueDto() =>
         ValueDto.ConstantDto(_value, _label);
+
+    public static Literal String(string value, string? segment = null, string? label = null) =>
+        new(new TypeIdentValue(new IdentifierReference(name: "string")), value, segment ?? "(1, 1)-(1, 1)", label);
+
+    public static Literal Number(double value, string? segment = null) =>
+        new(new TypeIdentValue(new IdentifierReference(name: "number")), value, segment ?? "(1, 1)-(1, 1)");
+
+    public static Literal Boolean(bool value, string? segment = null) =>
+        new(new TypeIdentValue(new IdentifierReference(name: "boolean")), value, segment ?? "(1, 1)-(1, 1)");
+
+    public static Literal Null(string? segment = null) =>
+        new(
+            new TypeIdentValue(new IdentifierReference(name: "null")),
+            value: null,
+            segment ?? "(1, 1)-(1, 1)",
+            label: "null");
 }

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/TopDownParser.cs

@@ -353,7 +353,7 @@ private FunctionDeclaration FunctionDeclaration()
             else if (CurrentIs("Assign"))
             {
                 Expect("Assign");
-                var value = Literal();
+                var value = LiteralNode();
                 indexOfFirstDefaultArgument = args.Count < indexOfFirstDefaultArgument
                     ? args.Count
                     : indexOfFirstDefaultArgument;
@@ -711,11 +711,11 @@ private Expression MultiplicativeExpression()
     }
 
     /// <summary>
-    /// UnaryExpression -> LeftHandSideExpression | ('-'|'!'|'~'|'$') UnaryExpression
+    /// UnaryExpression -> LeftHandSideExpression | ('-'|'!'|'~') UnaryExpression
     /// </summary>
     private Expression UnaryExpression()
     {
-        if (CurrentIsUnaryOperator())
+        if (CurrentIsUnaryOperator(expectEnv: false))
         {
             var op = Expect("Operator");
             return new UnaryExpression(op.Value, UnaryExpression())
@@ -761,7 +761,7 @@ private Expression PrimaryExpression()
 
         if (CurrentIsLiteral())
         {
-            return Literal();
+            return LiteralNode();
         }
 
         if (CurrentIs("LeftCurl"))
@@ -784,52 +784,35 @@ private Expression PrimaryExpression()
     ///            "StringLiteral"
     ///            "BooleanLiteral"
     /// </summary>
-    private Literal Literal()
+    private Literal LiteralNode()
     {
         var segment = _tokens.Current.Segment;
         if (CurrentIs("StringLiteral"))
         {
             var str = Expect("StringLiteral");
-            return new Literal(
-                new TypeIdentValue(
-                    TypeId: new IdentifierReference(name: "string")
-                        {Segment = str.Segment}),
+            return Literal.String(
                 value: Regex.Unescape(str.Value.Trim('"')),
                 segment,
                 label: str.Value
                     .Replace(@"\", @"\\")
                     .Replace(@"""", @"\"""));
         }
 
+        if (CurrentIs("NullLiteral"))
+        {
+            Expect("NullLiteral");
+            return Literal.Null(segment);
+        }
+
         return _tokens.Current.Type.Tag switch
         {
-            "NullLiteral" => new Literal(
-                new TypeIdentValue(
-                    TypeId: new IdentifierReference(name: "null")
-                        { Segment = _tokens.Current.Segment }),
-                Expect("NullLiteral").Value == "null" ? null : string.Empty,
-                segment,
-                label: "null"),
-            "IntegerLiteral" => new Literal(
-                new TypeIdentValue(
-                    TypeId: new IdentifierReference(name: "number")
-                        { Segment = _tokens.Current.Segment }),
-                value: double.Parse(Expect("IntegerLiteral").Value),
-                segment),
-            "FloatLiteral" => new Literal(
-                new TypeIdentValue(
-                    TypeId: new IdentifierReference(name: "number")
-                        { Segment = _tokens.Current.Segment }),
+            "IntegerLiteral" => Literal.Number(value: double.Parse(Expect("IntegerLiteral").Value), segment),
+            "FloatLiteral" => Literal.Number(
                 value: double.Parse(
                     Expect("FloatLiteral").Value,
                     CultureInfo.InvariantCulture),
                 segment),
-            "BooleanLiteral" => new Literal(
-                new TypeIdentValue(
-                    TypeId: new IdentifierReference(name: "boolean")
-                        { Segment = _tokens.Current.Segment }),
-                value: bool.Parse(Expect("BooleanLiteral").Value),
-                segment),
+            "BooleanLiteral" => Literal.Boolean(value: bool.Parse(Expect("BooleanLiteral").Value), segment),
             _ => throw new ParserException("There are no more supported literals")
         };
     }

tests/HydraScript.UnitTests/Application/ReturnAnalyzerTests.cs

@@ -27,8 +27,7 @@ public void Visit_FunctionWithMissingReturn_CodePathEndedWithReturnIsFalse()
             new BlockStatement([
                 new IfStatement(
                     new IdentifierReference("b"),
-                    new ReturnStatement(
-                        new Literal(new TypeIdentValue(new IdentifierReference("number")), 1, "segment")))
+                    new ReturnStatement(Literal.Number(1)))
             ]),
             indexOfFirstDefaultArgument: int.MaxValue);
 

tests/HydraScript.UnitTests/Application/WithExpressionData.cs

@@ -4,7 +4,6 @@
 using HydraScript.Domain.BackEnd.Impl.Values;
 using HydraScript.Domain.FrontEnd.Parser;
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast;
-using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Declarations;
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions;
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.ComplexLiterals;
 using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryExpressions;
@@ -24,8 +23,7 @@ public WithExpressionData()
                         new ObjectLiteral([
                             new Property(
                                 new IdentifierReference("x"),
-                                new Literal(new TypeIdentValue(new IdentifierReference("number")), 1,
-                                    "(1, 15)-(1, 16)"))
+                                Literal.Number(1, "(1, 15)-(1, 16)"))
                         ]),
                         new ObjectLiteral([])))),
             [
@@ -44,8 +42,7 @@ public WithExpressionData()
                         new ObjectLiteral([
                             new Property(
                                 new IdentifierReference("x"),
-                                new Literal(new TypeIdentValue(new IdentifierReference("number")), 1,
-                                    "(1, 15)-(1, 16)"))
+                                Literal.Number(1, "(1, 15)-(1, 16)"))
                         ]))
                     {
                         ComputedCopiedProperties = []