def test_branch_elimination(self):
        from nitrous.module import dump

        add_5 = False
        add_any = True

        @function(Long, a=Long, b=Bool)
        def f1(a, b):
            if add_any and b:
                a += 5
            return a

        @function(Long, a=Long)
        def f2(a):
            if add_any and add_5:
                a += 5
            return a

        m1 = module([f1])
        ir = " ".join(dump(m1).split("\n"))
        # In first function, conditional depends on a parameter
        self.assertRegexpMatches(ir, "icmp")

        m2 = module([f2])
        ir = " ".join(dump(m2).split("\n"))
        # In second, entire conditional is resolved at
        # compile time and optimized away
        self.assertNotRegexpMatches(ir, "icmp")

    def test_not_iterable(self):

        @function(a=Long)
        def foo(a):
            b, = a

        message = "Value of type 'Long' is not an iterable"
        with self.assertRaisesRegexp(TypeError, message):
            module([foo])

    def test_type_mismatch(self):

        @function(Bool, x=Long)
        def f1(x):
            return x < 1.0

        message = ">>>     return x < 1.0"
        with self.assertRaisesRegexp(TypeError, message):
            module([f1])

    def test_assign_wrong_type(self):

        @function(x=Array(Long, shape=(1,)), y=Double)
        def f(x, y):
            x[0] = y

        message = ">>>     x\[0\] = y"
        with self.assertRaisesRegexp(TypeError, message):
            module([f])

    def test_compound_test(self):
        """Support compound conditionals such as 1 < x < 2."""

        @function(Bool, x=Long)
        def f1(x):
            return 1 < x < 2

        message = ">>>     return 1 < x < 2"
        with self.assertRaisesRegexp(NotImplementedError, message):
            module([f1])

    def test_unexpected_type(self):
        """Raise error if returning unexpected value type."""

        @function(Double, x=Double)
        def f(x):
            return 5

        message = ">>>     return 5"
        with self.assertRaisesRegexp(TypeError, message):
            module([f])

    def test_missing_return(self):
        """Raise error if no return in function with non-void return type."""

        @function(Double)
        def f():
            pass

        message = ">>>     pass"
        with self.assertRaisesRegexp(TypeError, message):
            module([f])

    def test_shape_mismatch(self):
        """Raise error if packed/unpacked tuple lengths differ"""

        @function(Long, a=Long, b=Long)
        def foo(a, b):
            b, = a, b

        message = "Cannot unpack 2 values into 1"
        with self.assertRaisesRegexp(ValueError, message):
            module([foo])

    def test_missing_symbol(self):
        """Raise error if cannot resolve a symbol."""

        @function(Double, y=Long)
        def x(y):
            return z

        error = ">>>     return z"
        with self.assertRaisesRegexp(NameError, error):
            module([x])

    def test_return_non_void(self):
        """Raise error if void function returns non-void value"""

        @function()
        def f():
            return 5

        message = ">>>     return 5"
        with self.assertRaisesRegexp(ValueError, message):
            module([f])

    def test_unsupported_slice(self):
        """Raise error on unsupported context (eg. `del x`)."""

        @function(Long, y=Long)
        def x(y):
            y[:]
            return 0

        message = ">>>     y\[:\]"
        with self.assertRaisesRegexp(NotImplementedError, message):
            module([x])

    def test_unsupported_target(self):
        """Check for unsupported assignments."""

        @function(Long, a=Long, b=Long)
        def f(a, b):
            a, b = 1
            return 0

        message = ">>>     a, b = 1"
        with self.assertRaisesRegexp(TypeError, message):
            module([f])

    def test_unsupported_chain(self):
        """Raise error on chain assignment."""

        @function(Long)
        def f():
            a = b = 1
            return 0

        message = ">>>     a = b = 1"
        with self.assertRaisesRegexp(NotImplementedError, message):
            module([f])

    def test_if_expr_type_mismatch(self):
        """Raise error when `if` expression clause types don't match."""

        # Simple expression
        @function(Long, a=Long, b=Long)
        def max2(a, b):
            return 1.0 if a > b else 0

        message = ">>>     return 1.0 if a > b else 0"
        with self.assertRaisesRegexp(TypeError, message):
            module([max2])

    def test_symbol_out_of_scope(self):
        """Raise error if symbol is available but not in the current scope."""

        @function(Double, y=Long)
        def x(y):
            for i in range(y):
                z = i
            return z

        error = ">>>     return z"
        with self.assertRaisesRegexp(NameError, error):
            module([x])

    def test_unsupported_context(self):
        """Raise error on unsupported context (eg. `del x`)."""

        @function(Long)
        def x():
            y = 1
            del y
            return 0

        message = ">>>     del y"
        with self.assertRaisesRegexp(NotImplementedError, message):
            module([x])

    def test_invalid_cast(self):
        from nitrous.lib import cast
        from nitrous.types import Structure

        S = Structure("S", ("x", Long))

        @function(Long, a=S)
        def int_to_long(a):
            return cast(a, Long)

        with self.assertRaisesRegexp(TypeError, "Cannot cast"):
            module([int_to_long])

    def test_call_wrong_arg_type(self):

        @function(Long, x=Long)
        def f1(x):
            return x

        @function(Long, x=Long)
        def f2(x):
            return f1(1.0)

        message = "f1\(\) called with wrong argument type\(s\) for x"
        with self.assertRaisesRegexp(TypeError, message):
            module([f2])

    def test_call_wrong_arg_count(self):

        @function(Long, x=Long)
        def f1(x):
            return x

        @function(Long, x=Long)
        def f2(x):
            return f1(x, 1)

        message = "f1\(\) takes exactly 1 argument\(s\) \(2 given\)"
        with self.assertRaisesRegexp(TypeError, message):
            module([f2])

    def test_duplicate_function(self):

        def get_foo():

            @function(Long, a=Long)
            def foo(a):
                return 1

            return foo

        message = "Duplicate function name: foo"
        with self.assertRaisesRegexp(RuntimeError, message):
            module([get_foo(), get_foo()])