Déplacement des erreurs non noyau dans Pretype_errors ou Cases; localisation

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/coq/trunk@1445 85f007b7-540e-0410-9357-904b9bb8a0f7

4 files changed, 78 insertions, 57 deletions

diff --git a/pretyping/evarutil.ml b/pretyping/evarutil.ml
index 3b6acb1ba3..c155c45554 100644
--- a/pretyping/evarutil.ml
+++ b/pretyping/evarutil.ml
@@ -197,7 +197,7 @@ let real_clean isevars sp args rhs =
       | _ -> map_constr_with_binders succ subs k t
   in
   let body = subs 0 rhs in
-  if not (closed0 body) then error_not_clean CCI empty_env sp body;
+  if not (closed0 body) then error_not_clean empty_env sp body;
   body
 
 let make_evar_instance_with_rel env =
@@ -253,7 +253,7 @@ let keep_rels_and_vars c = match kind_of_term c with
   | _ -> mkImplicit   (* Mettre mkMeta ?? *)
 
 let evar_define isevars (ev,argsv) rhs =
-  if occur_evar ev rhs then error_occur_check CCI empty_env ev rhs;
+  if occur_evar ev rhs then error_occur_check empty_env ev rhs;
   let args = List.map keep_rels_and_vars (Array.to_list argsv) in 
   let evd = ise_map isevars ev in
   (* the substitution to invert *)
@@ -449,8 +449,7 @@ let split_tycon loc env isevars = function
 	      isevars := sigma;
 	      Some dom, Some rng
 	    else
-	      Stdpp.raise_with_loc loc
-		(Type_errors.TypeError (CCI,env,Type_errors.NotProduct c))
+	      error_not_product_loc loc env c
 
 let valcon_of_tycon x = x
 
diff --git a/pretyping/pretype_errors.ml b/pretyping/pretype_errors.ml
index ff57b0012c..985b7975c3 100644
--- a/pretyping/pretype_errors.ml
+++ b/pretyping/pretype_errors.ml
@@ -3,65 +3,81 @@
 
 open Names
 open Sign
+open Term
 open Environ
 open Type_errors
 open Rawterm
 
-let raise_pretype_error (loc,k,ctx,te) =
-  Stdpp.raise_with_loc loc (TypeError(k,ctx,te))
+type ml_case_error =
+  | MlCaseAbsurd
+  | MlCaseDependent
+
+type pretype_error =
+  (* Old Case *)
+  | MlCase of ml_case_error
+  | CantFindCaseType of constr
+  (* Unification *)
+  | OccurCheck of int * constr
+  | NotClean of int * constr
+  (* Pretyping *)
+  | VarNotFound of identifier
+  | UnexpectedType of constr * constr
+  | NotProduct of constr
+
+exception PretypeError of env * pretype_error
 
-let error_var_not_found_loc loc k s =
-  raise_pretype_error (loc,k, Global.env() (*bidon*), VarNotFound s)
+let raise_pretype_error (loc,ctx,te) =
+  Stdpp.raise_with_loc loc (PretypeError(ctx,te))
+
+let raise_located_type_error (loc,k,ctx,te) =
+  Stdpp.raise_with_loc loc (TypeError(k,ctx,te))
 
 let error_cant_find_case_type_loc loc env expr =
-  raise_pretype_error (loc, CCI, env, CantFindCaseType expr)
+  raise_pretype_error (loc, env, CantFindCaseType expr)
+
+let error_ill_formed_branch_loc loc k env c i actty expty =
+  raise_located_type_error (loc, k, env, IllFormedBranch (c,i,actty,expty))
 
 let error_actual_type_loc loc env c actty expty =
-  raise_pretype_error (loc, CCI, env, ActualType (c,actty,expty))
+  raise_located_type_error (loc, CCI, env, ActualType (c,actty,expty))
 
 let error_cant_apply_not_functional_loc loc env rator randl =
-  raise_pretype_error
+  raise_located_type_error
     (loc,CCI,env, CantApplyNonFunctional (rator,randl))
 
 let error_cant_apply_bad_type_loc loc env t rator randl =
-  raise_pretype_error (loc, CCI, env, CantApplyBadType (t,rator,randl))
+  raise_located_type_error (loc, CCI, env, CantApplyBadType (t,rator,randl))
 
 let error_ill_formed_branch k env c i actty expty =
   raise (TypeError (k, env, IllFormedBranch (c,i,actty,expty)))
 
 let error_number_branches_loc loc k env c ct expn =
-  raise_pretype_error (loc, k, env, NumberBranches (c,ct,expn))
+  raise_located_type_error (loc, k, env, NumberBranches (c,ct,expn))
 
 let error_case_not_inductive_loc loc k env c ct =
-  raise_pretype_error (loc, k, env, CaseNotInductive (c,ct))
+  raise_located_type_error (loc, k, env, CaseNotInductive (c,ct))
 
-(* Pattern-matching errors *)
 
-let error_bad_pattern_loc loc k cstr ind =
-  raise_pretype_error (loc, k, Global.env(), BadPattern (cstr,ind))
+(*s Implicit arguments synthesis errors *)
 
-let error_bad_constructor_loc loc k cstr ind =
-  raise_pretype_error (loc, k, Global.env(), BadConstructor (cstr,ind))
+let error_occur_check env ev c =
+  raise (PretypeError (env, OccurCheck (ev,c)))
 
