coconut-develop 3.1.0.post0.dev16__tar.gz → 3.1.1.post0.dev2__tar.gz

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/CONTRIBUTING.md

@@ -155,7 +155,7 @@ After you've tested your changes locally, you'll want to add more permanent test
 1. Preparation:
     1. Run `make check-reqs` and update dependencies as necessary
     2. Run `sudo make format`
-    3. Make sure `make test`, `make test-py2`, and `make test-easter-eggs` are passing
+    3. Make sure `make test`, `make test-pyright`, and `make test-easter-eggs` are passing
     4. Ensure that `coconut --watch` can successfully compile files when they're modified
     5. Check changes in [`compiled-cocotest`](https://github.com/evhub/compiled-cocotest), [`pyprover`](https://github.com/evhub/pyprover), and [`coconut-prelude`](https://github.com/evhub/coconut-prelude)
     6. Check [Codebeat](https://codebeat.co/a/evhub/projects) and [LGTM](https://lgtm.com/dashboard) for `coconut` and `compiled-cocotest`

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coconut-develop
-Version: 3.1.0.post0.dev16
+Version: 3.1.1.post0.dev2
 Summary: Simple, elegant, Pythonic functional programming.
 Home-page: http://coconut-lang.org
 Author: Evan Hubinger

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/command/command.py

@@ -73,6 +73,7 @@ from coconut.constants import (
     coconut_cache_dir,
     coconut_sys_kwargs,
     interpreter_uses_incremental,
+    pyright_config_file,
 )
 from coconut.util import (
     univ_open,
@@ -293,7 +294,6 @@ class Command(object):
                 set_recursion_limit(args.recursion_limit)
             self.fail_fast = args.fail_fast
             self.display = args.display
-            self.pyright = args.pyright
             self.prompt.vi_mode = args.vi_mode
             if args.style is not None:
                 self.prompt.set_style(args.style)
@@ -344,9 +344,11 @@ class Command(object):
                     ),
                 )
 
-            # process mypy args and print timing info (must come after compiler setup)
+            # process mypy + pyright args and print timing info (must come after compiler setup)
             if args.mypy is not None:
                 self.set_mypy_args(args.mypy)
+            if args.pyright:
+                self.enable_pyright()
             logger.log_compiler_stats(self.comp)
 
             # do compilation, keeping track of compiled filepaths
@@ -697,15 +699,15 @@ class Command(object):
                 errmsg = format_error(err)
             else:
                 errmsg = err.__class__.__name__
-        if errmsg is not None:
-            if self.errmsg is None:
-                self.errmsg = errmsg
-            elif errmsg not in self.errmsg:
-                if logger.verbose:
-                    self.errmsg += "\nAnd error: " + errmsg
-                else:
-                    self.errmsg += "; " + errmsg
-        if code is not None:
+        if code:
+            if errmsg is not None:
+                if self.errmsg is None:
+                    self.errmsg = errmsg
+                elif errmsg not in self.errmsg:
+                    if logger.verbose:
+                        self.errmsg += "\nAnd error: " + errmsg
+                    else:
+                        self.errmsg += "; " + errmsg
             self.exit_code = code or self.exit_code
 
     @contextmanager
@@ -888,7 +890,7 @@ class Command(object):
                     if no_str_code is not None:
                         result = mypy_builtin_regex.search(no_str_code)
                         if result:
-                            logger.warn("found mypy-only built-in " + repr(result.group(0)) + "; pass --mypy to use mypy-only built-ins at the interpreter")
+                            logger.warn("found type-checking-only built-in " + repr(result.group(0)) + "; pass --mypy to use such built-ins at the interpreter")
 
             else:  # header is included
                 compiled = rem_encoding(compiled)
@@ -935,10 +937,11 @@ class Command(object):
         if mypy_args is None:
             self.mypy_args = None
 
-        elif mypy_install_arg in mypy_args:
+        stub_dir = set_mypy_path()
+
+        if mypy_install_arg in mypy_args:
             if mypy_args != [mypy_install_arg]:
                 raise CoconutException("'--mypy install' cannot be used alongside other --mypy arguments")
-            stub_dir = set_mypy_path()
             logger.show_sig("Successfully installed MyPy stubs into " + repr(stub_dir))
             self.mypy_args = None
 
@@ -968,10 +971,15 @@ class Command(object):
             logger.log("MyPy args:", self.mypy_args)
             self.mypy_errs = []
 
+    def enable_pyright(self):
+        """Enable the use of Pyright for type-checking."""
+        update_pyright_config()
+        self.pyright = True
+
     def run_type_checking(self, paths=(), code=None):
         """Run type-checking on the given paths / code."""
         if self.mypy_args is not None:
-            set_mypy_path()
+            set_mypy_path(ensure_stubs=False)
             from coconut.command.mypy import mypy_run
             args = list(paths) + self.mypy_args
             if code is not None:  # interpreter
@@ -996,13 +1004,18 @@ class Command(object):
                             logger.printerr(line)
                         self.mypy_errs.append(line)
         if self.pyright:
-            config_file = update_pyright_config()
             if code is not None:
-                logger.warn("--pyright only works on files, not code snippets or at the interpreter")
+                logger.warn("--pyright only works on files, not code snippets or at the interpreter (use --mypy instead)")
             if paths:
-                from pyright import main
-                args = ["--project", config_file, "--pythonversion", self.type_checking_version] + list(paths)
-                main(args)
+                try:
+                    from pyright import main
+                except ImportError:
+                    raise CoconutException(
+                        "coconut --pyright requires Pyright",
+                        extra="run '{python} -m pip install coconut[pyright]' to fix".format(python=sys.executable),
+                    )
+                args = ["--project", pyright_config_file, "--pythonversion", self.type_checking_version] + list(paths)
+                self.register_exit_code(main(args), errmsg="Pyright error")
 
     def run_silent_cmd(self, *args):
         """Same as run_cmd$(show_output=logger.verbose)."""

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/command/mypy.py

@@ -34,7 +34,7 @@ try:
     from mypy.api import run
 except ImportError:
     raise CoconutException(
-        "--mypy flag requires MyPy library",
+        "coconut --mypy requires MyPy",
         extra="run '{python} -m pip install coconut[mypy]' to fix".format(python=sys.executable),
     )
 

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/command/util.py

@@ -488,10 +488,12 @@ def set_env_var(name, value):
     os.environ[py_str(name)] = py_str(value)
 
 
-def set_mypy_path():
+def set_mypy_path(ensure_stubs=True):
     """Put Coconut stubs in MYPYPATH."""
+    if ensure_stubs:
+        install_stubs()
     # mypy complains about the path if we don't use / over \
-    install_dir = install_stubs().replace(os.sep, "/")
+    install_dir = installed_stub_dir.replace(os.sep, "/")
     original = os.getenv(mypy_path_env_var)
     if original is None:
         new_mypy_path = install_dir
@@ -507,13 +509,20 @@ def set_mypy_path():
 
 def update_pyright_config(python_version=None):
     """Save an updated pyrightconfig.json."""
+    stubs_dir = install_stubs()
     update_existing = os.path.exists(pyright_config_file)
     with univ_open(pyright_config_file, "r+" if update_existing else "w") as config_file:
         if update_existing:
-            config = readfile(config_file, in_json=True)
+            try:
+                config = readfile(config_file, in_json=True)
+            except ValueError:
+                raise CoconutException("invalid JSON syntax in " + repr(pyright_config_file))
         else:
             config = extra_pyright_args.copy()
-        config["extraPaths"] = [install_stubs()]
+        if "extraPaths" not in config:
+            config["extraPaths"] = []
+        if stubs_dir not in config["extraPaths"]:
+            config["extraPaths"].append(stubs_dir)
         if python_version is not None:
             config["pythonVersion"] = python_version
         writefile(config_file, config, in_json=True, indent=tabideal)

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/compiler/compiler.py

@@ -246,12 +246,17 @@ else:
     )
 
 
