vtlengine 1.1rc1__py3-none-any.whl → 1.1.1__py3-none-any.whl

vtlengine/AST/ASTConstructorModules/ExprComponents.py

@@ -14,11 +14,13 @@ from vtlengine.AST import (
     MulOp,
     ParamConstant,
     ParamOp,
+    ParFunction,
     TimeAggregation,
     UDOCall,
     UnaryOp,
     VarID,
 )
+from vtlengine.AST.ASTConstructorModules import extract_token_info
 from vtlengine.AST.ASTConstructorModules.Terminals import Terminals
 from vtlengine.AST.Grammar.parser import Parser
 from vtlengine.AST.VtlVisitor import VtlVisitor
@@ -108,7 +110,7 @@ class ExprComp(VtlVisitor):
             has_scaped_char = token.text.find("'") != -1
             if has_scaped_char:
                 token.text = str(token.text.replace("'", ""))
-            var_id_node = VarID(token.text)
+            var_id_node = VarID(value=token.text, **extract_token_info(ctx))
             return var_id_node
 
         else:
@@ -124,7 +126,7 @@ class ExprComp(VtlVisitor):
             op = ctx_list[1].getSymbol().text
         right_node = self.visitExprComponent(ctx_list[2])
 
-        bin_op_node = BinOp(left_node, op, right_node)
+        bin_op_node = BinOp(left=left_node, op=op, right=right_node, **extract_token_info(ctx))
 
         return bin_op_node
 
@@ -148,7 +150,7 @@ class ExprComp(VtlVisitor):
             right_node = Terminals().visitValueDomainID(ctx_list[2])
         else:
             raise NotImplementedError
-        bin_op_node = BinOp(left_node, op, right_node)
+        bin_op_node = BinOp(left=left_node, op=op, right=right_node, **extract_token_info(ctx))
 
         return bin_op_node
 
@@ -156,14 +158,15 @@ class ExprComp(VtlVisitor):
         return self.bin_op_creator_comp(ctx)
 
     def visitParenthesisExprComp(self, ctx: Parser.ParenthesisExprContext):
-        return self.visitExprComponent(list(ctx.getChildren())[1])
+        operand = self.visitExprComponent(list(ctx.getChildren())[1])
+        return ParFunction(operand=operand, **extract_token_info(ctx))
 
     def visitUnaryExprComp(self, ctx: Parser.UnaryExprContext):
         c_list = list(ctx.getChildren())
         op = c_list[0].getSymbol().text
         right = self.visitExprComponent(c_list[1])
 
-        return UnaryOp(op, right)
+        return UnaryOp(op=op, operand=right, **extract_token_info(ctx))
 
     def visitIfExprComp(self, ctx: Parser.IfExprCompContext):
         ctx_list = list(ctx.getChildren())
@@ -172,7 +175,12 @@ class ExprComp(VtlVisitor):
         then_op_node = self.visitExprComponent(ctx_list[3])
         else_op_node = self.visitExprComponent(ctx_list[5])
 
-        if_node = If(condition_node, then_op_node, else_op_node)
+        if_node = If(
+            condition=condition_node,
+            thenOp=then_op_node,
+            elseOp=else_op_node,
+            **extract_token_info(ctx),
+        )
 
         return if_node
 
@@ -189,10 +197,12 @@ class ExprComp(VtlVisitor):
         for i in range(0, len(ctx_list), 4):
             condition = self.visitExprComponent(ctx_list[i + 1])
             thenOp = self.visitExprComponent(ctx_list[i + 3])
-            case_obj = CaseObj(condition, thenOp)
+            case_obj = CaseObj(
+                condition=condition, thenOp=thenOp, **extract_token_info(ctx_list[i + 1])
+            )
             cases.append(case_obj)
 
-        case_node = Case(cases, else_node)
+        case_node = Case(cases=cases, elseOp=else_node, **extract_token_info(ctx))
 
         return case_node
 
@@ -210,7 +220,7 @@ class ExprComp(VtlVisitor):
         elif isinstance(c, TerminalNodeImpl):
             token = c.getSymbol()
             opt = token.text
