text
stringlengths 12
786k
|
|---|
let print_out_exception ppf exn outv = match exn with Sys . Break -> fprintf ppf " Interrupted . . " @ | Out_of_memory -> fprintf ppf " Out of memory during evaluation . . " @ | Stack_overflow -> fprintf ppf " Stack overflow during evaluation ( looping recursion ) . . " ?@ | _ -> fprintf ppf " [ @ Exception :@ % a . ] . " @@ ! out_value outv |
let rec print_items ppf = function [ ] -> ( ) | ( Osig_typext ( ext , Oext_first ) , None ) :: items -> let rec gather_extensions acc items = match items with ( Osig_typext ( ext , Oext_next ) , None ) :: items -> gather_extensions ( ( ext . oext_name , ext . oext_args , ext . oext_ret_type ) :: acc ) items | _ -> ( List . rev acc , items ) in let exts , items = gather_extensions [ ( ext . oext_name , ext . oext_args , ext . oext_ret_type ) ] items in let te = { otyext_name = ext . oext_type_name ; otyext_params = ext . oext_type_params ; otyext_constructors = exts ; otyext_private = ext . oext_private } in fprintf ppf " [ @% a ] " @ ! out_type_extension te ; if items <> [ ] then fprintf ppf " @ % a " print_items items | ( tree , valopt ) :: items -> begin match valopt with Some v -> fprintf ppf " [ @< 2 >% a =@ % a ] " @ ! out_sig_item tree ! out_value v | None -> fprintf ppf " [ @% a ] " @ ! out_sig_item tree end ; if items <> [ ] then fprintf ppf " @ % a " print_items items |
let print_out_phrase ppf = function Ophr_eval ( outv , ty ) -> fprintf ppf " [ @- : % a @ =@ % a ] . " @@ ! out_type ty ! out_value outv | Ophr_signature [ ] -> ( ) | Ophr_signature items -> fprintf ppf " [ @< v >% a ] . " @@ print_items items | Ophr_exception ( exn , outv ) -> print_out_exception ppf exn outv |
let out_phrase = ref print_out_phrase |
module type XOR = sig type t val xor : t -> t -> t [ @@ logic ] end |
module type CIPHER = sig type elt type t val cipher : t -> t -> t end |
module Make ( X : XOR ) : CIPHER with type elt = X . t = struct type elt = X . t type t = elt list let rec cipher key msg = match ( key , msg ) with | [ ] , [ ] -> [ ] | x :: xs , y :: ys -> X . xor x y :: cipher xs ys | _ -> assert false let correct msg key = let r = cipher key msg in cipher r key end |
module XBool : XOR with type t = bool = struct type t = bool let [ @ logic ] xor t1 t2 = ( ( not t1 ) && t2 ) || ( t1 && not t2 ) end |
module XBool2 : XOR with type t = bool = struct type t = bool let [ @ logic ] xor t1 t2 = if t1 then not t2 else t2 end |
module XBit : XOR = struct type t = Zero | One let [ @ logic ] xor t1 t2 = match ( t1 , t2 ) with Zero , Zero | One , One -> Zero | _ -> One end |
module CBool = Make ( XBool ) |
module CBool2 = Make ( XBool2 ) |
module CBit = Make ( XBit ) |
module Make ( A : sig val rewrite : Path . t -> Outcometree . out_ident end ) = struct |
let unique_names = ref Ident . empty |
let ident_name id = try Ident . find_same id ! unique_names with Not_found -> Ident . name id |
let add_unique id = try ignore ( Ident . find_same id ! unique_names ) with Not_found -> unique_names := Ident . add id ( Ident . unique_toplevel_name id ) ! unique_names |
let ident ppf id = pp_print_string ppf ( ident_name id ) |
let ident_pervasive = Ident . create_persistent " Pervasives " |
let rec tree_of_path = function | Pident id -> Oide_ident ( ident_name id ) | Pdot ( Pident id , s , _pos ) when Ident . same id ident_pervasive -> Oide_ident s | Pdot ( p , s , _pos ) -> Oide_dot ( tree_of_path p , s ) | Papply ( p1 , p2 ) -> Oide_apply ( tree_of_path p1 , tree_of_path p2 ) |
let tree_of_path p = A . rewrite p |
let rec path ppf = function | Pident id -> ident ppf id | Pdot ( Pident id , s , _pos ) when Ident . same id ident_pervasive -> pp_print_string ppf s | Pdot ( p , s , _pos ) -> path ppf p ; pp_print_char ppf ' . ' ; pp_print_string ppf s | Papply ( p1 , p2 ) -> fprintf ppf " % a ( % a ) " path p1 path p2 |
let rec string_of_out_ident = function | Oide_ident s -> s | Oide_dot ( id , s ) -> String . concat " . " [ string_of_out_ident id ; s ] | Oide_apply ( id1 , id2 ) -> String . concat " " [ string_of_out_ident id1 ; " ( " ; string_of_out_ident id2 ; " ) " ] |
let tree_of_rec = function | Trec_not -> Orec_not | Trec_first -> Orec_first | Trec_next -> Orec_next |
let raw_list pr ppf = function [ ] -> fprintf ppf " [ ] " | a :: l -> fprintf ppf " [ @< 1 [ >% a % t ] ] " @ pr a ( fun ppf -> List . iter ( fun x -> fprintf ppf " ; , @% a " pr x ) l ) |
let kind_vars = ref [ ] |
let kind_count = ref 0 |
let rec safe_kind_repr v = function Fvar { contents = Some k } -> if List . memq k v then " Fvar loop " else safe_kind_repr ( k :: v ) k | Fvar r -> let vid = try List . assq r ! kind_vars with Not_found -> let c = incr kind_count ; ! kind_count in kind_vars := ( r , c ) :: ! kind_vars ; c in Printf . sprintf " Fvar { None } @% d " vid | Fpresent -> " Fpresent " | Fabsent -> " Fabsent " |
let rec safe_commu_repr v = function Cok -> " Cok " | Cunknown -> " Cunknown " | Clink r -> if List . memq r v then " Clink loop " else safe_commu_repr ( r :: v ) ! r |
let rec safe_repr v = function { desc = Tlink t } when not ( List . memq t v ) -> safe_repr ( t :: v ) t | t -> t |
let rec list_of_memo = function Mnil -> [ ] | Mcons ( _priv , p , _t1 , _t2 , rem ) -> p :: list_of_memo rem | Mlink rem -> list_of_memo ! rem |
let print_name ppf = function None -> fprintf ppf " None " | Some name -> fprintf ppf " " \% s " " \ name |
let string_of_label = function Nolabel -> " " | Labelled s -> s | Optional s -> " " ?^ s |
type param_subst = Id | Nth of int | Map of int list |
let is_nth = function Nth _ -> true | _ -> false |
let compose l1 = function | Id -> Map l1 | Map l2 -> Map ( List . map ( List . nth l1 ) l2 ) | Nth n -> Nth ( List . nth l1 n ) |
let apply_subst s1 tyl = match s1 with Nth n1 -> [ List . nth tyl n1 ] | Map l1 -> List . map ( List . nth tyl ) l1 | Id -> tyl |
type best_path = Paths of Path . t list | Best of Path . t |
let printing_env = ref Env . empty |
let printing_depth = ref 0 |
let printing_cont = ref ( [ ] : Env . iter_cont list ) |
let printing_old = ref Env . empty |
let printing_pers = ref Concr . empty |
let printing_map = ref PathMap . empty |
let rec index l x = match l with [ ] -> raise Not_found | a :: l -> if x == a then 0 else 1 + index l x |
let rec uniq = function [ ] -> true | a :: l -> not ( List . memq a l ) && uniq l |
let rec normalize_type_path ( ? cache = false ) env p = try let ( params , ty , _ ) = Env . find_type_expansion p env in let params = List . map repr params in match repr ty with { desc = Tconstr ( p1 , tyl , _ ) } -> let tyl = List . map repr tyl in if List . length params = List . length tyl && List . for_all2 ( ) == params tyl then normalize_type_path ~ cache env p1 else if cache || List . length params <= List . length tyl || not ( uniq tyl ) then ( p , Id ) else let l1 = List . map ( index params ) tyl in let ( p2 , s2 ) = normalize_type_path ~ cache env p1 in ( p2 , compose l1 s2 ) | ty -> ( p , Nth ( index params ty ) ) with Not_found -> ( Env . normalize_path None env p , Id ) |
let penalty s = if s <> " " && s . [ 0 ] = ' _ ' then 10 else try for i = 0 to String . length s - 2 do if s . [ i ] = ' _ ' && s . [ i + 1 ] = ' _ ' then raise Exit done ; 1 with Exit -> 10 |
let rec path_size = function Pident id -> penalty ( Ident . name id ) , - Ident . binding_time id | Pdot ( p , _ , _ ) -> let ( l , b ) = path_size p in ( 1 + l , b ) | Papply ( p1 , p2 ) -> let ( l , b ) = path_size p1 in ( l + fst ( path_size p2 ) , b ) |
let same_printing_env env = let used_pers = Env . used_persistent ( ) in Env . same_types ! printing_old env && Concr . equal ! printing_pers used_pers |
let set_printing_env env = printing_env := if ! Clflags . real_paths then Env . empty else env ; if ! printing_env == Env . empty || same_printing_env env then ( ) else begin printing_old := env ; printing_pers := Env . used_persistent ( ) ; printing_map := PathMap . empty ; printing_depth := 0 ; let cont = Env . iter_types ( fun p ( p ' , _decl ) -> let ( p1 , s1 ) = normalize_type_path env p ' ~ cache : true in if s1 = Id then try let r = PathMap . find p1 ! printing_map in match ! r with Paths l -> r := Paths ( p :: l ) | Best p ' -> r := Paths [ p ; p ' ] with Not_found -> printing_map := PathMap . add p1 ( ref ( Paths [ p ] ) ) ! printing_map ) env in printing_cont := [ cont ] ; end |
let wrap_printing_env env f = set_printing_env env ; try_finally f ( fun ( ) -> set_printing_env Env . empty ) |
let wrap_printing_env env f = Env . without_cmis ( wrap_printing_env env ) f |
let is_unambiguous path env = let l = Env . find_shadowed_types path env in List . exists ( Path . same path ) l || match l with [ ] -> true | p :: rem -> let normalize p = fst ( normalize_type_path ~ cache : true env p ) in let p ' = normalize p in List . for_all ( fun p -> Path . same ( normalize p ) p ' ) rem || let id = lid_of_path p in List . for_all ( fun p -> lid_of_path p = id ) rem && Path . same p ( Env . lookup_type id env ) |
let rec get_best_path r = match ! r with Best p ' -> p ' | Paths [ ] -> raise Not_found | Paths l -> r := Paths [ ] ; List . iter ( fun p -> match ! r with Best p ' when path_size p >= path_size p ' -> ( ) | _ -> if is_unambiguous p ! printing_env then r := Best p ) l ; get_best_path r |
let best_type_path p = if ! Clflags . real_paths || ! printing_env == Env . empty then ( p , Id ) else let ( p ' , s ) = normalize_type_path ! printing_env p in let get_path ( ) = get_best_path ( PathMap . find p ' ! printing_map ) in while ! printing_cont <> [ ] && try fst ( path_size ( get_path ( ) ) ) > ! printing_depth with Not_found -> true do printing_cont := List . map snd ( Env . run_iter_cont ! printing_cont ) ; incr printing_depth ; done ; let p ' ' = try get_path ( ) with Not_found -> p ' in ( p ' ' , s ) |
let names = ref ( [ ] : ( type_expr * string ) list ) |
let name_counter = ref 0 |
let named_vars = ref ( [ ] : string list ) |
let reset_names ( ) = names := [ ] ; name_counter := 0 ; named_vars := [ ] |
let add_named_var ty = match ty . desc with Tvar ( Some name ) | Tunivar ( Some name ) -> if List . mem name ! named_vars then ( ) else named_vars := name :: ! named_vars | _ -> ( ) |
let rec new_name ( ) = let name = if ! name_counter < 26 then String . make 1 ( Char . chr ( 97 + ! name_counter ) ) else String . make 1 ( Char . chr ( 97 + ! name_counter mod 26 ) ) ^ string_of_int ( ! name_counter / 26 ) in incr name_counter ; if List . mem name ! named_vars || List . exists ( fun ( _ , name ' ) -> name = name ' ) ! names then new_name ( ) else name |
let name_of_type t = try List . assq t ! names with Not_found -> let name = match t . desc with Tvar ( Some name ) | Tunivar ( Some name ) -> let current_name = ref name in let i = ref 0 in while List . exists ( fun ( _ , name ' ) -> ! current_name = name ' ) ! names do current_name := name ^ ( string_of_int ! i ) ; i := ! i + 1 ; done ; ! current_name | _ -> new_name ( ) in if name <> " _ " then names := ( t , name ) :: ! names ; name |
let check_name_of_type t = ignore ( name_of_type t ) |
let remove_names tyl = let tyl = List . map repr tyl in names := List . filter ( fun ( ty , _ ) -> not ( List . memq ty tyl ) ) ! names |
let visited_objects = ref ( [ ] : type_expr list ) |
let aliased = ref ( [ ] : type_expr list ) |
let delayed = ref ( [ ] : type_expr list ) |
let add_delayed t = if not ( List . memq t ! delayed ) then delayed := t :: ! delayed |
let is_aliased ty = List . memq ( proxy ty ) ! aliased |
let add_alias ty = let px = proxy ty in if not ( is_aliased px ) then begin aliased := px :: ! aliased ; add_named_var px end |
let aliasable ty = match ty . desc with Tvar _ | Tunivar _ | Tpoly _ -> false | Tconstr ( p , _ , _ ) -> not ( is_nth ( snd ( best_type_path p ) ) ) | _ -> true |
let namable_row row = row . row_name <> None && List . for_all ( fun ( _ , f ) -> match row_field_repr f with | Reither ( c , l , _ , _ ) -> row . row_closed && if c then l = [ ] else List . length l = 1 | _ -> true ) row . row_fields |
let rec mark_loops_rec visited ty = let ty = repr ty in let px = proxy ty in if List . memq px visited && aliasable ty then add_alias px else let visited = px :: visited in match ty . desc with | Tvar _ -> add_named_var ty | Tarrow ( _ , ty1 , ty2 , _ ) -> mark_loops_rec visited ty1 ; mark_loops_rec visited ty2 | Ttuple tyl -> List . iter ( mark_loops_rec visited ) tyl | Tconstr ( p , tyl , _ ) -> let ( _p ' , s ) = best_type_path p in List . iter ( mark_loops_rec visited ) ( apply_subst s tyl ) | Tpackage ( _ , _ , tyl ) -> List . iter ( mark_loops_rec visited ) tyl | Tvariant row -> if List . memq px ! visited_objects then add_alias px else begin let row = row_repr row in if not ( static_row row ) then visited_objects := px :: ! visited_objects ; match row . row_name with | Some ( _p , tyl ) when namable_row row -> List . iter ( mark_loops_rec visited ) tyl | _ -> iter_row ( mark_loops_rec visited ) row end | Tobject ( fi , nm ) -> if List . memq px ! visited_objects then add_alias px else begin if opened_object ty then visited_objects := px :: ! visited_objects ; begin match ! nm with | None -> let fields , _ = flatten_fields fi in List . iter ( fun ( _ , kind , ty ) -> if field_kind_repr kind = Fpresent then mark_loops_rec visited ty ) fields | Some ( _ , l ) -> List . iter ( mark_loops_rec visited ) ( List . tl l ) end end | Tfield ( _ , kind , ty1 , ty2 ) when field_kind_repr kind = Fpresent -> mark_loops_rec visited ty1 ; mark_loops_rec visited ty2 | Tfield ( _ , _ , _ , ty2 ) -> mark_loops_rec visited ty2 | Tnil -> ( ) | Tsubst ty -> mark_loops_rec visited ty | Tlink _ -> fatal_error " Printtyp . mark_loops_rec ( 2 ) " | Tpoly ( ty , tyl ) -> List . iter ( fun t -> add_alias t ) tyl ; mark_loops_rec visited ty | Tunivar _ -> add_named_var ty |
let mark_loops ty = normalize_type Env . empty ty ; mark_loops_rec [ ] ty ; ; |
let reset_loop_marks ( ) = visited_objects := [ ] ; aliased := [ ] ; delayed := [ ] |
let reset ( ) = unique_names := Ident . empty ; reset_names ( ) ; reset_loop_marks ( ) |
let reset_and_mark_loops ty = reset ( ) ; mark_loops ty |
let reset_and_mark_loops_list tyl = reset ( ) ; List . iter mark_loops tyl |
let print_labels = ref true |
let rec tree_of_typexp sch ty = let ty = repr ty in let px = proxy ty in if List . mem_assq px ! names && not ( List . memq px ! delayed ) then let mark = is_non_gen sch ty in Otyp_var ( mark , name_of_type px ) else let pr_typ ( ) = match ty . desc with | Tvar _ -> Otyp_var ( is_non_gen sch ty , name_of_type ty ) | Tarrow ( l , ty1 , ty2 , _ ) -> let pr_arrow l ty1 ty2 = let lab = if ! print_labels || is_optional l then string_of_label l else " " in let t1 = if is_optional l then match ( repr ty1 ) . desc with | Tconstr ( path , [ ty ] , _ ) when Path . same path Predef . path_option -> tree_of_typexp sch ty | _ -> Otyp_stuff " < hidden " > else tree_of_typexp sch ty1 in Otyp_arrow ( lab , t1 , tree_of_typexp sch ty2 ) in pr_arrow l ty1 ty2 | Ttuple tyl -> Otyp_tuple ( tree_of_typlist sch tyl ) | Tconstr ( p , tyl , _abbrev ) -> let p ' , s = best_type_path p in let tyl ' = apply_subst s tyl in if is_nth s then tree_of_typexp sch ( List . hd tyl ' ) else Otyp_constr ( tree_of_path p ' , tree_of_typlist sch tyl ' ) | Tvariant row -> let row = row_repr row in let fields = if row . row_closed then List . filter ( fun ( _ , f ) -> row_field_repr f <> Rabsent ) row . row_fields else row . row_fields in let present = List . filter ( fun ( _ , f ) -> match row_field_repr f with | Rpresent _ -> true | _ -> false ) fields in let all_present = List . length present = List . length fields in begin match row . row_name with | Some ( p , tyl ) when namable_row row -> let ( p ' , s ) = best_type_path p in let id = tree_of_path p ' in let args = tree_of_typlist sch ( apply_subst s tyl ) in if row . row_closed && all_present then if is_nth s then List . hd args else Otyp_constr ( id , args ) else let non_gen = is_non_gen sch px in let tags = if all_present then None else Some ( List . map fst present ) in let inh = match args with [ Otyp_constr ( i , a ) ] when is_nth s -> Ovar_name ( i , a ) | _ -> Ovar_name ( tree_of_path p , tree_of_typlist sch tyl ) in Otyp_variant ( non_gen , inh , row . row_closed , tags ) | _ -> let non_gen = not ( row . row_closed && all_present ) && is_non_gen sch px in let fields = List . map ( tree_of_row_field sch ) fields in let tags = if all_present then None else Some ( List . map fst present ) in Otyp_variant ( non_gen , Ovar_fields fields , row . row_closed , tags ) end | Tobject ( fi , nm ) -> tree_of_typobject sch fi ! nm | Tnil | Tfield _ -> tree_of_typobject sch ty None | Tsubst ty -> tree_of_typexp sch ty | Tlink _ -> fatal_error " Printtyp . tree_of_typexp " | Tpoly ( ty , [ ] ) -> tree_of_typexp sch ty | Tpoly ( ty , tyl ) -> let tyl = List . map repr tyl in if tyl = [ ] then tree_of_typexp sch ty else begin let old_delayed = ! delayed in List . iter add_delayed tyl ; let tl = List . map name_of_type tyl in let tr = Otyp_poly ( tl , tree_of_typexp sch ty ) in remove_names tyl ; delayed := old_delayed ; tr end | Tunivar _ -> Otyp_var ( false , name_of_type ty ) | Tpackage ( p , n , tyl ) -> let n = List . map ( fun li -> String . concat " . " ( Longident . flatten li ) ) n in Otyp_module ( Path . name p , n , tree_of_typlist sch tyl ) in if List . memq px ! delayed then delayed := List . filter ( ( ) != px ) ! delayed ; if is_aliased px && aliasable ty then begin check_name_of_type px ; Otyp_alias ( pr_typ ( ) , name_of_type px ) end else pr_typ ( ) match row_field_repr f with | Rpresent None | Reither ( true , [ ] , _ , _ ) -> ( l , false , [ ] ) | Rpresent ( Some ty ) -> ( l , false , [ tree_of_typexp sch ty ] ) | Reither ( c , tyl , _ , _ ) -> if c then ( l , true , tree_of_typlist sch tyl ) else ( l , false , tree_of_typlist sch tyl ) | Rabsent -> ( l , false , [ ] ) List . map ( tree_of_typexp sch ) tyl begin match nm with | None -> let pr_fields fi = let ( fields , rest ) = flatten_fields fi in let present_fields = List . fold_right ( fun ( n , k , t ) l -> match field_kind_repr k with | Fpresent -> ( n , t ) :: l | _ -> l ) fields [ ] in let sorted_fields = List . sort ( fun ( n , _ ) ( n ' , _ ) -> String . compare n n ' ) present_fields in tree_of_typfields sch rest sorted_fields in let ( fields , rest ) = pr_fields fi in Otyp_object ( fields , rest ) | Some ( p , ty :: tyl ) -> let non_gen = is_non_gen sch ( repr ty ) in let args = tree_of_typlist sch tyl in let ( p ' , s ) = best_type_path p in assert ( s = Id ) ; Otyp_class ( non_gen , tree_of_path p ' , args ) | _ -> fatal_error " Printtyp . tree_of_typobject " end sch && is_Tvar ty && ty . level <> generic_level | [ ] -> let rest = match rest . desc with | Tvar _ | Tunivar _ -> Some ( is_non_gen sch rest ) | Tconstr _ -> Some false | Tnil -> None | _ -> fatal_error " typfields ( 1 ) " in ( [ ] , rest ) | ( s , t ) :: l -> let field = ( s , tree_of_typexp sch t ) in let ( fields , rest ) = tree_of_typfields sch rest l in ( field :: fields , rest ) |
let typexp sch ppf ty = ! Xoprint . out_type ppf ( tree_of_typexp sch ty ) |
let type_expr ppf ty = typexp false ppf ty |
let type_scheme_max ( ? b_reset_names = true ) ppf ty = if b_reset_names then reset_names ( ) ; typexp true ppf ty |
let tree_of_type_scheme ty = reset_and_mark_loops ty ; tree_of_typexp true ty |
let tree_of_constraints params = List . fold_right ( fun ty list -> let ty ' = unalias ty in if proxy ty != proxy ty ' then let tr = tree_of_typexp true ty in ( tr , tree_of_typexp true ty ' ) :: list else list ) params [ ] |
let filter_params tyl = let params = List . fold_left ( fun tyl ty -> let ty = repr ty in if List . memq ty tyl then Btype . newgenty ( Tsubst ty ) :: tyl else ty :: tyl ) [ ] tyl in List . rev params |
let mark_loops_constructor_arguments = function | Cstr_tuple l -> List . iter mark_loops l | Cstr_record l -> List . iter ( fun l -> mark_loops l . ld_type ) l |
let rec tree_of_type_decl id decl = reset ( ) ; let params = filter_params decl . type_params in begin match decl . type_manifest with | Some ty -> let vars = free_variables ty in List . iter ( function { desc = Tvar ( Some " _ " ) } as ty -> if List . memq ty vars then ty . desc <- Tvar None | _ -> ( ) ) params | None -> ( ) end ; List . iter add_alias params ; List . iter mark_loops params ; List . iter check_name_of_type ( List . map proxy params ) ; let ty_manifest = match decl . type_manifest with | None -> None | Some ty -> let ty = match repr ty with { desc = Tvariant row } -> let row = row_repr row in begin match row . row_name with Some ( Pident id ' , _ ) when Ident . same id id ' -> newgenty ( Tvariant { row with row_name = None } ) | _ -> ty end | _ -> ty in mark_loops ty ; Some ty in begin match decl . type_kind with | Type_abstract -> ( ) | Type_variant cstrs -> List . iter ( fun c -> mark_loops_constructor_arguments c . cd_args ; may mark_loops c . cd_res ) cstrs | Type_record ( l , _rep ) -> List . iter ( fun l -> mark_loops l . ld_type ) l | Type_open -> ( ) end ; let type_param = function | Otyp_var ( _ , id ) -> id | _ -> " " ? in let type_defined decl = let abstr = match decl . type_kind with Type_abstract -> decl . type_manifest = None || decl . type_private = Private | Type_record _ -> decl . type_private = Private | Type_variant tll -> decl . type_private = Private || List . exists ( fun cd -> cd . cd_res <> None ) tll | Type_open -> decl . type_manifest = None in let vari = List . map2 ( fun ty v -> if abstr || not ( is_Tvar ( repr ty ) ) then Variance . get_upper v else ( true , true ) ) decl . type_params decl . type_variance in ( Ident . name id , List . map2 ( fun ty cocn -> type_param ( tree_of_typexp false ty ) , cocn ) params vari ) in let tree_of_manifest ty1 = match ty_manifest with | None -> ty1 | Some ty -> Otyp_manifest ( tree_of_typexp false ty , ty1 ) in let ( name , args ) = type_defined decl in let constraints = tree_of_constraints params in let ty , priv = match decl . type_kind with | Type_abstract -> begin match ty_manifest with | None -> ( Otyp_abstract , Public ) | Some ty -> tree_of_typexp false ty , decl . type_private end | Type_variant cstrs -> tree_of_manifest ( Otyp_sum ( List . map tree_of_constructor cstrs ) ) , decl . type_private | Type_record ( lbls , _rep ) -> tree_of_manifest ( Otyp_record ( List . map tree_of_label lbls ) ) , decl . type_private | Type_open -> tree_of_manifest Otyp_open , Public in let immediate = Builtin_attributes . immediate decl . type_attributes in { otype_name = name ; otype_params = args ; otype_type = ty ; otype_private = priv ; otype_immediate = immediate ; otype_unboxed = decl . type_unboxed . unboxed ; otype_cstrs = constraints } | Cstr_tuple l -> tree_of_typlist false l | Cstr_record l -> [ Otyp_record ( List . map tree_of_label l ) ] let name = Ident . name cd . cd_id in let arg ( ) = tree_of_constructor_arguments cd . cd_args in match cd . cd_res with | None -> ( name , arg ( ) , None ) | Some res -> let nm = ! names in names := [ ] ; let ret = tree_of_typexp false res in let args = arg ( ) in names := nm ; ( name , args , Some ret ) ( Ident . name l . ld_id , l . ld_mutable = Mutable , tree_of_typexp false l . ld_type ) |
let tree_of_type_declaration id decl rs = Osig_type ( tree_of_type_decl id decl , tree_of_rec rs ) |
let tree_of_extension_constructor id ext es = reset ( ) ; let ty_name = Path . name ext . ext_type_path in let ty_params = filter_params ext . ext_type_params in List . iter add_alias ty_params ; List . iter mark_loops ty_params ; List . iter check_name_of_type ( List . map proxy ty_params ) ; mark_loops_constructor_arguments ext . ext_args ; may mark_loops ext . ext_ret_type ; let type_param = function | Otyp_var ( _ , id ) -> id | _ -> " " ? in let ty_params = List . map ( fun ty -> type_param ( tree_of_typexp false ty ) ) ty_params in let name = Ident . name id in let args , ret = match ext . ext_ret_type with | None -> ( tree_of_constructor_arguments ext . ext_args , None ) | Some res -> let nm = ! names in names := [ ] ; let ret = tree_of_typexp false res in let args = tree_of_constructor_arguments ext . ext_args in names := nm ; ( args , Some ret ) in let ext = { oext_name = name ; oext_type_name = ty_name ; oext_type_params = ty_params ; oext_args = args ; oext_ret_type = ret ; oext_private = ext . ext_private } in let es = match es with Text_first -> Oext_first | Text_next -> Oext_next | Text_exception -> Oext_exception in Osig_typext ( ext , es ) |
let tree_of_value_description id decl = let id = Ident . name id in let ty = tree_of_type_scheme decl . val_type in let vd = { oval_name = id ; oval_type = ty ; oval_prims = [ ] ; oval_attributes = [ ] } in let vd = match decl . val_kind with | Val_prim p -> Primitive . print p vd | _ -> vd in Osig_value vd |
let method_type ( _ , kind , ty ) = match field_kind_repr kind , repr ty with Fpresent , { desc = Tpoly ( ty , tyl ) } -> ( ty , tyl ) | _ , ty -> ( ty , [ ] ) |
let tree_of_metho sch concrete csil ( lab , kind , ty ) = if lab <> dummy_method then begin let kind = field_kind_repr kind in let priv = kind <> Fpresent in let virt = not ( Concr . mem lab concrete ) in let ( ty , tyl ) = method_type ( lab , kind , ty ) in let tty = tree_of_typexp sch ty in remove_names tyl ; Ocsg_method ( lab , priv , virt , tty ) :: csil end else csil |
let rec prepare_class_type params = function | Cty_constr ( _p , tyl , cty ) -> let sty = Ctype . self_type cty in if List . memq ( proxy sty ) ! visited_objects || not ( List . for_all is_Tvar params ) || List . exists ( deep_occur sty ) tyl then prepare_class_type params cty else List . iter mark_loops tyl | Cty_signature sign -> let sty = repr sign . csig_self in let px = proxy sty in if List . memq px ! visited_objects then add_alias sty else visited_objects := px :: ! visited_objects ; let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sign . csig_self ) in List . iter ( fun met -> mark_loops ( fst ( method_type met ) ) ) fields ; Vars . iter ( fun _ ( _ , _ , ty ) -> mark_loops ty ) sign . csig_vars | Cty_arrow ( _ , ty , cty ) -> mark_loops ty ; prepare_class_type params cty |
let rec tree_of_class_type sch params = function | Cty_constr ( p ' , tyl , cty ) -> let sty = Ctype . self_type cty in if List . memq ( proxy sty ) ! visited_objects || not ( List . for_all is_Tvar params ) then tree_of_class_type sch params cty else Octy_constr ( tree_of_path p ' , tree_of_typlist true tyl ) | Cty_signature sign -> let sty = repr sign . csig_self in let self_ty = if is_aliased sty then Some ( Otyp_var ( false , name_of_type ( proxy sty ) ) ) else None in let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sign . csig_self ) in let csil = [ ] in let csil = List . fold_left ( fun csil ( ty1 , ty2 ) -> Ocsg_constraint ( ty1 , ty2 ) :: csil ) csil ( tree_of_constraints params ) in let all_vars = Vars . fold ( fun l ( m , v , t ) all -> ( l , m , v , t ) :: all ) sign . csig_vars [ ] in let all_vars = List . rev all_vars in let csil = List . fold_left ( fun csil ( l , m , v , t ) -> Ocsg_value ( l , m = Mutable , v = Virtual , tree_of_typexp sch t ) :: csil ) csil all_vars in let csil = List . fold_left ( tree_of_metho sch sign . csig_concr ) csil fields in Octy_signature ( self_ty , List . rev csil ) | Cty_arrow ( l , ty , cty ) -> let lab = if ! print_labels || is_optional l then string_of_label l else " " in let ty = if is_optional l then match ( repr ty ) . desc with | Tconstr ( path , [ ty ] , _ ) when Path . same path Predef . path_option -> ty | _ -> newconstr ( Path . Pident ( Ident . create " < hidden " ) ) > [ ] else ty in let tr = tree_of_typexp sch ty in Octy_arrow ( lab , tr , tree_of_class_type sch params cty ) |
let tree_of_class_param param variance = ( match tree_of_typexp true param with Otyp_var ( _ , s ) -> s | _ -> " " ) , ? if is_Tvar ( repr param ) then ( true , true ) else variance |
let class_variance = List . map Variance . ( fun v -> mem May_pos v , mem May_neg v ) |
let tree_of_class_declaration id cl rs = let params = filter_params cl . cty_params in reset ( ) ; List . iter add_alias params ; prepare_class_type params cl . cty_type ; let sty = Ctype . self_type cl . cty_type in List . iter mark_loops params ; List . iter check_name_of_type ( List . map proxy params ) ; if is_aliased sty then check_name_of_type ( proxy sty ) ; let vir_flag = cl . cty_new = None in Osig_class ( vir_flag , Ident . name id , List . map2 tree_of_class_param params ( class_variance cl . cty_variance ) , tree_of_class_type true params cl . cty_type , tree_of_rec rs ) |
let tree_of_cltype_declaration id cl rs = let params = List . map repr cl . clty_params in reset ( ) ; List . iter add_alias params ; prepare_class_type params cl . clty_type ; let sty = Ctype . self_type cl . clty_type in List . iter mark_loops params ; List . iter check_name_of_type ( List . map proxy params ) ; if is_aliased sty then check_name_of_type ( proxy sty ) ; let sign = Ctype . signature_of_class_type cl . clty_type in let virt = let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sign . csig_self ) in List . exists ( fun ( lab , _ , _ ) -> not ( lab = dummy_method || Concr . mem lab sign . csig_concr ) ) fields || Vars . fold ( fun _ ( _ , vr , _ ) b -> vr = Virtual || b ) sign . csig_vars false in Osig_class_type ( virt , Ident . name id , List . map2 tree_of_class_param params ( class_variance cl . clty_variance ) , tree_of_class_type true params cl . clty_type , tree_of_rec rs ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.