lean2/tests/lean/lua15.lean.expected.out

  Set: pp::colors
  Set: pp::unicode
  Imported 'Int'
  Assumed: i
  Assumed: j
  Assumed: p
[string]:5: Lean exception
elaborator exception
lua15.lean:9: error: executing script
Failed to solve
 ⊢ (?M::0 ≈ Nat::add) ⊕ (?M::0 ≈ Int::add)
    [string]:1:3: Overloading at
        (Int::add | Nat::add) i p
    Failed to solve
     ⊢ ℤ ≺ ℕ
        [string]:1:3: Type of argument 1 must be convertible to the expected type in the application of
            Nat::add
        with arguments:
            i
            p
    Failed to solve
     ⊢ Bool ≺ ℤ
        [string]:1:3: Type of argument 2 must be convertible to the expected type in the application of
            Int::add
        with arguments:
            i
            p
-												feat(lua): improve error handling in Lua API

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-11-17 02:21:42 +00:00
+								  Set: pp::colors
 								  Set: pp::unicode
-												chore(builtin): rename nat, int and real modules to Nat, Int and Real.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-01 21:52:25 +00:00
+								  Imported 'Int'
-												feat(lua): improve error handling in Lua API

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-11-17 02:21:42 +00:00
+								  Assumed: i
 								  Assumed: j
 								  Assumed: p
-												refactor(*): error messages

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-14 00:54:21 +00:00
+								[string]:5: Lean exception
-												refactor(util/lua): propagate C++ Lean exceptions in Lua

The following call sequence is possible:
C++ -> Lua -> C++ -> Lua -> C++

The first block of C++ is the Lean main function.
The main function invokes the Lua interpreter.
The Lua interpreter invokes a C++ Lean API.
Then the Lean API invokes a callback implemented in Lua.
The Lua callback invokes another Lean API.
Now, suppose the Lean API throws an exception.
We want the C++ exception to propagate over the mixed C++/Lua call stack.
We use the clone/rethrow exception idiom to achieve this goal.

Before this commit, the C++ exceptions were converted into strings
using the method what(), and then they were propagated over the Lua
stack using lua_error. A lua_error was then converted into a lua_exception when going back to C++.
This solution was very unsatisfactory, since all C++ exceptions were being converted into a lua_exception, and consequently the structure of the exception was being lost.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-11-27 20:19:54 +00:00
+								elaborator exception
-												refactor(*): error messages

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-14 00:54:21 +00:00
+								lua15.lean:9: error: executing script
-												feat(lua): improve error handling in Lua API

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-11-17 02:21:42 +00:00
+								Failed to solve
-												refactor(builtin): only load the kernel and natural numbers by default

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-12-30 21:35:37 +00:00
+								 ⊢ (?M::0 ≈ Nat::add) ⊕ (?M::0 ≈ Int::add)
-												refactor(*): error messages

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-14 00:54:21 +00:00
+								    [string]:1:3: Overloading at
-												refactor(builtin): only load the kernel and natural numbers by default

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-12-30 21:35:37 +00:00
+								        (Int::add | Nat::add) i p
-												refactor(util/lua): propagate C++ Lean exceptions in Lua

The following call sequence is possible:
C++ -> Lua -> C++ -> Lua -> C++

The first block of C++ is the Lean main function.
The main function invokes the Lua interpreter.
The Lua interpreter invokes a C++ Lean API.
Then the Lean API invokes a callback implemented in Lua.
The Lua callback invokes another Lean API.
Now, suppose the Lean API throws an exception.
We want the C++ exception to propagate over the mixed C++/Lua call stack.
We use the clone/rethrow exception idiom to achieve this goal.

Before this commit, the C++ exceptions were converted into strings
using the method what(), and then they were propagated over the Lua
stack using lua_error. A lua_error was then converted into a lua_exception when going back to C++.
This solution was very unsatisfactory, since all C++ exceptions were being converted into a lua_exception, and consequently the structure of the exception was being lost.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-11-27 20:19:54 +00:00
+								    Failed to solve
-												refactor(builtin): only load the kernel and natural numbers by default

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-12-30 21:35:37 +00:00
+								     ⊢ ℤ ≺ ℕ
-												refactor(*): error messages

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-14 00:54:21 +00:00
+								        [string]:1:3: Type of argument 1 must be convertible to the expected type in the application of
-												feat(kernel, library/elaborator, frontends/lean): improve how elaborator_exceptions are displayed in the Lean frontend

This commit affects different modules.
I used the following approach:
1- I store the metavariable environment at unification_failure_justifications. The idea is to capture the set of instantiated metavariables at the time of failure.
2- I added a remove_detail function. It removes propagation steps from the justification tree object. I also remove the backtracking search space associated with higher-order unificiation. I keep only the search related to case-splits due to coercions and overloads.

3- I use the metavariable environment captured at step 1 when pretty printing the justification of an elaborator_exception.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-04 01:13:10 +00:00
+								            Nat::add
 								        with arguments:
 								            i
 								            p
-												refactor(util/lua): propagate C++ Lean exceptions in Lua

The following call sequence is possible:
C++ -> Lua -> C++ -> Lua -> C++

The first block of C++ is the Lean main function.
The main function invokes the Lua interpreter.
The Lua interpreter invokes a C++ Lean API.
Then the Lean API invokes a callback implemented in Lua.
The Lua callback invokes another Lean API.
Now, suppose the Lean API throws an exception.
We want the C++ exception to propagate over the mixed C++/Lua call stack.
We use the clone/rethrow exception idiom to achieve this goal.

Before this commit, the C++ exceptions were converted into strings
using the method what(), and then they were propagated over the Lua
stack using lua_error. A lua_error was then converted into a lua_exception when going back to C++.
This solution was very unsatisfactory, since all C++ exceptions were being converted into a lua_exception, and consequently the structure of the exception was being lost.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-11-27 20:19:54 +00:00
+								    Failed to solve
-												refactor(builtin): only load the kernel and natural numbers by default

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2013-12-30 21:35:37 +00:00
+								     ⊢ Bool ≺ ℤ
-												refactor(*): error messages

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-14 00:54:21 +00:00
+								        [string]:1:3: Type of argument 2 must be convertible to the expected type in the application of
-												feat(kernel, library/elaborator, frontends/lean): improve how elaborator_exceptions are displayed in the Lean frontend

This commit affects different modules.
I used the following approach:
1- I store the metavariable environment at unification_failure_justifications. The idea is to capture the set of instantiated metavariables at the time of failure.
2- I added a remove_detail function. It removes propagation steps from the justification tree object. I also remove the backtracking search space associated with higher-order unificiation. I keep only the search related to case-splits due to coercions and overloads.

3- I use the metavariable environment captured at step 1 when pretty printing the justification of an elaborator_exception.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

											
										
										
											2014-01-04 01:13:10 +00:00
+								            Int::add
 								        with arguments:
 								            i
 								            p