jaseci 1.4.0.18__py3-none-any.whl → 1.4.0.20__py3-none-any.whl

jaseci/jac/interpreter/interp.py

@@ -10,7 +10,6 @@ from jaseci.utils.utils import is_jsonable, parse_str_token, uuid_re
 from jaseci.prim.element import Element
 from jaseci.prim.node import Node
 from jaseci.prim.edge import Edge
-from jaseci.prim.action import Action
 from jaseci.jac.jac_set import JacSet
 from jaseci.jac.ir.jac_code import jac_ast_to_ir, jac_ir_to_ast
 from jaseci.jac.machine.jac_scope import JacScope
@@ -20,6 +19,7 @@ from jaseci.jac.machine.machine_state import TryException
 from jaseci.jac.machine.jac_value import JacValue
 from jaseci.jac.machine.jac_value import jac_elem_unwrap as jeu
 from jaseci.jac.machine.jac_value import jac_wrap_value as jwv
+from json import dumps, loads
 from copy import copy, deepcopy
 from base64 import b64decode
 from itertools import pairwise
@@ -30,114 +30,6 @@ from jaseci.jac.jsci_vm.op_codes import JsCmp
 class Interp(VirtualMachine):
     """Shared interpreter class across both sentinels and walkers"""
 
-    def run_attr_stmt(self, jac_ast, obj):
-        """
-        attr_stmt: has_stmt | can_stmt;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        if kid[0].name == "has_stmt":
-            self.run_has_stmt(kid[0], obj)
-        #  Can statements in architype handled in architype load
-
-    def run_has_stmt(self, jac_ast, obj):
-        """
-        has_stmt: KW_HAS has_assign (COMMA has_assign)* SEMI;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        for i in kid:
-            if i.name == "has_assign":
-                self.run_has_assign(i, obj)
-
-    def run_has_assign(self, jac_ast, obj):
-        """
-        has_assign: KW_PRIVATE? KW_ANCHOR? (NAME | NAME EQ expression);
-        """
-        kid = self.set_cur_ast(jac_ast)
-        while kid[0].name in ["KW_PRIVATE", "KW_ANCHOR"]:
-            kid = kid[1:]
-        var_name = kid[0].token_text()
-        var_val = None  # jac's null
-        if len(kid) > 1:
-            self.run_expression(kid[2])
-            var_val = self.pop().value
-        if isinstance(obj, dict):
-            obj[var_name] = var_val
-        # Runs only once for walkers
-        elif var_name not in obj.context.keys() or obj.j_type != "walker":
-            JacValue(
-                self, ctx=obj, name=var_name, value=var_val, create_mode=True
-            ).write(kid[0], force=True)
-
-    def run_can_stmt(self, jac_ast, obj):
-        """
-        can_stmt:
-            KW_CAN dotted_name (preset_in_out event_clause)? (
-                COMMA dotted_name (preset_in_out event_clause)?
-            )* SEMI
-            | KW_CAN NAME event_clause? code_block;
-        """
-        kid = self.set_cur_ast(jac_ast)
-        kid = kid[1:]
-        while True:
-            action_type = "activity"
-            access_list = None
-            preset_in_out = None
-            if kid[0].name == "NAME":
-                action_name = kid[0].token_text()
-            else:
-                action_name = self.run_dotted_name(kid[0])
-            kid = kid[1:]
-            if len(kid) > 0 and kid[0].name == "preset_in_out":
-                preset_in_out = jac_ast_to_ir(kid[0])
-                kid = kid[1:]
-            if len(kid) > 0 and kid[0].name == "event_clause":
-                action_type, access_list = self.run_event_clause(kid[0])
-                kid = kid[1:]
-            # if (not isinstance(obj, node) and action_type != 'activity'):
-            #     self.rt_warn(
-            #         "Only nodes has on entry/exit, treating as activity",
-            #         kid[0])
-            #     action_type = 'activity'
-            if kid[0].name == "code_block":
-                act = Action(
-                    m_id=self._m_id,
-                    h=self._h,
-                    name=action_name,
-                    value=jac_ast_to_ir(kid[0]),
-                    preset_in_out=preset_in_out,
-                    access_list=access_list,
-                )
-                getattr(obj, f"{action_type}_action_ids").add_obj(act)
-                self._jac_scope.add_action(act)
-                break
-            else:
-                self.check_builtin_action(action_name, jac_ast)
-                act = Action(
-                    m_id=self._m_id,
-                    h=self._h,
-                    name=action_name,
-                    value=action_name,
-                    preset_in_out=preset_in_out,
-                    access_list=access_list,
-                )
-                getattr(obj, f"{action_type}_action_ids").add_obj(act)
-                self._jac_scope.add_action(act)
-            if not len(kid) or kid[0].name != "COMMA":
-                break
-            else:
-                kid = kid[1:]
-
-    def run_event_clause(self, jac_ast):
-        """
-        event_clause:
-                KW_WITH name_list? (KW_ENTRY | KW_EXIT | KW_ACTIVITY);
-        """
-        kid = self.set_cur_ast(jac_ast)
-        nl = []
-        if kid[1].name == "name_list":
-            nl = self.run_name_list(kid[1])
-        return kid[-1].token_text(), nl
-
     def run_dotted_name(self, jac_ast):
         """
         dotted_name: NAME (DOT NAME)*;
@@ -761,7 +653,7 @@ class Interp(VirtualMachine):
             | dict_val
             | LPAREN expression RPAREN
             | ability_op NAME spawn_ctx?
-            | atom atom_trailer+
+            | atom atom_trailer
             | KW_SYNC atom
             | spawn
             | ref
@@ -787,7 +679,11 @@ class Interp(VirtualMachine):
             elif kid[0].name == "LPAREN":
                 self.run_expression(kid[1])
             elif kid[0].name == "ability_op":
-                self.push(self.run_atom_trailer(jac_ast, None))
+                self.push(
+                    self.run_ability_call(
+                        jac_ast, atom_res=JacValue(self, value=self._jac_scope.has_obj)
+                    )
+                )
             elif kid[0].name == "atom":
                 self.run_atom(kid[0])
                 ret = self.pop()
@@ -819,13 +715,10 @@ class Interp(VirtualMachine):
             DOT built_in
             | DOT NAME
             | index_slice
-            | LPAREN param_list? RPAREN
-            | ability_op NAME spawn_ctx?;
+            | ability_call;
         """
         try:
             kid = self.set_cur_ast(jac_ast)
