basic support for try except

numba/controlflow.py

@@ -661,12 +661,17 @@ def run(self):
             fn = getattr(self, fname, None)
             if fn is not None:
                 fn(inst)
-            else:
+            elif inst.is_jump:
                 # this catches e.g. try... except
-                if inst.is_jump:
-                    l = Loc(self.bytecode.func_id.filename, inst.lineno)
+                l = Loc(self.bytecode.func_id.filename, inst.lineno)
+                if inst.opname in {"SETUP_EXCEPT", "SETUP_FINALLY"}:
+                    msg = "'try' block not supported until python3.7 or later"
+                else:
                     msg = "Use of unsupported opcode (%s) found" % inst.opname
-                    raise UnsupportedError(msg, loc=l)
+                raise UnsupportedError(msg, loc=l)
+            else:
+                # Non-jump instructions are ignored
+                pass  # intentionally
 
         # Close all blocks
         for cur, nxt in zip(self.blockseq, self.blockseq[1:]):

numba/dataflow.py

@@ -917,3 +917,11 @@ def terminator(self):
     @terminator.setter
     def terminator(self, inst):
         self._term = inst
+
+    @property
+    def active_try_block(self):
+        """Try except not supported.
+
+        See byteflow.py
+        """
+        return None

numba/interpreter.py

@@ -15,6 +15,7 @@
     OPERATORS_TO_BUILTINS,
     )
 from numba.byteflow import Flow, AdaptDFA, AdaptCFA
+from numba.unsafe import eh
 
 
 _logger = logging.getLogger(__name__)
@@ -86,6 +87,9 @@ def __init__(self, func_id):
         self.blocks = {}
         # { name: [definitions] } of local variables
         self.definitions = collections.defaultdict(list)
+        # A set to keep track of all exception variables.
+        # To be used in _legalize_exception_vars()
+        self._exception_vars = set()
 
     def interpret(self, bytecode):
         """
@@ -127,12 +131,37 @@ def interpret(self, bytecode):
         for inst, kws in self._iter_inst():
             self._dispatch(inst, kws)
 
+        self._legalize_exception_vars()
+
+        # Prepare FunctionIR
         fir = ir.FunctionIR(self.blocks, self.is_generator, self.func_id,
                              self.first_loc, self.definitions,
                              self.arg_count, self.arg_names)
         _logger.debug(fir.dump_to_string())
         return fir
 
+    def _legalize_exception_vars(self):
+        """Search for unsupported use of exception variables.
+        Note, they cannot be stored into user variable.
+        """
+        # Build a set of exception variables
+        excvars = self._exception_vars.copy()
+        # Propagate the exception variables to LHS of assignment
+        for varname, defnvars in self.definitions.items():
+            for v in defnvars:
+                if isinstance(v, ir.Var):
+                    k = v.name
+                    if k in excvars:
+                        excvars.add(varname)
+        # Filter out the user variables.
+        uservar = list(filter(lambda x: not x.startswith('$'), excvars))
+        if uservar:
+            # Complain about the first user-variable storing an exception
+            first = uservar[0]
+            loc = self.current_scope.get(first).loc
+            msg = "Exception object cannot be stored into variable ({})."
+            raise errors.UnsupportedError(msg.format(first), loc=loc)
+
     def init_first_block(self):
         # Define variables receiving the function arguments
         for index, name in enumerate(self.arg_names):
@@ -158,8 +187,24 @@ def _start_new_block(self, offset):
         self.insert_block(offset)
         # Ensure the last block is terminated
         if oldblock is not None and not oldblock.is_terminated:
-            jmp = ir.Jump(offset, loc=self.loc)
-            oldblock.append(jmp)
+            # Handle ending try block.
+            tryblk = self.dfainfo.active_try_block
+            # If there's an active try-block and the handler block is live.
+            if tryblk is not None and tryblk['end'] in self.cfa.graph.nodes():
+                # We are in a try-block, insert a branch to except-block.
+                # This logic cannot be in self._end_current_block()
+                # because we the non-raising next block-offset.
+                branch = ir.Branch(
+                    cond=self.get('$exception_check'),
+                    truebr=tryblk['end'],
+                    falsebr=offset,
+                    loc=self.loc,
+                )
+                oldblock.append(branch)
+            # Handle normal case
+            else:
+                jmp = ir.Jump(offset, loc=self.loc)
+                oldblock.append(jmp)
         # Get DFA block info
         self.dfainfo = self.dfa.infos[self.current_block_offset]
         self.assigner = Assigner()
@@ -171,9 +216,74 @@ def _start_new_block(self, offset):
                 break
 
     def _end_current_block(self):
+        # Handle try block
+        if not self.current_block.is_terminated:
+            tryblk = self.dfainfo.active_try_block
+            if tryblk is not None:
+                self._insert_exception_check()
+        # Handle normal block cleanup
         self._remove_unused_temporaries()
         self._insert_outgoing_phis()
 
+    def _inject_call(self, func, gv_name, res_name=None):
+        """A helper function to inject a call to *func* which is a python
+        function.
+
+        Parameters
+        ----------
+        func : callable
+            The function object to be called.
+        gv_name : str
+            The variable name to be used to store the function object.
+        res_name : str; optional
+            The variable name to be used to store the call result.
+            If ``None``, a name is created automatically.
+        """
+        gv_fn = ir.Global(gv_name, func, loc=self.loc)
+        self.store(value=gv_fn, name=gv_name, redefine=True)
+        callres = ir.Expr.call(self.get(gv_name), (), (), loc=self.loc)
+        res_name = res_name or '$callres_{}'.format(gv_name)
+        self.store(value=callres, name=res_name, redefine=True)
+
+    def _insert_try_block_begin(self):
+        """Insert IR-nodes to mark the start of a `try` block.
+        """
+        self._inject_call(eh.mark_try_block, 'mark_try_block')
+
+    def _insert_try_block_end(self):
+        """Insert IR-nodes to mark the end of a `try` block.
+        """
+        self._inject_call(eh.end_try_block, 'end_try_block')
+
+    def _insert_exception_variables(self):
+        """Insert IR-nodes to initialize the exception variables.
+        """
+        tryblk = self.dfainfo.active_try_block
+        # Get exception variables
+        endblk = tryblk['end']
+        edgepushed = self.dfainfo.outgoing_edgepushed.get(endblk)
+        # Note: the last value on the stack is the exception value
+        # Note: due to the current limitation, all exception variables are None
+        if edgepushed:
+            scope = self.current_scope
+            const_none = ir.Const(value=None, loc=self.loc)
+            # For each variable going to the handler block.
+            for var in edgepushed:
+                if var in self.definitions:
+                    raise AssertionError(
+                        "exception variable CANNOT be defined by other code",
+                    )
+                self.store(value=const_none, name=var)
+                self._exception_vars.add(var)
+
+    def _insert_exception_check(self):
+        """Called before the end of a block to inject checks if raised.
+        """
+        self._insert_exception_variables()
+        # Do exception check
+        self._inject_call(eh.exception_check, 'exception_check',
+                          '$exception_check')
+
     def _remove_unused_temporaries(self):
         """
         Remove assignments to unused temporary variables from the
@@ -580,6 +690,10 @@ def op_STORE_FAST(self, inst, value):
         value = self.get(value)
         self.store(value=value, name=dstname)
 
+    def op_DELETE_FAST(self, inst):
+        dstname = self.code_locals[inst.arg]
+        self.current_block.append(ir.Del(dstname, loc=self.loc))
+
     def op_DUP_TOPX(self, inst, orig, duped):
         for src, dst in zip(orig, duped):
             self.store(value=self.get(src), name=dst)
@@ -651,6 +765,13 @@ def op_SETUP_WITH(self, inst, contextmanager):
             begin=inst.offset, end=exitpt, loc=self.loc,
             ))
 
+    def op_SETUP_EXCEPT(self, inst):
+        # Removed since python3.8
+        self._insert_try_block_begin()
+
+    def op_SETUP_FINALLY(self, inst):
+        self._insert_try_block_begin()
+
     def op_WITH_CLEANUP(self, inst):
         "no-op"
 
@@ -663,10 +784,13 @@ def op_WITH_CLEANUP_FINISH(self, inst):
     def op_END_FINALLY(self, inst):
         "no-op"
 
-    def op_BEGIN_FINALLY(self, inst, state):
-        "no-op"
-        none = ir.Const(None, loc=self.loc)
-        self.store(value=none, name=state)
+    def op_BEGIN_FINALLY(self, inst, temps):
+        # The *temps* are the exception variables
+        const_none = ir.Const(None, loc=self.loc)
+        for tmp in temps:
+            # Set to None for now
+            self.store(const_none, name=tmp)
+            self._exception_vars.add(tmp)
 
     if PYVERSION < (3, 6):
 
@@ -961,8 +1085,11 @@ def op_JUMP_FORWARD(self, inst):
         jmp = ir.Jump(inst.get_jump_target(), loc=self.loc)
         self.current_block.append(jmp)
 
-    def op_POP_BLOCK(self, inst):
-        self.syntax_blocks.pop()
+    def op_POP_BLOCK(self, inst, kind=None):
+        if kind is None:
+            self.syntax_blocks.pop()
+        elif kind == 'try':
+            self._insert_try_block_end()
 
     def op_RETURN_VALUE(self, inst, retval, castval):
         self.store(ir.Expr.cast(self.get(retval), loc=self.loc), castval)
@@ -979,6 +1106,18 @@ def op_COMPARE_OP(self, inst, lhs, rhs, res):
             tmp = self.get(res)
             out = ir.Expr.unary('not', value=tmp, loc=self.loc)
             self.store(out, res)
+        elif op == 'exception match':
+            gv_fn = ir.Global(
+                "exception_match", eh.exception_match, loc=self.loc,
+            )
+            exc_match_name = '$exc_match'
+            self.store(value=gv_fn, name=exc_match_name, redefine=True)
+            lhs = self.get(lhs)
+            rhs = self.get(rhs)
+            exc = ir.Expr.call(
+                self.get(exc_match_name), args=(lhs, rhs), kws=(), loc=self.loc,
+            )
+            self.store(exc, res)
         else:
             self._binop(op, lhs, rhs, res)
 
@@ -1022,8 +1161,17 @@ def op_JUMP_IF_TRUE_OR_POP(self, inst, pred):
     def op_RAISE_VARARGS(self, inst, exc):
         if exc is not None:
             exc = self.get(exc)
-        stmt = ir.Raise(exception=exc, loc=self.loc)
-        self.current_block.append(stmt)
+        tryblk = self.dfainfo.active_try_block
+        if tryblk is not None:
+            # In a try block
+            stmt = ir.TryRaise(exception=exc, loc=self.loc)
+            self.current_block.append(stmt)
+            self._insert_try_block_end()
+            self.current_block.append(ir.Jump(tryblk['end'], loc=self.loc))
+        else:
+            # Not in a try block
+            stmt = ir.Raise(exception=exc, loc=self.loc)
+            self.current_block.append(stmt)
 
     def op_YIELD_VALUE(self, inst, value, res):
         # initialize index to None.  it's being set later in post-processing
@@ -1041,7 +1189,16 @@ def op_MAKE_FUNCTION(self, inst, name, code, closure, annotations, kwdefaults, d
                 defaults = tuple([self.get(name) for name in defaults])
             else:
                 defaults = self.get(defaults)
-        fcode = self.definitions[code][0].value
+
+        assume_code_const = self.definitions[code][0]
+        if not isinstance(assume_code_const, ir.Const):
+            msg = (
+                "Unsupported use of closure. "
+                "Probably caused by complex control-flow constructs; "
+                "e.g. try-except"
+            )
+            raise errors.UnsupportedError(msg, loc=self.loc)
+        fcode = assume_code_const.value
         if name:
             name = self.get(name)
         if closure:

numba/ir.py

@@ -710,6 +710,43 @@ def get_targets(self):
         return []
 
 
+class TryRaise(Stmt):
+    """A raise statement inside a try-block
+    Similar to ``Raise`` but does not terminate.
+    """
+    def __init__(self, exception, loc):
+        assert exception is None or isinstance(exception, Var)
+        assert isinstance(loc, Loc)
+        self.exception = exception
+        self.loc = loc
+
+    def __str__(self):
+        return "try_raise %s" % self.exception
+
+
+class StaticTryRaise(Stmt):
+    """A raise statement inside a try-block.
+    Similar to ``StaticRaise`` but does not terminate.
+    """
+
+    def __init__(self, exc_class, exc_args, loc):
+        assert exc_class is None or isinstance(exc_class, type)
+        assert isinstance(loc, Loc)
+        assert exc_args is None or isinstance(exc_args, tuple)
+        self.exc_class = exc_class
+        self.exc_args = exc_args
+        self.loc = loc
+
+    def __str__(self):
+        if self.exc_class is None:
+            return "static_try_raise"
+        elif self.exc_args is None:
+            return "static_try_raise %s" % (self.exc_class,)
+        else:
+            return "static_try_raise %s(%s)" % (self.exc_class,
+                                     ", ".join(map(repr, self.exc_args)))
+
+
 class Return(Terminator):
     """
     Return to caller.