Merge pull request #2463 from Kodiologist/try-empties

`try` cleanup

Author: Kodiologist

NEWS.rst

@@ -37,6 +37,8 @@ New Features
 * Python 3.12 is now supported.
 * `nonlocal` and `global` can now be called with no arguments, in which
   case they're no-ops.
+* `try` no longer requires `except`, `except*`, or `finally`, and it
+  allows `else` even without `except` or `except*`.
 * The `py` macro now implicitly parenthesizes the input code, so Python's
   indentation restrictions don't apply.
 * `cut` now has a function version in `hy.pyops`.

docs/api.rst

@@ -996,10 +996,8 @@ base names, such that ``hy.core.macros.foo`` can be called as just ``foo``.
    list of exception types, followed by more body forms. Finally there are an
    optional ``else`` form and an optional ``finally`` form, which again are
    expressions that begin with the symbol in question and then comprise body
-   forms. As in Python, at least one of ``except``, ``except*``, or ``finally``
-   is required; ``else`` is only allowed if at least one ``except`` or
-   ``except*`` is provided; ``except*`` requires Python 3.11; and ``except``
-   and ``except*`` may not both be used in the same ``try``.
+   forms. Note that ``except*`` requires Python 3.11, and ``except*`` and
+   ``except`` may not both be used in the same ``try``.
 
    Here's an example of several of the allowed kinds of child forms::
 

hy/core/result_macros.py

@@ -1292,7 +1292,16 @@ def compile_raise_expression(compiler, expr, root, exc, cause):
     ],
 )
 def compile_try_expression(compiler, expr, root, body, catchers, orelse, finalbody):
+    if orelse is not None and not catchers:
+        # Python forbids `else` when there are no `except` clauses.
+        # But we can get the same effect by appending the `else` forms
+        # to the body.
+        body += list(orelse)
+        orelse = None
     body = compiler._compile_branch(body)
+    if not (catchers or finalbody):
+        # Python forbids this, so just return the body, per `do`.
+        return body
 
     return_var = asty.Name(expr, id=mangle(compiler.get_anon_var()), ctx=ast.Store())
 
@@ -1367,15 +1376,6 @@ def compile_try_expression(compiler, expr, root, body, catchers, orelse, finalbo
         finalbody += finalbody.expr_as_stmt()
         finalbody = finalbody.stmts
 
-    # Using (else) without (except) is verboten!
-    if orelse and not handlers:
-        raise compiler._syntax_error(expr, "`try' cannot have `else' without `except'")
-    # Likewise a bare (try) or (try BODY).
-    if not (handlers or finalbody):
-        raise compiler._syntax_error(
-            expr, "`try' must have an `except' or `finally' clause"
-        )
-
     returnable = Result(
         expr=asty.Name(expr, id=return_var.id, ctx=ast.Load()),
         temp_variables=[return_var],

setup.cfg

@@ -1,6 +1,6 @@
 [tool:pytest]
 # Be sure to include Hy test functions with mangled names.
-python_functions=test_* is_test_* hyx_test_* hyx_is_test_*
+python_functions=test_* hyx_test_*
 filterwarnings =
     once::DeprecationWarning
     once::PendingDeprecationWarning

tests/compilers/test_ast.py

@@ -113,13 +113,7 @@ def test_ast_good_try():
 
 
 def test_ast_bad_try():
-    cant_compile("(try)")
-    cant_compile("(try 1)")
-    cant_compile("(try 1 bla)")
-    cant_compile("(try 1 bla bla)")
-    cant_compile("(try (do bla bla))")
     cant_compile("(try (do) (else 1) (else 2))")
-    cant_compile("(try 1 (else 1))")
     cant_compile("(try 1 (else 1) (except []))")
     cant_compile("(try 1 (finally 1) (except []))")
     cant_compile("(try 1 (except []) (finally 1) (else 1))")

tests/native_tests/try.hy

@@ -1,25 +1,38 @@
 ;; Tests of `try` and `raise`
 
-(defn test-try []
+(import
+  pytest)
 
-  (try (do) (except []))
 
-  (try (do) (except [IOError]) (except []))
+(defn test-try-missing-parts []
+  (assert (is (try) None))
+  (assert (= (try 1) 1))
+  (assert (is (try (except [])) None))
+  (assert (is (try (finally)) None))
+  (assert (= (try 1 (finally 2)) 1))
+  (assert (is (try (else)) None))
+  (assert (= (try 1 (else 2)) 2)))
 
-  ; test that multiple statements in a try get evaluated
+
+(defn test-try-multiple-statements []
   (setv value 0)
   (try (+= value 1) (+= value 2)  (except [IOError]) (except []))
-  (assert (= value 3))
+  (assert (= value 3)))
+
 
-  ; test that multiple expressions in a try get evaluated
+(defn test-try-multiple-expressions []
   ; https://github.com/hylang/hy/issues/1584
+
   (setv l [])
   (defn f [] (.append l 1))
   (try (f) (f) (f) (except [IOError]))
   (assert (= l [1 1 1]))
   (setv l [])
   (try (f) (f) (f) (except [IOError]) (else (f)))
-  (assert (= l [1 1 1 1]))
+  (assert (= l [1 1 1 1])))
+
+
+(defn test-raise-nullary []
 
   ;; Test correct (raise)
   (setv passed False)
@@ -38,123 +51,60 @@
    (raise)
    (except [RuntimeError]
      (setv passed True)))
-  (assert passed)
-
-  ;; Test (finally)
-  (setv passed False)
-  (try
-   (do)
-   (finally (setv passed True)))
-  (assert passed)
-
-  ;; Test (finally) + (raise)
-  (setv passed False)
-  (try
-   (raise Exception)
-   (except [])
-   (finally (setv passed True)))
-  (assert passed)
-
-
-  ;; Test (finally) + (raise) + (else)
-  (setv passed False
-        not-elsed True)
-  (try
-   (raise Exception)
-   (except [])
-   (else (setv not-elsed False))
-   (finally (setv passed True)))
-  (assert passed)
-  (assert not-elsed)
-
-  (try
-   (raise (KeyError))
-   (except [[IOError]] (assert False))
-   (except [e [KeyError]] (assert e)))
-
-  (try
-   (raise (KeyError))
-   (except [[IOError]] (assert False))
-   (except [e [KeyError]] (assert e)))
-
-  (try
-   (get [1] 3)
-   (except [IndexError] (assert True))
-   (except [IndexError] (do)))
-
-  (try
-   (print foobar42ofthebaz)
-   (except [IndexError] (assert False))
-   (except [NameError] (do)))
-
-  (try
-   (get [1] 3)
-   (except [e IndexError] (assert (isinstance e IndexError))))
-
-  (try
-   (get [1] 3)
-   (except [e [IndexError NameError]] (assert (isinstance e IndexError))))
-
-  (try
-   (print foobar42ofthebaz)
-   (except [e [IndexError NameError]] (assert (isinstance e NameError))))
-
-  (try
-   (print foobar42)
-   (except [[IndexError NameError]] (do)))
+  (assert passed))
 
-  (try
-   (get [1] 3)
-   (except [[IndexError NameError]] (do)))
 
-  (try
-   (print foobar42ofthebaz)
-   (except []))
+(defn test-try-clauses []
 
-  (try
-   (print foobar42ofthebaz)
-   (except [] (do)))
-
-  (try
-   (print foobar42ofthebaz)
-   (except []
-     (setv foobar42ofthebaz 42)
-     (assert (= foobar42ofthebaz 42))))
-
-  (setv passed False)
-  (try
-   (try (do) (except []) (else (bla)))
-   (except [NameError] (setv passed True)))
-  (assert passed)
+  (defmacro try-it [body v1 v2]
+    `(assert (= (_try-it (fn [] ~body)) [~v1 ~v2])))
+  (defn _try-it [callback]
+    (setv did-finally-clause? False)
+    (try
+      (callback)
+      (except [ZeroDivisionError]
+        (setv out ["aaa" None]))
+      (except [[IndexError NameError]]
+        (setv out ["bbb" None]))
+      (except [e TypeError]
+        (setv out ["ccc" (type e)]))
+      (except [e [KeyError AttributeError]]
+        (setv out ["ddd" (type e)]))
+      (except []
+        (setv out ["eee" None]))
+      (else
+        (setv out ["zzz" None]))
+      (finally
+        (setv did-finally-clause? True)))
+    (assert did-finally-clause?)
+    out)
+
+  (try-it  (/ 1 0)             "aaa" None)
+  (try-it  (get "foo" 5)       "bbb" None)
+  (try-it  unbound             "bbb" None)
+  (try-it  (abs "hi")          "ccc" TypeError)
+  (try-it  (get {1 2} 3)       "ddd" KeyError)
+  (try-it  True.a              "ddd" AttributeError)
+  (try-it  (raise ValueError)  "eee" None)
+  (try-it  "hi"                "zzz" None))
+
+
+(defn test-finally-executes-for-uncaught-exception []
+  (setv x "")
+  (with [(pytest.raises ZeroDivisionError)]
+    (try
+      (+= x "a")
+      (/ 1 0)
+      (+= x "b")
+      (finally
+        (+= x "c"))))
+  (assert (= x "ac")))
 
-  (setv x 0)
-  (try
-   (raise IOError)
-   (except [IOError]
-     (setv x 45))
-   (else (setv x 44)))
-  (assert (= x 45))
 
-  (setv x 0)
-  (try
-   (raise KeyError)
-   (except []
-     (setv x 45))
-   (else (setv x 44)))
-  (assert (= x 45))
+(defn test-nonsyntactical-except []
+  #[[Test that [except ...] and ("except" ...) aren't treated like (except ...),
+  and that the code there is evaluated normally.]]
 
-  (setv x 0)
-  (try
-   (try
-    (raise KeyError)
-    (except [IOError]
-      (setv x 45))
-    (else (setv x 44)))
-   (except []))
-  (assert (= x 0))
-
-  ; test that [except ...] and ("except" ...) aren't treated like (except ...),
-  ; and that the code there is evaluated normally
   (setv x 0)
   (try
     (+= x 1)
@@ -186,26 +136,35 @@
   ; https://github.com/hylang/hy/issues/798
 
   (assert (= "ef" ((fn []
-    (try (+ "a" "b")
-      (except [NameError] (+ "c" "d"))
-      (else (+ "e" "f")))))))
+    (try
+      (+ "a" "b")
+      (except [NameError]
+        (+ "c" "d"))
+      (else
+        (+ "e" "f")))))))
 
   (setv foo
-    (try (+ "A" "B")
-      (except [NameError] (+ "C" "D"))
-      (else (+ "E" "F"))))
+    (try
+      (+ "A" "B")
+      (except [NameError]
+        (+ "C" "D"))
+      (else
+        (+ "E" "F"))))
   (assert (= foo "EF"))
 
-  ; Check that the lvalue isn't assigned in the main `try` body
-  ; there's an `else`.
+  ; Check that the lvalue isn't assigned by the main `try` body
+  ; when there's an `else`.
   (setv x 1)
   (setv y 0)
   (setv x
-    (try (+ "G" "H")
-      (except [NameError] (+ "I" "J"))
+    (try
+      (+ "G" "H")
+      (except [NameError]
+        (+ "I" "J"))
       (else
         (setv y 1)
         (assert (= x 1))
+          ; `x` still has its value from before the `try`.
         (+ "K" "L"))))
   (assert (= x "KL"))
   (assert (= y 1)))

tests/test_hy2py.py

@@ -23,13 +23,15 @@ def test_hy2py_import():
     import subprocess
 
     path = "tests/resources/pydemo_as_py.py"
+    env = dict(os.environ)
+    env["PYTHONIOENCODING"] = "UTF-8"
+    env["PYTHONPATH"] = "." + os.pathsep + env.get("PYTHONPATH", "")
     try:
         with open(path, "wb") as o:
             subprocess.check_call(
                 ["hy2py", "tests/resources/pydemo.hy"],
                 stdout=o,
-                env={**os.environ, "PYTHONIOENCODING": "UTF-8"},
-            )
+                env=env)
         import tests.resources.pydemo_as_py as m
     finally:
         with contextlib.suppress(FileNotFoundError):