-            if atom_res is None:
-                atom_res = JacValue(self, value=self._jac_scope.has_obj)
             if isinstance(atom_res.value, Element):
                 self._write_candidate = atom_res.value
             if kid[0].name == "DOT":
@@ -857,28 +750,40 @@ class Interp(VirtualMachine):
                 if not self.rt_check_type(atom_res.value, [list, str, dict], kid[0]):
                     return atom_res
                 return self.run_index_slice(kid[0], atom_res)
-            elif kid[0].name == "LPAREN":
-                param_list = {"args": [], "kwargs": {}}
-                if kid[1].name == "param_list":
-                    param_list = self.run_param_list(kid[1]).value
-                if isinstance(atom_res.value, Action):
-                    ret = atom_res.value.trigger(param_list, self._jac_scope, self)
-                    return JacValue(self, value=ret)
-                else:
-                    self.rt_error("Unable to execute ability", kid[0])
-            elif kid[0].name == "ability_op":
-                arch = self.run_ability_op(kid[0], atom_res)
-                if len(kid) > 2:
-                    self.run_spawn_ctx(kid[2], atom_res.value)
-                self.call_ability(
-                    nd=atom_res.value,
-                    name=kid[1].token_text(),
-                    act_list=arch.get_all_actions(),
-                )
-                return atom_res
+            elif kid[0].name == "ability_call":
+                return self.run_ability_call(kid[0], atom_res)
         except Exception as e:
             self.jac_try_exception(e, jac_ast)
 