-            return ID("OPTIONAL", opt)
+            return ID(type_="OPTIONAL", value=opt, **extract_token_info(ctx))
 
     """____________________________________________________________________________________
 
@@ -292,7 +302,7 @@ class ExprComp(VtlVisitor):
             if isinstance(element, Parser.ParameterComponentContext)
         ]
 
-        return UDOCall(op=op, params=param_nodes)
+        return UDOCall(op=op, params=param_nodes, **extract_token_info(ctx))
 
     def visitEvalAtomComponent(self, ctx: Parser.EvalAtomComponentContext):
         """
@@ -343,6 +353,7 @@ class ExprComp(VtlVisitor):
             operands=children_nodes[0],
             output=output_node[0],
             language=language_name[0].getSymbol().text,
+            **extract_token_info(ctx),
         )
 
     def visitCastExprComponent(self, ctx: Parser.CastExprComponentContext):
@@ -374,7 +385,11 @@ class ExprComp(VtlVisitor):
 
         if len(ctx_list) > 6:
             param_node = [
-                ParamConstant("PARAM_CAST", str_.symbol.text.strip('"'))
+                ParamConstant(
+                    type_="PARAM_CAST",
+                    value=str_.symbol.text.strip('"'),
+                    **extract_token_info(str_.getSymbol()),
+                )
                 for str_ in ctx_list
                 if isinstance(str_, TerminalNodeImpl)
                 and str_.getSymbol().type == Parser.STRING_CONSTANT
@@ -385,7 +400,9 @@ class ExprComp(VtlVisitor):
         if len(basic_scalar_type) == 1:
             children_nodes = expr_node + basic_scalar_type
 
-            return ParamOp(op=op, children=children_nodes, params=param_node)
+            return ParamOp(
+                op=op, children=children_nodes, params=param_node, **extract_token_info(ctx)
+            )
 
         else:
             # AST_ASTCONSTRUCTOR.14
@@ -398,7 +415,7 @@ class ExprComp(VtlVisitor):
         if isinstance(c, Parser.ExprComponentContext):
             return self.visitExprComponent(c)
         elif isinstance(c, TerminalNodeImpl):
-            return ID("OPTIONAL", c.getSymbol().text)
+            return ID(type_="OPTIONAL", value=c.getSymbol().text, **extract_token_info(ctx))
         else:
             raise NotImplementedError
 
@@ -427,7 +444,7 @@ class ExprComp(VtlVisitor):
         token = c.getSymbol()
         op_node = token.text
         operand_node = self.visitExprComponent(ctx_list[2])
-        return UnaryOp(op_node, operand_node)
+        return UnaryOp(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     def visitSubstrAtomComponent(self, ctx: Parser.SubstrAtomComponentContext):
         ctx_list = list(ctx.getChildren())
@@ -450,7 +467,9 @@ class ExprComp(VtlVisitor):
             for param in params:
                 params_nodes.append(self.visitOptionalExprComponent(param))
 
-        return ParamOp(op_node, children_nodes, params_nodes)
+        return ParamOp(
+            op=op_node, children=children_nodes, params=params_nodes, **extract_token_info(ctx)
+        )
 
     def visitReplaceAtomComponent(self, ctx: Parser.ReplaceAtomComponentContext):
         ctx_list = list(ctx.getChildren())
@@ -473,7 +492,9 @@ class ExprComp(VtlVisitor):
         children_nodes = [expressions[0]]
         params_nodes = [expressions[1]] + params
 
-        return ParamOp(op_node, children_nodes, params_nodes)
+        return ParamOp(
+            op=op_node, children=children_nodes, params=params_nodes, **extract_token_info(ctx)
+        )
 
     def visitInstrAtomComponent(self, ctx: Parser.InstrAtomComponentContext):
         ctx_list = list(ctx.getChildren())
@@ -496,7 +517,9 @@ class ExprComp(VtlVisitor):
         children_nodes = [expressions[0]]
         params_nodes = [expressions[1]] + params
 
-        return ParamOp(op_node, children_nodes, params_nodes)
+        return ParamOp(
+            op=op_node, children=children_nodes, params=params_nodes, **extract_token_info(ctx)
+        )
 
     """
                         -----------------------------------
@@ -521,7 +544,7 @@ class ExprComp(VtlVisitor):
         token = c.getSymbol()
         op_node = token.text
         operand_node = self.visitExprComponent(ctx_list[2])
-        return UnaryOp(op_node, operand_node)
+        return UnaryOp(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     def visitUnaryWithOptionalNumericComponent(
         self, ctx: Parser.UnaryWithOptionalNumericComponentContext
@@ -546,7 +569,9 @@ class ExprComp(VtlVisitor):
             for param in params:
                 params_nodes.append(self.visitOptionalExprComponent(param))
 
-        return ParamOp(op_node, children_nodes, params_nodes)
+        return ParamOp(
+            op=op_node, children=children_nodes, params=params_nodes, **extract_token_info(ctx)
+        )
 
     def visitBinaryNumericComponent(self, ctx: Parser.BinaryNumericComponentContext):
         ctx_list = list(ctx.getChildren())
@@ -557,7 +582,7 @@ class ExprComp(VtlVisitor):
         left_node = self.visitExprComponent(ctx_list[2])
         op_node = token.text
         right_node = self.visitExprComponent(ctx_list[4])
-        return BinOp(left_node, op_node, right_node)
+        return BinOp(left=left_node, op=op_node, right=right_node, **extract_token_info(ctx))
 
     """
                             -----------------------------------
@@ -617,7 +642,7 @@ class ExprComp(VtlVisitor):
             # AST_ASTCONSTRUCTOR.15
             raise NotImplementedError
 
-        return UnaryOp(op=op, operand=operand_node[0])
+        return UnaryOp(op=op, operand=operand_node[0], **extract_token_info(ctx))
 
     def visitTimeShiftAtomComponent(self, ctx: Parser.TimeShiftAtomComponentContext):
         """
@@ -628,9 +653,13 @@ class ExprComp(VtlVisitor):
 
         op = c.getSymbol().text
         left_node = self.visitExprComponent(ctx_list[2])
-        right_node = Constant("INTEGER_CONSTANT", int(ctx_list[4].getSymbol().text))
+        right_node = Constant(
+            type_="INTEGER_CONSTANT",
+            value=int(ctx_list[4].getSymbol().text),
+            **extract_token_info(ctx),
+        )
 
-        return BinOp(left=left_node, op=op, right=right_node)
+        return BinOp(left=left_node, op=op, right=right_node, **extract_token_info(ctx))
 
     def visitFillTimeAtomComponent(self, ctx: Parser.FillTimeAtomComponentContext):
         """
@@ -643,11 +672,19 @@ class ExprComp(VtlVisitor):
         children_node = [self.visitExprComponent(ctx_list[2])]
 
         if len(ctx_list) > 4:
-            param_constant_node = [ParamConstant("PARAM_TIMESERIES", ctx_list[4].getSymbol().text)]
+            param_constant_node = [
+                ParamConstant(
+                    type_="PARAM_TIMESERIES",
+                    value=ctx_list[4].getSymbol().text,
+                    **extract_token_info(ctx),
+                )
+            ]
         else:
             param_constant_node = []
 
-        return ParamOp(op=op, children=children_node, params=param_constant_node)
+        return ParamOp(
+            op=op, children=children_node, params=param_constant_node, **extract_token_info(ctx)
+        )
 
     def visitTimeAggAtomComponent(self, ctx: Parser.TimeAggAtomComponentContext):
         """
@@ -679,24 +716,24 @@ class ExprComp(VtlVisitor):
             if isinstance(operand_node, ID):
                 operand_node = None
             elif isinstance(operand_node, Identifier):
-                operand_node = VarID(operand_node.value)  # Converting Identifier to VarID
+                operand_node = VarID(
+                    value=operand_node.value, **extract_token_info(ctx.op)
+                )  # Converting Identifier to VarID
         else:
             operand_node = None
 
-        if operand_node is None:
-            # AST_ASTCONSTRUCTOR.17
-            raise SemanticError("1-4-2-2")
         return TimeAggregation(
             op=op,
             operand=operand_node,
             period_to=period_to,
             period_from=period_from,
             conf=conf,
+            **extract_token_info(ctx),
         )
 
     def visitCurrentDateAtomComponent(self, ctx: Parser.CurrentDateAtomComponentContext):
         c = list(ctx.getChildren())[0]
-        return MulOp(op=c.getSymbol().text, children=[])
+        return MulOp(op=c.getSymbol().text, children=[], **extract_token_info(ctx))
 
     def visitDateDiffAtomComponent(self, ctx: Parser.TimeShiftAtomComponentContext):
         """ """
@@ -707,7 +744,7 @@ class ExprComp(VtlVisitor):
         left_node = self.visitExprComponent(ctx_list[2])
         right_node = self.visitExprComponent(ctx_list[4])
 
-        return BinOp(left=left_node, op=op, right=right_node)
+        return BinOp(left=left_node, op=op, right=right_node, **extract_token_info(ctx))
 
     def visitDateAddAtomComponentContext(self, ctx: Parser.DateAddAtomComponentContext):
         """ """
@@ -724,7 +761,9 @@ class ExprComp(VtlVisitor):
             if len(ctx_list) > 6:
                 param_constant_node.append(self.visitExprComponent(ctx_list[6]))
 
-        return ParamOp(op=op, children=children_node, params=param_constant_node)
+        return ParamOp(
+            op=op, children=children_node, params=param_constant_node, **extract_token_info(ctx)
+        )
 
     """
                             -----------------------------------
@@ -749,7 +788,7 @@ class ExprComp(VtlVisitor):
         left_node = self.visitExprComponent(ctx_list[2])
         op_node = token.text
         right_node = self.visitExprComponent(ctx_list[4])
-        return BinOp(left_node, op_node, right_node)
+        return BinOp(left=left_node, op=op_node, right=right_node, **extract_token_info(ctx))
 
     """
                         -----------------------------------
@@ -780,7 +819,7 @@ class ExprComp(VtlVisitor):
         for children in childrens:
             children_nodes.append(self.visitExprComponent(children))
 
-        return MulOp(op_node, children_nodes)
+        return MulOp(op=op_node, children=children_nodes, **extract_token_info(ctx))
 
     def visitCharsetMatchAtomComponent(self, ctx: Parser.CharsetMatchAtomComponentContext):
         ctx_list = list(ctx.getChildren())
@@ -790,7 +829,7 @@ class ExprComp(VtlVisitor):
         left_node = self.visitExprComponent(ctx_list[2])
         op_node = token.text
         right_node = self.visitExprComponent(ctx_list[4])
-        return BinOp(left_node, op_node, right_node)
+        return BinOp(left=left_node, op=op_node, right=right_node, **extract_token_info(ctx))
 
     def visitIsNullAtomComponent(self, ctx: Parser.IsNullAtomComponentContext):
         ctx_list = list(ctx.getChildren())
@@ -798,7 +837,7 @@ class ExprComp(VtlVisitor):
         token = c.getSymbol()
         op_node = token.text
         operand_node = self.visitExprComponent(ctx_list[2])
-        return UnaryOp(op_node, operand_node)
+        return UnaryOp(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     """
                             -----------------------------------
@@ -818,12 +857,12 @@ class ExprComp(VtlVisitor):
         ctx_list = list(ctx.getChildren())
         op_node = ctx_list[0].getSymbol().text
         operand_node = self.visitExprComponent(ctx_list[2])
-        return Aggregation(op_node, operand_node)
+        return Aggregation(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     def visitCountAggrComp(self, ctx: Parser.CountAggrCompContext):
         ctx_list = list(ctx.getChildren())
         op_node = ctx_list[0].getSymbol().text
-        return Aggregation(op_node)
+        return Aggregation(op=op_node, **extract_token_info(ctx))
 
     """
                                 -----------------------------------
@@ -872,6 +911,7 @@ class ExprComp(VtlVisitor):
             partition_by=partition_by,
             order_by=order_by,
             window=params,
+            **extract_token_info(ctx),
         )
 
     def visitLagOrLeadAnComponent(self, ctx: Parser.LagOrLeadAnComponentContext):
@@ -906,6 +946,7 @@ class ExprComp(VtlVisitor):
             partition_by=partition_by,
             order_by=order_by,
             params=params,
+            **extract_token_info(ctx),
         )
 
     def visitRankAnComponent(self, ctx: Parser.RankAnComponentContext):
@@ -930,6 +971,7 @@ class ExprComp(VtlVisitor):
             partition_by=partition_by,
             order_by=order_by,
             window=None,
+            **extract_token_info(ctx),
         )
 
     def visitRatioToReportAnComponent(self, ctx: Parser.RatioToReportAnComponentContext):
@@ -949,4 +991,5 @@ class ExprComp(VtlVisitor):
             partition_by=partition_by,
             order_by=order_by,
             window=params,
+            **extract_token_info(ctx),
         )

vtlengine/AST/ASTConstructorModules/Terminals.py

@@ -12,6 +12,7 @@ from vtlengine.AST import (
     VarID,
     Windowing,
 )
+from vtlengine.AST.ASTConstructorModules import extract_token_info
 from vtlengine.AST.Grammar.parser import Parser
 from vtlengine.AST.VtlVisitor import VtlVisitor
 from vtlengine.DataTypes import (
@@ -37,26 +38,27 @@ def _remove_scaped_characters(text):
 class Terminals(VtlVisitor):
     def visitConstant(self, ctx: Parser.ConstantContext):
         token = ctx.children[0].getSymbol()
+        token_info = extract_token_info(token)
 
         if token.type == Parser.INTEGER_CONSTANT:
-            constant_node = Constant("INTEGER_CONSTANT", int(token.text))
+            constant_node = Constant(type_="INTEGER_CONSTANT", value=int(token.text), **token_info)
 
         elif token.type == Parser.NUMBER_CONSTANT:
-            constant_node = Constant("FLOAT_CONSTANT", float(token.text))
+            constant_node = Constant(type_="FLOAT_CONSTANT", value=float(token.text), **token_info)
 
         elif token.type == Parser.BOOLEAN_CONSTANT:
             if token.text == "true":
-                constant_node = Constant("BOOLEAN_CONSTANT", True)
+                constant_node = Constant(type_="BOOLEAN_CONSTANT", value=True, **token_info)
             elif token.text == "false":
-                constant_node = Constant("BOOLEAN_CONSTANT", False)
+                constant_node = Constant(type_="BOOLEAN_CONSTANT", value=False, **token_info)
             else:
                 raise NotImplementedError
 
         elif token.type == Parser.STRING_CONSTANT:
-            constant_node = Constant("STRING_CONSTANT", token.text[1:-1])
+            constant_node = Constant(type_="STRING_CONSTANT", value=token.text[1:-1], **token_info)
 
         elif token.type == Parser.NULL_CONSTANT:
-            constant_node = Constant("NULL_CONSTANT", None)
+            constant_node = Constant(type_="NULL_CONSTANT", value=None, **token_info)
 
         else:
             raise NotImplementedError
@@ -66,7 +68,8 @@ class Terminals(VtlVisitor):
     def visitVarID(self, ctx: Parser.VarIDContext):
         token = ctx.children[0].getSymbol()
         token.text = _remove_scaped_characters(token.text)
-        var_id_node = VarID(token.text)
+        token_info = extract_token_info(token)
+        var_id_node = VarID(value=token.text, **token_info)
         return var_id_node
 
     def visitVarIdExpr(self, ctx: Parser.VarIdExprContext):
@@ -76,7 +79,8 @@ class Terminals(VtlVisitor):
         token = ctx.children[0].getSymbol()
         # check token text
         token.text = _remove_scaped_characters(token.text)
-        var_id_node = VarID(token.text)
+        token_info = extract_token_info(token)
+        var_id_node = VarID(value=token.text, **token_info)
         return var_id_node
 
     def visitSimpleComponentId(self, ctx: Parser.SimpleComponentIdContext):
@@ -87,7 +91,7 @@ class Terminals(VtlVisitor):
         # check token text
         token.text = _remove_scaped_characters(token.text)
 
-        return Identifier(token.text, "ComponentID")
+        return Identifier(value=token.text, kind="ComponentID", **extract_token_info(ctx))
 
     def visitComponentID(self, ctx: Parser.ComponentIDContext):
         ctx_list = list(ctx.getChildren())
@@ -98,7 +102,11 @@ class Terminals(VtlVisitor):
                 "'"
             ):  # The component could be imbalance, errorcode or errorlevel
                 component_name = component_name[1:-1]
-            return Identifier(component_name, "ComponentID")
+            return Identifier(
+                value=component_name,
+                kind="ComponentID",
+                **extract_token_info(ctx_list[0].getSymbol()),
+            )
         else:
             component_name = ctx_list[2].getSymbol().text
             if component_name.startswith("'") and component_name.endswith(
@@ -107,9 +115,18 @@ class Terminals(VtlVisitor):
                 component_name = component_name[1:-1]
             op_node = ctx_list[1].getSymbol().text
             return BinOp(
-                left=Identifier(ctx_list[0].getSymbol().text, "DatasetID"),
+                left=Identifier(
+                    value=ctx_list[0].getSymbol().text,
+                    kind="DatasetID",
+                    **extract_token_info(ctx_list[0].getSymbol()),
+                ),
                 op=op_node,
-                right=Identifier(component_name, "ComponentID"),
+                right=Identifier(
+                    value=component_name,
+                    kind="ComponentID",
+                    **extract_token_info(ctx_list[1].getSymbol()),
+                ),
+                **extract_token_info(ctx),
             )
 
     def visitOperatorID(self, ctx: Parser.OperatorIDContext):
@@ -130,6 +147,7 @@ class Terminals(VtlVisitor):
             children=[],
             kind="ValueDomain",
             type="",
+            **extract_token_info(ctx),
         )
 
     def visitRulesetID(self, ctx: Parser.RulesetIDContext):
@@ -254,7 +272,9 @@ class Terminals(VtlVisitor):
         for scalar_with_cast in scalars_with_cast:
             scalar_nodes.append(self.visitScalarWithCast(scalar_with_cast))
 
-        return Collection("Set", None, scalar_nodes)
+        return Collection(
+            name="List", type="Lists", children=scalar_nodes, **extract_token_info(ctx)
+        )
 
     def visitMultModifier(self, ctx: Parser.MultModifierContext):
         """
@@ -508,12 +528,22 @@ class Terminals(VtlVisitor):
         const_node = self.visitConstant(ctx_list[2])
         basic_scalar_type = [self.visitBasicScalarType(ctx_list[4])]
 
-        param_node = [ParamConstant("PARAM_CAST", ctx_list[6])] if len(ctx_list) > 6 else []
+        param_node = (
+            [
+                ParamConstant(
+                    type_="PARAM_CAST", value=ctx_list[6], **extract_token_info(ctx_list[6])
+                )
+            ]
+            if len(ctx_list) > 6
+            else []
+        )
 
         if len(basic_scalar_type) == 1:
             children_nodes = [const_node, basic_scalar_type[0]]
 
-            return ParamOp(op=op, children=children_nodes, params=param_node)
+            return ParamOp(
+                op=op, children=children_nodes, params=param_node, **extract_token_info(ctx)
+            )
 
         else:
             # AST_ASTCONSTRUCTOR.14
@@ -536,14 +566,20 @@ class Terminals(VtlVisitor):
 
         if token.type == Parser.BOOLEAN_CONSTANT:
             if token.text == "true":
-                param_constant_node = Constant("BOOLEAN_CONSTANT", True)
+                param_constant_node = Constant(
+                    type_="BOOLEAN_CONSTANT", value=True, **extract_token_info(token)
+                )
             elif token.text == "false":
-                param_constant_node = Constant("BOOLEAN_CONSTANT", False)
+                param_constant_node = Constant(
+                    type_="BOOLEAN_CONSTANT", value=False, **extract_token_info(token)
+                )
             else:
                 raise NotImplementedError
 
         elif token.type == Parser.ALL:
-            param_constant_node = ParamConstant("PARAM_CONSTANT", token.text)
+            param_constant_node = ParamConstant(
+                type_="PARAM_CONSTANT", value=token.text, **extract_token_info(token)
+            )
 
         else:
             raise NotImplementedError
@@ -565,7 +601,7 @@ class Terminals(VtlVisitor):
         return ctx.children[0].getSymbol().text
 
     def visitSignedInteger(self, ctx: Parser.SignedIntegerContext):
-        return ctx.children[0].getSymbol().text
+        return int(ctx.children[0].getSymbol().text)
 
     def visitComparisonOperand(self, ctx: Parser.ComparisonOperandContext):
         return ctx.children[0].getSymbol().text
@@ -596,6 +632,7 @@ class Terminals(VtlVisitor):
         """
         VarID (AS alias)?
         """
+        token_info = extract_token_info(ctx)
 
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
@@ -605,10 +642,10 @@ class Terminals(VtlVisitor):
         alias_name = None
 
         if len(ctx_list) == 1:
-            return DPRIdentifier(value=node_name, kind=kind, alias=alias_name)
+            return DPRIdentifier(value=node_name, kind=kind, alias=alias_name, **token_info)
 
         alias_name = self.visitAlias(ctx_list[2])
-        return DPRIdentifier(value=node_name, kind=kind, alias=alias_name)
+        return DPRIdentifier(value=node_name, kind=kind, alias=alias_name, **token_info)
 
     """
         From Hierarchical
@@ -663,6 +700,8 @@ class Terminals(VtlVisitor):
 
         win_mode = ctx_list[0].getSymbol().text  # Windowing mode (data points | range )
 
+        token_info = extract_token_info(ctx)
+
         if win_mode == "data":
             num_rows_1, mode_1 = self.visitLimitClauseItem(ctx_list[3])
             num_rows_2, mode_2 = self.visitLimitClauseItem(ctx_list[5])
@@ -694,31 +733,36 @@ class Terminals(VtlVisitor):
 
         if mode_1 == mode_2:
             if mode_1 == "preceding" and first != -1 and second > first:  # 3 and 1: must be [-3:-1]
-                return create_windowing(win_mode, [second, first], [mode_2, mode_1])
+                return create_windowing(win_mode, [second, first], [mode_2, mode_1], token_info)
             if mode_1 == "preceding" and second == -1:
-                return create_windowing(win_mode, [second, first], [mode_2, mode_1])
+                return create_windowing(win_mode, [second, first], [mode_2, mode_1], token_info)
             if mode_1 == "following" and second != -1 and second < first:  # 3 and 1: must be [1:3]
-                return create_windowing(win_mode, [second, first], [mode_2, mode_1])
+                return create_windowing(win_mode, [second, first], [mode_2, mode_1], token_info)
             if mode_1 == "following" and first == -1:
-                return create_windowing(win_mode, [second, first], [mode_2, mode_1])
+                return create_windowing(win_mode, [second, first], [mode_2, mode_1], token_info)
 
-        return create_windowing(win_mode, [first, second], [mode_1, mode_2])
+        return create_windowing(win_mode, [first, second], [mode_1, mode_2], token_info)
 
     def visitOrderByItem(self, ctx: Parser.OrderByItemContext):
         ctx_list = list(ctx.getChildren())
 
+        token_info = extract_token_info(ctx)
+
         if len(ctx_list) == 1:
-            return OrderBy(component=self.visitComponentID(ctx_list[0]).value, order="asc")
+            return OrderBy(
+                component=self.visitComponentID(ctx_list[0]).value, order="asc", **token_info
+            )
 
         return OrderBy(
             component=self.visitComponentID(ctx_list[0]).value,
             order=ctx_list[1].getSymbol().text,
+            **token_info,
         )
 
     def visitLimitClauseItem(self, ctx: Parser.LimitClauseItemContext):
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
-        if c.getSymbol().text == "unbounded":
+        if c.getSymbol().text.lower() == "unbounded":
             result = -1
         elif c.getSymbol().text == "current":
             result = 0
@@ -733,12 +777,12 @@ class Terminals(VtlVisitor):
         return result, ctx_list[1].getSymbol().text
 
 
-def create_windowing(win_mode, values, modes):
+def create_windowing(win_mode, values, modes, token_info):
     for e in range(0, 2):
         if values[e] == -1:
-            values[e] = "UNBOUNDED"
+            values[e] = "unbounded"
         elif values[e] == 0:
-            values[e] = "CURRENT ROW"
+            values[e] = "current row"
 
     return Windowing(
         type_=win_mode,
@@ -746,4 +790,5 @@ def create_windowing(win_mode, values, modes):
         stop=values[1],
         start_mode=modes[0],
         stop_mode=modes[1],
+        **token_info,
     )