Improve undefined name detection

Author: evhub

DOCS.md

@@ -4913,11 +4913,11 @@ _Deprecated: `coconut.convenience` is a deprecated alias for `coconut.api`._
 
 #### `get_state`
 
-**coconut.api.get\_state**(_state_=`None`)
+**coconut.api.get\_state**(_state_=`True`)
 
 Gets a state object which stores the current compilation parameters. State objects can be configured with [**setup**](#setup) or [**cmd**](#cmd) and then used in [**parse**](#parse) or other endpoints.
 
-If _state_ is `None`, gets a new state object, whereas if _state_ is `False`, the global state object is returned.
+If _state_ is `True`, gets a new state object, whereas if _state_ is `False`, the global state object is returned.
 
 #### `parse`
 

coconut/api.py

@@ -53,10 +53,10 @@
 GLOBAL_STATE = None
 
 
-def get_state(state=None):
-    """Get a Coconut state object; None gets a new state, False gets the global state."""
+def get_state(state=True):
+    """Get a Coconut state object; True gets a new state, False gets the global state."""
     global GLOBAL_STATE
-    if state is None:
+    if state is None or state is True:
         return Command()
     elif state is False:
         if GLOBAL_STATE is None:

coconut/api.pyi

@@ -38,15 +38,15 @@ class CoconutException(Exception):
 GLOBAL_STATE: Optional[Command] = None
 
 
-def get_state(state: Optional[Command] = None) -> Command:
+def get_state(state: Optional[Command] | bool = None) -> Command:
     """Get a Coconut state object; None gets a new state, False gets the global state."""
     ...
 
 
 def cmd(
     args: Text | bytes | Iterable,
     *,
-    state: Command | None = ...,
+    state: Optional[Command] | bool = ...,
     argv: Iterable[Text] | None = None,
     interact: bool = False,
     default_target: Text | None = None,
@@ -81,7 +81,7 @@ def setup(
     no_tco: bool = False,
     no_wrap: bool = False,
     pure: bool = False,
-    state: Optional[Command] = ...,
+    state: Optional[Command] | bool = ...,
 ) -> None:
     """Set up the given state object."""
     ...
@@ -91,7 +91,7 @@ def warm_up(
     streamline: bool = False,
     enable_incremental_mode: bool = False,
     *,
-    state: Optional[Command] = ...,
+    state: Optional[Command] | bool = ...,
 ) -> None:
     """Warm up the given state object."""
     ...
@@ -103,7 +103,7 @@ PARSERS: Dict[Text, Callable] = ...
 def parse(
     code: Text,
     mode: Text = ...,
-    state: Optional[Command] = ...,
+    state: Optional[Command] | bool = ...,
     keep_internal_state: Optional[bool] = None,
 ) -> Text:
     """Compile Coconut code."""
@@ -114,7 +114,7 @@ def coconut_exec(
     expression: Text,
     globals: Optional[Dict[Text, Any]] = None,
     locals: Optional[Dict[Text, Any]] = None,
-    state: Optional[Command] = ...,
+    state: Optional[Command] | bool = ...,
     keep_internal_state: Optional[bool] = None,
 ) -> None:
     """Compile and evaluate Coconut code."""
@@ -125,7 +125,7 @@ def coconut_eval(
     expression: Text,
     globals: Optional[Dict[Text, Any]] = None,
     locals: Optional[Dict[Text, Any]] = None,
-    state: Optional[Command] = ...,
+    state: Optional[Command] | bool = ...,
     keep_internal_state: Optional[bool] = None,
 ) -> Any:
     """Compile and evaluate Coconut code."""

coconut/compiler/compiler.py

@@ -635,20 +635,16 @@ def genhash(self, code, package_level=-1):
     def get_empty_scope(self, inner=False):
         """Get an empty scope for the parsing_context."""
         parent = self.current_parsing_context("scope")
+        if parent is not None and parent["all_vars"] is None:
+            inner = True
         return {
             "final_vars": {},
             "pure_vars": {},
             "all_vars": None if inner else set(),
             "parent": parent,
+            "callbacks": [],
         }
 
-    def init_parsing_context(self, inner=False):
-        """Initialize parsing context."""
-        self.parsing_context = defaultdict(list)
-        # initialize module-level scopes
-        self.parsing_context["scope"].append(self.get_empty_scope(inner=inner))
-        return self.parsing_context
-
     def reset(self, keep_state=False, filename=None):
         """Reset references.
 
@@ -683,8 +679,7 @@ def reset(self, keep_state=False, filename=None):
         self.shown_warnings = set()
         if not keep_state:
             self.computation_graph_caches = defaultdict(staledict)
-        self.final_checks = []
-        self.init_parsing_context()
+        self.parsing_context = defaultdict(list)
 
     @contextmanager
     def inner_environment(self, ln=None):
@@ -702,11 +697,13 @@ def inner_environment(self, ln=None):
         num_lines, self.num_lines = self.num_lines, 0
         remaining_original, self.remaining_original = self.remaining_original, None
         shown_warnings, self.shown_warnings = self.shown_warnings, set()
-        parsing_context = self.parsing_context
-        self.init_parsing_context(inner=True)
+        parsing_context, self.parsing_context = self.parsing_context, defaultdict(list)
         try:
-            with ComputationNode.using_overrides():
-                yield
+            with self.add_to_parsing_context({
+                "scope": self.get_empty_scope(inner=True),
+            }):
+                with ComputationNode.using_overrides():
+                    yield
         finally:
             self.outer_ln = outer_ln
             self.line_numbers = line_numbers
@@ -1525,8 +1522,8 @@ def parsing(self, keep_state=False, codepath=None):
         """Acquire the lock and reset the parser."""
         filename = None if codepath is None else os.path.basename(codepath)
         with self.lock:
-            self.reset(keep_state, filename)
             Compiler.current_compiler = self
+            self.reset(keep_state, filename)
             yield
 
     def streamline(self, grammars, inputstring=None, force=False, inner=False):
@@ -1557,8 +1554,6 @@ def run_final_checks(self, original, keep_state=False):
                 if info["imported"] and not info["referenced"]:
                     for loc in info["imported"]:
                         self.strict_err_or_warn("found unused import " + repr(self.reformat(name, ignore_errors=True)), original, loc, noqa_able=True, endpoint=False)
-            for final_check in self.final_checks:
-                final_check()
 
     def pickle_cache(self, original, cache_path, include_incremental=True):
         """Pickle the pyparsing cache for original to cache_path."""
@@ -1838,11 +1833,15 @@ def parse(
                 with logger.gather_parsing_stats():
                     try:
                         pre_procd = self.pre(inputstring, keep_state=keep_state, **preargs)
-                        if isinstance(parser, tuple):
-                            init_parser, line_parser = parser
-                            parsed = self.parse_line_by_line(init_parser, line_parser, pre_procd)
-                        else:
-                            parsed = parse(parser, pre_procd, inner=False)
+                        # handle module-level scope
+                        with self.add_to_parsing_context({
+                            "scope": self.get_empty_scope(inner=keep_state),
+                        }):
+                            if isinstance(parser, tuple):
+                                init_parser, line_parser = parser
+                                parsed = self.parse_line_by_line(init_parser, line_parser, pre_procd)
+                            else:
+                                parsed = parse(parser, pre_procd, inner=False)
                         out = self.post(parsed, keep_state=keep_state, **postargs)
                     except ParseBaseException as err:
                         raise self.make_parse_err(err)
@@ -4643,11 +4642,12 @@ def {func_name}({iter_var}):
     def get_parent_expr_setnames(self):
         """Get all expr_setnames in parent contexts, but not the current context."""
         expr_setname_context = self.current_parsing_context("expr_setnames")
-        parent_context = expr_setname_context["parent"]
         parent_setnames = set()
-        while parent_context:
-            parent_setnames |= parent_context["new_names"]
-            parent_context = parent_context["parent"]
+        if expr_setname_context is not None:
+            parent_context = expr_setname_context["parent"]
+            while parent_context:
+                parent_setnames |= parent_context["new_names"]
+                parent_context = parent_context["parent"]
         return parent_setnames
 
     def handle_expr_scope_closure(self, name, loc):
@@ -5303,7 +5303,7 @@ def current_parsing_context(self, name, default=None):
             return default
 
     @contextmanager
-    def add_to_parsing_context(self, name_obj_dict, callbacks_keys_dict=None):
+    def add_to_parsing_context(self, name_obj_dict):
         """Put all the given objects on their respective parsing context stacks."""
         for name, obj in name_obj_dict.items():
             self.parsing_context[name].append(obj)
@@ -5312,11 +5312,9 @@ def add_to_parsing_context(self, name_obj_dict, callbacks_keys_dict=None):
         finally:
             for name in name_obj_dict:
                 popped_ctx = self.parsing_context[name].pop()
-                if callbacks_keys_dict is not None:
-                    callbacks_key = callbacks_keys_dict.get(name)
-                    if callbacks_key is not None:
-                        for callback in popped_ctx[callbacks_key]:
-                            callback()
+                if "callbacks" in popped_ctx:
+                    for callback in popped_ctx["callbacks"]:
+                        callback()
 
     def funcname_typeparams_handle(self, tokens):
         """Handle function names with type parameters."""
@@ -5584,7 +5582,6 @@ def has_expr_setname_manage(self, original, loc, item):
                 "callbacks": [],
                 "loc": loc,
             }},
-            callbacks_keys_dict={"expr_setnames": "callbacks"},
         ):
             yield
 
@@ -5788,7 +5785,10 @@ def name_handle(self, original, loc, tokens, assign=False, outer_setname=False,
                 and name not in self.get_parent_expr_setnames()
             ))
         ):
-            self.final_checks.append(partial(self.check_undefined_name, original, loc, name, scope, self.outer_ln))
+            parent_scope = scope
+            while parent_scope["parent"] is not None:
+                parent_scope = parent_scope["parent"]
+            parent_scope["callbacks"].append(partial(self.check_undefined_name, original, loc, name, scope, self.outer_ln))
 
         # only mark as final after all checks pass
         if is_final:

coconut/root.py

@@ -26,7 +26,7 @@
 VERSION = "3.2.0"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 15
+DEVELOP = 16
 ALPHA = False  # for pre releases rather than post releases
 
 assert DEVELOP is False or DEVELOP >= 1, "DEVELOP must be False or an int >= 1"