+    def run_ability_call(self, jac_ast, atom_res):
+        """
+        ability_call:
+            LPAREN param_list? RPAREN
+            | ability_op NAME spawn_ctx?;
+        """
+        from jaseci.prim.ability import Ability
+
+        kid = self.set_cur_ast(jac_ast)
+        if kid[0].name == "LPAREN":
+            param_list = {"args": [], "kwargs": {}}
+            if kid[1].name == "param_list":
+                param_list = self.run_param_list(kid[1]).value
+            if isinstance(atom_res.value, Ability):
+                ret = atom_res.value.run_action(param_list, self._jac_scope, self)
+                return JacValue(self, value=ret)
+            else:
+                self.rt_error("Unable to execute ability", kid[0])
+        elif kid[0].name == "ability_op":
+            arch = self.run_ability_op(kid[0], atom_res)
+            if len(kid) > 2:
+                self.run_spawn_ctx(kid[2], atom_res.value)
+            self.call_ability(
+                nd=atom_res.value,
+                name=kid[1].token_text(),
+                act_list=arch.get_all_abilities(),
+            )
+            return atom_res
+
     def run_ability_op(self, jac_ast, atom_res):
         """
         ability_op: DBL_COLON | DBL_COLON NAME COLON;
@@ -952,21 +857,13 @@ class Interp(VirtualMachine):
                 return JacValue(
                     self,
                     value=self.obj_set_to_jac_set(
-                        self.current_node.attached_edges(atom_res.value)
+                        self.here().attached_edges(atom_res.value)
                     ),
                 )
             elif isinstance(atom_res.value, Edge):
                 return atom_res
             elif isinstance(atom_res.value, JacSet):
                 return JacValue(self, value=self._relevant_edges)
-                # res = jac_set()
-                # for i in atom_res.value.obj_list():
-                #     if(isinstance(i, edge)):
-                #         res.add_obj(i)
-                #     elif(isinstance(i, node)):
-                #         res += self.obj_set_to_jac_set(
-                #             self.current_node.attached_edges(i))
-                # return jac_value(self, value=res)
             else:
                 self.rt_error(
                     f"Cannot get edges from {atom_res.value}. "
@@ -996,7 +893,12 @@ class Interp(VirtualMachine):
                 )
         else:
             try:
-                atom_res.value = typ.value(atom_res.value)
+                if isinstance(atom_res.value, str) and typ.value == dict:
+                    atom_res.value = loads(atom_res.value)
+                elif isinstance(atom_res.value, dict) and typ.value == str:
+                    atom_res.value = dumps(atom_res.value)
+                else:
+                    atom_res.value = typ.value(atom_res.value)
             except Exception as e:
                 self.rt_error(
                     f"Invalid cast of {atom_res.jac_type()} "
@@ -1394,7 +1296,7 @@ class Interp(VirtualMachine):
         """
         kid = self.set_cur_ast(jac_ast)
         if not location:
-            location = self.current_node
+            location = self.here()
         result = JacSet()
         for i in location.outbound_edges() + location.bidirected_edges():
             if len(kid) > 2 and not i.get_architype().is_instance(kid[2].token_text()):
@@ -1414,7 +1316,7 @@ class Interp(VirtualMachine):
         """
         kid = self.set_cur_ast(jac_ast)
         if not location:
-            location = self.current_node
+            location = self.here()
         result = JacSet()
         for i in location.inbound_edges() + location.bidirected_edges():
             if len(kid) > 2 and not i.get_architype().is_instance(kid[2].token_text()):
@@ -1435,7 +1337,7 @@ class Interp(VirtualMachine):
         """
         kid = self.set_cur_ast(jac_ast)
         if not location:
-            location = self.current_node
+            location = self.here()
         result = JacSet()
         for i in location.attached_edges():
             if len(kid) > 2 and not i.get_architype().is_instance(kid[2].token_text()):
@@ -1814,24 +1716,18 @@ class Interp(VirtualMachine):
         return False
 
     def call_ability(self, nd, name, act_list):
-        m = Interp(parent_override=self.parent(), caller=self)
-        m.current_node = nd
-        arch = nd.get_architype()
-        m.push_scope(
-            JacScope(parent=self, has_obj=nd, action_sets=[arch.get_all_actions()])
-        )
-        m._jac_scope.inherit_agent_refs(self._jac_scope, nd)
+        ability = act_list.get_obj_by_name(name)
         try:
-            m.run_code_block(jac_ir_to_ast(act_list.get_obj_by_name(name).value))
+            ability.run_ability(here=nd, visitor=self._jac_scope.visitor())
         except Exception as e:
-            self.rt_error(f"Internal Exception: {e}", m._cur_jac_ast)
-        self.inherit_runtime_state(m)
+            self.rt_error(f"Internal Exception: {e}", ability._cur_jac_ast)
+        self.inherit_runtime_state(ability)
 
     def visibility_prune(self, node_set=None):
         """Returns all nodes that shouldnt be ignored"""
         ret = JacSet()
         if node_set is None:
-            node_set = self.current_node.attached_nodes()
+            node_set = self.here().attached_nodes()
         for i in node_set:
             if i not in self.ignore_node_ids.obj_list():
                 ret.add_obj(i)

jaseci/jac/interpreter/sentinel_interp.py

@@ -9,6 +9,7 @@ from jaseci.jac.interpreter.interp import Interp
 from jaseci.utils.utils import parse_str_token
 from jaseci.jac.ir.jac_code import jac_ast_to_ir
 from jaseci.jac.machine.jac_scope import JacScope
+from jaseci.prim.ability import Ability
 
 
 class SentinelInterp(Interp):
@@ -124,17 +125,84 @@ class SentinelInterp(Interp):
     def arch_can_compile(self, jac_ast, arch):
         """Helper function to statically compile can stmts for arch"""
         kid = self.set_cur_ast(jac_ast)
-        self.push_scope(JacScope(parent=self, has_obj=self, action_sets=[]))
+        self.push_scope(
+            JacScope(parent=self, name=f"a_cgen:{jac_ast.loc_str()}", has_obj=None)
+        )
         if jac_ast.name in ["attr_block", "walker_block"]:
             for i in kid:
                 if i.name == "attr_stmt" and i.kid[0].name == "can_stmt":
                     self.run_can_stmt(i.kid[0], arch)
-        elif kid[0].name == "graph_block_spawn":
-            kid = kid[0].kid[2].kid
-            for i in kid:
-                self.run_can_stmt(i, arch)
+        elif jac_ast.name == "graph_block":
+            self.run_can_block(jac_ast.kid[2], arch)
         self.pop_scope()
 
+    def run_can_block(self, jac_ast, arch):
+        """
+        can_block: (can_stmt)*;
+        """
+        kid = self.set_cur_ast(jac_ast)
+        for i in kid:
+            if i.name == "can_stmt":
+                self.run_can_stmt(i, arch)
+
+    def run_can_stmt(self, jac_ast, obj):
+        """
+        can_stmt:
+            KW_CAN dotted_name (preset_in_out event_clause)? (
+                COMMA dotted_name (preset_in_out event_clause)?
+            )* SEMI
+            | KW_CAN NAME event_clause? code_block;
+        """
+        kid = self.set_cur_ast(jac_ast)
+        kid = kid[1:]
+        ir = None
+        while True:
+            action_type = "activity"
+            access_list = None
+            preset_in_out = None
+            if kid[0].name == "NAME":
+                action_name = kid[0].token_text()
+            else:
+                action_name = self.run_dotted_name(kid[0])
+            kid = kid[1:]
+            if len(kid) > 0 and kid[0].name == "preset_in_out":
+                preset_in_out = jac_ast_to_ir(kid[0])
+                kid = kid[1:]
+            if len(kid) > 0 and kid[0].name == "event_clause":
+                action_type, access_list = self.run_event_clause(kid[0])
+                kid = kid[1:]
+            if kid[0].name != "code_block":
+                self.check_builtin_action(action_name, jac_ast)
+            else:
+                ir = kid[0]
+            getattr(obj, f"{action_type}_ability_ids").add_obj(
+                Ability(
+                    m_id=self._m_id,
+                    h=self._h,
+                    name=action_name,
+                    kind="ability",
+                    code_ir=ir,
+                    preset_in_out=preset_in_out,
+                    access_list=access_list,
+                    parent=self,
+                )
+            )
+            if not len(kid) or kid[0].name != "COMMA":
+                break
+            else:
+                kid = kid[1:]
+
+    def run_event_clause(self, jac_ast):
+        """
+        event_clause:
+                KW_WITH name_list? (KW_ENTRY | KW_EXIT | KW_ACTIVITY);
+        """
+        kid = self.set_cur_ast(jac_ast)
+        nl = []
+        if kid[1].name == "name_list":
+            nl = self.run_name_list(kid[1])
+        return kid[-1].token_text(), nl
+
     def load_test(self, jac_ast):
         """
         test:

jaseci/jac/interpreter/walker_interp.py

@@ -9,7 +9,6 @@ from jaseci.jac.interpreter.interp import Interp
 from jaseci.jac.jac_set import JacSet
 from jaseci.jac.machine.jac_scope import JacScope
 from jaseci.jac.ir.jac_code import jac_ir_to_ast
-from jaseci.utils.id_list import IdList
 
 
 class WalkerInterp(Interp):
@@ -25,6 +24,7 @@ class WalkerInterp(Interp):
         self.scope_and_run(
             jac_ast if jac_ast.name == "walker_block" else kid[-1],
             self.run_walker_block,
+            scope_name=f"w_run:{jac_ast.loc_str()}",
         )
 
     def run_walker_block(self, jac_ast):
@@ -36,15 +36,8 @@ class WalkerInterp(Interp):
             )* walk_exit_block? RBRACE;
         """
         kid = self.set_cur_ast(jac_ast)
