vtlengine 1.1rc2__py3-none-any.whl → 1.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
@@ -116,7 +118,12 @@ 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
 
@@ -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,7 +225,10 @@ 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
@@ -316,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
@@ -330,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
 
@@ -340,9 +355,14 @@ 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):
         """
@@ -419,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))
 
     """
                         -----------------------------------
@@ -451,7 +471,7 @@ 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):
         """
@@ -499,6 +519,7 @@ 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):
@@ -528,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
@@ -539,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
@@ -552,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
 
@@ -581,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())
@@ -602,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())
@@ -623,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())
@@ -644,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)
+        )
 
     """
                         -----------------------------------
@@ -669,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())
@@ -690,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())
@@ -701,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))
 
     """
                         -----------------------------------
@@ -734,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())
@@ -744,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())
@@ -752,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())
@@ -768,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))
 
     """
                             -----------------------------------
@@ -826,7 +863,7 @@ class Expr(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 visitTimeShiftAtom(self, ctx: Parser.TimeShiftAtomContext):
         """
@@ -837,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):
         """
@@ -852,11 +893,19 @@ 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):
         """
@@ -886,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
 
@@ -899,6 +948,7 @@ class Expr(VtlVisitor):
             period_to=period_to,
             period_from=period_from,
             conf=conf,
+            **extract_token_info(ctx),
         )
 
     def visitFlowAtom(self, ctx: Parser.FlowAtomContext):
@@ -906,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):
         """ """
@@ -921,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):
         """ """
@@ -939,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)
+        )
 
     """
                             -----------------------------------
@@ -962,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))
 
     """
                             -----------------------------------
@@ -991,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())
@@ -999,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())
@@ -1007,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)
+        )
 
     """
                             -----------------------------------
@@ -1024,13 +1082,18 @@ 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 = []
         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))
@@ -1051,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):
@@ -1062,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)
 
@@ -1070,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),
         )
 
     """
@@ -1118,7 +1190,12 @@ 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):
@@ -1132,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
@@ -1140,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))
@@ -1161,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):
@@ -1173,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)
 
@@ -1181,6 +1273,7 @@ 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):
@@ -1214,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):
@@ -1273,6 +1367,7 @@ class Expr(VtlVisitor):
             grouping_op=grouping_op,
             grouping=group_node,
             having_clause=have_node,
+            **extract_token_info(ctx),
         )
 
     """
@@ -1323,6 +1418,7 @@ class Expr(VtlVisitor):
                 stop=0,
                 start_mode="preceding",
                 stop_mode="current",
+                **extract_token_info(ctx),
             )
 
         return Analytic(
@@ -1331,6 +1427,7 @@ class Expr(VtlVisitor):
             partition_by=partition_by,
             order_by=order_by,
             window=window,
+            **extract_token_info(ctx),
         )
 
     def visitLagOrLeadAn(self, ctx: Parser.LagOrLeadAnContext):
@@ -1369,6 +1466,7 @@ class Expr(VtlVisitor):
             partition_by=partition_by,
             order_by=order_by,
             params=params,
+            **extract_token_info(ctx),
         )
 
     def visitRatioToReportAn(self, ctx: Parser.RatioToReportAnContext):
@@ -1382,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),
+        )
 
     """______________________________________________________________________________________
 
@@ -1458,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):
         """
@@ -1474,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))
 
     """
                     -----------------------------------
@@ -1522,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):
         """
@@ -1555,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):
         """
@@ -1612,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())
@@ -1660,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))
 
     """
                     -----------------------------------
@@ -1687,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):
         """
@@ -1702,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):
         """
@@ -1729,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))
 
     """
                     -----------------------------------
@@ -1750,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))
 
     """
                     -----------------------------------
@@ -1775,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())
@@ -1783,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):
         """
@@ -1799,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))