-def imported_names(imports):
-    """Yields all the names imported by imports = [[imp1], [imp2, as], ...]."""
+def get_imported_names(imports):
+    """Returns all the names imported by imports = [[imp1], [imp2, as], ...] and whether there is a star import."""
+    saw_names = []
+    saw_star = False
     for imp in imports:
         imp_name = imp[-1].split(".", 1)[0]
-        if imp_name != "*":
-            yield imp_name
+        if imp_name == "*":
+            saw_star = True
+        else:
+            saw_names.append(imp_name)
+    return saw_names, saw_star
 
 
 def special_starred_import_handle(imp_all=False):
@@ -529,7 +534,8 @@ class Compiler(Grammar, pickleable_obj):
         # but always overwrite temp_vars_by_key since they store locs that will be invalidated
         self.temp_vars_by_key = {}
         self.parsing_context = defaultdict(list)
-        self.unused_imports = defaultdict(list)
+        self.name_info = defaultdict(lambda: {"imported": [], "referenced": [], "assigned": []})
+        self.star_import = False
         self.kept_lines = []
         self.num_lines = 0
         self.disable_name_check = False
@@ -942,6 +948,11 @@ class Compiler(Grammar, pickleable_obj):
         if self.strict:
             raise self.make_err(CoconutStyleError, *args, **kwargs)
 
+    def strict_warn(self, *args, **kwargs):
+        internal_assert("extra" not in kwargs, "cannot pass extra=... to strict_warn")
+        if self.strict:
+            self.syntax_warning(*args, extra="remove --strict to dismiss", **kwargs)
+
     def syntax_warning(self, message, original, loc, **kwargs):
         """Show a CoconutSyntaxWarning. Usage:
             self.syntax_warning(message, original, loc)
@@ -1319,21 +1330,30 @@ class Compiler(Grammar, pickleable_obj):
             elif inputstring is not None and not inner:
                 logger.log("No streamlining done for input of length {length}.".format(length=input_len))
 
+    def qa_error(self, msg, original, loc):
+        """Strict error or warn an error that should be disabled by a NOQA comment."""
+        ln = self.adjust(lineno(loc, original))
+        comment = self.reformat(" ".join(self.comments[ln]), ignore_errors=True)
+        if not self.noqa_regex.search(comment):
+            self.strict_err_or_warn(
+                msg + " (add '# NOQA' to suppress)",
+                original,
+                loc,
+                endpoint=False,
+            )
+
     def run_final_checks(self, original, keep_state=False):
         """Run post-parsing checks to raise any necessary errors/warnings."""
-        # only check for unused imports if we're not keeping state accross parses
+        # only check for unused imports/etc. if we're not keeping state accross parses
         if not keep_state:
-            for name, locs in self.unused_imports.items():
-                for loc in locs:
-                    ln = self.adjust(lineno(loc, original))
-                    comment = self.reformat(" ".join(self.comments[ln]), ignore_errors=True)
-                    if not self.noqa_regex.search(comment):
-                        self.strict_err_or_warn(
-                            "found unused import " + repr(self.reformat(name, ignore_errors=True)) + " (add '# NOQA' to suppress)",
-                            original,
-                            loc,
-                            endpoint=False,
-                        )
+            for name, info in self.name_info.items():
+                if info["imported"] and not info["referenced"]:
+                    for loc in info["imported"]:
+                        self.qa_error("found unused import " + repr(self.reformat(name, ignore_errors=True)), original, loc)
+                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.qa_error("found undefined name " + repr(self.reformat(name, ignore_errors=True)), original, loc)
 
     def parse_line_by_line(self, init_parser, line_parser, original):
         """Apply init_parser then line_parser repeatedly."""
@@ -3731,13 +3751,17 @@ if {store_var} is not _coconut_sentinel:
         else:
             raise CoconutInternalException("invalid import tokens", tokens)
         imports = list(imports)
-        if imp_from == "*" or imp_from is None and "*" in imports:
+        imported_names, star_import = get_imported_names(imports)
+        self.star_import = self.star_import or star_import
+        if star_import:
+            self.strict_warn("found * import; these disable Coconut's undefined name detection", original, loc)
+        if imp_from == "*" or (imp_from is None and star_import):
             if not (len(imports) == 1 and imports[0] == "*"):
                 raise self.make_err(CoconutSyntaxError, "only [from *] import * allowed, not from * import name", original, loc)
             self.syntax_warning("[from *] import * is a Coconut Easter egg and should not be used in production code", original, loc)
             return special_starred_import_handle(imp_all=bool(imp_from))
-        for imp_name in imported_names(imports):
-            self.unused_imports[imp_name].append(loc)
+        for imp_name in imported_names:
+            self.name_info[imp_name]["imported"].append(loc)
         return self.universal_import(loc, imports, imp_from=imp_from)
 
     def complex_raise_stmt_handle(self, loc, tokens):
@@ -4575,7 +4599,7 @@ async with {iter_item} as {temp_var}:
             return tokens[0]
         else:
             if not allow_silent_concat:
-                self.strict_err_or_warn("found Python-style implicit string concatenation (use explicit '+' instead)", original, loc)
+                self.strict_err_or_warn("found implicit string concatenation (use explicit '+' instead)", original, loc)
             if any(s.endswith(")") for s in tokens):  # has .format() calls
                 # parens are necessary for string_atom_handle
                 return "(" + " + ".join(tokens) + ")"
@@ -4989,8 +5013,10 @@ class {protocol_var}({tokens}, _coconut.typing.Protocol): pass
                             )
                         return typevars[name]
 
-        if not assign:
-            self.unused_imports.pop(name, None)
+        if assign:
+            self.name_info[name]["assigned"].append(loc)
+        else:
+            self.name_info[name]["referenced"].append(loc)
 
         if (
             assign

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/compiler/header.py

@@ -939,8 +939,8 @@ def getheader(which, use_hash, target, no_tco, strict, no_wrap):
         header += "from __future__ import print_function, absolute_import, unicode_literals, division\n"
     # including generator_stop here is fine, even though to universalize generator returns
     #  we raise StopIteration errors, since we only do so when target_info < (3, 3)
-    elif target_info >= (3, 13):
-        # 3.13 supports lazy annotations, so we should just use that instead of from __future__ import annotations
+    elif target_info >= (3, 14):
+        # 3.14 supports lazy annotations, so we should just use that instead of from __future__ import annotations
         header += "from __future__ import generator_stop\n"
     elif target_info >= (3, 7):
         if no_wrap:

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/constants.py

@@ -222,6 +222,7 @@ supported_py3_vers = (
     (3, 11),
     (3, 12),
     (3, 13),
+    (3, 14),
 )
 
 # must be in ascending order and kept up-to-date with https://devguide.python.org/versions
@@ -233,6 +234,7 @@ py_vers_with_eols = (
     ("311", dt.datetime(2027, 11, 1)),
     ("312", dt.datetime(2028, 11, 1)),
     ("313", dt.datetime(2029, 11, 1)),
+    ("314", dt.datetime(2030, 11, 1)),
 )
 
 # must match supported vers above and must be replicated in DOCS
@@ -251,6 +253,7 @@ specific_targets = (
     "311",
     "312",
     "313",
+    "314",
 )
 pseudo_targets = {
     "universal": "",
@@ -604,15 +607,20 @@ python_builtins = (
     "tuple", "type",
     "vars",
     "zip",
+    'Ellipsis',
     "__import__",
     '__name__',
     '__file__',
     '__annotations__',
     '__debug__',
+    '__build_class__',
+    '__loader__',
+    '__package__',
+    '__spec__',
 )
 
 python_exceptions = (
-    "BaseException", "BaseExceptionGroup", "GeneratorExit", "KeyboardInterrupt", "SystemExit", "Exception", "ArithmeticError", "FloatingPointError", "OverflowError", "ZeroDivisionError", "AssertionError", "AttributeError", "BufferError", "EOFError", "ExceptionGroup", "BaseExceptionGroup", "ImportError", "ModuleNotFoundError", "LookupError", "IndexError", "KeyError", "MemoryError", "NameError", "UnboundLocalError", "OSError", "BlockingIOError", "ChildProcessError", "ConnectionError", "BrokenPipeError", "ConnectionAbortedError", "ConnectionRefusedError", "ConnectionResetError", "FileExistsError", "FileNotFoundError", "InterruptedError", "IsADirectoryError", "NotADirectoryError", "PermissionError", "ProcessLookupError", "TimeoutError", "ReferenceError", "RuntimeError", "NotImplementedError", "RecursionError", "StopAsyncIteration", "StopIteration", "SyntaxError", "IndentationError", "TabError", "SystemError", "TypeError", "ValueError", "UnicodeError", "UnicodeDecodeError", "UnicodeEncodeError", "UnicodeTranslateError", "Warning", "BytesWarning", "DeprecationWarning", "EncodingWarning", "FutureWarning", "ImportWarning", "PendingDeprecationWarning", "ResourceWarning", "RuntimeWarning", "SyntaxWarning", "UnicodeWarning", "UserWarning",
+    'ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError'
 )
 
 always_keep_parse_name_prefix = "HAS_"
@@ -1043,7 +1051,7 @@ unpinned_min_versions = {
     ("argparse", "py<27"): (1, 4),
     "pexpect": (4,),
     ("trollius", "py<3;cpy"): (2, 2),
-    "requests": (2, 31),
+    "requests": (2, 32),
     ("numpy", "py39"): (1, 26),
     ("xarray", "py39"): (2024,),
     ("dataclasses", "py==36"): (0, 8),
@@ -1055,14 +1063,14 @@ unpinned_min_versions = {
     "pyright": (1, 1),
     ("jupyter-console", "py37"): (6, 6),
     ("typing", "py<35"): (3, 10),
-    ("typing_extensions", "py>=38"): (4, 11),
+    ("typing_extensions", "py>=38"): (4, 12),
     ("ipykernel", "py38"): (6,),
     ("jedi", "py39"): (0, 19),
-    ("pygments", "py>=39"): (2, 17),
+    ("pygments", "py>=39"): (2, 18),
     ("xonsh", "py39"): (0, 16),
     ("async_generator", "py35"): (1, 10),
     ("exceptiongroup", "py37;py<311"): (1,),
-    ("ipython", "py>=310"): (8, 24),
+    ("ipython", "py>=310"): (8, 25),
     "py-spy": (0, 3),
 }
 

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/root.py

@@ -23,10 +23,10 @@ import sys as _coconut_sys
 # VERSION:
 # -----------------------------------------------------------------------------------------------------------------------
 
-VERSION = "3.1.0"
+VERSION = "3.1.1"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 16
+DEVELOP = 2
 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.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/tests/__main__.py

@@ -44,12 +44,13 @@ def main(args=None):
 
     # compile everything
     print("Compiling Coconut test suite with args %r and agnostic_target=%r." % (args, agnostic_target))
+    type_checking = "--mypy" in args or "--pyright" in args
     comp_all(
         args,
         agnostic_target=agnostic_target,
-        expect_retcode=0 if "--mypy" not in args else None,
+        expect_retcode=0 if not type_checking else None,
         check_errors="--verbose" not in args,
-        ignore_output=WINDOWS and "--mypy" not in args,
+        ignore_output=WINDOWS and not type_checking,
     )
 
 

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/tests/main_test.py

@@ -154,6 +154,8 @@ always_err_strs = (
 ignore_error_lines_with = (
     # ignore SyntaxWarnings containing assert_raises or raise
     "raise",
+    # ignore Pyright errors
+    " - error: ",
 )
 
 mypy_snip = "a: str = count()[0]"
@@ -179,7 +181,8 @@ ignore_last_lines_with = (
     "from distutils.version import LooseVersion",
     ": SyntaxWarning: 'int' object is not ",
     ": CoconutWarning: Deprecated use of ",
-    " assert_raises(",
+    "  assert_raises(",
+    "  assert ",
     "Populating initial parsing cache",
     "_coconut.warnings.warn(",
     ": SyntaxWarning: invalid escape sequence",

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/tests/src/cocotest/agnostic/primary_1.coco

@@ -90,7 +90,7 @@ def primary_test_1() -> bool:
     \\assert data == 3
     \\def backslash_test():
         return (x) -> x
-    assert \(1) == 1 == backslash_test()(1)
+    assert \(1) == 1 == backslash_test()(1)  # NOQA
     assert True is (\(
             "hello"
         ) == "hello" == \(
@@ -100,7 +100,7 @@ def primary_test_1() -> bool:
                                    x,
                                    y):
         return x + y
-    assert multiline_backslash_test(1, 2) == 3
+    assert multiline_backslash_test(1, 2) == 3  # noqa
     \\ assert True
     class one_line_class: pass
     assert isinstance(one_line_class(), one_line_class)

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/tests/src/cocotest/agnostic/primary_2.coco

@@ -465,6 +465,7 @@ def primary_test_2() -> bool:
 "{x}"
 """ == '\n"2"\n'
     assert f"\{1}" == "\\1"
+    assert f''' '{1}' ''' == " '1' "
 
     with process_map.multiple_sequential_calls():  # type: ignore
         assert map((+), range(3), range(4)$[:-1], strict=True) |> list == [0, 2, 4] == process_map((+), range(3), range(4)$[:-1], strict=True) |> list  # type: ignore

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/tests/src/cocotest/agnostic/tutorial.coco

@@ -22,13 +22,15 @@ assert range(1, 5) |> product == 24
 first_five_words = .split() ..> .$[:5] ..> " ".join
 assert first_five_words("ab cd ef gh ij kl") == "ab cd ef gh ij"
 
-@recursive_iterator
+# TODO: recursive_iterator -> recursive_generator
+@recursive_iterator  # noqa
 def fib() = (1, 1) :: map((+), fib(), fib()$[1:])
 assert fib()$[:5] |> list == [1, 1, 2, 3, 5]
 
+# TODO: parallel_map -> process_map
 # can't use parallel_map here otherwise each process would have to rerun all
 #  the tutorial tests since we don't guard them behind __name__ == "__main__"
-assert range(100) |> concurrent_map$(.**2) |> list |> .$[-1] == 9801
+assert range(100) |> thread_map$(.**2) |> list |> .$[-1] == 9801
 
 def factorial(n, acc=1):
     match n:

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/tests/src/cocotest/target_2/py2_test.coco

@@ -4,5 +4,5 @@ def py2_test() -> bool:
     assert py_map((+)$(2), range(5)) == [2, 3, 4, 5, 6]
     assert py_range(5) == [0, 1, 2, 3, 4]
     assert not isinstance(long(1), py_int)  # type: ignore
-    assert py_str(3) == b"3" == unicode(b"3")  # type: ignore
+    assert py_str(3) == b"3" == unicode(b"3")  # noqa  # type: ignore
     return True

{coconut-develop-3.1.0.post0.dev16 → coconut-develop-3.1.1.post0.dev2}/coconut/tests/src/extras.coco

@@ -414,6 +414,16 @@ import abc
     except CoconutStyleError as err:
         assert str(err) == """found unused import 'abc' (add '# NOQA' to suppress) (remove --strict to downgrade to a warning) (line 1)
   import abc"""
+    try:
+        parse("""
+1
+2 + x
+3
+        """.strip())
+    except CoconutStyleError as err:
+        assert str(err) == """found undefined name 'x' (add '# NOQA' to suppress) (remove --strict to downgrade to a warning) (line 2)
+  2 + x
+      ^"""
     assert_raises(-> parse("""
 class A(object):
     1