-        if self.current_step == 0:
-            for i in kid:
-                if i.name == "attr_stmt":
-                    self.run_attr_stmt(jac_ast=i, obj=self)
-        archs = self.current_node.get_architype().arch_with_supers()
-        act_list = IdList(self)
-        for i in archs:
-            act_list += i.entry_action_ids
-        self.auto_trigger_node_actions(nd=self.current_node, act_list=act_list)
+        act_list = self.current_node.get_architype().get_entry_abilities()
+        self.auto_trigger_node_actions(act_list=act_list)
 
         for i in kid:
             if i.name == "walk_entry_block":
@@ -54,12 +47,8 @@ class WalkerInterp(Interp):
             if i.name == "walk_activity_block":
                 self.run_walk_activity_block(i)
 
-        # self.trigger_activity_actions()
-        archs = self.current_node.get_architype().arch_with_supers()
-        act_list = IdList(self)
-        for i in archs:
-            act_list += i.exit_action_ids
-        self.auto_trigger_node_actions(nd=self.current_node, act_list=act_list)
+        act_list = self.current_node.get_architype().get_exit_abilities()
+        self.auto_trigger_node_actions(act_list=act_list)
 
         if not self.yielded and kid[-2].name == "walk_exit_block":
             self.run_walk_exit_block(kid[-2])
@@ -190,7 +179,7 @@ class WalkerInterp(Interp):
             expr_func(kid[1])
         self.yield_walk()
 
-    def run_preset_in_out(self, jac_ast, obj, act):
+    def run_preset_in_out(self, jac_ast, act):
         """
         preset_in_out:
             DBL_COLON param_list? (DBL_COLON | COLON_OUT expression);
@@ -200,29 +189,34 @@ class WalkerInterp(Interp):
         """
         kid = self.set_cur_ast(jac_ast)
         param_list = {"args": [], "kwargs": []}
-        m = Interp(parent_override=self.parent(), caller=self)
-        arch = obj.get_architype()
-        m.push_scope(
-            JacScope(parent=self, has_obj=obj, action_sets=[arch.activity_action_ids])
+        self.push_scope(
+            JacScope(
+                parent=self,
+                name=f"p_in_out:{jac_ast.loc_str()}",
+                has_obj=self.current_node,
+                here=self.current_node,
+                visitor=self,
+            )
         )
-        m._jac_scope.set_agent_refs(cur_node=self.current_node, cur_walker=self)
 
         if kid[1].name == "param_list":
-            param_list = m.run_param_list(kid[1]).value
+            param_list = self.run_param_list(kid[1]).value
         try:
-            result = act.trigger(param_list, self._jac_scope, self)
+            result = act.run_action(param_list, self._jac_scope, self)
         except Exception as e:
-            self.rt_error(f"Internal Exception: {e}", m._cur_jac_ast)
+            self.rt_error(f"Internal Exception: {e}", self._cur_jac_ast)
             result = None
         if kid[-1].name == "expression":
-            m.run_expression(kid[-1])
-            dest = m.pop()
+            self.run_expression(kid[-1])
+            dest = self.pop()
             dest.value = result
             dest.write(kid[-1])
+        self.pop_scope()
 
     # Helper Functions ##################
-    def auto_trigger_node_actions(self, nd, act_list):
+    def auto_trigger_node_actions(self, act_list):
         already_executed = []  # handles inhereted duplicates, (overriding)
+        nd = self.current_node
         for i in act_list.obj_list():
             if (
                 i.access_list
@@ -231,30 +225,25 @@ class WalkerInterp(Interp):
             ):
                 continue
             if i.preset_in_out:
-                self.run_preset_in_out(jac_ir_to_ast(i.preset_in_out), nd, i)
+                self.run_preset_in_out(jac_ir_to_ast(i.preset_in_out), i)
             else:
                 self.call_ability(nd=nd, name=i.name, act_list=act_list)
             if not i.preset_in_out:  # All preset in and outs get executed
                 already_executed.append(i.name)
 
-    def scope_and_run(self, jac_ast, run_func):
+    def scope_and_run(self, jac_ast, run_func, scope_name):
         """
         Helper to run ast elements with execution scope added
         (Useful for running arbitrary code blocks as one-offs)
         """
-        node_arch = self.current_node.get_architype()
-        walk_arch = self.get_architype()
         self.push_scope(
             JacScope(
                 parent=self,
+                name=scope_name,
                 has_obj=self,
-                action_sets=[
-                    walk_arch.activity_action_ids,
-                    node_arch.activity_action_ids,
-                ],
+                here=self.current_node,
+                visitor=self,
             )
         )
-        self._jac_scope.set_agent_refs(cur_node=self.current_node, cur_walker=self)
-
         run_func(jac_ast)
         self.pop_scope()

jaseci/jac/ir/ast.py

@@ -16,7 +16,12 @@ class Ast:
     ):
         self.name = "unparsed"
         self.kid = []
