coconut-develop 3.2.0.post0.dev5__tar.gz → 3.2.0.post0.dev7__tar.gz

{coconut_develop-3.2.0.post0.dev5 → coconut_develop-3.2.0.post0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coconut-develop
-Version: 3.2.0.post0.dev5
+Version: 3.2.0.post0.dev7
 Summary: Simple, elegant, Pythonic functional programming.
 Home-page: http://coconut-lang.org
 Author: Evan Hubinger

{coconut_develop-3.2.0.post0.dev5 → coconut_develop-3.2.0.post0.dev7}/coconut/compiler/compiler.py

@@ -105,6 +105,7 @@ from coconut.constants import (
     incremental_cache_limit,
     use_line_by_line_parser,
     coconut_cache_dir,
+    wildcard,
 )
 from coconut.util import (
     pickle,
@@ -785,7 +786,7 @@ class Compiler(Grammar, pickleable_obj):
         cls.type_alias_stmt <<= handle_and_manage(
             cls.type_alias_stmt_ref,
             cls.method("type_alias_stmt_handle"),
-            cls.method("type_alias_stmt_manage"),
+            cls.method("scope_manage"),
             include_in_packrat_context=False,
         )
 
@@ -869,6 +870,7 @@ class Compiler(Grammar, pickleable_obj):
         cls.no_partial_trailer_atom <<= attach(cls.no_partial_trailer_atom_ref, cls.method("item_handle"))
         cls.simple_assign <<= attach(cls.simple_assign_ref, cls.method("item_handle"))
         cls.expr_simple_assign <<= attach(cls.expr_simple_assign_ref, cls.method("item_handle"))
+        cls.unsafe_simple_assign <<= attach(cls.unsafe_simple_assign_ref, cls.method("item_handle"))
 
         # handle all star assignments with star_assign_item_check
         cls.star_assign_item <<= attach(cls.star_assign_item_ref, cls.method("star_assign_item_check"))
@@ -903,6 +905,16 @@ class Compiler(Grammar, pickleable_obj):
         cls.name_match_funcdef <<= attach(cls.name_match_funcdef_ref, cls.method("name_match_funcdef_handle"))
         cls.op_match_funcdef <<= attach(cls.op_match_funcdef_ref, cls.method("op_match_funcdef_handle"))
         cls.base_case_funcdef <<= attach(cls.base_case_funcdef_ref, cls.method("base_case_funcdef_handle"))
+        cls.case_funcdef_case <<= manage(
+            cls.case_funcdef_case_ref,
+            cls.method("case_funcdef_clause_manage"),
+            include_in_packrat_context=False,
+        )
+        cls.case_funcdef_type <<= manage(
+            cls.case_funcdef_type_ref,
+            cls.method("case_funcdef_clause_manage"),
+            include_in_packrat_context=False,
+        )
         cls.yield_from <<= attach(cls.yield_from_ref, cls.method("yield_from_handle"))
         cls.typedef <<= attach(cls.typedef_ref, cls.method("typedef_handle"))
         cls.typedef_default <<= attach(cls.typedef_default_ref, cls.method("typedef_handle"))
@@ -5196,19 +5208,6 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                 raise CoconutInternalException("invalid TypeVarFunc", TypeVarFunc, "(", name, ")")
         return "_coconut.typing.Generic[" + ", ".join(generics) + "]"
 
-    @contextmanager
-    def type_alias_stmt_manage(self, original=None, loc=None, item=None):
-        """Manage the typevars parsing context."""
-        prev_typevar_info = self.current_parsing_context("typevars")
-        with self.add_to_parsing_context({
-            "typevars": {
-                "all_typevars": {} if prev_typevar_info is None else prev_typevar_info["all_typevars"].copy(),
-                "new_typevars": [],
-                "typevar_locs": {},
-            },
-        }):
-            yield
-
     def type_alias_stmt_handle(self, tokens):
         """Handle type alias statements."""
         if len(tokens) == 2:
@@ -5276,6 +5275,26 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
 
         return self.wrap_passthrough(out, early=True)
 
+    @property
+    def in_method(self):
+        """Determine if currently in a method."""
+        cls_context = self.current_parsing_context("class")
+        return cls_context is not None and cls_context["name"] is not None and cls_context["in_method"]
+
+    @contextmanager
+    def scope_manage(self, original=None, loc=None, item=None):
+        """Manage a context that opens a new scope."""
+        prev_typevar_info = self.current_parsing_context("typevars")
+        with self.add_to_parsing_context({
+            "scope": self.get_empty_scope(),
+            "typevars": {
+                "all_typevars": {} if prev_typevar_info is None else prev_typevar_info["all_typevars"].copy(),
+                "new_typevars": [],
+                "typevar_locs": {},
+            },
+        }):
+            yield
+
     @contextmanager
     def class_manage(self, original, loc, item):
         """Manage the class parsing context."""
@@ -5296,12 +5315,9 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
             "in_method": False,
         })
         try:
-            # handles support for class type variables
-            with self.type_alias_stmt_manage():
-                with self.add_to_parsing_context({
-                    "scope": self.get_empty_scope(),
-                }):
-                    yield
+            # handles support for class type variables and opens a new scope
+            with self.scope_manage():
+                yield
         finally:
             cls_stack.pop()
 
@@ -5312,21 +5328,20 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         if cls_context is not None:
             in_method, cls_context["in_method"] = cls_context["in_method"], True
         try:
-            # handles support for function type variables
-            with self.type_alias_stmt_manage():
-                with self.add_to_parsing_context({
-                    "scope": self.get_empty_scope(),
-                }):
-                    yield
+            # handles support for function type variables and opens a new scope
+            with self.scope_manage():
+                yield
         finally:
             if cls_context is not None:
                 cls_context["in_method"] = in_method
 
-    @property
-    def in_method(self):
-        """Determine if currently in a method."""
-        cls_context = self.current_parsing_context("class")
-        return cls_context is not None and cls_context["name"] is not None and cls_context["in_method"]
+    @contextmanager
+    def case_funcdef_clause_manage(self, original, loc, item):
+        """Manage the scope for each case clause in a case def."""
+        with self.add_to_parsing_context({
+            "scope": self.get_empty_scope(),
+        }):
+            yield
 
     @contextmanager
     def has_expr_setname_manage(self, original, loc, item):
@@ -5519,7 +5534,15 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
         # only mark as final after all checks pass
         if is_final:
             final_vars[name] = loc
-        if self.pure and assign and not escaped and not expr_setname:
+        if (
+            self.pure
+            and assign
+            and not escaped
+            and not expr_setname
+            # wildcard matching uses setname but doesn't actually assign the name,
+            #  so we need this to avoid false positives
+            and name != wildcard
+        ):
             pure_vars[name] = loc
 
         if name == "exec":

{coconut_develop-3.2.0.post0.dev5 → coconut_develop-3.2.0.post0.dev7}/coconut/compiler/grammar.py

@@ -1511,9 +1511,27 @@ class Grammar(object):
         expr_assign_item = expr_base_assign_item | expr_star_assign_item
         expr_assignlist <<= itemlist(expr_assign_item, comma, suppress_trailing=False)
 
+        # must be kept in sync with assignlist block above (but with unsafe_name)
+        unsafe_simple_assign = Forward()
+        unsafe_simple_assign_ref = maybeparens(
+            lparen,
+            (
+                # refname if there's a trailer, unsafe_name if not
+                (refname | passthrough_atom) + OneOrMore(ZeroOrMore(complex_trailer) + OneOrMore(simple_trailer))
+                | unsafe_name
+                | passthrough_atom
+            ),
+            rparen,
+        )
+
         simple_assignlist = maybeparens(lparen, itemlist(simple_assign, comma, suppress_trailing=False), rparen)
         typed_assign_stmt = Forward()
-        typed_assign_stmt_ref = simple_assign + colon.suppress() + typedef_test + Optional(equals.suppress() + test_expr)
+        typed_assign_stmt_ref = (
+            # with assignment value, use simple_assign
+            simple_assign + colon.suppress() + typedef_test + equals.suppress() + test_expr
+            # bare annotation, use unsafe_simple_assign
+            | unsafe_simple_assign + colon.suppress() + typedef_test
+        )
         basic_stmt = addspace(ZeroOrMore(assignlist + equals) + test_expr)
 
         type_param = Forward()