-let error_wrong_numarg_constructor_loc loc k c n =
-  raise_pretype_error (loc, k, Global.env(), WrongNumargConstructor (c,n))
+let error_not_clean env ev c =
+  raise (PretypeError (env, NotClean (ev,c)))
 
-let error_wrong_predicate_arity_loc loc env c n1 n2 =
-  raise_pretype_error (loc, CCI, env, WrongPredicateArity (c,n1,n2))
+(*s Ml Case errors *)
 
-let error_needs_inversion k env x t =
-  raise (TypeError (k, env, NeedsInversion (x,t)))
+let error_ml_case_loc loc env mes =
+  raise_pretype_error (loc, env, MlCase mes)
 
-let error_ill_formed_branch_loc loc k env c i actty expty =
-  raise_pretype_error (loc, k, env, IllFormedBranch (c,i,actty,expty))
+(*s Pretyping errors *)
 
-(*s Implicit arguments synthesis errors *)
+let error_var_not_found_loc loc s =
+  raise_pretype_error (loc, Global.env() (*bidon*), VarNotFound s)
 
 let error_unexpected_type_loc loc env actty expty =
-  raise_pretype_error (loc, CCI, env, UnexpectedType (actty, expty))
-
-let error_occur_check k env ev c =
-  raise (TypeError (k, env, OccurCheck (ev,c)))
+  raise_pretype_error (loc, env, UnexpectedType (actty, expty))
 
-let error_not_clean k env ev c =
-  raise (TypeError (k, env, NotClean (ev,c)))
+let error_not_product_loc loc env c =
+  raise_pretype_error (loc, env, NotProduct c)
diff --git a/pretyping/pretype_errors.mli b/pretyping/pretype_errors.mli
index a48329bd18..ba8c0e4e77 100644
--- a/pretyping/pretype_errors.mli
+++ b/pretyping/pretype_errors.mli
@@ -13,10 +13,25 @@ open Rawterm
 
 (*s The type of errors raised by the pretyper *)
 
-val error_var_not_found_loc :
-  loc -> path_kind -> identifier -> 'a
-
-val error_cant_find_case_type_loc : 
+type ml_case_error =
+  | MlCaseAbsurd
+  | MlCaseDependent
+
+type pretype_error =
+  (* Old Case *)
+  | MlCase of ml_case_error
+  | CantFindCaseType of constr
+  (* Unification *)
+  | OccurCheck of int * constr
+  | NotClean of int * constr
+  (* Pretyping *)
+  | VarNotFound of identifier
+  | UnexpectedType of constr * constr
+  | NotProduct of constr
+
+exception PretypeError of env * pretype_error
+
+val error_cant_find_case_type_loc :
   loc -> env -> constr -> 'a
 
 val error_ill_formed_branch_loc : 
@@ -38,29 +53,20 @@ val error_number_branches_loc :
 val error_case_not_inductive_loc :
   loc -> path_kind -> env -> constr -> constr -> 'b
 
-(*s Pattern-matching errors *)
-
-val error_bad_pattern_loc : 
-  loc -> path_kind -> constructor -> constr -> 'b
+(*s Implicit arguments synthesis errors *)
 
-val error_bad_constructor_loc : 
-  loc -> path_kind -> constructor -> inductive -> 'b
+val error_occur_check : env -> int -> constr -> 'a
 
-val error_wrong_numarg_constructor_loc : 
-  loc -> path_kind -> constructor_path -> int -> 'b
+val error_not_clean : env -> int -> constr -> 'a
 
-val error_wrong_predicate_arity_loc :
-  loc -> env -> constr -> constr -> constr -> 'b
+(*s Ml Case errors *)
 
-val error_needs_inversion : path_kind -> env -> constr -> constr -> 'a
+val error_ml_case_loc : loc -> env -> ml_case_error -> 'a
 
+(*s Pretyping errors *)
 
-(*s Implicit arguments synthesis errors *)
+val error_var_not_found_loc : loc -> identifier -> 'a
 
 val error_unexpected_type_loc : loc -> env -> constr -> constr -> 'b
 
-val error_occur_check : path_kind -> env -> int -> constr -> 'a
-
-val error_not_clean : path_kind -> env -> int -> constr -> 'a
-
-
+val error_not_product_loc : loc -> env -> constr -> 'a
diff --git a/pretyping/pretyping.ml b/pretyping/pretyping.ml
index ba3e56aea6..806a84d665 100644
--- a/pretyping/pretyping.ml
+++ b/pretyping/pretyping.ml
@@ -160,7 +160,7 @@ let pretype_id loc env lvar id =
     let typ = lookup_id_type id (named_context env) in
     { uj_val  = mkVar id; uj_type = typ }
   with Not_found ->
-    error_var_not_found_loc loc CCI id
+    error_var_not_found_loc loc id
 
 (*************************************************************************)
 (* Main pretyping function                                               *)
@@ -372,7 +372,7 @@ let rec pretype tycon env isevars lvar lmeta = function
 		      pretype (mk_tycon expti) env isevars lvar lmeta lf.(i) in
 		    let efjt = nf_ise1 !isevars fj.uj_type in 
 		    let pred = 
-		      Cases.pred_case_ml_onebranch env !isevars isrec indt
+		      Cases.pred_case_ml_onebranch loc env !isevars isrec indt
 			(i,fj.uj_val,efjt) in
 		    if has_undefined_isevars isevars pred then findtype (i+1)
 		    else