-        self.loc = [0, 0, mod_name if mod_name is not None else "@default", {}]
+        self.loc = [
+            0,
+            0,
+            mod_name if mod_name is not None else "@default",
+            {},
+        ]  # line, col, module, tokens
 
     def is_terminal(self):
         """Returns true if node is a terminal"""
@@ -37,6 +42,9 @@ class Ast:
         if self.is_terminal():
             return self.token()["symbol"]
 
+    def loc_str(self):
+        return f"{self.loc[2]}:{self.loc[0]}"
+
     def __str__(self):
         res = f"{self.name}:{self.loc[2]}:{self.loc[0]}:{self.loc[1]}:"
         if self.is_terminal():

jaseci/jac/jac.g4

@@ -72,9 +72,7 @@ struct_block: LBRACE (has_stmt)* RBRACE | COLON has_stmt | SEMI;
 
 can_block: (can_stmt)*;
 
-graph_block: graph_block_spawn;
-
-graph_block_spawn:
+graph_block:
 	LBRACE has_root can_block KW_SPAWN code_block RBRACE
 	| COLON has_root can_block KW_SPAWN code_block SEMI;
 
@@ -228,7 +226,10 @@ atom_trailer:
 	DOT built_in
 	| DOT NAME
 	| index_slice
-	| LPAREN param_list? RPAREN
+	| ability_call;
+
+ability_call:
+	LPAREN param_list? RPAREN
 	| ability_op NAME spawn_ctx?;
 
 ability_op: DBL_COLON | DBL_COLON NAME COLON;

jaseci/jac/jac_parse/jacListener.py

@@ -161,14 +161,6 @@ class jacListener(ParseTreeListener):
     def exitGraph_block(self, ctx: jacParser.Graph_blockContext):
         pass
 
-    # Enter a parse tree produced by jacParser#graph_block_spawn.
-    def enterGraph_block_spawn(self, ctx: jacParser.Graph_block_spawnContext):
-        pass
-
-    # Exit a parse tree produced by jacParser#graph_block_spawn.
-    def exitGraph_block_spawn(self, ctx: jacParser.Graph_block_spawnContext):
-        pass
-
     # Enter a parse tree produced by jacParser#has_root.
     def enterHas_root(self, ctx: jacParser.Has_rootContext):
         pass
@@ -537,6 +529,14 @@ class jacListener(ParseTreeListener):
     def exitAtom_trailer(self, ctx: jacParser.Atom_trailerContext):
         pass
 
+    # Enter a parse tree produced by jacParser#ability_call.
+    def enterAbility_call(self, ctx: jacParser.Ability_callContext):
+        pass
+
+    # Exit a parse tree produced by jacParser#ability_call.
+    def exitAbility_call(self, ctx: jacParser.Ability_callContext):
+        pass
+
     # Enter a parse tree produced by jacParser#ability_op.
     def enterAbility_op(self, ctx: jacParser.Ability_opContext):
         pass