@@ -2369,6 +2387,41 @@ class Grammar(object):
         )
 
         base_case_funcdef = Forward()
+        case_funcdef_case = Forward()
+        case_funcdef_case_ref = (
+            keyword("case").suppress()
+            + lparen.suppress()
+            + match_args_list
+            + match_guard
+            + rparen.suppress()
+            + (
+                colon.suppress()
+                + (
+                    newline.suppress()
+                    + indent.suppress()
+                    + attach(condense(OneOrMore(stmt)), make_suite_handle)
+                    + dedent.suppress()
+                    | attach(simple_stmt, make_suite_handle)
+                )
+                | equals.suppress()
+                + (
+                    (
+                        newline.suppress()
+                        + indent.suppress()
+                        + attach(math_funcdef_body, make_suite_handle)
+                        + dedent.suppress()
+                    )
+                    | attach(implicit_return_stmt, make_suite_handle)
+                )
+            )
+        )
+        case_funcdef_type = Forward()
+        case_funcdef_type_ref = (
+            keyword("type").suppress()
+            + parameters
+            + return_typedef
+            + newline.suppress()
+        )
         base_case_funcdef_ref = (
             keyword("def").suppress()
             + Group(
@@ -2381,38 +2434,11 @@ class Grammar(object):
             - Optional(docstring)
             - Group(OneOrMore(
                 labeled_group(
-                    keyword("case").suppress()
-                    + lparen.suppress()
-                    + match_args_list
-                    + match_guard
-                    + rparen.suppress()
-                    + (
-                        colon.suppress()
-                        + (
-                            newline.suppress()
-                            + indent.suppress()
-                            + attach(condense(OneOrMore(stmt)), make_suite_handle)
-                            + dedent.suppress()
-                            | attach(simple_stmt, make_suite_handle)
-                        )
-                        | equals.suppress()
-                        + (
-                            (
-                                newline.suppress()
-                                + indent.suppress()
-                                + attach(math_funcdef_body, make_suite_handle)
-                                + dedent.suppress()
-                            )
-                            | attach(implicit_return_stmt, make_suite_handle)
-                        )
-                    ),
+                    case_funcdef_case,
                     "match",
                 )
                 | labeled_group(
-                    keyword("type").suppress()
-                    + parameters
-                    + return_typedef
-                    + newline.suppress(),
+                    case_funcdef_type,
                     "type",
                 )
             ))

{coconut_develop-3.2.0.post0.dev5 → coconut_develop-3.2.0.post0.dev7}/coconut/compiler/util.py

@@ -1393,7 +1393,10 @@ class Wrap(ParseElementEnhance):
 
 
 def manage(item, manager, include_in_packrat_context, greedy=True):
-    """Attach a manager to the given parse item."""
+    """Attach a manager to the given parse item.
+
+    include_in_packrat_context should be True if the manager changes whether a parse can succeed and False otherwise.
+    """
     return Wrap(item, manager, include_in_packrat_context=include_in_packrat_context, greedy=greedy)
 
 

{coconut_develop-3.2.0.post0.dev5 → coconut_develop-3.2.0.post0.dev7}/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 = 5
+DEVELOP = 7
 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.dev5 → coconut_develop-3.2.0.post0.dev7}/coconut/tests/main_test.py

@@ -1113,7 +1113,7 @@ if TEST_ALL:
         if not PYPY or PY2:
             def test_prelude(self):
                 with using_paths(prelude):
-                    comp_prelude(expect_retcode=None)
+                    comp_prelude(["--strict", "--pure"], expect_retcode=None)
                     if MYPY and PY38:
                         run_prelude()
 

{coconut_develop-3.2.0.post0.dev5 → coconut_develop-3.2.0.post0.dev7}/coconut/tests/src/extras.coco

@@ -572,6 +572,15 @@ class A:
 class A:
     def mk_int(x) = int(x)
     """.strip())
+    assert parse("""
+x: int
+x = 1
+    """.strip())
+    assert parse("""
+case def f:
+    case(x) = x
+    case(x, y) = x + y
+    """.strip())
     assert_raises(-> parse("""
 def f():
     global x