Fix more --pure errors

Author: evhub

coconut/compiler/compiler.py

@@ -869,6 +869,7 @@ def bind(cls):
         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 +904,16 @@ def bind(cls):
         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"))
@@ -5276,6 +5287,12 @@ def where_stmt_handle(self, loc, tokens):
 
         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 class_manage(self, original, loc, item):
         """Manage the class parsing context."""
@@ -5322,11 +5339,13 @@ def func_manage(self, original, loc, item):
             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):

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/compiler/util.py

@@ -1393,7 +1393,10 @@ def __repr__(self):
 
 
 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/root.py

@@ -26,7 +26,7 @@
 VERSION = "3.2.0"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 5
+DEVELOP = 6
 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/tests/main_test.py

@@ -1113,7 +1113,7 @@ class TestExternal(unittest.TestCase):
         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/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