vtlengine 1.0.3rc3__py3-none-any.whl → 1.1__py3-none-any.whl

vtlengine/AST/ASTConstructorModules/Expr.py

@@ -20,6 +20,7 @@ from vtlengine.AST import (
     MulOp,
     ParamConstant,
     ParamOp,
+    ParFunction,
     RegularAggregation,
     RenameNode,
     TimeAggregation,
@@ -29,6 +30,7 @@ from vtlengine.AST import (
     VarID,
     Windowing,
 )
+from vtlengine.AST.ASTConstructorModules import extract_token_info
 from vtlengine.AST.ASTConstructorModules.ExprComponents import ExprComp
 from vtlengine.AST.ASTConstructorModules.Terminals import Terminals
 from vtlengine.AST.ASTDataExchange import de_ruleset_elements
@@ -45,7 +47,8 @@ class Expr(VtlVisitor):
 
                                 Expr Definition.
 
-    _______________________________________________________________________________________"""
+    _______________________________________________________________________________________
+    """
 
     def visitExpr(self, ctx: Parser.ExprContext):
         """
@@ -66,7 +69,7 @@ class Expr(VtlVisitor):
                | constant														        # constantExpr
                | varID															        # varIdExpr
         ;
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -115,13 +118,17 @@ class Expr(VtlVisitor):
             then_op_node = self.visitExpr(ctx_list[3])
             else_op_node = self.visitExpr(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
 
         # CASE WHEN expr THEN expr ELSE expr END                             # caseExpr
         elif isinstance(c, TerminalNodeImpl) and (c.getSymbol().type == Parser.CASE):
-
             if len(ctx_list) % 4 != 3:
                 raise ValueError("Syntax error.")
 
@@ -132,10 +139,12 @@ class Expr(VtlVisitor):
             for i in range(0, len(ctx_list), 4):
                 condition = self.visitExpr(ctx_list[i + 1])
                 thenOp = self.visitExpr(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
 
@@ -159,8 +168,8 @@ class Expr(VtlVisitor):
         else:
             op = ctx_list[1].getSymbol().text
         right_node = self.visitExpr(ctx_list[2])
-
-        bin_op_node = BinOp(left_node, op, right_node)
+        token_info = extract_token_info(ctx)
+        bin_op_node = BinOp(left=left_node, op=op, right=right_node, **token_info)
 
         return bin_op_node
 
@@ -184,7 +193,7 @@ class Expr(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
 
@@ -192,14 +201,15 @@ class Expr(VtlVisitor):
         return self.bin_op_creator(ctx)
 
     def visitParenthesisExpr(self, ctx: Parser.ParenthesisExprContext):
-        return self.visitExpr(list(ctx.getChildren())[1])
+        operand = self.visitExpr(list(ctx.getChildren())[1])
+        return ParFunction(operand=operand, **extract_token_info(ctx))
 
     def visitUnaryExpr(self, ctx: Parser.UnaryExprContext):
         c_list = list(ctx.getChildren())
         op = c_list[0].getSymbol().text
         right = self.visitExpr(c_list[1])
 
-        return UnaryOp(op, right)
+        return UnaryOp(op=op, operand=right, **extract_token_info(ctx))
 
     def visitMembershipExpr(self, ctx: Parser.MembershipExprContext):
         ctx_list = list(ctx.getChildren())
@@ -215,13 +225,15 @@ class Expr(VtlVisitor):
         # It is only possible to put a membership at the end so go the last one.
         if len(membership) != 0:
             previous_node = BinOp(
-                previous_node, "#", Terminals().visitSimpleComponentId(membership[0])
+                left=previous_node,
+                op="#",
+                right=Terminals().visitSimpleComponentId(membership[0]),
+                **extract_token_info(ctx),
             )
 
         return previous_node
 
     def visitClauseExpr(self, ctx: Parser.ClauseExprContext):
-
         ctx_list = list(ctx.getChildren())
 
         dataset = self.visitExpr(ctx_list[0])
@@ -317,8 +329,10 @@ class Expr(VtlVisitor):
 
         body_node = self.visitJoinBody(ctx_list[3])
 
+        token_info = extract_token_info(ctx)
+
         if len(body_node) != 0:
-            previous_node = JoinOp(op_node, clause_node, using_node)
+            previous_node = JoinOp(op=op_node, clauses=clause_node, using=using_node, **token_info)
             regular_aggregation = None
             for body in body_node:
                 regular_aggregation = body
@@ -331,7 +345,7 @@ class Expr(VtlVisitor):
             return regular_aggregation
 
         else:
-            join_node = JoinOp(op_node, clause_node, using_node)
+            join_node = JoinOp(op=op_node, clauses=clause_node, using=using_node, **token_info)
             join_node.isLast = True
             return join_node
 
@@ -341,13 +355,18 @@ class Expr(VtlVisitor):
         if len(ctx_list) == 1:
             return left_node
 
+        token_info = extract_token_info(ctx)
         intop_node = ctx_list[1].getSymbol().text
-        right_node = Identifier(Terminals().visitAlias(ctx_list[2]), "DatasetID")
-        return BinOp(left_node, intop_node, right_node)
+        right_node = Identifier(
+            value=Terminals().visitAlias(ctx_list[2]),
+            kind="DatasetID",
+            **extract_token_info(ctx_list[1].getSymbol()),
+        )
+        return BinOp(left=left_node, op=intop_node, right=right_node, **token_info)
 
     def visitJoinClause(self, ctx: Parser.JoinClauseContext):
         """
-        joinClauseItem (COMMA joinClauseItem)* (USING componentID (COMMA componentID)*)?
+        JoinClauseItem (COMMA joinClauseItem)* (USING componentID (COMMA componentID)*)?
         """
         ctx_list = list(ctx.getChildren())
 
@@ -373,7 +392,7 @@ class Expr(VtlVisitor):
     def visitJoinClauseWithoutUsing(self, ctx: Parser.JoinClauseWithoutUsingContext):
         """
         joinClause: joinClauseItem (COMMA joinClauseItem)* (USING componentID (COMMA componentID)*)? ;
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
 
         clause_nodes = []
@@ -388,7 +407,7 @@ class Expr(VtlVisitor):
     def visitJoinBody(self, ctx: Parser.JoinBodyContext):
         """
         joinBody: filterClause? (calcClause|joinApplyClause|aggrClause)? (keepOrDropClause)? renameClause?
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
 
         body_nodes = []
@@ -420,7 +439,7 @@ class Expr(VtlVisitor):
         op_node = ctx_list[0].getSymbol().text
         operand_nodes = [self.visitExpr(ctx_list[1])]
 
-        return RegularAggregation(op_node, operand_nodes)
+        return RegularAggregation(op=op_node, children=operand_nodes, **extract_token_info(ctx))
 
     """
                         -----------------------------------
@@ -452,12 +471,12 @@ class Expr(VtlVisitor):
             if isinstance(element, Parser.ParameterContext)
         ]
 
