function
C.Rel m when m = n -> false
| C.Rel _
+(* FG/CSC: maybe we assume the meta is guarded so we do not recur on its *)
+(* explicit subsitutions (copied from the kernel) ??? *)
| C.Meta _
| C.Sort _
| C.Implicit _ -> true
| C.Lambda (name,so,dest) ->
does_not_occur n so &&
does_not_occur (n + 1) dest
- | C.LetIn (name,so,dest) ->
+ | C.LetIn (name,so,ty,dest) ->
does_not_occur n so &&
- does_not_occur (n + 1) dest
+ does_not_occur n ty &&
+ does_not_occur (n + 1) dest
| C.Appl l ->
List.fold_right (fun x i -> i && does_not_occur n x) l true
| C.Var (_,exp_named_subst)
C.Prod (n, beta_reduce s, beta_reduce t)
| C.Lambda (n,s,t) ->
C.Lambda (n, beta_reduce s, beta_reduce t)
- | C.LetIn (n,s,t) ->
- C.LetIn (n, beta_reduce s, beta_reduce t)
+ | C.LetIn (n,s,ty,t) ->
+ C.LetIn (n, beta_reduce s, beta_reduce ty, beta_reduce t)
| C.Appl ((C.Lambda (name,s,t))::he::tl) ->
let he' = S.subst he t in
if tl = [] then
(try
match List.nth context (n - 1) with
Some (_,C.Decl t) -> S.lift n t
- | Some (_,C.Def (_,Some ty)) -> S.lift n ty
- | Some (_,C.Def (bo,None)) ->
- type_of_aux context (S.lift n bo) expectedty
- | None -> raise RelToHiddenHypothesis
+ | Some (_,C.Def (_,ty)) -> S.lift n ty
+ | None -> raise RelToHiddenHypothesis
with
_ -> raise (NotWellTyped "Not a close term")
)
[] -> []
| (Some (n,C.Decl t))::tl ->
(Some (n,C.Decl (S.subst_meta l (S.lift i t))))::(aux (i+1) tl)
- | (Some (n,C.Def (t,None)))::tl ->
- (Some (n,C.Def ((S.subst_meta l (S.lift i t)),None)))::
- (aux (i+1) tl)
+ | (Some (n,C.Def (t,ty)))::tl ->
+ (Some (n,
+ C.Def
+ ((S.subst_meta l (S.lift i t)),S.subst_meta l (S.lift i t))))::
+ (aux (i+1) tl)
| None::tl -> None::(aux (i+1) tl)
- | (Some (_,C.Def (_,Some _)))::_ -> assert false
in
aux 1 canonical_context
in
in
(* Checks suppressed *)
C.Prod (n,s,type2)
- | C.LetIn (n,s,t) ->
+ | C.LetIn (n,s,ty,t) ->
(*CSC: What are the right expected types for the source and *)
(*CSC: target of a LetIn? None used. *)
(* Let's visit all the subterms that will not be visited later *)
- let ty = type_of_aux context s None in
+ let _ = type_of_aux context ty None in
+ let _ = type_of_aux context s (Some ty) in
let t_typ =
(* Checks suppressed *)
- type_of_aux ((Some (n,(C.Def (s,Some ty))))::context) t None
+ type_of_aux ((Some (n,(C.Def (s,ty))))::context) t None
in (* CicSubstitution.subst s t_typ *)
if does_not_occur 1 t_typ then
(* since [Rel 1] does not occur in typ, substituting any term *)
(* in place of [Rel 1] is equivalent to delifting once *)
CicSubstitution.subst (C.Implicit None) t_typ
else
- C.LetIn (n,s,t_typ)
+ C.LetIn (n,s,ty,t_typ)
| C.Appl (he::tl) when List.length tl > 0 ->
(*
let expected_hetype =
in
let rec check uris_and_types subst =
match uris_and_types,subst with
- _,[] -> []
+ _,[] -> ()
| (uri,ty)::tytl,(uri',t)::substtl when uri = uri' ->
ignore (type_of_aux context t (Some ty)) ;
let tytl' =