coconut-develop 3.2.0.post0.dev13__tar.gz → 3.2.0.post0.dev15__tar.gz

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/DOCS.md

@@ -1197,6 +1197,8 @@ infix_pattern ::= bar_or_pattern ("`" EXPR "`" [EXPR])*  # infix check
 
 bar_or_pattern ::= pattern ("|" pattern)*  # match any
 
+capture ::= NAME | "(" pattern ")"  # in unambiguous capture positions
+
 base_pattern ::= (
     "(" pattern ")"                  # parentheses
     | "None" | "True" | "False"      # constants
@@ -1230,29 +1232,29 @@ base_pattern ::= (
     | [(                             # sequence splits
         "(" patterns ")"
         | "[" patterns "]"
-      ) "+"] NAME ["+" (
+      ) "+"] capture ["+" (
         "(" patterns ")"                 # this match must be the same
         | "[" patterns "]"               #  construct as the first match
-      )] ["+" NAME ["+" (
-        "(" patterns ")"                 # and same here
+      )] ["+" NAME ["+" (              # search splits require NAME
+        "(" patterns ")"                 # must be same as first match
         | "[" patterns "]"
       )]]
     | [(                             # iterable splits
         "(" patterns ")"
         | "[" patterns "]"
         | "(|" patterns "|)"
-      ) "::"] NAME ["::" (
+      ) "::"] capture ["::" (
         "(" patterns ")"
         | "[" patterns "]"
         | "(|" patterns "|)"
-      )] [ "::" NAME [
+      )] [ "::" NAME [               # search splits require NAME
         "(" patterns ")"
         | "[" patterns "]"
         | "(|" patterns "|)"
       ]]
-    | [STRING "+"] NAME              # complex string matching
+    | [STRING "+"] capture           # complex string matching
         ["+" STRING]
-        ["+" NAME ["+" STRING]]
+        ["+" NAME ["+" STRING]]      # search splits require NAME
 )
 ```
 
@@ -1287,13 +1289,13 @@ base_pattern ::= (
 - Sequence Destructuring:
   - Lists (`[<patterns>]`), Tuples (`(<patterns>)`): will only match a sequence (`collections.abc.Sequence`) of the same length, and will check the contents against `<patterns>` (Coconut automatically registers `numpy` arrays and `collections.deque` objects as sequences).
   - Lazy lists (`(|<patterns>|)`): same as list or tuple matching, but checks for an Iterable (`collections.abc.Iterable`) instead of a Sequence.
-  - Head-Tail Splits (`<list/tuple> + <var>` or `(<patterns>, *<var>)`): will match the beginning of the sequence against the `<list/tuple>`/`<patterns>`, then bind the rest to `<var>`, and make it the type of the construct used.
-  - Init-Last Splits (`<var> + <list/tuple>` or `(*<var>, <patterns>)`): exactly the same as head-tail splits, but on the end instead of the beginning of the sequence.
-  - Head-Last Splits (`<list/tuple> + <var> + <list/tuple>` or `(<patterns>, *<var>, <patterns>)`): the combination of a head-tail and an init-last split.
-  - Search Splits (`<var1> + <list/tuple> + <var2>` or `(*<var1>, <patterns>, *<var2>)`): searches for the first occurrence of the `<list/tuple>`/`<patterns>` in the sequence, then puts everything before into `<var1>` and everything after into `<var2>`.
+  - Head-Tail Splits (`<list/tuple> + <capture>` or `(<patterns>, *<var>)`): will match the beginning of the sequence against the `<list/tuple>`/`<patterns>`, then bind the rest to `<capture>`, and make it the type of the construct used. `<capture>` can be a variable name or a parenthesized match pattern (e.g. `(int -> x)`).
+  - Init-Last Splits (`<capture> + <list/tuple>` or `(*<var>, <patterns>)`): exactly the same as head-tail splits, but on the end instead of the beginning of the sequence.
+  - Head-Last Splits (`<list/tuple> + <capture> + <list/tuple>` or `(<patterns>, *<var>, <patterns>)`): the combination of a head-tail and an init-last split.
+  - Search Splits (`<var1> + <list/tuple> + <var2>` or `(*<var1>, <patterns>, *<var2>)`): searches for the first occurrence of the `<list/tuple>`/`<patterns>` in the sequence, then puts everything before into `<var1>` and everything after into `<var2>`. Search split captures must be variable names, not parenthesized patterns.
   - Head-Last Search Splits (`<list/tuple> + <var> + <list/tuple> + <var> + <list/tuple>` or `(<patterns>, *<var>, <patterns>, *<var>, <patterns>)`): the combination of a head-tail split and a search split.
-  - Iterable Splits (`<list/tuple/lazy list> :: <var> :: <list/tuple/lazy list> :: <var> :: <list/tuple/lazy list>`): same as other sequence destructuring, but works on any iterable (`collections.abc.Iterable`), including infinite iterators (note that if an iterator is matched against it will be modified unless it is [`reiterable`](#reiterable)).
-  - Complex String Matching (`<string> + <var> + <string> + <var> + <string>`): string matching supports the same destructuring options as above.
+  - Iterable Splits (`<list/tuple/lazy list> :: <capture> :: <list/tuple/lazy list> :: <var> :: <list/tuple/lazy list>`): same as other sequence destructuring, but works on any iterable (`collections.abc.Iterable`), including infinite iterators (note that if an iterator is matched against it will be modified unless it is [`reiterable`](#reiterable)).
+  - Complex String Matching (`<string> + <capture> + <string> + <var> + <string>`): string matching supports the same destructuring options as above. In unambiguous positions (single capture), `<capture>` can be a variable name or a parenthesized match pattern (e.g. `(int -> n) + "px"`).
 
 _Note: Like [iterator slicing](#iterator-slicing), iterator and lazy list matching make no guarantee that the original iterator matched against be preserved (to preserve the iterator, use Coconut's [`reiterable`](#reiterable) built-in)._
 

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: coconut-develop
-Version: 3.2.0.post0.dev13
+Version: 3.2.0.post0.dev15
 Summary: Simple, elegant, Pythonic functional programming.
 Home-page: http://coconut-lang.org
 Author: Evan Hubinger
 Author-email: evanjhub@gmail.com
 License: Apache-2.0
-Keywords: functional,programming,language,compiler,pattern,pattern-matching,algebraic,data type,data types,lambda,lambdas,evaluation,lazy list,lazy lists,tail,recursion,call,recursive,recursive_iterator,infix,function,composition,compose,partial,application,currying,curry,pipeline,pipe,unicode,operator,operators,frozenset,literal,syntax,destructuring,assignment,fold,datamaker,prepattern,iterator,generator,none,coalesce,coalescing,statement,lru_cache,memoization,backport,typing,embed,PEP 622,overrides,islice,itertools,functools,TYPE_CHECKING,Expected,breakpoint,help,reduce,takewhile,dropwhile,tee,count,makedata,consume,process_map,thread_map,addpattern,recursive_generator,fmap,starmap,reiterable,scan,groupsof,memoize,zip_longest,override,flatten,ident,call,safe_call,flip,const,lift,lift_apart,all_equal,collectby,mapreduce,multi_enumerate,cartesian_product,multiset,cycle,windowsof,and_then,and_then_await,async_map,py_chr,py_dict,py_hex,py_input,py_int,py_map,py_object,py_oct,py_open,py_print,py_range,py_str,py_super,py_zip,py_filter,py_reversed,py_enumerate,py_raw_input,py_xrange,py_repr,py_breakpoint,py_min,py_max,_namedtuple_of,reveal_type,reveal_locals,MatchError,CoconutWarning,__fmap__,__iter_getitem__,data,match,case,cases,where,final,addpattern,then,operator,type,copyclosure,lazy,λ
+Keywords: functional,programming,language,compiler,pattern,pattern-matching,algebraic,data type,data types,lambda,lambdas,evaluation,lazy list,lazy lists,tail,recursion,call,recursive,recursive_iterator,infix,function,composition,compose,partial,application,currying,curry,pipeline,pipe,unicode,operator,operators,frozenset,literal,syntax,destructuring,assignment,fold,datamaker,prepattern,iterator,generator,none,coalesce,coalescing,statement,lru_cache,memoization,backport,typing,embed,PEP 622,overrides,islice,itertools,functools,TYPE_CHECKING,Expected,breakpoint,help,reduce,takewhile,dropwhile,tee,count,makedata,consume,process_map,thread_map,addpattern,recursive_generator,fmap,starmap,reiterable,scan,groupsof,memoize,zip_longest,override,flatten,ident,call,safe_call,flip,const,lift,lift_apart,all_equal,collectby,mapreduce,multi_enumerate,cartesian_product,multiset,cycle,windowsof,and_then,and_then_await,async_map,py_bytes,py_chr,py_dict,py_hex,py_input,py_int,py_map,py_object,py_oct,py_open,py_print,py_range,py_str,py_super,py_zip,py_filter,py_reversed,py_enumerate,py_raw_input,py_xrange,py_repr,py_breakpoint,py_min,py_max,_namedtuple_of,reveal_type,reveal_locals,MatchError,CoconutWarning,__fmap__,__iter_getitem__,data,match,case,cases,where,final,addpattern,then,operator,type,copyclosure,lazy,λ
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
@@ -220,27 +220,6 @@ Requires-Dist: pytest>=7; (python_version >= "3.6" and python_version < "3.8") a
 Requires-Dist: pytest<8.1,>=8.0; python_version >= "3.8" and extra == "tests"
 Requires-Dist: pexpect>=4; extra == "tests"
 Requires-Dist: pytest_remotedata>=0.3; extra == "tests"
-Requires-Dist: ipython>=5.4; python_version < "3" and extra == "tests"
-Requires-Dist: ipython<7.10,>=7.9; (python_version >= "3" and python_version < "3.7") and extra == "tests"
-Requires-Dist: ipython>=7.34; (python_version >= "3.7" and python_version < "3.8") and extra == "tests"
-Requires-Dist: ipython>=8.12; (python_version >= "3.8" and python_version < "3.9") and extra == "tests"
-Requires-Dist: ipython>=8.18; (python_version >= "3.9" and python_version < "3.11") and extra == "tests"
-Requires-Dist: ipython>=9; python_version >= "3.11" and extra == "tests"
-Requires-Dist: ipykernel>=4.10; python_version < "3" and extra == "tests"
-Requires-Dist: ipykernel>=5.5; (python_version >= "3" and python_version < "3.8") and extra == "tests"
-Requires-Dist: ipykernel>=6; (python_version >= "3.8" and python_version < "3.10") and extra == "tests"
-Requires-Dist: ipykernel>=7; python_version >= "3.10" and extra == "tests"
-Requires-Dist: jupyter-client>=5.3; python_version < "3.5" and extra == "tests"
-Requires-Dist: jupyter-client<6.1.13,>=6.1.12; (python_version >= "3.5" and python_version < "3.6") and extra == "tests"
-Requires-Dist: jupyter-client>=7.1.2; python_version >= "3.6" and extra == "tests"
-Requires-Dist: jedi<0.18,>=0.17; python_version < "3.9" and extra == "tests"
-Requires-Dist: jedi>=0.19; python_version >= "3.9" and extra == "tests"
-Requires-Dist: pywinpty<0.6,>=0.5; (python_version < "3" and os_name == "nt") and extra == "tests"
-Requires-Dist: jupyter>=1.1; extra == "tests"
-Requires-Dist: jupyter-console>=5.2; python_version < "3.5" and extra == "tests"
-Requires-Dist: jupyter-console>=6.1; (python_version >= "3.5" and python_version < "3.7") and extra == "tests"
-Requires-Dist: jupyter-console>=6.6; python_version >= "3.7" and extra == "tests"
-Requires-Dist: papermill>=1.2; extra == "tests"
 Provides-Extra: dev
 Requires-Dist: ipython>=5.4; python_version < "3" and extra == "dev"
 Requires-Dist: ipython<7.10,>=7.9; (python_version >= "3" and python_version < "3.7") and extra == "dev"

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/_pyparsing.py

@@ -45,6 +45,7 @@ from coconut.constants import (
     default_incremental_cache_size,
     never_clear_incremental_cache,
     warn_on_multiline_regex,
+    warn_on_undefined_ParseResults_name,
     num_displayed_timing_items,
     use_pyparsing_cache_file,
     use_line_by_line_parser,
@@ -274,6 +275,7 @@ if DEVELOP:
         _pyparsing._enable_all_warnings()
     _pyparsing.__diag__.warn_name_set_on_empty_Forward = False
     _pyparsing.__diag__.warn_on_incremental_multiline_regex = warn_on_multiline_regex
+    _pyparsing.__diag__.warn_on_undefined_ParseResults_name = warn_on_undefined_ParseResults_name
 
 if MODERN_PYPARSING and use_left_recursion_if_available:
     ParserElement.enable_left_recursion()

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/compiler/compiler.py

@@ -632,18 +632,21 @@ class Compiler(Grammar, pickleable_obj):
     temp_var_counts = None
     operators = None
 
-    def get_empty_scope(self):
+    def get_empty_scope(self, inner=False):
         """Get an empty scope for the parsing_context."""
+        parent = self.current_parsing_context("scope")
         return {
             "final_vars": {},
             "pure_vars": {},
+            "all_vars": None if inner else set(),
+            "parent": parent,
         }
 
-    def init_parsing_context(self):
+    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())
+        self.parsing_context["scope"].append(self.get_empty_scope(inner=inner))
         return self.parsing_context
 
     def reset(self, keep_state=False, filename=None):
@@ -680,6 +683,7 @@ class Compiler(Grammar, pickleable_obj):
         self.shown_warnings = set()
         if not keep_state:
             self.computation_graph_caches = defaultdict(staledict)
+        self.final_checks = []
         self.init_parsing_context()
 
     @contextmanager
@@ -699,7 +703,7 @@ class Compiler(Grammar, pickleable_obj):
         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()
+        self.init_parsing_context(inner=True)
         try:
             with ComputationNode.using_overrides():
                 yield
@@ -890,20 +894,32 @@ class Compiler(Grammar, pickleable_obj):
 
         # name handlers
         cls.refname <<= attach(cls.name_ref, cls.method("name_handle"))
-        cls.nonfinal_setname <<= attach(cls.name_ref, cls.method("name_handle", assign=True))
+        cls.nonfinal_setname <<= attach(
+            cls.name_ref,
+            cls.method("name_handle", assign=True),
+        )
         cls.final_setname <<= attach(
             cls.final_setname_ref,
             cls.method("name_handle", assign=True, is_final=True),
             greedy=True,
         )
+        cls.nonfinal_outer_setname <<= attach(
+            cls.name_ref,
+            cls.method("name_handle", assign=True, outer_setname=True),
+        )
+        cls.final_outer_setname <<= attach(
+            cls.final_setname_ref,
+            cls.method("name_handle", assign=True, outer_setname=True, is_final=True),
+            greedy=True,
+        )
         cls.nonfinal_classname <<= attach(
             cls.name_ref,
-            cls.method("name_handle", assign=True, classname=True),
+            cls.method("name_handle", assign=True, outer_setname=True, classname=True),
             greedy=True,
         )
         cls.final_classname <<= attach(
             cls.final_setname_ref,
-            cls.method("name_handle", assign=True, classname=True, is_final=True),
+            cls.method("name_handle", assign=True, outer_setname=True, classname=True, is_final=True),
             greedy=True,
         )
         cls.expr_setname <<= attach(
@@ -1541,10 +1557,8 @@ class Compiler(Grammar, pickleable_obj):
                 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)
-                if not self.star_import:  # only check for undefined names when there are no * imports
-                    if name not in all_builtins and info["referenced"] and not (info["assigned"] or info["imported"]):
-                        for loc in info["referenced"]:
-                            self.strict_err_or_warn("found undefined name " + 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."""
@@ -4058,7 +4072,7 @@ else:
             type_ignore=self.type_ignore_comment(),
         )
 
-    def _make_import_stmt(self, imp_from, imp, imp_as, raw=False, lazy=False):
+    def make_import_stmt(self, imp_from, imp, imp_as, raw=False, lazy=False):
         """Generate an import statement."""
         if not raw and imp != "*":
             module_path = (imp if imp_from is None else imp_from).split(".", 1)
@@ -4075,7 +4089,7 @@ else:
         raise _coconut.ImportError(_coconut.str(_coconut_imp_err))
                     """,
                 ).format(
-                    raw_import=self._make_import_stmt(imp_from, imp, imp_as, raw=True),
+                    raw_import=self.make_import_stmt(imp_from, imp, imp_as, raw=True),
                     imp_name=imp_as if imp_as is not None else imp,
                     imp_lookup=".".join([existing_imp] + module_path[1:] + ([imp] if imp_from is not None else [])),
                 )
@@ -4121,14 +4135,14 @@ else:
 
         if imp_as is not None and "." in imp_as:
             import_as_var = self.get_temp_var("import", loc)
-            out.append(self._make_import_stmt(imp_from, imp, import_as_var, lazy=lazy))
+            out.append(self.make_import_stmt(imp_from, imp, import_as_var, lazy=lazy))
             fake_mods = imp_as.split(".")
             for i in range(1, len(fake_mods)):
                 mod_name = ".".join(fake_mods[:i])
                 out.append(self.ensure_module_or_create_fake(mod_name))
             out.append(".".join(fake_mods) + " = " + import_as_var)
         else:
-            out.append(self._make_import_stmt(imp_from, imp, imp_as, lazy=lazy))
+            out.append(self.make_import_stmt(imp_from, imp, imp_as, lazy=lazy))
 
         if type_ignore:
             for i, line in enumerate(out):
@@ -4579,7 +4593,7 @@ def {name}({match_func_paramdef}):
 
             self.add_code_before[name] = self.decoratable_funcdef_stmt_handle(original, loc, [decorators, funcdef], is_async, is_stmt_lambda=True)
 
-        return self._handle_expr_scope_closure(name, loc)
+        return self.handle_expr_scope_closure(name, loc)
 
     def match_comp_expr_handle(self, original, loc, tokens, dict_val=None):
         """Build a match comprehension by creating a temp match function.
@@ -4619,26 +4633,31 @@ def {func_name}({iter_var}):
 
         self.add_code_before[func_name] = self.decoratable_funcdef_stmt_handle(original, loc, [funcdef], is_stmt_lambda=True)
 
-        func_expr = self._handle_expr_scope_closure(func_name, loc)
+        func_expr = self.handle_expr_scope_closure(func_name, loc)
 
         if dict_val is not None:
             return "_coconut.dict((" + func_expr + "(" + iter_var + ") for " + iter_var + " in " + iterable + "))"
         else:
             return func_expr + "(" + iter_var + ") for " + iter_var + " in " + iterable
 
-    def _handle_expr_scope_closure(self, name, loc):
+    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"]
+        return parent_setnames
+
+    def handle_expr_scope_closure(self, name, loc):
         """Extracts the definition of a name to a separate function that closes on all local expr setnames."""
         expr_setname_context = self.current_parsing_context("expr_setnames")
         if expr_setname_context is None:
             return name
         else:
             builder_name = self.get_temp_var("lambda_builder", loc)
-
-            parent_context = expr_setname_context["parent"]
-            parent_setnames = set()
-            while parent_context:
-                parent_setnames |= parent_context["new_names"]
-                parent_context = parent_context["parent"]
+            parent_setnames = self.get_parent_expr_setnames()
 
             def stmt_lambdef_callback():
                 expr_setnames = parent_setnames | expr_setname_context["new_names"]
@@ -5569,12 +5588,14 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         ):
             yield
 
-    def name_handle(self, original, loc, tokens, assign=False, classname=False, expr_setname=False, is_final=False):
+    def name_handle(self, original, loc, tokens, assign=False, outer_setname=False, expr_setname=False, classname=False, is_final=False):
         """Handle the given base name."""
-        if expr_setname:
-            internal_assert(assign, "expr_setname should always imply assign", (expr_setname, assign))
+        if classname:
+            internal_assert(outer_setname and not expr_setname, "classname should always imply outer_setname", tokens)
+        if outer_setname or expr_setname:
+            internal_assert(assign, "classname/funcname/expr_setname should always imply assign", tokens)
         if is_final:
-            internal_assert(assign and not expr_setname, "only setnames should ever be final", (assign, is_final))
+            internal_assert(assign and not expr_setname, "only setnames should ever be final", tokens)
 
         name, = tokens
 
@@ -5595,24 +5616,6 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
             always_wrap=is_greedy,
         )
 
-        # register non-mid-expression variable assignments inside of where statements for later mangling
-        if assign and not expr_setname:
-            where_context = self.current_parsing_context("where")
-            if where_context is not None:
-                where_assigns = where_context["assigns"]
-                if where_assigns is not None:
-                    where_assigns.add(name)
-
-        if classname:
-            cls_context = self.current_parsing_context("class")
-            self.internal_assert(cls_context is not None, original, loc, "found classname outside of class", tokens)
-            cls_context["name"] = name
-
-        if expr_setname:
-            expr_setnames_context = self.current_parsing_context("expr_setnames")
-            self.internal_assert(expr_setnames_context is not None, original, loc, "found expr_setname outside of has_expr_setname_manage", tokens)
-            expr_setnames_context["new_names"].add(name)
-
         if not escaped:
             typevar_info = self.current_parsing_context("typevars")
             if typevar_info is not None:
@@ -5633,18 +5636,45 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                         # note that this is the one case where we return early that isn't an error
                         return typevars[name]
 
+        # register non-mid-expression variable assignments inside of where statements for later mangling
+        if assign and not expr_setname:
+            where_context = self.current_parsing_context("where")
+            if where_context is not None:
+                where_assigns = where_context["assigns"]
+                if where_assigns is not None:
+                    where_assigns.add(name)
+
+        cls_context = self.current_parsing_context("class")
+        expr_setnames_context = self.current_parsing_context("expr_setnames")
+
+        if classname:
+            self.internal_assert(cls_context is not None, original, loc, "found classname outside of class", tokens)
+            cls_context["name"] = name
+
+        if expr_setname:
+            self.internal_assert(expr_setnames_context is not None, original, loc, "found expr_setname outside of has_expr_setname_manage", tokens)
+            expr_setnames_context["new_names"].add(name)
+
+        scope = self.current_parsing_context("scope")
+        self.internal_assert(scope is not None, original, loc, "no scope context")
+
         # track assigned/referenced early so that even if we return early with an
         #  error, the name is marked as used (e.g. for unused import checking)
         if assign:
             is_new = loc not in self.name_info[name]["assigned"]
             self.name_info[name]["assigned"].add(loc)
+            if (
+                outer_setname
+                and scope["parent"] is not None
+                and scope["parent"]["all_vars"] is not None
+            ):
+                scope["parent"]["all_vars"].add(name)
+            elif not expr_setname and scope["all_vars"] is not None:
+                scope["all_vars"].add(name)
         else:
             is_new = loc not in self.name_info[name]["referenced"]
             self.name_info[name]["referenced"].add(loc)
 
-        scope = self.current_parsing_context("scope")
-        self.internal_assert(scope is not None, original, loc, "no scope context")
-
         # final variable checking (setting final_vars happens at the end)
         final_vars = scope["final_vars"]
         if (
@@ -5693,7 +5723,8 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                     return err
 
         is_class_attr = (
-            self.current_parsing_context("class")
+            assign
+            and cls_context
             and not self.in_method
             and (
                 # for classnames, we need special handling for nested classes
@@ -5712,14 +5743,14 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         if (
             assign
             and not escaped
-            # if we're creating a class attribute, then we're not actually shadowing anything
-            and not is_class_attr
             # if we're not using the computation graph, then name is handled
             #  greedily, which means this might be an invalid parse, in which
             #  case we can't be sure this is actually shadowing a builtin;
             #  BUT if we're on strict mode, then it's an actual error, rather
             #  than a warning, which means we can just wrap it
             and safe_to_show_warnings
+            # if we're creating a class attribute, then we're not actually shadowing anything
+            and not is_class_attr
         ):
             if name in all_builtins:
                 err = self.strict_err_or_warn(
@@ -5735,7 +5766,7 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
             # the import statement itself, not an assignment shadowing an import
             if any(not same_line(original, loc, imp_loc) for imp_loc in self.name_info[name]["imported"]):
                 err = self.strict_err_or_warn(
-                    "assignment shadows imported name '{name}' (use explicit '\\{name}' syntax when purposefully redefining imported names)".format(name=name),
+                    "assignment shadows imported '{name}' (use explicit '\\{name}' syntax when purposefully redefining imported names)".format(name=name),
                     original,
                     loc,
                     raise_err_func=local_raise_or_wrap_error,
@@ -5743,6 +5774,22 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                 if err is not None:
                     return err
 
+        # undefined name checking
+        if (
+            not assign
+            and not escaped
+            and safe_to_show_warnings
+            and not self.star_import
+            and scope["all_vars"] is not None
+            and name not in all_builtins
+            and name != wildcard
+            and (expr_setnames_context is None or (
+                name not in expr_setnames_context["new_names"]
+                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))
+
         # only mark as final after all checks pass
         if is_final:
             final_vars[name] = loc
@@ -5772,7 +5819,6 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                 return "_coconut_exec"
         elif not assign and name in super_names and not self.target.startswith("3"):
             if self.in_method:
-                cls_context = self.current_parsing_context("class")
                 enclosing_cls = cls_context["name_prefix"] + cls_context["name"]
                 return self.add_code_before_marker_with_replacement(name, "__class__ = " + enclosing_cls + "\n", add_spaces=False)
             else:
@@ -5787,6 +5833,25 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         else:
             return name
 
+    def check_undefined_name(self, original, loc, name, scope, outer_ln):
+        """Run a deferred check for name being undefined in the scope chain.
+
+        We need outer_ln=self.outer_ln to be put in the partial so we know what
+        the outer_ln was when this check was set up."""
+        current_scope = scope
+        while current_scope is not None:
+            if current_scope["all_vars"] is None or name in current_scope["all_vars"]:
+                return
+            current_scope = current_scope["parent"]
+        self.strict_err_or_warn(
+            "found undefined name '{name}' (use explicit '\\{name}' syntax to bypass)".format(name=name),
+            original,
+            loc,
+            ln=outer_ln,
+            noqa_able=True,
+            endpoint=False,
+        )
+
 # end: MANAGERS
 # -----------------------------------------------------------------------------------------------------------------------
 # CHECKING HANDLERS:

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/compiler/grammar.py

@@ -861,18 +861,23 @@ class Grammar(object):
         expr_setname = Forward()
         final_setname = Forward()
         nonfinal_setname = Forward()
+        # classname and outer_setname define their vars in the outer scope
         final_classname = Forward()
         nonfinal_classname = Forward()
+        final_outer_setname = Forward()
+        nonfinal_outer_setname = Forward()
 
         name_ref = combine(Optional(backslash) + base_name)
         final_setname_ref = keyword("final").suppress() + name_ref
         setname = final_setname | nonfinal_setname
         classname = final_classname | nonfinal_classname
+        outer_setname = final_outer_setname | nonfinal_outer_setname
         unsafe_name = combine(Optional(backslash.suppress()) + base_name)
 
         # use unsafe_name for dotted components since name should only be used for base names
         dotted_refname = condense(refname + ZeroOrMore(dot + unsafe_name))
         dotted_setname = condense(setname + ZeroOrMore(dot + unsafe_name))
+        dotted_outer_setname = condense(outer_setname + ZeroOrMore(dot + unsafe_name))
         unsafe_dotted_name = condense(unsafe_name + ZeroOrMore(dot + unsafe_name))
         must_be_dotted_name = condense(refname + OneOrMore(dot + unsafe_name))
 
@@ -1566,7 +1571,7 @@ class Grammar(object):
         type_params = Group(lbrack.suppress() + tokenlist(type_param, comma) + rbrack.suppress())
 
         type_alias_stmt = Forward()
-        type_alias_stmt_ref = keyword("type").suppress() + setname + Optional(type_params) + equals.suppress() + typedef_test
+        type_alias_stmt_ref = keyword("type").suppress() + outer_setname + Optional(type_params) + equals.suppress() + typedef_test
 
         await_expr = Forward()
         await_expr_ref = keyword("await").suppress() + atom_item
@@ -2056,6 +2061,10 @@ class Grammar(object):
         del_stmt = addspace(keyword("del") - simple_assignlist)
 
         interior_name_match = labeled_group(setname, "var")
+        interior_capture_match = (
+            interior_name_match
+            | labeled_group(lparen.suppress() + match + rparen.suppress(), "paren")
+        )
         matchlist_anon_named_tuple_item = (
             Group(Optional(dot) + unsafe_name) + equals + match
             | Group(Optional(dot) + interior_name_match) + equals
@@ -2103,18 +2112,18 @@ class Grammar(object):
         match_string = interleaved_tokenlist(
             # f_string_atom must come first
             f_string_atom("f_string") | fixed_len_string_tokens("string"),
-            interior_name_match("capture"),
+            interior_capture_match("capture"),
             plus,
             at_least_two=True,
         )("string_sequence")
         sequence_match = interleaved_tokenlist(
             (match_list | match_tuple)("literal"),
-            interior_name_match("capture"),
+            interior_capture_match("capture"),
             plus,
         )("sequence")
         iter_match = interleaved_tokenlist(
             (match_list | match_tuple | match_lazy)("literal"),
-            interior_name_match("capture"),
+            interior_capture_match("capture"),
             unsafe_dubcolon,
             at_least_two=True,
         )("iter")
@@ -2306,7 +2315,7 @@ class Grammar(object):
         with_stmt = Forward()
 
         funcname_typeparams = Forward()
-        funcname_typeparams_tokens = dotted_setname + Optional(type_params)
+        funcname_typeparams_tokens = dotted_outer_setname + Optional(type_params)
         name_funcdef = condense(funcname_typeparams + parameters)
         op_tfpdef = unsafe_typedef_default | condense(setname + Optional(default))
         op_funcdef_arg = setname | condense(lparen.suppress() + op_tfpdef + rparen.suppress())

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/compiler/header.py

@@ -772,7 +772,7 @@ def _coconut_trollius_coroutine(func):
         def raise_import_error(*args, **kwargs):
             raise err
         return raise_import_error
-asyncio.coroutine = _coconut_trollius_coroutine
+types.ModuleType.__setattr__(asyncio, "coroutine", _coconut_trollius_coroutine)
 asyncio_Return = _coconut_lazy_module("trollius", attr="Return")
             ''',
             if_ge='''

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/compiler/matching.py

@@ -812,6 +812,8 @@ if {assign_to} is _coconut_sentinel:
                 if len(seq_groups) == 3:
                     (front_gtype, front_match), mid_group, (back_gtype, back_match) = seq_groups
                     internal_assert(front_gtype == "capture" == back_gtype, "invalid sequence match middle groups", seq_groups)
+                    if "paren" in front_match or "paren" in back_match:
+                        raise CoconutDeferredSyntaxError("parenthesized match patterns cannot be used in sequence search patterns", self.loc)
                     mid_gtype, mid_contents = mid_group
 
                     if iter_match:

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/constants.py

@@ -119,6 +119,7 @@ py_version_str = sys.version.split()[0]
 use_fast_pyparsing_reprs = get_bool_env_var("COCONUT_FAST_PYPARSING_REPRS", True)
 
 warn_on_multiline_regex = False
+warn_on_undefined_ParseResults_name = False
 
 default_whitespace_chars = " \t\f"  # the only non-newline whitespace Python allows
 
@@ -844,6 +845,7 @@ coconut_specific_builtins = (
     "and_then",
     "and_then_await",
     "async_map",
+    "py_bytes",
     "py_chr",
     "py_dict",
     "py_hex",

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/root.py

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

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/tests/src/cocotest/agnostic/primary_1.coco

@@ -445,10 +445,10 @@ def primary_test_1() -> bool:
     price = 100
     assert 0 == (requested_quantity ?? default_quantity) * price
     assert range(10) |> .[1] .. .[1:] == 2 == range(10) |> .[1:] |> .[1]
-    assert None?.herp(derp) is None  # type: ignore
-    assert None?[herp].derp is None  # type: ignore
-    assert None?(derp)[herp] is None  # type: ignore
-    assert None?$(herp)(derp) is None  # type: ignore
+    assert None?.herp(derp) is None  # type: ignore  # NOQA
+    assert None?[herp].derp is None  # type: ignore  # NOQA
+    assert None?(derp)[herp] is None  # type: ignore  # NOQA
+    assert None?$(herp)(derp) is None  # type: ignore  # NOQA
     a: int[]? = None  # type: ignore
     assert a is None
     assert range(5) |> iter |> reiterable |> .[1] == 1
@@ -962,7 +962,7 @@ def primary_test_1() -> bool:
     def ret_abc():
         return "abc"
     )
-    assert ret_abc() == "abc"
+    assert ret_abc() == "abc"  # NOQA
     assert """" """ == '" '
     assert "" == """"""
     assert (,)(*(1, 2), 3) == (1, 2, 3)

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/tests/src/cocotest/agnostic/primary_2.coco

@@ -732,6 +732,22 @@ def primary_test_2() -> bool:
     assert isinstance(lazy_d, lazy_deque)
     assert issubclass(type(lazy_d), lazy_deque)
 
+    # Issue #882: parenthesized match patterns in string captures
+    (int -> n882) + "G" = "8G"
+    assert n882 == 8
+    "G" + (int -> n882b) = "G8"
+    assert n882b == 8
+    "[" + (int -> n882c) + "]" = "[42]"
+    assert n882c == 42
+
+    a882 = "hello"
+    (==a882) + " world" = "hello world"
+
+    match (int -> mv882) + "px" in "100px":
+        assert mv882 == 100
+    else:
+        assert False
+
     # deferred ImportError on lazy imports
     lazy import coconut_nonexistent_test_module
     assert_raises(=> coconut_nonexistent_test_module.attr, ImportError)

{coconut_develop-3.2.0.post0.dev13 → coconut_develop-3.2.0.post0.dev15}/coconut/tests/src/extras.coco

@@ -143,6 +143,10 @@ def test_setup_none() -> bool:
     assert_raises(-> parse("def f(x) = return x"), CoconutSyntaxError)
     assert_raises(-> parse("def f(x) =\n return x"), CoconutSyntaxError)
     assert_raises(-> parse("10 20"), CoconutSyntaxError)
+    assert_raises(-> parse('x + "1" + (=="2") = "test"'), CoconutSyntaxError)
+    assert_raises(-> parse('(==x) + "1" + y = "test"'), CoconutSyntaxError)
+    assert_raises(-> parse(r'd"\n    hello"'), CoconutSyntaxError)
+    assert_raises(-> parse('d"""    hello"""'), CoconutSyntaxError)
 
     assert_raises(-> parse("()[(())"), CoconutSyntaxError, err_has="""
 unclosed open '[' (line 1)
@@ -433,7 +437,7 @@ line 6''')
         3
         """)
     except CoconutStyleError as err:
-        assert str(err) == """found undefined name 'x' (add '# NOQA' to suppress) (remove --strict to downgrade to a warning) (line 2)
+        assert str(err) == """found undefined name 'x' (use explicit '\\x' syntax to bypass) (add '# NOQA' to suppress) (remove --strict to downgrade to a warning) (line 2)
   2 + x
       ^"""
     assert_raises(-> parse(d"""
@@ -456,32 +460,58 @@ line 6''')
     """), CoconutStyleError, **(dict(err_has="\n ...\n") if not PYPY else {}))
     assert_raises(-> parse('["abc", "def" "ghi"]'), CoconutStyleError, err_has="implicit string concatenation")
 
+    # scope-aware undefined name tests
+    assert_raises(-> parse(d"""
+    def f():
+        x = 1
+    y = x
+    """), CoconutStyleError, err_has="undefined name")
+    assert_raises(-> parse(d"""
+    def f():
+        x = 1
+    def g():
+        y = x
+    """), CoconutStyleError, err_has="undefined name")
+    assert parse(d"""
+    x = 1
+    def f():
+        y = x
+    """)
+    assert parse(d"""
+    x = 1
+    y = x
+    """)
+    assert parse(d"""
+    import abc
+    abc.ABCMeta
+    """)
+
     # imported name shadowing tests
     assert_raises(-> parse(d"""
     import abc
     abc: int = 1
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     assert_raises(-> parse(d"""
     from os import path
     path = 'test'
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     assert_raises(-> parse(d"""
     from collections import OrderedDict
     def OrderedDict() = None
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     assert_raises(-> parse(d"""
     import abc
     class abc:
         pass
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     assert_raises(-> parse(d"""
     from os import path
     [path for path in []]
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     assert_raises(-> parse(d"""
     import abc
     final abc = 1
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     # class attribute shadowing should be allowed (not module-level shadowing)
     # (use NOQA to suppress unused import warning since we're intentionally shadowing)
     assert parse(d"""
@@ -501,7 +531,7 @@ line 6''')
     class Foo:
         def bar(self):
             abc = 1
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     assert_raises(-> parse(d"""
     class Foo:
         def bar(self):
@@ -545,7 +575,7 @@ line 6''')
         def foo(self):
             class abc:
                 pass
-    """), CoconutStyleError, err_has="shadows imported name")
+    """), CoconutStyleError, err_has="shadows import")
     # deeply nested: class inside class inside method - no error because super is a class attribute of B
     assert parse(d"""
     class A: