Failure _ -> assert false)
| C.Sort _
| C.Implicit _ -> true
- | C.Meta (_,l) ->
+ | C.Meta (mno,l) ->
List.fold_right
(fun x i ->
match x with
None -> i
| Some x -> i && does_not_occur ~subst context n nn x) l true &&
(try
- let (canonical_context,term,ty) = CicUtil.lookup_subst n subst in
+ let (canonical_context,term,ty) = CicUtil.lookup_subst mno subst in
does_not_occur ~subst context n nn (CicSubstitution.subst_meta l term)
with
CicUtil.Subst_not_found _ -> true)
*)
C.Appl ((C.MutInd (uri',_,_))::tl) when UriManager.eq uri' uri -> true
| C.MutInd (uri',0,_) when UriManager.eq uri' uri -> true
- | C.Prod (C.Anonymous,source,dest) ->
- strictly_positive context n nn
- (subst_inductive_type_with_dummy_mutind source) &&
- weakly_positive ((Some (C.Anonymous,(C.Decl source)))::context)
- (n + 1) (nn + 1) uri dest
| C.Prod (name,source,dest) when
- does_not_occur ((Some (name,(C.Decl source)))::context) 0 n dest ->
+ does_not_occur ((Some (name,(C.Decl source)))::context) 0 1 dest ->
(* dummy abstraction, so we behave as in the anonimous case *)
strictly_positive context n nn
(subst_inductive_type_with_dummy_mutind source) &&
strictly_positive ((Some (name,(C.Decl so)))::context) (n+1) (nn+1) ta
| C.Appl ((C.Rel m)::tl) when m > n && m <= nn ->
List.fold_right (fun x i -> i && does_not_occur context n nn x) tl true
- | C.Appl ((C.MutInd (uri,i,exp_named_subst))::tl) ->
+ | C.Appl ((C.MutInd (uri,i,exp_named_subst))::_)
+ | (C.MutInd (uri,i,exp_named_subst)) as t ->
+ let tl = match t with C.Appl (_::tl) -> tl | _ -> [] in
let (ok,paramsno,ity,cl,name) =
let o,_ = CicEnvironment.get_obj CicUniv.empty_ugraph uri in
match o with
raise (TypeCheckerFailure
(lazy ("Non-positive occurence in mutual inductive definition(s) [3]"^
UriManager.string_of_uri uri)))
- | C.Prod (C.Anonymous,source,dest) ->
- let b = strictly_positive context n nn source in
- b &&
- are_all_occurrences_positive
- ((Some (C.Anonymous,(C.Decl source)))::context) uri indparamsno
- (i+1) (n + 1) (nn + 1) dest
| C.Prod (name,source,dest) when
- does_not_occur ((Some (name,(C.Decl source)))::context) 0 n dest ->
+ does_not_occur ((Some (name,(C.Decl source)))::context) 0 1 dest ->
(* dummy abstraction, so we behave as in the anonimous case *)
strictly_positive context n nn source &&
are_all_occurrences_positive
| (_,_,ty,_)::_ ->
fst (split_prods ~subst [] paramsno ty)
in
- (tys@lefts,List.length tl,isinductive,paramsno,cl')
+ (lefts@tys,List.length tl,isinductive,paramsno,cl')
| _ ->
raise (TypeCheckerFailure
(lazy ("Unknown mutual inductive definition:" ^
| (_,_,ty,_)::_ ->
fst (split_prods ~subst [] paramsno ty)
in
- (tys@lefts,List.length tl,isinductive,paramsno,cl')
+ (lefts@tys,List.length tl,isinductive,paramsno,cl')
| _ ->
raise (TypeCheckerFailure
(lazy ("Unknown mutual inductive definition:" ^
function
C.Rel m when m > n && m <= nn -> false
| C.Rel m ->
- (match List.nth context (n-1) with
+ (match List.nth context (m-1) with
Some (_,C.Decl _) -> true
| Some (_,C.Def (bo,_)) ->
- guarded_by_destructors ~subst context m nn kl x safes
+ guarded_by_destructors ~subst context n nn kl x safes
(CicSubstitution.lift m bo)
| None -> raise (TypeCheckerFailure (lazy "Reference to deleted hypothesis"))
)
| (_,_,ty,_)::_ ->
fst (split_prods ~subst [] paramsno ty)
in
- (tys@lefts,len,isinductive,paramsno,cl')
+ (lefts@tys,len,isinductive,paramsno,cl')
| _ ->
raise (TypeCheckerFailure
(lazy ("Unknown mutual inductive definition:" ^
| (_,_,ty,_)::_ ->
fst (split_prods ~subst [] paramsno ty)
in
- (tys@lefts,List.length tl,isinductive,paramsno,cl')
+ (lefts@tys,List.length tl,isinductive,paramsno,cl')
| _ ->
raise (TypeCheckerFailure
(lazy ("Unknown mutual inductive definition:" ^
let arity1 = CicReduction.whd ~subst context arity1 in
let rec check_allowed_sort_elimination_aux ugraph context arity2 need_dummy =
match arity1, CicReduction.whd ~subst context arity2 with
- (C.Prod (_,so1,de1), C.Prod (_,so2,de2)) ->
+ (C.Prod (name,so1,de1), C.Prod (_,so2,de2)) ->
let b,ugraph1 =
CicReduction.are_convertible ~subst ~metasenv context so1 so2 ugraph in
if b then
- check_allowed_sort_elimination ~subst ~metasenv ~logger context uri i
+ check_allowed_sort_elimination ~subst ~metasenv ~logger
+ ((Some (name,C.Decl so1))::context) uri i
need_dummy (C.Appl [CicSubstitution.lift 1 ind ; C.Rel 1]) de1 de2
ugraph1
else
| C.LetIn (n,s,ty,t) ->
(* only to check if s is well-typed *)
let ty',ugraph1 = type_of_aux ~logger context s ugraph in
+ let _,ugraph1 = type_of_aux ~logger context ty ugraph1 in
let b,ugraph1 =
R.are_convertible ~subst ~metasenv context ty ty' ugraph1
in
let (_,ty,_) = List.nth fl i in
ty,ugraph2
- and check_exp_named_subst ~logger ~subst context ugraph =
+ and check_exp_named_subst ~logger ~subst context =
let rec check_exp_named_subst_aux ~logger esubsts l ugraph =
match l with
[] -> ugraph
raise (TypeCheckerFailure (lazy "Wrong Explicit Named Substitution"))
end
in
- check_exp_named_subst_aux ~logger [] ugraph
+ check_exp_named_subst_aux ~logger []
and sort_of_prod ~subst context (name,s) (t1, t2) ugraph =
let module C = Cic in
let _,ugraph = type_of ~logger ty ugraph in
ugraph
| C.CurrentProof (_,conjs,te,ty,_,_) ->
+ (* this block is broken since the metasenv should
+ * be topologically sorted before typing metas *)
+ ignore(assert false);
let _,ugraph =
List.fold_left
(fun (metasenv,ugraph) ((_,context,ty) as conj) ->
~logger:(new CicLogger.logger) [] uri i true
(Cic.Implicit None) (* never used *) (Cic.Sort s1) (Cic.Sort s2)
CicUniv.empty_ugraph)
+;;
+
+Deannotate.type_of_aux' := fun context t -> fst (type_of_aux' [] context t CicUniv.oblivion_ugraph);;