-        return UDOCall(op=op, params=param_nodes)
+        return UDOCall(op=op, params=param_nodes, **extract_token_info(ctx))
 
     def visitEvalAtom(self, ctx: Parser.EvalAtomContext):
         """
         | EVAL LPAREN routineName LPAREN (varID|scalarItem)? (COMMA (varID|scalarItem))* RPAREN (LANGUAGE STRING_CONSTANT)? (RETURNS evalDatasetType)? RPAREN     # evalAtom
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
 
         routine_name = Terminals().visitRoutineName(ctx_list[2])
@@ -500,12 +519,13 @@ class Expr(VtlVisitor):
             operands=children_nodes,
             output=output_node[0],
             language=language_name[0].getSymbol().text,
+            **extract_token_info(ctx),
         )
 
     def visitCastExprDataset(self, ctx: Parser.CastExprDatasetContext):
         """
         | CAST LPAREN expr COMMA (basicScalarType|valueDomainName) (COMMA STRING_CONSTANT)? RPAREN        # castExprDataset
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -529,7 +549,11 @@ class Expr(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
@@ -540,7 +564,9 @@ class Expr(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
@@ -553,7 +579,9 @@ class Expr(VtlVisitor):
         if isinstance(c, Parser.ExprContext):
             return self.visitExpr(c)
         elif isinstance(c, TerminalNodeImpl):
-            return ID("OPTIONAL", c.getSymbol().text)
+            return ID(
+                type_="OPTIONAL", value=c.getSymbol().text, **extract_token_info(c.getSymbol())
+            )
         else:
             raise NotImplementedError
 
@@ -582,7 +610,7 @@ class Expr(VtlVisitor):
         token = c.getSymbol()
         op_node = token.text
         operand_node = self.visitExpr(ctx_list[2])
-        return UnaryOp(op_node, operand_node)
+        return UnaryOp(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     def visitSubstrAtom(self, ctx: Parser.SubstrAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -603,7 +631,9 @@ class Expr(VtlVisitor):
             for param in params:
                 params_nodes.append(self.visitOptionalExpr(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 visitReplaceAtom(self, ctx: Parser.ReplaceAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -624,7 +654,9 @@ class Expr(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 visitInstrAtom(self, ctx: Parser.InstrAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -645,7 +677,9 @@ class Expr(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)
+        )
 
     """
                         -----------------------------------
@@ -670,7 +704,7 @@ class Expr(VtlVisitor):
         token = c.getSymbol()
         op_node = token.text
         operand_node = self.visitExpr(ctx_list[2])
-        return UnaryOp(op_node, operand_node)
+        return UnaryOp(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     def visitUnaryWithOptionalNumeric(self, ctx: Parser.UnaryWithOptionalNumericContext):
         ctx_list = list(ctx.getChildren())
@@ -691,7 +725,9 @@ class Expr(VtlVisitor):
             for param in params:
                 params_nodes.append(self.visitOptionalExpr(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 visitBinaryNumeric(self, ctx: Parser.BinaryNumericContext):
         ctx_list = list(ctx.getChildren())
@@ -702,7 +738,7 @@ class Expr(VtlVisitor):
         left_node = self.visitExpr(ctx_list[2])
         op_node = token.text
         right_node = self.visitExpr(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))
 
     """
                         -----------------------------------
@@ -735,7 +771,7 @@ class Expr(VtlVisitor):
         for children in childrens:
             children_nodes.append(self.visitExpr(children))
 
-        return MulOp(op_node, children_nodes)
+        return MulOp(op=op_node, children=children_nodes, **extract_token_info(ctx))
 
     def visitCharsetMatchAtom(self, ctx: Parser.CharsetMatchAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -745,7 +781,7 @@ class Expr(VtlVisitor):
         left_node = self.visitExpr(ctx_list[2])
         op_node = token.text
         right_node = self.visitExpr(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 visitIsNullAtom(self, ctx: Parser.IsNullAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -753,7 +789,7 @@ class Expr(VtlVisitor):
         token = c.getSymbol()
         op_node = token.text
         operand_node = self.visitExpr(ctx_list[2])
-        return UnaryOp(op_node, operand_node)
+        return UnaryOp(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     def visitExistInAtom(self, ctx: Parser.ExistInAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -769,7 +805,7 @@ class Expr(VtlVisitor):
             if isinstance(retain, Parser.RetainTypeContext)
         ]
 
-        return MulOp(op=op, children=operand_nodes + retain_nodes)
+        return MulOp(op=op, children=operand_nodes + retain_nodes, **extract_token_info(ctx))
 
     """
                             -----------------------------------
@@ -795,15 +831,19 @@ class Expr(VtlVisitor):
             return self.visitTimeDiffAtom(ctx)
         elif isinstance(ctx, Parser.DateAddAtomContext):
             return self.visitTimeAddAtom(ctx)
-        elif isinstance(ctx, (Parser.YearAtomContext,
-                              Parser.MonthAtomContext,
-                              Parser.DayOfMonthAtomContext,
-                              Parser.DayOfYearAtomContext,
-                              Parser.DayToYearAtomContext,
-                              Parser.DayToMonthAtomContext,
-                              Parser.YearTodayAtomContext,
-                              Parser.MonthTodayAtomContext)):
-
+        elif isinstance(
+            ctx,
+            (
+                Parser.YearAtomContext,
+                Parser.MonthAtomContext,
+                Parser.DayOfMonthAtomContext,
+                Parser.DayOfYearAtomContext,
+                Parser.DayToYearAtomContext,
+                Parser.DayToMonthAtomContext,
+                Parser.YearTodayAtomContext,
+                Parser.MonthTodayAtomContext,
+            ),
+        ):
             return self.visitTimeUnaryAtom(ctx)
         else:
             raise NotImplementedError
@@ -823,27 +863,7 @@ class Expr(VtlVisitor):
             # AST_ASTCONSTRUCTOR.15
             raise NotImplementedError
 
-        return UnaryOp(op=op, operand=operand_node[0])
-
-    # def visitPeriodAtom(self, ctx: Parser.PeriodAtomContext):
-    #     """
-    #     periodExpr: PERIOD_INDICATOR '(' expr? ')' ;
-    #     """
-    #     ctx_list = list(ctx.getChildren())
-    #     c = ctx_list[0]
-    #
-    #     op = c.getSymbol().text
-    #     operand_node = [
-    #         self.visitExpr(operand)
-    #         for operand in ctx_list
-    #         if isinstance(operand, Parser.ExprContext)
-    #     ]
-    #
-    #     if len(operand_node) == 0:
-    #         # 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 visitTimeShiftAtom(self, ctx: Parser.TimeShiftAtomContext):
         """
@@ -854,9 +874,13 @@ class Expr(VtlVisitor):
 
         op = c.getSymbol().text
         left_node = self.visitExpr(ctx_list[2])
-        right_node = Constant("INTEGER_CONSTANT", Terminals().visitSignedInteger(ctx_list[4]))
+        right_node = Constant(
+            type_="INTEGER_CONSTANT",
+            value=Terminals().visitSignedInteger(ctx_list[4]),
+            **extract_token_info(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 visitFillTimeAtom(self, ctx: Parser.FillTimeAtomContext):
         """
@@ -869,16 +893,24 @@ class Expr(VtlVisitor):
         children_node = [self.visitExpr(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_list[4].getSymbol()),
+                )
+            ]
         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 visitTimeAggAtom(self, ctx: Parser.TimeAggAtomContext):
         """
         TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? (COMMA op=optionalExpr)? (COMMA (FIRST|LAST))? RPAREN     # timeAggAtom
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -903,7 +935,7 @@ class Expr(VtlVisitor):
             if isinstance(operand_node, ID):
                 operand_node = None
             elif isinstance(operand_node, Identifier):
-                operand_node = VarID(operand_node.value)
+                operand_node = VarID(value=operand_node.value, **extract_token_info(ctx))
         else:
             operand_node = None
 
@@ -911,7 +943,12 @@ class Expr(VtlVisitor):
             # AST_ASTCONSTRUCTOR.17
             raise Exception("Optional as expression node is not allowed in Time Aggregation")
         return TimeAggregation(
-            op=op, operand=operand_node, period_to=period_to, period_from=period_from, conf=conf
+            op=op,
+            operand=operand_node,
+            period_to=period_to,
+            period_from=period_from,
+            conf=conf,
+            **extract_token_info(ctx),
         )
 
     def visitFlowAtom(self, ctx: Parser.FlowAtomContext):
@@ -919,11 +956,11 @@ class Expr(VtlVisitor):
 
         op_node = ctx_list[0].getSymbol().text
         operand_node = self.visitExpr(ctx_list[2])
-        return UnaryOp(op_node, operand_node)
+        return UnaryOp(op=op_node, operand=operand_node, **extract_token_info(ctx))
 
     def visitCurrentDateAtom(self, ctx: Parser.CurrentDateAtomContext):
         c = list(ctx.getChildren())[0]
-        return MulOp(op=c.getSymbol().text, children=[])
+        return MulOp(op=c.getSymbol().text, children=[], **extract_token_info(ctx))
 
     def visitTimeDiffAtom(self, ctx: Parser.TimeShiftAtomContext):
         """ """
@@ -934,7 +971,7 @@ class Expr(VtlVisitor):
         left_node = self.visitExpr(ctx_list[2])
         right_node = self.visitExpr(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 visitTimeAddAtom(self, ctx: Parser.TimeShiftAtomContext):
         """ """
@@ -952,7 +989,9 @@ class Expr(VtlVisitor):
             if len(ctx_list) > 6:
                 param_constant_node.append(self.visitExpr(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)
+        )
 
     """
                             -----------------------------------
@@ -975,7 +1014,7 @@ class Expr(VtlVisitor):
         left_node = self.visitExpr(ctx_list[2])
         op_node = token.text
         right_node = self.visitExpr(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))
 
     """
                             -----------------------------------
@@ -988,7 +1027,7 @@ class Expr(VtlVisitor):
         setExpr:     UNION LPAREN left=expr (COMMA expr)+ RPAREN                             # unionAtom
                     | INTERSECT LPAREN left=expr (COMMA expr)+ RPAREN                       # intersectAtom
                     | op=(SETDIFF|SYMDIFF) LPAREN left=expr COMMA right=expr RPAREN         # setOrSYmDiffAtom
-        """ # noqa E501
+        """  # noqa E501
         if isinstance(ctx, Parser.UnionAtomContext):
             return self.visitUnionAtom(ctx)
         elif isinstance(ctx, Parser.IntersectAtomContext):
@@ -1004,7 +1043,9 @@ class Expr(VtlVisitor):
             self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
         ]
 
-        return MulOp(ctx_list[0].getSymbol().text, exprs_nodes)
+        return MulOp(
+            op=ctx_list[0].getSymbol().text, children=exprs_nodes, **extract_token_info(ctx)
+        )
 
     def visitIntersectAtom(self, ctx: Parser.IntersectAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -1012,7 +1053,9 @@ class Expr(VtlVisitor):
             self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
         ]
 
-        return MulOp(op=ctx_list[0].getSymbol().text, children=exprs_nodes)
+        return MulOp(
+            op=ctx_list[0].getSymbol().text, children=exprs_nodes, **extract_token_info(ctx)
+        )
 
     def visitSetOrSYmDiffAtom(self, ctx: Parser.SetOrSYmDiffAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -1020,7 +1063,9 @@ class Expr(VtlVisitor):
             self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
         ]
 
-        return MulOp(op=ctx_list[0].getSymbol().text, children=exprs_nodes)
+        return MulOp(
+            op=ctx_list[0].getSymbol().text, children=exprs_nodes, **extract_token_info(ctx)
+        )
 
     """
                             -----------------------------------
@@ -1031,19 +1076,24 @@ class Expr(VtlVisitor):
     def visitHierarchyFunctions(self, ctx: Parser.HierarchyFunctionsContext):
         """
         HIERARCHY LPAREN op=expr COMMA hrName=IDENTIFIER (conditionClause)? (RULE ruleComponent=componentID)? (validationMode)? (inputModeHierarchy)? outputModeHierarchy? RPAREN
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
         op = c.getSymbol().text
         dataset_node = self.visitExpr(ctx_list[2])
-        rule_name_node = Identifier(value=ctx_list[4].getSymbol().text, kind="RuleID")
+        rule_name_node = Identifier(
+            value=ctx_list[4].getSymbol().text,
+            kind="RuleID",
+            **extract_token_info(ctx_list[4].getSymbol()),
+        )
 
         conditions = []
         modes = "non_null"
         inputs = "rule"
         retains = "computed"
         rule_comp = None
+
         for c in ctx_list:
             if isinstance(c, Parser.ConditionClauseContext):
                 conditions.append(Terminals().visitConditionClause(c))
@@ -1064,9 +1114,15 @@ class Expr(VtlVisitor):
             raise NotImplementedError("Dataset Priority input mode on HR is not implemented")
         param_constant_node = []
 
-        param_constant_node.append(ParamConstant("PARAM_MODE", modes))
-        param_constant_node.append(ParamConstant("PARAM_INPUT", inputs))
-        param_constant_node.append(ParamConstant("PARAM_OUTPUT", retains))
+        param_constant_node.append(
+            ParamConstant(type_="PARAM_MODE", value=modes, **extract_token_info(ctx))
+        )
+        param_constant_node.append(
+            ParamConstant(type_="PARAM_INPUT", value=inputs, **extract_token_info(ctx))
+        )
+        param_constant_node.append(
+            ParamConstant(type_="PARAM_OUTPUT", value=retains, **extract_token_info(ctx))
+        )
 
         if not rule_comp:
             if isinstance(de_ruleset_elements[rule_name_node.value], list):
@@ -1075,7 +1131,9 @@ class Expr(VtlVisitor):
                 rule_element = de_ruleset_elements[rule_name_node.value]
             if rule_element.kind == "DatasetID":
                 check_hierarchy_rule = rule_element.value
-                rule_comp = Identifier(check_hierarchy_rule, "ComponentID")
+                rule_comp = Identifier(
+                    value=check_hierarchy_rule, kind="ComponentID", **extract_token_info(ctx)
+                )
             else:  # ValuedomainID
                 raise SemanticError("1-1-10-4", op=op)
 
@@ -1083,6 +1141,7 @@ class Expr(VtlVisitor):
             op=op,
             children=[dataset_node, rule_comp, rule_name_node, *conditions],
             params=param_constant_node,
+            **extract_token_info(ctx),
         )
 
     """
@@ -1102,7 +1161,7 @@ class Expr(VtlVisitor):
     def visitValidateDPruleset(self, ctx: Parser.ValidateDPrulesetContext):
         """
         validationDatapoint: CHECK_DATAPOINT '(' expr ',' IDENTIFIER (COMPONENTS componentID (',' componentID)*)? (INVALID|ALL_MEASURES|ALL)? ')' ;
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -1131,13 +1190,18 @@ class Expr(VtlVisitor):
         if isinstance(ctx_list[-2], Parser.ValidationOutputContext):
             output = Terminals().visitValidationOutput(ctx_list[-2])
 
-        return ParamOp(op=op, children=[operand_node, rule_name, *components], params=[output])
+        return ParamOp(
+            op=op,
+            children=[operand_node, rule_name, *components],
+            params=[output],
+            **extract_token_info(ctx),
+        )
 
     # TODO Not fully implemented only basic usage available.
     def visitValidateHRruleset(self, ctx: Parser.ValidateHRrulesetContext):
         """
         CHECK_HIERARCHY LPAREN op=expr COMMA hrName=IDENTIFIER conditionClause? (RULE componentID)? validationMode? inputMode? validationOutput? RPAREN     # validateHRruleset
-        """ # noqa E501
+        """  # noqa E501
 
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
@@ -1145,7 +1209,11 @@ class Expr(VtlVisitor):
         op = c.getSymbol().text
 
         dataset_node = self.visitExpr(ctx_list[2])
-        rule_name_node = Identifier(value=ctx_list[4].getSymbol().text, kind="RuleID")
+        rule_name_node = Identifier(
+            value=ctx_list[4].getSymbol().text,
+            kind="RuleID",
+            **extract_token_info(ctx_list[4].getSymbol()),
+        )
 
         conditions = []
         # Default values
@@ -1153,6 +1221,7 @@ class Expr(VtlVisitor):
         inputs = "dataset"
         retains = "invalid"
         rule_comp = None
+
         for c in ctx_list:
             if isinstance(c, Parser.ConditionClauseContext):
                 conditions.append(Terminals().visitConditionClause(c))
@@ -1174,9 +1243,15 @@ class Expr(VtlVisitor):
         if inputs == DATASET_PRIORITY:
             raise NotImplementedError("Dataset Priority input mode on HR is not implemented")
 
-        param_constant_node.append(ParamConstant("PARAM_MODE", modes))
-        param_constant_node.append(ParamConstant("PARAM_INPUT", inputs))
-        param_constant_node.append(ParamConstant("PARAM_OUTPUT", retains))
+        param_constant_node.append(
+            ParamConstant(type_="PARAM_MODE", value=modes, **extract_token_info(ctx))
+        )
+        param_constant_node.append(
+            ParamConstant(type_="PARAM_INPUT", value=inputs, **extract_token_info(ctx))
+        )
+        param_constant_node.append(
+            ParamConstant(type_="PARAM_OUTPUT", value=retains, **extract_token_info(ctx))
+        )
 
         if not rule_comp:
             if isinstance(de_ruleset_elements[rule_name_node.value], list):
@@ -1186,7 +1261,11 @@ class Expr(VtlVisitor):
 
             if rule_element.kind == "DatasetID":
                 check_hierarchy_rule = rule_element.value
-                rule_comp = Identifier(check_hierarchy_rule, "ComponentID")
+                rule_comp = Identifier(
+                    value=check_hierarchy_rule,
+                    kind="ComponentID",
+                    **extract_token_info(ctx),
+                )
             else:  # ValuedomainID
                 raise SemanticError("1-1-10-4", op=op)
 
@@ -1194,12 +1273,13 @@ class Expr(VtlVisitor):
             op=op,
             children=[dataset_node, rule_comp, rule_name_node, *conditions],
             params=param_constant_node,
+            **extract_token_info(ctx),
         )
 
     def visitValidationSimple(self, ctx: Parser.ValidationSimpleContext):
         """
         | CHECK LPAREN op=expr (codeErr=erCode)? (levelCode=erLevel)? imbalanceExpr?  output=(INVALID|ALL)? RPAREN	        # validationSimple
-        """ # noqa E501
+        """  # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
         token = c.getSymbol()
@@ -1227,6 +1307,7 @@ class Expr(VtlVisitor):
             error_level=error_level,
             imbalance=inbalance_node,
             invalid=invalid_value,
+            **extract_token_info(ctx),
         )
 
     def visitImbalanceExpr(self, ctx: Parser.ImbalanceExprContext):
@@ -1286,6 +1367,7 @@ class Expr(VtlVisitor):
             grouping_op=grouping_op,
             grouping=group_node,
             having_clause=have_node,
+            **extract_token_info(ctx),
         )
 
     """
@@ -1331,11 +1413,21 @@ class Expr(VtlVisitor):
 
         if window is None:
             window = Windowing(
-                type_="data", start=-1, stop=0, start_mode="preceding", stop_mode="current"
+                type_="data",
+                start=-1,
+                stop=0,
+                start_mode="preceding",
+                stop_mode="current",
+                **extract_token_info(ctx),
             )
 
         return Analytic(
-            op=op_node, operand=operand, partition_by=partition_by, order_by=order_by, window=window
+            op=op_node,
+            operand=operand,
+            partition_by=partition_by,
+            order_by=order_by,
+            window=window,
+            **extract_token_info(ctx),
         )
 
     def visitLagOrLeadAn(self, ctx: Parser.LagOrLeadAnContext):
@@ -1369,7 +1461,12 @@ class Expr(VtlVisitor):
             raise Exception(f"{op_node} requires an offset parameter.")
 
         return Analytic(
-            op=op_node, operand=operand, partition_by=partition_by, order_by=order_by, params=params
+            op=op_node,
+            operand=operand,
+            partition_by=partition_by,
+            order_by=order_by,
+            params=params,
+            **extract_token_info(ctx),
         )
 
     def visitRatioToReportAn(self, ctx: Parser.RatioToReportAnContext):
@@ -1383,7 +1480,13 @@ class Expr(VtlVisitor):
 
         partition_by = Terminals().visitPartitionByClause(ctx_list[5])
 
-        return Analytic(op=op_node, operand=operand, partition_by=partition_by, order_by=order_by)
+        return Analytic(
+            op=op_node,
+            operand=operand,
+            partition_by=partition_by,
+            order_by=order_by,
+            **extract_token_info(ctx),
+        )
 
     """______________________________________________________________________________________
 
@@ -1459,7 +1562,9 @@ class Expr(VtlVisitor):
         for ctx_rename in renames:
             rename_nodes.append(self.visitRenameClauseItem(ctx_rename))
 
-        return RegularAggregation(op=ctx_list[0].getSymbol().text, children=rename_nodes)
+        return RegularAggregation(
+            op=ctx_list[0].getSymbol().text, children=rename_nodes, **extract_token_info(ctx)
+        )
 
     def visitRenameClauseItem(self, ctx: Parser.RenameClauseItemContext):
         """
@@ -1475,7 +1580,7 @@ class Expr(VtlVisitor):
 
         right_node = Terminals().visitVarID(ctx_list[2]).value
 
-        return RenameNode(left_node, right_node)
+        return RenameNode(old_name=left_node, new_name=right_node, **extract_token_info(ctx))
 
     """
                     -----------------------------------
@@ -1523,7 +1628,7 @@ class Expr(VtlVisitor):
         # Cannot find another way with less lines of code
         left_node.role = role
 
-        return Assignment(left_node, op_node, right_node)
+        return Assignment(left=left_node, op=op_node, right=right_node, **extract_token_info(ctx))
 
     def visitAggrClause(self, ctx: Parser.AggrClauseContext):
         """
@@ -1556,10 +1661,11 @@ class Expr(VtlVisitor):
                 grouping_op=grouping_op,
                 grouping=group_node,
                 having_clause=have_node,
+                **extract_token_info(ctx_list[1]),
             )
             children.append(copy(element))
 
-        return RegularAggregation(op=op_node, children=children)
+        return RegularAggregation(op=op_node, children=children, **extract_token_info(ctx))
 
     def visitGroupingClause(self, ctx: Parser.GroupingClauseContext):
         """
@@ -1613,7 +1719,9 @@ class Expr(VtlVisitor):
         else:
             raise NotImplementedError
 
-        return ParamOp(op=op_node, children=None, params=param_nodes), expr
+        return ParamOp(
+            op=op_node, children=None, params=param_nodes, **extract_token_info(ctx)
+        ), expr
 
     def visitGroupByOrExcept(self, ctx: Parser.GroupByOrExceptContext):
         ctx_list = list(ctx.getChildren())
@@ -1661,7 +1769,7 @@ class Expr(VtlVisitor):
         operand_nodes = []
         operand_nodes.append(ExprComp().visitExprComponent(ctx_list[1]))
 
-        return RegularAggregation(op_node, operand_nodes)
+        return RegularAggregation(op=op_node, children=operand_nodes, **extract_token_info(ctx))
 
     """
                     -----------------------------------
@@ -1688,7 +1796,9 @@ class Expr(VtlVisitor):
             result = self.visitCalcClauseItem(calcClauseItem)
             calcClauseItems_nodes.append(result)
 
-        return RegularAggregation(op_node, calcClauseItems_nodes)
+        return RegularAggregation(
+            op=op_node, children=calcClauseItems_nodes, **extract_token_info(ctx)
+        )
 
     def visitCalcClauseItem(self, ctx: Parser.CalcClauseItemContext):
         """
@@ -1703,17 +1813,25 @@ class Expr(VtlVisitor):
             left_node = Terminals().visitComponentID(ctx_list[1])
             op_node = ":="
             right_node = ExprComp().visitExprComponent(ctx_list[3])
-            operand_node = Assignment(left_node, op_node, right_node)
+            operand_node = Assignment(
+                left=left_node, op=op_node, right=right_node, **extract_token_info(ctx)
+            )
             if role is None:
-                return UnaryOp(Role.MEASURE.value.lower(), operand_node)
-            return UnaryOp(role.value.lower(), operand_node)
+                return UnaryOp(
+                    op=Role.MEASURE.value.lower(), operand=operand_node, **extract_token_info(c)
+                )
+            return UnaryOp(op=role.value.lower(), operand=operand_node, **extract_token_info(c))
         else:
             left_node = Terminals().visitSimpleComponentId(c)
             op_node = ":="
             right_node = ExprComp().visitExprComponent(ctx_list[2])
 
-            operand_node = Assignment(left_node, op_node, right_node)
-            return UnaryOp(Role.MEASURE.value.lower(), operand_node)
+            operand_node = Assignment(
+                left=left_node, op=op_node, right=right_node, **extract_token_info(ctx)
+            )
+            return UnaryOp(
+                op=Role.MEASURE.value.lower(), operand=operand_node, **extract_token_info(ctx)
+            )
 
     def visitKeepOrDropClause(self, ctx: Parser.KeepOrDropClauseContext):
         """
@@ -1730,7 +1848,7 @@ class Expr(VtlVisitor):
         for item in items:
             nodes.append(Terminals().visitComponentID(item))
 
-        return RegularAggregation(op_node, nodes)
+        return RegularAggregation(op=op_node, children=nodes, **extract_token_info(ctx))
 
     """
                     -----------------------------------
@@ -1751,7 +1869,7 @@ class Expr(VtlVisitor):
         children_nodes.append(Terminals().visitComponentID(ctx_list[1]))
         children_nodes.append(Terminals().visitComponentID(ctx_list[3]))
 
-        return RegularAggregation(op_node, children_nodes)
+        return RegularAggregation(op=op_node, children=children_nodes, **extract_token_info(ctx))
 
     """
                     -----------------------------------
@@ -1776,7 +1894,7 @@ class Expr(VtlVisitor):
             subspace_nodes.append(self.visitSubspaceClauseItem(subspace))
 
         op_node = c.getSymbol().text
-        return RegularAggregation(op_node, subspace_nodes)
+        return RegularAggregation(op=op_node, children=subspace_nodes, **extract_token_info(ctx))
 
     def visitSubspaceClauseItem(self, ctx: Parser.SubspaceClauseItemContext):
         ctx_list = list(ctx.getChildren())
@@ -1784,7 +1902,7 @@ class Expr(VtlVisitor):
         left_node = Terminals().visitVarID(ctx_list[0])
         op_node = ctx_list[1].getSymbol().text
         right_node = Terminals().visitScalarItem(ctx_list[2])
-        return BinOp(left_node, op_node, right_node)
+        return BinOp(left=left_node, op=op_node, right=right_node, **extract_token_info(ctx))
 
     def visitOptionalExpr(self, ctx: Parser.OptionalExprContext):
         """
@@ -1800,4 +1918,4 @@ class Expr(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))