AllenGeng/ocamlgithub · Datasets at Hugging Face

text stringlengths 12 786k
let extract_constraints cty = let sign = Ctype . signature_of_class_type cty in ( Vars . fold ( fun lab _ vars -> lab :: vars ) sign . csig_vars [ ] , begin let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sign . csig_self ) in List . fold_left ( fun meths ( lab , _ , _ ) -> if lab = dummy_method then meths else lab :: meths ) [ ] fields end , sign . csig_concr )
let rec abbreviate_class_type path params cty = match cty with Cty_constr ( _ , _ , _ ) \| Cty_signature _ -> Cty_constr ( path , params , cty ) \| Cty_arrow ( l , ty , cty ) -> Cty_arrow ( l , ty , abbreviate_class_type path params cty )
let rec closed_class_type = function Cty_constr ( _ , params , _ ) -> List . for_all ( Ctype . closed_schema Env . empty ) params \| Cty_signature sign -> Ctype . closed_schema Env . empty sign . csig_self && Vars . fold ( fun _ ( _ , _ , ty ) cc -> Ctype . closed_schema Env . empty ty && cc ) sign . csig_vars true \| Cty_arrow ( _ , ty , cty ) -> Ctype . closed_schema Env . empty ty && closed_class_type cty
let closed_class cty = List . for_all ( Ctype . closed_schema Env . empty ) cty . cty_params && closed_class_type cty . cty_type
let rec limited_generalize rv = function Cty_constr ( _path , params , cty ) -> List . iter ( Ctype . limited_generalize rv ) params ; limited_generalize rv cty \| Cty_signature sign -> Ctype . limited_generalize rv sign . csig_self ; Vars . iter ( fun _ ( _ , _ , ty ) -> Ctype . limited_generalize rv ty ) sign . csig_vars ; List . iter ( fun ( _ , tl ) -> List . iter ( Ctype . limited_generalize rv ) tl ) sign . csig_inher \| Cty_arrow ( _ , ty , cty ) -> Ctype . limited_generalize rv ty ; limited_generalize rv cty
let rc node = Cmt_format . add_saved_type ( Cmt_format . Partial_class_expr node ) ; Stypes . record ( Stypes . Ti_class node ) ; node
let enter_met_env ? check loc lab kind unbound_kind ty val_env met_env par_env = let val_env = Env . enter_unbound_value lab unbound_kind val_env in let par_env = Env . enter_unbound_value lab unbound_kind par_env in let ( id , met_env ) = Env . enter_value ? check lab { val_type = ty ; val_kind = kind ; val_attributes = [ ] ; Types . val_loc = loc } met_env in ( id , val_env , met_env , par_env )
let enter_val cl_num vars inh lab mut virt ty val_env met_env par_env loc = let ( id , virt ) = try let ( id , mut ' , virt ' , ty ' ) = Vars . find lab ! vars in if mut ' <> mut then raise ( Error ( loc , val_env , Mutability_mismatch ( lab , mut ) ) ) ; Ctype . unify val_env ( Ctype . instance ty ) ( Ctype . instance ty ' ) ; ( if not inh then Some id else None ) , ( if virt ' = Concrete then virt ' else virt ) with Ctype . Unify tr -> raise ( Error ( loc , val_env , Field_type_mismatch ( " instance variable " , lab , tr ) ) ) \| Not_found -> None , virt in let ( id , _ , _ , _ ) as result = match id with Some id -> ( id , val_env , met_env , par_env ) \| None -> enter_met_env Location . none lab ( Val_ivar ( mut , cl_num ) ) Val_unbound_instance_variable ty val_env met_env par_env in vars := Vars . add lab ( id , mut , virt , ty ) ! vars ; result
let concr_vals vars = Vars . fold ( fun id ( _ , vf , _ ) s -> if vf = Virtual then s else Concr . add id s ) vars Concr . empty
let inheritance self_type env ovf concr_meths warn_vals loc parent = match scrape_class_type parent with Cty_signature cl_sig -> begin try Ctype . unify env self_type cl_sig . csig_self with Ctype . Unify trace -> let open Ctype . Unification_trace in match trace with \| Diff _ :: Incompatible_fields { name = n ; _ } :: rem -> raise ( Error ( loc , env , Field_type_mismatch ( " method " , n , rem ) ) ) \| _ -> assert false end ; let over_meths = Concr . inter cl_sig . csig_concr concr_meths in let concr_vals = concr_vals cl_sig . csig_vars in let over_vals = Concr . inter concr_vals warn_vals in begin match ovf with Some Fresh -> let cname = match parent with Cty_constr ( p , _ , _ ) -> Path . name p \| _ -> " inherited " in if not ( Concr . is_empty over_meths ) then Location . prerr_warning loc ( Warnings . Method_override ( cname :: Concr . elements over_meths ) ) ; if not ( Concr . is_empty over_vals ) then Location . prerr_warning loc ( Warnings . Instance_variable_override ( cname :: Concr . elements over_vals ) ) ; \| Some Override when Concr . is_empty over_meths && Concr . is_empty over_vals -> raise ( Error ( loc , env , No_overriding ( " " , " " ) ) ) \| _ -> ( ) end ; let concr_meths = Concr . union cl_sig . csig_concr concr_meths and warn_vals = Concr . union concr_vals warn_vals in ( cl_sig , concr_meths , warn_vals ) \| _ -> raise ( Error ( loc , env , Structure_expected parent ) )
let virtual_method val_env meths self_type lab priv sty loc = let ( _ , ty ' ) = Ctype . filter_self_method val_env lab priv meths self_type in let sty = Ast_helper . Typ . force_poly sty in let cty = transl_simple_type val_env false sty in let ty = cty . ctyp_type in begin try Ctype . unify val_env ty ty ' with Ctype . Unify trace -> raise ( Error ( loc , val_env , Field_type_mismatch ( " method " , lab , trace ) ) ) ; end ; cty
let delayed_meth_specs = ref [ ]
let declare_method val_env meths self_type lab priv sty loc = let ( _ , ty ' ) = Ctype . filter_self_method val_env lab priv meths self_type in let unif ty = try Ctype . unify val_env ty ty ' with Ctype . Unify trace -> raise ( Error ( loc , val_env , Field_type_mismatch ( " method " , lab , trace ) ) ) in let sty = Ast_helper . Typ . force_poly sty in match sty . ptyp_desc , priv with Ptyp_poly ( [ ] , sty ' ) , Public -> let returned_cty = ctyp Ttyp_any ( Ctype . newty Tnil ) val_env loc in delayed_meth_specs := Warnings . mk_lazy ( fun ( ) -> let cty = transl_simple_type_univars val_env sty ' in let ty = cty . ctyp_type in unif ty ; returned_cty . ctyp_desc <- Ttyp_poly ( [ ] , cty ) ; returned_cty . ctyp_type <- ty ; ) :: ! delayed_meth_specs ; returned_cty \| _ -> let cty = transl_simple_type val_env false sty in let ty = cty . ctyp_type in unif ty ; cty
let type_constraint val_env sty sty ' loc = let cty = transl_simple_type val_env false sty in let ty = cty . ctyp_type in let cty ' = transl_simple_type val_env false sty ' in let ty ' = cty ' . ctyp_type in begin try Ctype . unify val_env ty ty ' with Ctype . Unify trace -> raise ( Error ( loc , val_env , Unconsistent_constraint trace ) ) ; end ; ( cty , cty ' )
let make_method loc cl_num expr = let open Ast_helper in let mkid s = mkloc s loc in Exp . fun_ ~ loc : expr . pexp_loc Nolabel None ( Pat . alias ~ loc ( Pat . var ~ loc ( mkid " self " ) ) -* ( mkid ( " self " - ^ cl_num ) ) ) expr
let add_val lab ( mut , virt , ty ) val_sig = let virt = try let ( _mut ' , virt ' , _ty ' ) = Vars . find lab val_sig in if virt ' = Concrete then virt ' else virt with Not_found -> virt in Vars . add lab ( mut , virt , ty ) val_sig
let rec class_type_field env self_type meths arg ctf = Builtin_attributes . warning_scope ctf . pctf_attributes ( fun ( ) -> class_type_field_aux env self_type meths arg ctf ) ( fields , val_sig , concr_meths , inher ) ctf = let loc = ctf . pctf_loc in let mkctf desc = { ctf_desc = desc ; ctf_loc = loc ; ctf_attributes = ctf . pctf_attributes } in match ctf . pctf_desc with Pctf_inherit sparent -> let parent = class_type env sparent in let inher = match parent . cltyp_type with Cty_constr ( p , tl , _ ) -> ( p , tl ) :: inher \| _ -> inher in let ( cl_sig , concr_meths , _ ) = inheritance self_type env None concr_meths Concr . empty sparent . pcty_loc parent . cltyp_type in let val_sig = Vars . fold add_val cl_sig . csig_vars val_sig in ( mkctf ( Tctf_inherit parent ) :: fields , val_sig , concr_meths , inher ) \| Pctf_val ( { txt = lab } , mut , virt , sty ) -> let cty = transl_simple_type env false sty in let ty = cty . ctyp_type in ( mkctf ( Tctf_val ( lab , mut , virt , cty ) ) :: fields , add_val lab ( mut , virt , ty ) val_sig , concr_meths , inher ) \| Pctf_method ( { txt = lab } , priv , virt , sty ) -> let cty = declare_method env meths self_type lab priv sty ctf . pctf_loc in let concr_meths = match virt with \| Concrete -> Concr . add lab concr_meths \| Virtual -> concr_meths in ( mkctf ( Tctf_method ( lab , priv , virt , cty ) ) :: fields , val_sig , concr_meths , inher ) \| Pctf_constraint ( sty , sty ' ) -> let ( cty , cty ' ) = type_constraint env sty sty ' ctf . pctf_loc in ( mkctf ( Tctf_constraint ( cty , cty ' ) ) :: fields , val_sig , concr_meths , inher ) \| Pctf_attribute x -> Builtin_attributes . warning_attribute x ; ( mkctf ( Tctf_attribute x ) :: fields , val_sig , concr_meths , inher ) \| Pctf_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) ) let meths = ref Meths . empty in let self_cty = transl_simple_type env false sty in let self_cty = { self_cty with ctyp_type = Ctype . expand_head env self_cty . ctyp_type } in let self_type = self_cty . ctyp_type in let dummy_obj = Ctype . newvar ( ) in Ctype . unify env ( Ctype . filter_method env dummy_method Private dummy_obj ) ( Ctype . newty ( Ttuple [ ] ) ) ; begin try Ctype . unify env self_type dummy_obj with Ctype . Unify _ -> raise ( Error ( sty . ptyp_loc , env , Pattern_type_clash self_type ) ) end ; let ( rev_fields , val_sig , concr_meths , inher ) = Builtin_attributes . warning_scope [ ] ( fun ( ) -> List . fold_left ( class_type_field env self_type meths ) ( [ ] , Vars . empty , Concr . empty , [ ] ) sign ) in let cty = { csig_self = self_type ; csig_vars = val_sig ; csig_concr = concr_meths ; csig_inher = inher } in { csig_self = self_cty ; csig_fields = List . rev rev_fields ; csig_type = cty ; } Builtin_attributes . warning_scope scty . pcty_attributes ( fun ( ) -> class_type_aux env scty ) let cltyp desc typ = { cltyp_desc = desc ; cltyp_type = typ ; cltyp_loc = scty . pcty_loc ; cltyp_env = env ; cltyp_attributes = scty . pcty_attributes ; } in match scty . pcty_desc with Pcty_constr ( lid , styl ) -> let ( path , decl ) = Env . lookup_cltype ~ loc : scty . pcty_loc lid . txt env in if Path . same decl . clty_path unbound_class then raise ( Error ( scty . pcty_loc , env , Unbound_class_type_2 lid . txt ) ) ; let ( params , clty ) = Ctype . instance_class decl . clty_params decl . clty_type in if List . length params <> List . length styl then raise ( Error ( scty . pcty_loc , env , Parameter_arity_mismatch ( lid . txt , List . length params , List . length styl ) ) ) ; let ctys = List . map2 ( fun sty ty -> let cty ' = transl_simple_type env false sty in let ty ' = cty ' . ctyp_type in begin try Ctype . unify env ty ' ty with Ctype . Unify trace -> raise ( Error ( sty . ptyp_loc , env , Parameter_mismatch trace ) ) end ; cty ' ) styl params in let typ = Cty_constr ( path , params , clty ) in cltyp ( Tcty_constr ( path , lid , ctys ) ) typ \| Pcty_signature pcsig -> let clsig = class_signature env pcsig in let typ = Cty_signature clsig . csig_type in cltyp ( Tcty_signature clsig ) typ \| Pcty_arrow ( l , sty , scty ) -> let cty = transl_simple_type env false sty in let ty = cty . ctyp_type in let ty = if Btype . is_optional l then Ctype . newty ( Tconstr ( Predef . path_option , [ ty ] , ref Mnil ) ) else ty in let clty = class_type env scty in let typ = Cty_arrow ( l , ty , clty . cltyp_type ) in cltyp ( Tcty_arrow ( l , cty , clty ) ) typ \| Pcty_open ( od , e ) -> let ( od , newenv ) = ! type_open_descr env od in let clty = class_type newenv e in cltyp ( Tcty_open ( od , clty ) ) clty . cltyp_type \| Pcty_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) )
let class_type env scty = delayed_meth_specs := [ ] ; let cty = class_type env scty in List . iter Lazy . force ( List . rev ! delayed_meth_specs ) ; delayed_meth_specs := [ ] ; cty
let rec class_field self_loc cl_num self_type meths vars arg cf = Builtin_attributes . warning_scope cf . pcf_attributes ( fun ( ) -> class_field_aux self_loc cl_num self_type meths vars arg cf ) ( val_env , met_env , par_env , fields , concr_meths , warn_vals , inher , local_meths , local_vals ) cf = let loc = cf . pcf_loc in let mkcf desc = { cf_desc = desc ; cf_loc = loc ; cf_attributes = cf . pcf_attributes } in match cf . pcf_desc with Pcf_inherit ( ovf , sparent , super ) -> let parent = class_expr cl_num val_env par_env sparent in let inher = match parent . cl_type with Cty_constr ( p , tl , _ ) -> ( p , tl ) :: inher \| _ -> inher in let ( cl_sig , concr_meths , warn_vals ) = inheritance self_type val_env ( Some ovf ) concr_meths warn_vals sparent . pcl_loc parent . cl_type in let ( val_env , met_env , par_env , inh_vars ) = Vars . fold ( fun lab info ( val_env , met_env , par_env , inh_vars ) -> let mut , vr , ty = info in let ( id , val_env , met_env , par_env ) = enter_val cl_num vars true lab mut vr ty val_env met_env par_env sparent . pcl_loc in ( val_env , met_env , par_env , ( lab , id ) :: inh_vars ) ) cl_sig . csig_vars ( val_env , met_env , par_env , [ ] ) in let inh_meths = Concr . fold ( fun lab rem -> ( lab , Ident . create_local lab ) :: rem ) cl_sig . csig_concr [ ] in let ( val_env , met_env , par_env , super ) = match super with None -> ( val_env , met_env , par_env , None ) \| Some { txt = name } -> let ( _id , val_env , met_env , par_env ) = enter_met_env ~ check ( : fun s -> Warnings . Unused_ancestor s ) sparent . pcl_loc name ( Val_anc ( inh_meths , cl_num ) ) Val_unbound_ancestor self_type val_env met_env par_env in ( val_env , met_env , par_env , Some name ) in ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_inherit ( ovf , parent , super , inh_vars , inh_meths ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) \| Pcf_val ( lab , mut , Cfk_virtual styp ) -> if ! Clflags . principal then Ctype . begin_def ( ) ; let cty = Typetexp . transl_simple_type val_env false styp in let ty = cty . ctyp_type in if ! Clflags . principal then begin Ctype . end_def ( ) ; Ctype . generalize_structure ty end ; let ( id , val_env , met_env ' , par_env ) = enter_val cl_num vars false lab . txt mut Virtual ty val_env met_env par_env loc in ( val_env , met_env ' , par_env , lazy ( mkcf ( Tcf_val ( lab , mut , id , Tcfk_virtual cty , met_env == met_env ' ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) \| Pcf_val ( lab , mut , Cfk_concrete ( ovf , sexp ) ) -> if Concr . mem lab . txt local_vals then raise ( Error ( loc , val_env , Duplicate ( " instance variable " , lab . txt ) ) ) ; if Concr . mem lab . txt warn_vals then begin if ovf = Fresh then Location . prerr_warning lab . loc ( Warnings . Instance_variable_override [ lab . txt ] ) end else begin if ovf = Override then raise ( Error ( loc , val_env , No_overriding ( " instance variable " , lab . txt ) ) ) end ; if ! Clflags . principal then Ctype . begin_def ( ) ; let exp = type_exp val_env sexp in if ! Clflags . principal then begin Ctype . end_def ( ) ; Ctype . generalize_structure exp . exp_type end ; let ( id , val_env , met_env ' , par_env ) = enter_val cl_num vars false lab . txt mut Concrete exp . exp_type val_env met_env par_env loc in ( val_env , met_env ' , par_env , lazy ( mkcf ( Tcf_val ( lab , mut , id , Tcfk_concrete ( ovf , exp ) , met_env == met_env ' ) ) ) :: fields , concr_meths , Concr . add lab . txt warn_vals , inher , local_meths , Concr . add lab . txt local_vals ) \| Pcf_method ( lab , priv , Cfk_virtual sty ) -> let cty = virtual_method val_env meths self_type lab . txt priv sty loc in ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_method ( lab , priv , Tcfk_virtual cty ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) \| Pcf_method ( lab , priv , Cfk_concrete ( ovf , expr ) ) -> let expr = match expr . pexp_desc with \| Pexp_poly _ -> expr \| _ -> Ast_helper . Exp . poly ~ loc : expr . pexp_loc expr None in if Concr . mem lab . txt local_meths then raise ( Error ( loc , val_env , Duplicate ( " method " , lab . txt ) ) ) ; if Concr . mem lab . txt concr_meths then begin if ovf = Fresh then Location . prerr_warning loc ( Warnings . Method_override [ lab . txt ] ) end else begin if ovf = Override then raise ( Error ( loc , val_env , No_overriding ( " method " , lab . txt ) ) ) end ; let ( _ , ty ) = Ctype . filter_self_method val_env lab . txt priv meths self_type in begin try match expr . pexp_desc with Pexp_poly ( sbody , sty ) -> begin match sty with None -> ( ) \| Some sty -> let sty = Ast_helper . Typ . force_poly sty in let cty ' = Typetexp . transl_simple_type val_env false sty in let ty ' = cty ' . ctyp_type in Ctype . unify val_env ty ' ty end ; begin match ( Ctype . repr ty ) . desc with Tvar _ -> let ty ' = Ctype . newvar ( ) in Ctype . unify val_env ( Ctype . newty ( Tpoly ( ty ' , [ ] ) ) ) ty ; Ctype . unify val_env ( type_approx val_env sbody ) ty ' \| Tpoly ( ty1 , tl ) -> let _ , ty1 ' = Ctype . instance_poly false tl ty1 in let ty2 = type_approx val_env sbody in Ctype . unify val_env ty2 ty1 ' \| _ -> assert false end \| _ -> assert false with Ctype . Unify trace -> raise ( Error ( loc , val_env , Field_type_mismatch ( " method " , lab . txt , trace ) ) ) end ; let meth_expr = make_method self_loc cl_num expr in let vars_local = ! vars in let field = Warnings . mk_lazy ( fun ( ) -> let ( _ , ty ) = Meths . find lab . txt ! meths in let meth_type = mk_expected ( Btype . newgenty ( Tarrow ( Nolabel , self_type , ty , Cok ) ) ) in Ctype . raise_nongen_level ( ) ; vars := vars_local ; let texp = type_expect met_env meth_expr meth_type in Ctype . end_def ( ) ; mkcf ( Tcf_method ( lab , priv , Tcfk_concrete ( ovf , texp ) ) ) ) in ( val_env , met_env , par_env , field :: fields , Concr . add lab . txt concr_meths , warn_vals , inher , Concr . add lab . txt local_meths , local_vals ) \| Pcf_constraint ( sty , sty ' ) -> let ( cty , cty ' ) = type_constraint val_env sty sty ' loc in ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_constraint ( cty , cty ' ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) \| Pcf_initializer expr -> let expr = make_method self_loc cl_num expr in let vars_local = ! vars in let field = lazy begin Ctype . raise_nongen_level ( ) ; let meth_type = mk_expected ( Ctype . newty ( Tarrow ( Nolabel , self_type , Ctype . instance Predef . type_unit , Cok ) ) ) in vars := vars_local ; let texp = type_expect met_env expr meth_type in Ctype . end_def ( ) ; mkcf ( Tcf_initializer texp ) end in ( val_env , met_env , par_env , field :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) \| Pcf_attribute x -> Builtin_attributes . warning_attribute x ; ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_attribute x ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) \| Pcf_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) ) { pcstr_self = spat ; pcstr_fields = str } = let par_env = met_env in let self_loc = { spat . ppat_loc with Location . loc_ghost = true } in let self_type = Ctype . newobj ( Ctype . newvar ( ) ) in if not final then Ctype . unify val_env ( Ctype . filter_method val_env dummy_method Private self_type ) ( Ctype . newty ( Ttuple [ ] ) ) ; let private_self = if final then Ctype . newvar ( ) else self_type in let ( pat , meths , vars , val_env , meth_env , par_env ) = type_self_pattern cl_num private_self val_env met_env par_env spat in let public_self = pat . pat_type in let ty = if final then Ctype . newobj ( Ctype . newvar ( ) ) else self_type in begin try Ctype . unify val_env public_self ty with Ctype . Unify _ -> raise ( Error ( spat . ppat_loc , val_env , Pattern_type_clash public_self ) ) end ; let get_methods ty = ( fst ( Ctype . flatten_fields ( Ctype . object_fields ( Ctype . expand_head val_env ty ) ) ) ) in if final then begin List . iter ( fun ( lab , kind , ty ) -> let k = if Btype . field_kind_repr kind = Fpresent then Public else Private in try Ctype . unify val_env ty ( Ctype . filter_method val_env lab k self_type ) with _ -> assert false ) ( get_methods public_self ) end ; let ( _ , _ , _ , fields , concr_meths , _ , inher , _local_meths , _local_vals ) = Builtin_attributes . warning_scope [ ] ( fun ( ) -> List . fold_left ( class_field self_loc cl_num self_type meths vars ) ( val_env , meth_env , par_env , [ ] , Concr . empty , Concr . empty , [ ] , Concr . empty , Concr . empty ) str ) in Ctype . unify val_env self_type ( Ctype . newvar ( ) ) ; let sign = { csig_self = public_self ; csig_vars = Vars . map ( fun ( _id , mut , vr , ty ) -> ( mut , vr , ty ) ) ! vars ; csig_concr = concr_meths ; csig_inher = inher } in let methods = get_methods self_type in let priv_meths = List . filter ( fun ( _ , kind , _ ) -> Btype . field_kind_repr kind <> Fpresent ) methods in List . iter ( fun ( met , _kind , _ty ) -> if Meths . mem met ! meths then ( ) else ignore ( Ctype . filter_self_method val_env met Private meths self_type ) ) methods ; if final then begin if not ( Ctype . close_object self_type ) then raise ( Error ( loc , val_env , Closing_self_type self_type ) ) ; let mets = virtual_methods { sign with csig_self = self_type } in let vals = Vars . fold ( fun name ( _mut , vr , _ty ) l -> if vr = Virtual then name :: l else l ) sign . csig_vars [ ] in if mets <> [ ] \|\| vals <> [ ] then raise ( Error ( loc , val_env , Virtual_class ( true , final , mets , vals ) ) ) ; let self_methods = List . fold_right ( fun ( lab , kind , ty ) rem -> Ctype . newty ( Tfield ( lab , Btype . copy_kind kind , ty , rem ) ) ) methods ( Ctype . newty Tnil ) in begin try Ctype . unify val_env private_self ( Ctype . newty ( Tobject ( self_methods , ref None ) ) ) ; Ctype . unify val_env public_self self_type with Ctype . Unify trace -> raise ( Error ( loc , val_env , Final_self_clash trace ) ) end ; end ; begin let ms = ! meths in Meths . iter ( fun _ ( _ , ty ) -> Ctype . generalize_spine ty ) ms ; meths := Meths . map ( fun ( id , ty ) -> ( id , Ctype . generic_instance ty ) ) ms ; Meths . iter ( fun _ ( _ , ty ) -> Ctype . unify val_env ty ( Ctype . newvar ( ) ) ) ms end ; let fields = List . map Lazy . force ( List . rev fields ) in let meths = Meths . map ( function ( id , _ty ) -> id ) ! meths in let pub_meths ' = List . filter ( fun ( _ , kind , _ ) -> Btype . field_kind_repr kind = Fpresent ) ( get_methods public_self ) in let names = List . map ( fun ( x , _ , _ ) -> x ) in let l1 = names priv_meths and l2 = names pub_meths ' in let added = List . filter ( fun x -> List . mem x l1 ) l2 in if added <> [ ] then Location . prerr_warning loc ( Warnings . Implicit_public_methods added ) ; let sign = if final then sign else { sign with Types . csig_self = Ctype . expand_head val_env public_self } in { cstr_self = pat ; cstr_fields = fields ; cstr_type = sign ; cstr_meths = meths } , sign Builtin_attributes . warning_scope scl . pcl_attributes ( fun ( ) -> class_expr_aux cl_num val_env met_env scl ) match scl . pcl_desc with Pcl_constr ( lid , styl ) -> let ( path , decl ) = Env . lookup_class ~ loc : scl . pcl_loc lid . txt val_env in if Path . same decl . cty_path unbound_class then raise ( Error ( scl . pcl_loc , val_env , Unbound_class_2 lid . txt ) ) ; let tyl = List . map ( fun sty -> transl_simple_type val_env false sty ) styl in let ( params , clty ) = Ctype . instance_class decl . cty_params decl . cty_type in let clty ' = abbreviate_class_type path params clty in if List . length params <> List . length tyl then raise ( Error ( scl . pcl_loc , val_env , Parameter_arity_mismatch ( lid . txt , List . length params , List . length tyl ) ) ) ; List . iter2 ( fun cty ' ty -> let ty ' = cty ' . ctyp_type in try Ctype . unify val_env ty ' ty with Ctype . Unify trace -> raise ( Error ( cty ' . ctyp_loc , val_env , Parameter_mismatch trace ) ) ) tyl params ; let cl = rc { cl_desc = Tcl_ident ( path , lid , tyl ) ; cl_loc = scl . pcl_loc ; cl_type = clty ' ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } in let ( vals , meths , concrs ) = extract_constraints clty in rc { cl_desc = Tcl_constraint ( cl , None , vals , meths , concrs ) ; cl_loc = scl . pcl_loc ; cl_type = clty ' ; cl_env = val_env ; cl_attributes = [ ] ; } \| Pcl_structure cl_str -> let ( desc , ty ) = class_structure cl_num false val_env met_env scl . pcl_loc cl_str in rc { cl_desc = Tcl_structure desc ; cl_loc = scl . pcl_loc ; cl_type = Cty_signature ty ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } \| Pcl_fun ( l , Some default , spat , sbody ) -> let loc = default . pexp_loc in let open Ast_helper in let scases = [ Exp . case ( Pat . construct ~ loc ( mknoloc ( Longident . ( Ldot ( Lident " * predef " , * " Some " ) ) ) ) ( Some ( Pat . var ~ loc ( mknoloc " * sth " ) ) ) ) * ( Exp . ident ~ loc ( mknoloc ( Longident . Lident " * sth " ) ) ) ; * Exp . case ( Pat . construct ~ loc ( mknoloc ( Longident . ( Ldot ( Lident " * predef " , * " None " ) ) ) ) None ) default ; ] in let smatch = Exp . match_ ~ loc ( Exp . ident ~ loc ( mknoloc ( Longident . Lident " * opt " ) ) ) * scases in let sfun = Cl . fun_ ~ loc : scl . pcl_loc l None ( Pat . var ~ loc ( mknoloc " * opt " ) ) * ( Cl . let_ ~ loc : scl . pcl_loc Nonrecursive [ Vb . mk spat smatch ] sbody ) in class_expr cl_num val_env met_env sfun \| Pcl_fun ( l , None , spat , scl ' ) -> if ! Clflags . principal then Ctype . begin_def ( ) ; let ( pat , pv , val_env ' , met_env ) = Typecore . type_class_arg_pattern cl_num val_env met_env l spat in if ! Clflags . principal then begin Ctype . end_def ( ) ; iter_pattern ( fun { pat_type = ty } -> Ctype . generalize_structure ty ) pat end ; let pv = List . map begin fun ( id , id ' , _ty ) -> let path = Pident id ' in let vd = Env . find_value path val_env ' in ( id , { exp_desc = Texp_ident ( path , mknoloc ( Longident . Lident ( Ident . name id ) ) , vd ) ; exp_loc = Location . none ; exp_extra = [ ] ; exp_type = Ctype . instance vd . val_type ; exp_attributes = [ ] ; exp_env = val_env ' } ) end pv in let not_function = function Cty_arrow _ -> false \| _ -> true in let partial = let dummy = type_exp val_env ( Ast_helper . Exp . unreachable ( ) ) in Typecore . check_partial val_env pat . pat_type pat . pat_loc [ { c_lhs = pat ; c_guard = None ; c_rhs = dummy } ] in Ctype . raise_nongen_level ( ) ; let cl = class_expr cl_num val_env ' met_env scl ' in Ctype . end_def ( ) ; if Btype . is_optional l && not_function cl . cl_type then Location . prerr_warning pat . pat_loc Warnings . Unerasable_optional_argument ; rc { cl_desc = Tcl_fun ( l , pat , pv , cl , partial ) ; cl_loc = scl . pcl_loc ; cl_type = Cty_arrow ( l , Ctype . instance pat . pat_type , cl . cl_type ) ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } \| Pcl_apply ( scl ' , sargs ) -> assert ( sargs <> [ ] ) ; if ! Clflags . principal then Ctype . begin_def ( ) ; let cl = class_expr cl_num val_env met_env scl ' in if ! Clflags . principal then begin Ctype . end_def ( ) ; generalize_class_type false cl . cl_type ; end ; let rec nonopt_labels ls ty_fun = match ty_fun with \| Cty_arrow ( l , _ , ty_res ) -> if Btype . is_optional l then nonopt_labels ls ty_res else nonopt_labels ( l :: ls ) ty_res \| _ -> ls in let ignore_labels = ! Clflags . classic \|\| let labels = nonopt_labels [ ] cl . cl_type in List . length labels = List . length sargs && List . for_all ( fun ( l , _ ) -> l = Nolabel ) sargs && List . exists ( fun l -> l <> Nolabel ) labels && begin Location . prerr_warning cl . cl_loc ( Warnings . Labels_omitted ( List . map Printtyp . string_of_label ( List . filter ( ( ) <> Nolabel ) labels ) ) ) ; true end in let rec type_args args omitted ty_fun ty_fun0 sargs more_sargs = match ty_fun , ty_fun0 with \| Cty_arrow ( l , ty , ty_fun ) , Cty_arrow ( _ , ty0 , ty_fun0 ) when sargs <> [ ] \|\| more_sargs <> [ ] -> let name = Btype . label_name l and optional = Btype . is_optional l in let sargs , more_sargs , arg = if ignore_labels && not ( Btype . is_optional l ) then begin match sargs , more_sargs with ( l ' , sarg0 ) :: _ , _ -> raise ( Error ( sarg0 . pexp_loc , val_env , Apply_wrong_label l ' ) ) \| _ , ( l ' , sarg0 ) :: more_sargs -> if l <> l ' && l ' <> Nolabel then raise ( Error ( sarg0 . pexp_loc , val_env , Apply_wrong_label l ' ) ) else ( [ ] , more_sargs , Some ( type_argument val_env sarg0 ty ty0 ) ) \| _ -> assert false end else try let ( l ' , sarg0 , sargs , more_sargs ) = try let ( l ' , sarg0 , sargs1 , sargs2 ) = Btype . extract_label name sargs in ( l ' , sarg0 , sargs1 @ sargs2 , more_sargs ) with Not_found -> let ( l ' , sarg0 , sargs1 , sargs2 ) = Btype . extract_label name more_sargs in ( l ' , sarg0 , sargs @ sargs1 , sargs2 ) in if not optional && Btype . is_optional l ' then Location . prerr_warning sarg0 . pexp_loc ( Warnings . Nonoptional_label ( Printtyp . string_of_label l ) ) ; sargs , more_sargs , if not optional \|\| Btype . is_optional l ' then Some ( type_argument val_env sarg0 ty ty0 ) else let ty ' = extract_option_type val_env ty and ty0 ' = extract_option_type val_env ty0 in let arg = type_argument val_env sarg0 ty ' ty0 ' in Some ( option_some val_env arg ) with Not_found -> sargs , more_sargs , if Btype . is_optional l && ( List . mem_assoc Nolabel sargs \|\| List . mem_assoc Nolabel more_sargs ) then Some ( option_none val_env ty0 Location . none ) else None in let omitted = if arg = None then ( l , ty0 ) :: omitted else omitted in type_args ( ( l , arg ) :: args ) omitted ty_fun ty_fun0 sargs more_sargs \| _ -> match sargs @ more_sargs with ( l , sarg0 ) :: _ -> if omitted <> [ ] then raise ( Error ( sarg0 . pexp_loc , val_env , Apply_wrong_label l ) ) else raise ( Error ( cl . cl_loc , val_env , Cannot_apply cl . cl_type ) ) \| [ ] -> ( List . rev args , List . fold_left ( fun ty_fun ( l , ty ) -> Cty_arrow ( l , ty , ty_fun ) ) ty_fun0 omitted ) in let ( args , cty ) = let ( _ , ty_fun0 ) = Ctype . instance_class [ ] cl . cl_type in if ignore_labels then type_args [ ] [ ] cl . cl_type ty_fun0 [ ] sargs else type_args [ ] [ ] cl . cl_type ty_fun0 sargs [ ] in rc { cl_desc = Tcl_apply ( cl , args ) ; cl_loc = scl . pcl_loc ; cl_type = cty ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } \| Pcl_let ( rec_flag , sdefs , scl ' ) -> let ( defs , val_env ) = Typecore . type_let In_class_def val_env rec_flag sdefs None in let ( vals , met_env ) = List . fold_right ( fun ( id , _id_loc , _typ ) ( vals , met_env ) -> let path = Pident id in let vd = Env . find_value path val_env in Ctype . begin_def ( ) ; let expr = { exp_desc = Texp_ident ( path , mknoloc ( Longident . Lident ( Ident . name id ) ) , vd ) ; exp_loc = Location . none ; exp_extra = [ ] ; exp_type = Ctype . instance vd . val_type ; exp_attributes = [ ] ; exp_env = val_env ; } in Ctype . end_def ( ) ; Ctype . generalize expr . exp_type ; let desc = { val_type = expr . exp_type ; val_kind = Val_ivar ( Immutable , cl_num ) ; val_attributes = [ ] ; Types . val_loc = vd . Types . val_loc ; } in let id ' = Ident . create_local ( Ident . name id ) in ( ( id ' , expr ) :: vals , Env . add_value id ' desc met_env ) ) ( let_bound_idents_full defs ) ( [ ] , met_env ) in let cl = class_expr cl_num val_env met_env scl ' in let ( ) = if rec_flag = Recursive then check_recursive_bindings val_env defs in rc { cl_desc = Tcl_let ( rec_flag , defs , vals , cl ) ; cl_loc = scl . pcl_loc ; cl_type = cl . cl_type ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } \| Pcl_constraint ( scl ' , scty ) -> Ctype . begin_class_def ( ) ; let context = Typetexp . narrow ( ) in let cl = class_expr cl_num val_env met_env scl ' in Typetexp . widen context ; let context = Typetexp . narrow ( ) in let clty = class_type val_env scty in Typetexp . widen context ; Ctype . end_def ( ) ; limited_generalize ( Ctype . row_variable ( Ctype . self_type cl . cl_type ) ) cl . cl_type ; limited_generalize ( Ctype . row_variable ( Ctype . self_type clty . cltyp_type ) ) clty . cltyp_type ; begin match Includeclass . class_types val_env cl . cl_type clty . cltyp_type with [ ] -> ( ) \| error -> raise ( Error ( cl . cl_loc , val_env , Class_match_failure error ) ) end ; let ( vals , meths , concrs ) = extract_constraints clty . cltyp_type in rc { cl_desc = Tcl_constraint ( cl , Some clty , vals , meths , concrs ) ; cl_loc = scl . pcl_loc ; cl_type = snd ( Ctype . instance_class [ ] clty . cltyp_type ) ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } \| Pcl_open ( pod , e ) -> let used_slot = ref false in let ( od , new_val_env ) = ! type_open_descr ~ used_slot val_env pod in let ( _ , new_met_env ) = ! type_open_descr ~ used_slot met_env pod in let cl = class_expr cl_num new_val_env new_met_env e in rc { cl_desc = Tcl_open ( od , cl ) ; cl_loc = scl . pcl_loc ; cl_type = cl . cl_type ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } \| Pcl_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) )
let var_option = Predef . type_option ( Btype . newgenvar ( ) )
let rec approx_declaration cl = match cl . pcl_desc with Pcl_fun ( l , _ , _ , cl ) -> let arg = if Btype . is_optional l then Ctype . instance var_option else Ctype . newvar ( ) in Ctype . newty ( Tarrow ( l , arg , approx_declaration cl , Cok ) ) \| Pcl_let ( _ , _ , cl ) -> approx_declaration cl \| Pcl_constraint ( cl , _ ) -> approx_declaration cl \| _ -> Ctype . newvar ( )
let rec approx_description ct = match ct . pcty_desc with Pcty_arrow ( l , _ , ct ) -> let arg = if Btype . is_optional l then Ctype . instance var_option else Ctype . newvar ( ) in Ctype . newty ( Tarrow ( l , arg , approx_description ct , Cok ) ) \| _ -> Ctype . newvar ( )
let temp_abbrev loc env id arity = let params = ref [ ] in for _i = 1 to arity do params := Ctype . newvar ( ) :: ! params done ; let ty = Ctype . newobj ( Ctype . newvar ( ) ) in let env = Env . add_type ~ check : true id { type_params = ! params ; type_arity = arity ; type_kind = Type_abstract ; type_private = Public ; type_manifest = Some ty ; type_variance = Misc . replicate_list Variance . full arity ; type_is_newtype = false ; type_expansion_scope = Btype . lowest_level ; type_loc = loc ; type_attributes = [ ] ; type_immediate = Unknown ; type_unboxed = unboxed_false_default_false ; } env in ( ! params , ty , env )
let initial_env define_class approx ( res , env ) ( cl , id , ty_id , obj_id , cl_id ) = let arity = List . length cl . pci_params in let ( obj_params , obj_ty , env ) = temp_abbrev cl . pci_loc env obj_id arity in let ( cl_params , cl_ty , env ) = temp_abbrev cl . pci_loc env cl_id arity in let constr_type = approx cl . pci_expr in if ! Clflags . principal then Ctype . generalize_spine constr_type ; let dummy_cty = Cty_signature { csig_self = Ctype . newvar ( ) ; csig_vars = Vars . empty ; csig_concr = Concr . empty ; csig_inher = [ ] } in let dummy_class = { Types . cty_params = [ ] ; cty_variance = [ ] ; cty_type = dummy_cty ; cty_path = unbound_class ; cty_new = begin match cl . pci_virt with \| Virtual -> None \| Concrete -> Some constr_type end ; cty_loc = Location . none ; cty_attributes = [ ] ; } in let env = Env . add_cltype ty_id { clty_params = [ ] ; clty_variance = [ ] ; clty_type = dummy_cty ; clty_path = unbound_class ; clty_loc = Location . none ; clty_attributes = [ ] ; } ( if define_class then Env . add_class id dummy_class env else env ) in ( ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) :: res , env )
let class_infos define_class kind ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) ( res , env ) = reset_type_variables ( ) ; Ctype . begin_class_def ( ) ; let ci_params = let make_param ( sty , v ) = try ( transl_type_param env sty , v ) with Already_bound -> raise ( Error ( sty . ptyp_loc , env , Repeated_parameter ) ) in List . map make_param cl . pci_params in let params = List . map ( fun ( cty , _ ) -> cty . ctyp_type ) ci_params in let coercion_locs = ref [ ] in let ( expr , typ ) = try Typecore . self_coercion := ( Path . Pident obj_id , coercion_locs ) :: ! Typecore . self_coercion ; let res = kind env cl . pci_expr in Typecore . self_coercion := List . tl ! Typecore . self_coercion ; res with exn -> Typecore . self_coercion := [ ] ; raise exn in Ctype . end_def ( ) ; let sty = Ctype . self_type typ in let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sty ) in List . iter ( fun ( met , _ , ty ) -> if met = dummy_method then Ctype . generalize ty ) fields ; let rv = Ctype . row_variable sty in List . iter ( Ctype . limited_generalize rv ) params ; limited_generalize rv typ ; let ( obj_params ' , obj_type ) = Ctype . instance_class params typ in let constr = Ctype . newconstr ( Path . Pident obj_id ) obj_params in begin let ty = Ctype . self_type obj_type in Ctype . hide_private_methods ty ; if not ( Ctype . close_object ty ) then raise ( Error ( cl . pci_loc , env , Closing_self_type ty ) ) ; begin try List . iter2 ( Ctype . unify env ) obj_params obj_params ' with Ctype . Unify _ -> raise ( Error ( cl . pci_loc , env , Bad_parameters ( obj_id , constr , Ctype . newconstr ( Path . Pident obj_id ) obj_params ' ) ) ) end ; begin try Ctype . unify env ty constr with Ctype . Unify _ -> raise ( Error ( cl . pci_loc , env , Abbrev_type_clash ( constr , ty , Ctype . expand_head env constr ) ) ) end end ; begin let ( cl_params ' , cl_type ) = Ctype . instance_class params typ in let ty = Ctype . self_type cl_type in Ctype . hide_private_methods ty ; Ctype . set_object_name obj_id ( Ctype . row_variable ty ) cl_params ty ; begin try List . iter2 ( Ctype . unify env ) cl_params cl_params ' with Ctype . Unify _ -> raise ( Error ( cl . pci_loc , env , Bad_parameters ( cl_id , Ctype . newconstr ( Path . Pident cl_id ) cl_params , Ctype . newconstr ( Path . Pident cl_id ) cl_params ' ) ) ) end ; begin try Ctype . unify env ty cl_ty with Ctype . Unify _ -> let constr = Ctype . newconstr ( Path . Pident cl_id ) params in raise ( Error ( cl . pci_loc , env , Abbrev_type_clash ( constr , ty , cl_ty ) ) ) end end ; begin try Ctype . unify env ( constructor_type constr obj_type ) ( Ctype . instance constr_type ) with Ctype . Unify trace -> raise ( Error ( cl . pci_loc , env , Constructor_type_mismatch ( cl . pci_name . txt , trace ) ) ) end ; let cty_variance = List . map ( fun _ -> Variance . full ) params in let cltydef = { clty_params = params ; clty_type = class_body typ ; clty_variance = cty_variance ; clty_path = Path . Pident obj_id ; clty_loc = cl . pci_loc ; clty_attributes = cl . pci_attributes ; } and clty = { cty_params = params ; cty_type = typ ; cty_variance = cty_variance ; cty_path = Path . Pident obj_id ; cty_new = begin match cl . pci_virt with \| Virtual -> None \| Concrete -> Some constr_type end ; cty_loc = cl . pci_loc ; cty_attributes = cl . pci_attributes ; } in dummy_class . cty_type <- typ ; let env = Env . add_cltype ty_id cltydef ( if define_class then Env . add_class id clty env else env ) in if cl . pci_virt = Concrete then begin let sign = Ctype . signature_of_class_type typ in let mets = virtual_methods sign in let vals = Vars . fold ( fun name ( _mut , vr , _ty ) l -> if vr = Virtual then name :: l else l ) sign . csig_vars [ ] in if mets <> [ ] \|\| vals <> [ ] then raise ( Error ( cl . pci_loc , env , Virtual_class ( define_class , false , mets , vals ) ) ) ; end ; let arity = Ctype . class_type_arity typ in let pub_meths = let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields ( Ctype . expand_head env obj_ty ) ) in List . map ( function ( lab , _ , _ ) -> lab ) fields in let ( params ' , typ ' ) = Ctype . instance_class params typ in let cltydef = { clty_params = params ' ; clty_type = class_body typ ' ; clty_variance = cty_variance ; clty_path = Path . Pident obj_id ; clty_loc = cl . pci_loc ; clty_attributes = cl . pci_attributes ; } and clty = { cty_params = params ' ; cty_type = typ ' ; cty_variance = cty_variance ; cty_path = Path . Pident obj_id ; cty_new = begin match cl . pci_virt with \| Virtual -> None \| Concrete -> Some ( Ctype . instance constr_type ) end ; cty_loc = cl . pci_loc ; cty_attributes = cl . pci_attributes ; } in let obj_abbr = { type_params = obj_params ; type_arity = List . length obj_params ; type_kind = Type_abstract ; type_private = Public ; type_manifest = Some obj_ty ; type_variance = List . map ( fun _ -> Variance . full ) obj_params ; type_is_newtype = false ; type_expansion_scope = Btype . lowest_level ; type_loc = cl . pci_loc ; type_attributes = [ ] ; type_immediate = Unknown ; type_unboxed = unboxed_false_default_false ; } in let ( cl_params , cl_ty ) = Ctype . instance_parameterized_type params ( Ctype . self_type typ ) in Ctype . hide_private_methods cl_ty ; Ctype . set_object_name obj_id ( Ctype . row_variable cl_ty ) cl_params cl_ty ; let cl_abbr = { type_params = cl_params ; type_arity = List . length cl_params ; type_kind = Type_abstract ; type_private = Public ; type_manifest = Some cl_ty ; type_variance = List . map ( fun _ -> Variance . full ) cl_params ; type_is_newtype = false ; type_expansion_scope = Btype . lowest_level ; type_loc = cl . pci_loc ; type_attributes = [ ] ; type_immediate = Unknown ; type_unboxed = unboxed_false_default_false ; } in ( ( cl , id , clty , ty_id , cltydef , obj_id , obj_abbr , cl_id , cl_abbr , ci_params , arity , pub_meths , List . rev ! coercion_locs , expr ) :: res , env )
let final_decl env define_class ( cl , id , clty , ty_id , cltydef , obj_id , obj_abbr , cl_id , cl_abbr , ci_params , arity , pub_meths , coe , expr ) = begin try Ctype . collapse_conj_params env clty . cty_params with Ctype . Unify trace -> raise ( Error ( cl . pci_loc , env , Non_collapsable_conjunction ( id , clty , trace ) ) ) end ; begin let self_type = Ctype . self_type clty . cty_type in let methods , _ = Ctype . flatten_fields ( Ctype . object_fields ( Ctype . expand_head env self_type ) ) in List . iter ( fun ( lab , kind , _ ) -> if lab = dummy_method then match Btype . field_kind_repr kind with Fvar r -> Btype . set_kind r Fabsent \| _ -> ( ) ) methods end ; List . iter Ctype . generalize clty . cty_params ; generalize_class_type true clty . cty_type ; Option . iter Ctype . generalize clty . cty_new ; List . iter Ctype . generalize obj_abbr . type_params ; Option . iter Ctype . generalize obj_abbr . type_manifest ; List . iter Ctype . generalize cl_abbr . type_params ; Option . iter Ctype . generalize cl_abbr . type_manifest ; if not ( closed_class clty ) then raise ( Error ( cl . pci_loc , env , Non_generalizable_class ( id , clty ) ) ) ; begin match Ctype . closed_class clty . cty_params ( Ctype . signature_of_class_type clty . cty_type ) with None -> ( ) \| Some reason -> let printer = if define_class then function ppf -> Printtyp . class_declaration id ppf clty else function ppf -> Printtyp . cltype_declaration id ppf cltydef in raise ( Error ( cl . pci_loc , env , Unbound_type_var ( printer , reason ) ) ) end ; { id ; clty ; ty_id ; cltydef ; obj_id ; obj_abbr ; cl_id ; cl_abbr ; arity ; pub_meths ; coe ; expr ; id_loc = cl . pci_name ; req = { ci_loc = cl . pci_loc ; ci_virt = cl . pci_virt ; ci_params = ci_params ; ci_id_name = cl . pci_name ; ci_id_class = id ; ci_id_class_type = ty_id ; ci_id_object = obj_id ; ci_id_typehash = cl_id ; ci_expr = expr ; ci_decl = clty ; ci_type_decl = cltydef ; ci_attributes = cl . pci_attributes ; } }
let class_infos define_class kind ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) ( res , env ) = Builtin_attributes . warning_scope cl . pci_attributes ( fun ( ) -> class_infos define_class kind ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) ( res , env ) )
let extract_type_decls { clty ; cltydef ; obj_id ; obj_abbr ; cl_abbr ; req } decls = ( obj_id , obj_abbr , cl_abbr , clty , cltydef , req ) :: decls
let merge_type_decls decl ( obj_abbr , cl_abbr , clty , cltydef ) = { decl with obj_abbr ; cl_abbr ; clty ; cltydef }
let final_env define_class env { id ; clty ; ty_id ; cltydef ; obj_id ; obj_abbr ; cl_id ; cl_abbr } = Env . add_type ~ check : true obj_id ( Subst . type_declaration Subst . identity obj_abbr ) ( Env . add_type ~ check : true cl_id ( Subst . type_declaration Subst . identity cl_abbr ) ( Env . add_cltype ty_id ( Subst . cltype_declaration Subst . identity cltydef ) ( if define_class then Env . add_class id ( Subst . class_declaration Subst . identity clty ) env else env ) ) )
let check_coercions env { id ; id_loc ; clty ; ty_id ; cltydef ; obj_id ; obj_abbr ; cl_id ; cl_abbr ; arity ; pub_meths ; coe ; req } = begin match coe with [ ] -> ( ) \| loc :: _ -> let cl_ty , obj_ty = match cl_abbr . type_manifest , obj_abbr . type_manifest with Some cl_ab , Some obj_ab -> let cl_params , cl_ty = Ctype . instance_parameterized_type cl_abbr . type_params cl_ab and obj_params , obj_ty = Ctype . instance_parameterized_type obj_abbr . type_params obj_ab in List . iter2 ( Ctype . unify env ) cl_params obj_params ; cl_ty , obj_ty \| _ -> assert false in begin try Ctype . subtype env cl_ty obj_ty ( ) with Ctype . Subtype ( tr1 , tr2 ) -> raise ( Typecore . Error ( loc , env , Typecore . Not_subtype ( tr1 , tr2 ) ) ) end ; if not ( Ctype . opened_object cl_ty ) then raise ( Error ( loc , env , Cannot_coerce_self obj_ty ) ) end ; { cls_id = id ; cls_id_loc = id_loc ; cls_decl = clty ; cls_ty_id = ty_id ; cls_ty_decl = cltydef ; cls_obj_id = obj_id ; cls_obj_abbr = obj_abbr ; cls_typesharp_id = cl_id ; cls_abbr = cl_abbr ; cls_arity = arity ; cls_pub_methods = pub_meths ; cls_info = req }
let type_classes define_class approx kind env cls = let scope = Ctype . create_scope ( ) in let cls = List . map ( function cl -> ( cl , Ident . create_scoped ~ scope cl . pci_name . txt , Ident . create_scoped ~ scope cl . pci_name . txt , Ident . create_scoped ~ scope cl . pci_name . txt , Ident . create_scoped ~ scope ( " " # ^ cl . pci_name . txt ) ) ) cls in Ctype . begin_class_def ( ) ; let ( res , env ) = List . fold_left ( initial_env define_class approx ) ( [ ] , env ) cls in let ( res , env ) = List . fold_right ( class_infos define_class kind ) res ( [ ] , env ) in Ctype . end_def ( ) ; let res = List . rev_map ( final_decl env define_class ) res in let decls = List . fold_right extract_type_decls res [ ] in let decls = try Typedecl_variance . update_class_decls env decls with Typedecl_variance . Error ( loc , err ) -> raise ( Typedecl . Error ( loc , Typedecl . Variance err ) ) in let res = List . map2 merge_type_decls res decls in let env = List . fold_left ( final_env define_class ) env res in let res = List . map ( check_coercions env ) res in ( res , env )
let class_num = ref 0
let class_declaration env sexpr = incr class_num ; let expr = class_expr ( Int . to_string ! class_num ) env env sexpr in ( expr , expr . cl_type )
let class_description env sexpr = let expr = class_type env sexpr in ( expr , expr . cltyp_type )
let class_declarations env cls = let info , env = type_classes true approx_declaration class_declaration env cls in let ids , exprs = List . split ( List . map ( fun ci -> ci . cls_id , ci . cls_info . ci_expr ) info ) in check_recursive_class_bindings env ids exprs ; info , env
let class_descriptions env cls = type_classes true approx_description class_description env cls
let class_type_declarations env cls = let ( decls , env ) = type_classes false approx_description class_description env cls in ( List . map ( fun decl -> { clsty_ty_id = decl . cls_ty_id ; clsty_id_loc = decl . cls_id_loc ; clsty_ty_decl = decl . cls_ty_decl ; clsty_obj_id = decl . cls_obj_id ; clsty_obj_abbr = decl . cls_obj_abbr ; clsty_typesharp_id = decl . cls_typesharp_id ; clsty_abbr = decl . cls_abbr ; clsty_info = decl . cls_info } ) decls , env )
let rec unify_parents env ty cl = match cl . cl_desc with Tcl_ident ( p , _ , _ ) -> begin try let decl = Env . find_class p env in let _ , body = Ctype . find_cltype_for_path env decl . cty_path in Ctype . unify env ty ( Ctype . instance body ) with Not_found -> ( ) \| _exn -> assert false end \| Tcl_structure st -> unify_parents_struct env ty st \| Tcl_open ( _ , cl ) \| Tcl_fun ( _ , _ , _ , cl , _ ) \| Tcl_apply ( cl , _ ) \| Tcl_let ( _ , _ , _ , cl ) \| Tcl_constraint ( cl , _ , _ , _ , _ ) -> unify_parents env ty cl List . iter ( function \| { cf_desc = Tcf_inherit ( _ , cl , _ , _ , _ ) } -> unify_parents env ty cl \| _ -> ( ) ) st . cstr_fields
let type_object env loc s = incr class_num ; let ( desc , sign ) = class_structure ( Int . to_string ! class_num ) true env env loc s in let sty = Ctype . expand_head env sign . csig_self in Ctype . hide_private_methods sty ; let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sty ) in let meths = List . map ( fun ( s , _ , _ ) -> s ) fields in unify_parents_struct env sign . csig_self desc ; ( desc , sign , meths )
let ( ) = Typecore . type_object := type_object
let approx_class sdecl = let open Ast_helper in let self ' = Typ . any ( ) in let clty ' = Cty . signature ~ loc : sdecl . pci_expr . pcty_loc ( Csig . mk self ' [ ] ) in { sdecl with pci_expr = clty ' }
let approx_class_declarations env sdecls = fst ( class_type_declarations env ( List . map approx_class sdecls ) )
let report_error env ppf = function \| Repeated_parameter -> fprintf ppf " A type parameter occurs several times " \| Unconsistent_constraint trace -> fprintf ppf " The class constraints are not consistent . . " ; @ Printtyp . report_unification_error ppf env trace ( fun ppf -> fprintf ppf " Type " ) ( fun ppf -> fprintf ppf " is not compatible with type " ) \| Field_type_mismatch ( k , m , trace ) -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " The % s % s @ has type " k m ) ( function ppf -> fprintf ppf " but is expected to have type " ) \| Structure_expected clty -> fprintf ppf " [ @ This class expression is not a class structure ; it has type @ % a ] " @ Printtyp . class_type clty \| Cannot_apply _ -> fprintf ppf " This class expression is not a class function , it cannot be applied " \| Apply_wrong_label l -> let mark_label = function \| Nolabel -> " out label " \| l -> sprintf " label % s " ( Btype . prefixed_label_name l ) in fprintf ppf " This argument cannot be applied with % s " ( mark_label l ) \| Pattern_type_clash ty -> fprintf ppf " [ @% s @ % a ] " @ " This pattern cannot match self : it only matches values of type " Printtyp . type_expr ty \| Unbound_class_2 cl -> fprintf ppf " [ @ The class @ % a @ is not yet completely defined ] " @ Printtyp . longident cl \| Unbound_class_type_2 cl -> fprintf ppf " [ @ The class type @ % a @ is not yet completely defined ] " @ Printtyp . longident cl \| Abbrev_type_clash ( abbrev , actual , expected ) -> Printtyp . reset_and_mark_loops_list [ abbrev ; actual ; expected ] ; fprintf ppf " [ @ The abbreviation @ % a @ expands to type @ % a @ \ but is used with type @ % a ] " @ ! Oprint . out_type ( Printtyp . tree_of_typexp false abbrev ) ! Oprint . out_type ( Printtyp . tree_of_typexp false actual ) ! Oprint . out_type ( Printtyp . tree_of_typexp false expected ) \| Constructor_type_mismatch ( c , trace ) -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " The expression " \ new % s " \ has type " c ) ( function ppf -> fprintf ppf " but is used with type " ) \| Virtual_class ( cl , imm , mets , vals ) -> let print_mets ppf mets = List . iter ( function met -> fprintf ppf " @ % s " met ) mets in let missings = match mets , vals with [ ] , _ -> " variables " \| _ , [ ] -> " methods " \| _ -> " methods and variables " in let print_msg ppf = if imm then fprintf ppf " This object has virtual % s " missings else if cl then fprintf ppf " This class should be virtual " else fprintf ppf " This class type should be virtual " in fprintf ppf " [ @% t . @ [ @< 2 > The following % s are undefined :% a ] ] " @@ print_msg missings print_mets ( mets @ vals ) \| Parameter_arity_mismatch ( lid , expected , provided ) -> fprintf ppf " [ @ The class constructor % a @ expects % i type argument ( s ) , @ \ but is here applied to % i type argument ( s ) ] " @ Printtyp . longident lid expected provided \| Parameter_mismatch trace -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " The type parameter " ) ( function ppf -> fprintf ppf " does not meet its constraint : it should be " ) \| Bad_parameters ( id , params , cstrs ) -> Printtyp . reset_and_mark_loops_list [ params ; cstrs ] ; fprintf ppf " [ @ The abbreviation % a @ is used with parameters @ % a @ \ which are incompatible with constraints @ % a ] " @ Printtyp . ident id ! Oprint . out_type ( Printtyp . tree_of_typexp false params ) ! Oprint . out_type ( Printtyp . tree_of_typexp false cstrs ) \| Class_match_failure error -> Includeclass . report_error ppf error \| Unbound_val lab -> fprintf ppf " Unbound instance variable % s " lab \| Unbound_type_var ( printer , reason ) -> let print_common ppf kind ty0 real lab ty = let ty1 = if real then ty0 else Btype . newgenty ( Tobject ( ty0 , ref None ) ) in List . iter Printtyp . mark_loops [ ty ; ty1 ] ; fprintf ppf " The % s % s @ has type ; @< 1 2 >% a @ where @ % a @ is unbound " kind lab ! Oprint . out_type ( Printtyp . tree_of_typexp false ty ) ! Oprint . out_type ( Printtyp . tree_of_typexp false ty0 ) in let print_reason ppf = function \| Ctype . CC_Method ( ty0 , real , lab , ty ) -> print_common ppf " method " ty0 real lab ty \| Ctype . CC_Value ( ty0 , real , lab , ty ) -> print_common ppf " instance variable " ty0 real lab ty in Printtyp . reset ( ) ; fprintf ppf " [ @< v [ >@ Some type variables are unbound in this type ; :@< 1 2 >% t ] @@ \ [ @% a ] ] " @@ printer print_reason reason \| Non_generalizable_class ( id , clty ) -> fprintf ppf " [ @ The type of this class , @ % a , @ \ contains type variables that cannot be generalized ] " @ ( Printtyp . class_declaration id ) clty \| Cannot_coerce_self ty -> fprintf ppf " [ @ The type of self cannot be coerced to @ \ the type of the current class :@ % a . . @\ Some occurrences are contravariant ] " @ Printtyp . type_scheme ty \| Non_collapsable_conjunction ( id , clty , trace ) -> fprintf ppf " [ @ The type of this class , @ % a , @ \ contains non - collapsible conjunctive types in constraints . @ % t ] " @ ( Printtyp . class_declaration id ) clty ( fun ppf -> Printtyp . report_unification_error ppf env trace ( fun ppf -> fprintf ppf " Type " ) ( fun ppf -> fprintf ppf " is not compatible with type " ) ) \| Final_self_clash trace -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " This object is expected to have type " ) ( function ppf -> fprintf ppf " but actually has type " ) \| Mutability_mismatch ( _lab , mut ) -> let mut1 , mut2 = if mut = Immutable then " mutable " , " immutable " else " immutable " , " mutable " in fprintf ppf " [ @ The instance variable is % s ; @ it cannot be redefined as % s ] " @ mut1 mut2 \| No_overriding ( _ , " " ) -> fprintf ppf " [ @ This inheritance does not override any method @ % s ] " @ " instance variable " \| No_overriding ( kind , name ) -> fprintf ppf " [ @ The % s ` % s ' @ has no previous definition ] " @ kind name \| Duplicate ( kind , name ) -> fprintf ppf " [ @ The % s ` % s ' @ has multiple definitions in this object ] " @ kind name \| Closing_self_type self -> fprintf ppf " [ @ Cannot close type of object literal :@ % a , @\ it has been unified with the self type of a class that is not yet @ \ completely defined . ] " @ Printtyp . type_scheme self
let report_error env ppf err = Printtyp . wrap_printing_env ~ error : true env ( fun ( ) -> report_error env ppf err )
let ( ) = Location . register_error_of_exn ( function \| Error ( loc , env , err ) -> Some ( Location . error_of_printer ~ loc ( report_error env ) err ) \| Error_forward err -> Some err \| _ -> None )
type unary_interval = { upper_bound : Type . t ; lower_bound : Type . t ; }
type callable_parameter_interval = \| Top \| Singleton of Type . Callable . parameters \| Bottom
type tuple_interval = \| TopTuple \| BottomTuple \| SingletonTuple of Type . t Type . OrderedTypes . record
type t = { unaries : unary_interval UnaryVariable . Map . t ; callable_parameters : callable_parameter_interval ParameterVariable . Map . t ; tuple_variadics : tuple_interval TupleVariable . Map . t ; have_fallbacks : Type . Variable . Set . t ; }
let show_map map ~ show_key ~ show_data ~ short_name = if Map . is_empty map then " " else let show ~ key ~ data sofar = Printf . sprintf " % s => % s " ( show_key key ) ( show_data data ) :: sofar in Map . fold map ~ init [ ] : ~ f : show \|> String . concat ~ sep " :\ n " \|> Format . sprintf " % s : [ % s ] " short_name
let pp format { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } = let unaries = show_map unaries ~ show_key : UnaryVariable . show ~ show_data : show_unary_interval ~ short_name " : un " in let callable_parameters = show_map callable_parameters ~ show_key : ParameterVariable . show ~ show_data : show_callable_parameter_interval ~ short_name " : cb " in let tuple_variadics = show_map tuple_variadics ~ show_key : TupleVariable . show ~ show_data : show_tuple_interval ~ short_name " : variadic_tuple " in let have_fallbacks = Set . to_list have_fallbacks \|> List . to_string ~ f : Type . Variable . show \|> Format . sprintf " \ nHave Fallbacks to Any : % s " in Format . fprintf format " { % s % s % s % s } " unaries callable_parameters tuple_variadics have_fallbacks
let show annotation = Format . asprintf " % a " pp annotation
let empty = { unaries = UnaryVariable . Map . empty ; callable_parameters = ParameterVariable . Map . empty ; tuple_variadics = TupleVariable . Map . empty ; have_fallbacks = Type . Variable . Set . empty ; }
let exists_in_bounds { unaries ; callable_parameters ; tuple_variadics ; _ } ~ variables = let contains_variable annotation = let contains_unary = Type . Variable . GlobalTransforms . Unary . collect_all annotation \|> List . exists ~ f ( : fun variable -> List . mem variables ( Type . Variable . Unary variable ) ~ equal : Type . Variable . equal ) in let contains_parameter_variadic = let parameter_variadic_contained_in_list variable = List . mem variables ( Type . Variable . ParameterVariadic variable ) ~ equal : Type . Variable . equal in Type . Variable . GlobalTransforms . ParameterVariadic . collect_all annotation \|> List . exists ~ f : parameter_variadic_contained_in_list in let contains_tuple_variadic = Type . Variable . GlobalTransforms . TupleVariadic . collect_all annotation \|> List . exists ~ f ( : fun variable -> List . mem variables ( Type . Variable . TupleVariadic variable ) ~ equal : Type . Variable . equal ) in contains_unary \|\| contains_parameter_variadic \|\| contains_tuple_variadic in let exists_in_interval_bounds { upper_bound ; lower_bound } = contains_variable upper_bound \|\| contains_variable lower_bound in let exists_in_callable_parameter_interval_bounds = function \| Singleton parameters -> Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) \|> contains_variable \| _ -> false in let exists_in_tuple_interval_bound = function \| SingletonTuple ordered_type -> Type . Tuple ordered_type \|> contains_variable \| _ -> false in UnaryVariable . Map . exists unaries ~ f : exists_in_interval_bounds \|\| ParameterVariable . Map . exists callable_parameters ~ f : exists_in_callable_parameter_interval_bounds \|\| TupleVariable . Map . exists tuple_variadics ~ f : exists_in_tuple_interval_bound
module Solution = struct type t = { unaries : Type . t UnaryVariable . Map . t ; callable_parameters : Type . Callable . parameters ParameterVariable . Map . t ; tuple_variadics : Type . t Type . OrderedTypes . record TupleVariable . Map . t ; } let equal left right = UnaryVariable . Map . equal Type . equal left . unaries right . unaries && ParameterVariable . Map . equal Type . Callable . equal_parameters left . callable_parameters right . callable_parameters && TupleVariable . Map . equal ( Type . OrderedTypes . equal_record Type . equal ) left . tuple_variadics right . tuple_variadics let show { unaries ; callable_parameters ; tuple_variadics } = let unaries = show_map unaries ~ show_key : UnaryVariable . show ~ show_data : Type . show ~ short_name " : un " in let callable_parameters = show_map callable_parameters ~ show_key : ParameterVariable . show ~ show_data : Type . Callable . show_parameters ~ short_name " : cb " in let tuple_variadics = show_map tuple_variadics ~ show_key : TupleVariable . show ~ show_data ( : Type . OrderedTypes . show_record Type . pp ) ~ short_name " : variadic_tuple " in Format . sprintf " { % s % s % s } " unaries callable_parameters tuple_variadics let pp format solution = Format . fprintf format " % s " ( show solution ) let empty = { unaries = UnaryVariable . Map . empty ; callable_parameters = ParameterVariable . Map . empty ; tuple_variadics = TupleVariable . Map . empty ; } let instantiate { unaries ; callable_parameters ; tuple_variadics } annotation = let annotation = if UnaryVariable . Map . is_empty unaries then annotation else Type . Variable . GlobalTransforms . Unary . replace_all ( fun variable -> UnaryVariable . Map . find unaries variable ) annotation in let annotation = if ParameterVariable . Map . is_empty callable_parameters then annotation else Type . Variable . GlobalTransforms . ParameterVariadic . replace_all ( fun variable -> ParameterVariable . Map . find callable_parameters variable ) annotation in let annotation = if TupleVariable . Map . is_empty tuple_variadics then annotation else Type . Variable . GlobalTransforms . TupleVariadic . replace_all ( fun variable -> TupleVariable . Map . find tuple_variadics variable ) annotation in annotation let instantiate_single_variable { unaries ; _ } = UnaryVariable . Map . find unaries let instantiate_single_parameter_variadic { callable_parameters ; _ } = ParameterVariable . Map . find callable_parameters let instantiate_ordered_types solution ordered_type = match instantiate solution ( Type . Tuple ordered_type ) with \| Type . Tuple instantiated_ordered_type -> instantiated_ordered_type \| _ -> failwith " expected Tuple " let instantiate_callable_parameters solution parameters = match instantiate solution ( Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) ) with \| Type . Callable { implementation = { parameters ; _ } ; _ } -> parameters \| _ -> failwith " instantiate is not preserving callables " let set ( { unaries ; callable_parameters ; tuple_variadics } as solution ) = function \| Type . Variable . UnaryPair ( key , data ) -> { solution with unaries = UnaryVariable . Map . set unaries ~ key ~ data } \| Type . Variable . ParameterVariadicPair ( key , data ) -> { solution with callable_parameters = ParameterVariable . Map . set callable_parameters ~ key ~ data ; } \| Type . Variable . TupleVariadicPair ( key , data ) -> { solution with tuple_variadics = TupleVariable . Map . set tuple_variadics ~ key ~ data } let create = List . fold ~ f : set ~ init : empty end
module type OrderedConstraintsType = sig type order val add_lower_bound : t -> order : order -> pair : Type . Variable . pair -> t option val add_upper_bound : t -> order : order -> pair : Type . Variable . pair -> t option val add_fallback_to_any : t -> Type . Variable . t -> t val solve : t -> order : order -> Solution . t option val extract_partial_solution : t -> order : order -> variables : Type . Variable . t list -> ( t * Solution . t ) option end
module type OrderType = sig type t val always_less_or_equal : t -> left : Type . t -> right : Type . t -> bool val meet : t -> Type . t -> Type . t -> Type . t val join : t -> Type . t -> Type . t -> Type . t end
module OrderedConstraints ( Order : OrderType ) = struct module IntervalContainer = struct module type Interval = sig module Variable : Type . Variable . VariableKind type t val create : ? upper_bound : Variable . domain -> ? lower_bound : Variable . domain -> unit -> t val intersection : t -> t -> order : Order . t -> t option val narrowest_valid_value : t -> order : Order . t -> variable : Variable . t -> Variable . domain option val merge_solution_in : t -> variable : Variable . t -> solution : Solution . t -> t val is_trivial : t -> variable : Variable . t -> bool val free_variables : t -> Type . Variable . t list end module Make ( Interval : Interval ) = struct let add_bound container ~ order ~ variable ~ bound ~ is_lower_bound = if Interval . Variable . equal_domain bound ( Interval . Variable . self_reference variable ) then Some container else let new_constraint = if is_lower_bound then Interval . create ~ lower_bound : bound ( ) else Interval . create ~ upper_bound : bound ( ) in let existing = Map . find container variable \|> Option . value ~ default ( : Interval . create ( ) ) in Interval . intersection existing new_constraint ~ order >>= fun intersection -> Interval . narrowest_valid_value intersection ~ order ~ variable >>\| fun _ -> Map . set container ~ key : variable ~ data : intersection let merge_solution container ~ solution = Map . mapi container ~ f ( : fun ~ key ~ data -> Interval . merge_solution_in data ~ variable : key ~ solution ) \|> Map . filteri ~ f ( : fun ~ key ~ data -> not ( Interval . is_trivial data ~ variable : key ) ) let partition_independent_dependent container ~ with_regards_to = let contains_key { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } key = let has_constraints = match key with \| Type . Variable . Unary unary -> Map . mem unaries unary \| Type . Variable . ParameterVariadic parameters -> Map . mem callable_parameters parameters \| Type . Variable . TupleVariadic variadic -> Map . mem tuple_variadics variadic in has_constraints \|\| Set . mem have_fallbacks key in let is_independent target = Interval . free_variables target \|> List . exists ~ f ( : contains_key with_regards_to ) \|> not in Map . partition_tf container ~ f : is_independent let add_solution container partial_solution ~ order = let add_solution ~ key : variable ~ data : target = function \| Some partial_solution -> Interval . narrowest_valid_value target ~ order ~ variable >>\| ( fun value -> Interval . Variable . pair variable value ) >>\| Solution . set partial_solution \| None -> None in Map . fold container ~ f : add_solution ~ init ( : Some partial_solution ) end end module UnaryTypeInterval = struct module Variable = UnaryVariable type t = unary_interval let lower_bound { lower_bound ; _ } = lower_bound let upper_bound { upper_bound ; _ } = upper_bound let create ( ? upper_bound = Type . Top ) ( ? lower_bound = Type . Bottom ) ( ) = { upper_bound ; lower_bound } let intersection left right ~ order = Some { upper_bound = Order . meet order left . upper_bound right . upper_bound ; lower_bound = Order . join order left . lower_bound right . lower_bound ; } let narrowest_valid_value interval ~ order ~ variable { : UnaryVariable . constraints = exogenous_constraint ; _ } = let lowest_non_bottom_member interval ~ order = let non_empty { upper_bound ; lower_bound } ~ order = Order . always_less_or_equal order ~ left : lower_bound ~ right : upper_bound in Option . some_if ( non_empty interval ~ order ) ( lower_bound interval ) >>\| function \| Type . Bottom -> upper_bound interval \| other -> other in match exogenous_constraint with \| Explicit explicits -> let collect annotation sofar = let add_to_explicits_if_safe sofar candidate = match candidate with \| { Type . Variable . Unary . constraints = Explicit left_constraints ; _ } as candidate -> let exists_in_explicits left_constraint = List . exists explicits ~ f ( : Type . equal left_constraint ) in if List . for_all left_constraints ~ f : exists_in_explicits then Type . Variable candidate :: sofar else sofar \| _ -> sofar in Type . Variable . GlobalTransforms . Unary . collect_all annotation \|> List . fold ~ f : add_to_explicits_if_safe ~ init : sofar in let explicits = collect ( lower_bound interval ) explicits \|> collect ( upper_bound interval ) in let contains { upper_bound ; lower_bound } candidate ~ order = Order . always_less_or_equal order ~ left : candidate ~ right : upper_bound && Order . always_less_or_equal order ~ left : lower_bound ~ right : candidate in List . find ~ f ( : contains interval ~ order ) explicits \| Bound exogenous_bound -> intersection interval ( create ~ upper_bound : exogenous_bound ( ) ) ~ order >>= lowest_non_bottom_member ~ order \| Unconstrained -> lowest_non_bottom_member interval ~ order \| LiteralIntegers -> ( let is_literal_integer = function \| Type . Literal ( Type . Integer _ ) -> true \| Variable { constraints = LiteralIntegers ; _ } -> true \| _ -> false in let member = lowest_non_bottom_member interval ~ order in match member with \| Some found_member when is_literal_integer found_member -> member \| Some ( Type . Union union ) when List . for_all union ~ f : is_literal_integer -> member \| _ -> None ) let merge_solution_in { upper_bound ; lower_bound } ~ variable ~ solution = let smart_instantiate annotation = let instantiated = Solution . instantiate solution annotation in Option . some_if ( not ( Type . equal instantiated ( Type . Variable variable ) ) ) instantiated in let upper_bound = smart_instantiate upper_bound in let lower_bound = smart_instantiate lower_bound in create ? upper_bound ? lower_bound ( ) let is_trivial interval ~ variable : _ = match interval with \| { upper_bound = Type . Top ; lower_bound = Type . Bottom } -> true \| _ -> false let free_variables { upper_bound ; lower_bound } = Type . Variable . all_free_variables upper_bound @ Type . Variable . all_free_variables lower_bound end module CallableParametersInterval = struct module Variable = ParameterVariable type t = callable_parameter_interval let create ? upper_bound ? lower_bound ( ) = match upper_bound , lower_bound with \| None , None -> Bottom \| Some only , None \| None , Some only -> Singleton only \| Some left , Some right when Type . Callable . equal_parameters left right -> Singleton left \| Some _ , Some _ -> Top let narrowest_valid_value interval ~ order : _ ~ variable : _ = match interval with \| Top \| Bottom -> None \| Singleton parameters -> Some parameters let intersection left right ~ order : _ = match left , right with \| Top , _ \| _ , Top -> Some Top \| other , Bottom \| Bottom , other -> Some other \| Singleton left , Singleton right when Type . Callable . equal_parameters left right -> Some ( Singleton left ) \| _ , _ -> Some Top let merge_solution_in target ~ variable : _ ~ solution = match target with \| Top \| Bottom -> target \| Singleton parameters -> ( let callable = Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) in match Solution . instantiate solution callable with \| Type . Callable { implementation = { parameters = instantiated_parameters ; _ } ; _ } -> Singleton instantiated_parameters \| _ -> failwith " impossible " ) let is_trivial interval ~ variable = match interval with \| Singleton ( Type . Callable . ParameterVariadicTypeVariable { head = [ ] ; variable = target_variable } ) -> ParameterVariable . equal variable target_variable \| _ -> false let free_variables = function \| Top \| Bottom -> [ ] \| Singleton parameters -> Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) \|> Type . Variable . all_free_variables end module TupleInterval = struct module Variable = TupleVariable type t = tuple_interval let create ? upper_bound ? lower_bound ( ) = match lower_bound , upper_bound with \| None , None -> BottomTuple \| None , Some only \| Some only , None -> SingletonTuple only \| Some left , Some right when Type . OrderedTypes . equal_record Type . equal left right -> SingletonTuple left \| _ -> TopTuple let intersection left right ~ order = match left , right with \| TopTuple , _ \| _ , TopTuple -> Some TopTuple \| other , BottomTuple \| BottomTuple , other -> Some other \| SingletonTuple left , SingletonTuple right -> if Order . always_less_or_equal order ~ left ( : Type . Tuple left ) ~ right ( : Type . Tuple right ) then Some ( SingletonTuple right ) else if Order . always_less_or_equal order ~ left ( : Type . Tuple right ) ~ right ( : Type . Tuple left ) then Some ( SingletonTuple left ) else None let narrowest_valid_value interval ~ order : _ ~ variable : _ = match interval with \| TopTuple \| BottomTuple -> None \| SingletonTuple ordered_type -> Some ordered_type let merge_solution_in target ~ variable : _ ~ solution = match target with \| TopTuple \| BottomTuple -> target \| SingletonTuple ordered_type -> ( match Solution . instantiate solution ( Type . Tuple ordered_type ) with \| Type . Tuple instantiated_ordered_type -> SingletonTuple instantiated_ordered_type \| _ -> failwith " impossible " ) let is_trivial interval ~ variable = match interval with \| SingletonTuple ( Type . OrderedTypes . Concatenation concatenation ) -> Type . OrderedTypes . Concatenation . extract_sole_variadic concatenation >>\| ( fun variadic -> TupleVariable . equal variadic variable ) \|> Option . value ~ default : false \| _ -> false let free_variables = function \| TopTuple \| BottomTuple -> [ ] \| SingletonTuple ordered_type -> Type . Variable . all_free_variables ( Type . Tuple ordered_type ) end module CallableParametersIntervalContainer = IntervalContainer . Make ( CallableParametersInterval ) module UnaryIntervalContainer = IntervalContainer . Make ( UnaryTypeInterval ) module TupleIntervalContainer = IntervalContainer . Make ( TupleInterval ) type order = Order . t let add_bound ( { unaries ; callable_parameters ; tuple_variadics ; _ } as constraints ) ~ order ~ pair ~ is_lower_bound = match pair with \| Type . Variable . UnaryPair ( variable , bound ) -> UnaryIntervalContainer . add_bound unaries ~ order ~ variable ~ bound ~ is_lower_bound >>\| fun unaries -> { constraints with unaries } \| Type . Variable . ParameterVariadicPair ( variable , bound ) -> CallableParametersIntervalContainer . add_bound callable_parameters ~ order ~ variable ~ bound ~ is_lower_bound >>\| fun callable_parameters -> { constraints with callable_parameters } \| Type . Variable . TupleVariadicPair ( variable , bound ) -> TupleIntervalContainer . add_bound tuple_variadics ~ order ~ variable ~ bound ~ is_lower_bound >>\| fun tuple_variadics -> { constraints with tuple_variadics } let add_lower_bound = add_bound ~ is_lower_bound : true let add_upper_bound = add_bound ~ is_lower_bound : false let add_fallback_to_any ( { have_fallbacks ; _ } as constraints ) addition = { constraints with have_fallbacks = Set . add have_fallbacks addition } let merge_solution { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } solution = { unaries = UnaryIntervalContainer . merge_solution unaries ~ solution ; callable_parameters = CallableParametersIntervalContainer . merge_solution callable_parameters ~ solution ; tuple_variadics = TupleIntervalContainer . merge_solution tuple_variadics ~ solution ; have_fallbacks ; } let apply_fallbacks solution ~ have_fallbacks = let optional_add map key data = match Map . add map ~ key ~ data with \| ` Ok map -> map \| ` Duplicate -> map in let add_fallback ( { Solution . unaries ; callable_parameters ; tuple_variadics } as solution ) = function \| Type . Variable . Unary variable -> { solution with unaries = optional_add unaries variable Type . Any } \| Type . Variable . ParameterVariadic variable -> { solution with callable_parameters = optional_add callable_parameters variable Type . Callable . Undefined ; } \| Type . Variable . TupleVariadic variadic -> { solution with tuple_variadics = optional_add tuple_variadics variadic TupleVariable . any ; } in Set . to_list have_fallbacks \|> List . fold ~ init : solution ~ f : add_fallback let solve constraints ~ order = let rec build_solution ~ remaining_constraints ~ partial_solution = let independent_constraints , dependent_constraints = let independent_unaries , dependent_unaries = UnaryIntervalContainer . partition_independent_dependent remaining_constraints . unaries ~ with_regards_to : remaining_constraints in let independent_tuple_variadics , dependent_tuple_variadics = TupleIntervalContainer . partition_independent_dependent remaining_constraints . tuple_variadics ~ with_regards_to : remaining_constraints in let independent_parameters , dependent_parameters = CallableParametersIntervalContainer . partition_independent_dependent remaining_constraints . callable_parameters ~ with_regards_to : remaining_constraints in let independent_fallbacks , dependent_fallbacks = let matches = function \| Type . Variable . Unary key -> not ( Map . mem dependent_unaries key ) \| ParameterVariadic key -> not ( Map . mem dependent_parameters key ) \| TupleVariadic key -> not ( Map . mem dependent_tuple_variadics key ) in Set . partition_tf remaining_constraints . have_fallbacks ~ f : matches in ( { unaries = independent_unaries ; callable_parameters = independent_parameters ; tuple_variadics = independent_tuple_variadics ; have_fallbacks = independent_fallbacks ; } , { unaries = dependent_unaries ; callable_parameters = dependent_parameters ; tuple_variadics = dependent_tuple_variadics ; have_fallbacks = dependent_fallbacks ; } ) in let handle_dependent_constraints partial_solution = let is_empty { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } = UnaryVariable . Map . is_empty unaries && ParameterVariable . Map . is_empty callable_parameters && TupleVariable . Map . is_empty tuple_variadics && Set . is_empty have_fallbacks in if is_empty dependent_constraints then Some partial_solution else if is_empty independent_constraints then None else let remaining_constraints = merge_solution dependent_constraints partial_solution in build_solution ~ remaining_constraints ~ partial_solution in UnaryIntervalContainer . add_solution independent_constraints . unaries partial_solution ~ order >>= CallableParametersIntervalContainer . add_solution independent_constraints . callable_parameters ~ order >>= TupleIntervalContainer . add_solution independent_constraints . tuple_variadics ~ order >>\| apply_fallbacks ~ have_fallbacks : independent_constraints . have_fallbacks >>= handle_dependent_constraints in build_solution ~ remaining_constraints : constraints ~ partial_solution : Solution . empty let extract_partial_solution { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } ~ order ~ variables = let extracted_constraints , remaining_constraints = let unary_matches ~ key ~ data : _ = List . exists variables ~ f ( : Type . Variable . equal ( Type . Variable . Unary key ) ) in let callable_parameters_matches ~ key ~ data : _ = List . exists variables ~ f ( : Type . Variable . equal ( Type . Variable . ParameterVariadic key ) ) in let tuple_variadic_matches ~ key ~ data : _ = List . exists variables ~ f ( : Type . Variable . equal ( Type . Variable . TupleVariadic key ) ) in let extracted_unaries , remaining_unaries = UnaryVariable . Map . partitioni_tf unaries ~ f : unary_matches in let extracted_variadics , remaining_variadics = ParameterVariable . Map . partitioni_tf callable_parameters ~ f : callable_parameters_matches in let extracted_tuple_variadics , remaining_tuple_variadics = TupleVariable . Map . partitioni_tf tuple_variadics ~ f : tuple_variadic_matches in let extracted_fallbacks , remaining_fallbacks = let matches = function \| Type . Variable . Unary key -> unary_matches ~ key ~ data ( ) : \| ParameterVariadic key -> callable_parameters_matches ~ key ~ data ( ) : \| TupleVariadic key -> tuple_variadic_matches ~ key ~ data ( ) : in Set . partition_tf have_fallbacks ~ f : matches in ( { unaries = extracted_unaries ; callable_parameters = extracted_variadics ; tuple_variadics = extracted_tuple_variadics ; have_fallbacks = extracted_fallbacks ; } , { unaries = remaining_unaries ; callable_parameters = remaining_variadics ; tuple_variadics = remaining_tuple_variadics ; have_fallbacks = remaining_fallbacks ; } ) in solve extracted_constraints ~ order >>\| fun solution -> merge_solution remaining_constraints solution , solution end
let empty_head variable = { Type . Callable . head = [ ] ; variable }
let child = Type . Primitive " Child "
let left_parent = Type . Primitive " left_parent "
let right_parent = Type . Primitive " right_parent "
let grandparent = Type . Primitive " Grandparent "
module DiamondOrder = struct type t = unit let rec always_less_or_equal _ ~ left ~ right = match left , right with \| _ , _ when Type . equal left right -> true \| _ , Type . Top -> true \| Type . Bottom , _ -> true \| Type . Primitive " Child " , Type . Primitive " left_parent " -> true \| Type . Primitive " Child " , Type . Primitive " right_parent " -> true \| Type . Primitive " Child " , Type . Primitive " Grandparent " -> true \| Type . Primitive " left_parent " , Type . Primitive " Grandparent " -> true \| Type . Primitive " right_parent " , Type . Primitive " Grandparent " -> true \| left , Union rights -> List . exists rights ~ f ( : fun right -> always_less_or_equal ( ) ~ left ~ right ) \| Tuple ( Concrete left ) , Tuple ( Concrete right ) -> ( match List . for_all2 left right ~ f ( : fun left right -> always_less_or_equal ( ) ~ left ~ right ) with \| Ok result -> result \| _ -> false ) \| _ -> false let meet _ left right = match left , right with \| left , right when always_less_or_equal ( ) ~ left ~ right -> left \| right , left when always_less_or_equal ( ) ~ left ~ right -> left \| Type . Primitive " left_parent " , Type . Primitive " right_parent " -> Type . Primitive " Child " \| _ -> Type . Bottom let join _ left right = match left , right with \| left , right when always_less_or_equal ( ) ~ left ~ right -> right \| right , left when always_less_or_equal ( ) ~ left ~ right -> right \| Type . Primitive " left_parent " , Type . Primitive " right_parent " -> Type . Primitive " Grandparent " \| _ -> Type . Top end
module DiamondOrderedConstraints = OrderedConstraints ( DiamondOrder )
let variable ( ? name = " _V " ) constraints = Type . Variable . Unary . create name ~ constraints
let add_bound constraints bound = let order = ( ) in constraints >>= fun constraints -> match bound with \| ` Lower pair -> DiamondOrderedConstraints . add_lower_bound constraints ~ order ~ pair \| ` Upper pair -> DiamondOrderedConstraints . add_upper_bound constraints ~ order ~ pair \| ` Fallback variable -> DiamondOrderedConstraints . add_fallback_to_any constraints variable \|> Option . some
let test_add_bound _ = let assert_add_bound_has_result ( ? preconstraints = Some empty ) bound ~ expected_is_some = let result = add_bound preconstraints bound \|> Option . is_some in assert_equal ~ printer ( : Printf . sprintf " % B " ) expected_is_some result in let assert_add_bound_succeeds = assert_add_bound_has_result ~ expected_is_some : true in let assert_add_bound_fails = assert_add_bound_has_result ~ expected_is_some : false in let unconstrained = variable Type . Variable . Unconstrained in assert_add_bound_succeeds ( ` Lower ( UnaryPair ( unconstrained , child ) ) ) ; assert_add_bound_fails ~ preconstraints ( : add_bound ( Some empty ) ( ` Lower ( UnaryPair ( unconstrained , left_parent ) ) ) ) ( ` Upper ( UnaryPair ( unconstrained , right_parent ) ) ) ; assert_add_bound_fails ( ` Lower ( UnaryPair ( variable ( Type . Variable . Bound child ) , left_parent ) ) ) ; assert_add_bound_succeeds ( ` Lower ( UnaryPair ( variable ( Type . Variable . Bound child ) , child ) ) ) ; assert_add_bound_succeeds ( ` Upper ( UnaryPair ( variable ( Type . Variable . Bound child ) , left_parent ) ) ) ; let explicit_parent_a_parent_b = variable ( Type . Variable . Explicit [ left_parent ; right_parent ] ) in assert_add_bound_succeeds ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , left_parent ) ) ) ; assert_add_bound_succeeds ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , right_parent ) ) ) ; assert_add_bound_succeeds ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , Variable ( Type . Variable . Unary . mark_as_bound explicit_parent_a_parent_b ) ) ) ) ; assert_add_bound_succeeds ( ` Upper ( UnaryPair ( explicit_parent_a_parent_b , Variable ( Type . Variable . Unary . mark_as_bound explicit_parent_a_parent_b ) ) ) ) ; assert_add_bound_fails ~ preconstraints : ( add_bound ( Some empty ) ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , left_parent ) ) ) ) ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , right_parent ) ) ) ; let parameter_variadic = Type . Variable . Variadic . Parameters . create " T " in assert_add_bound_succeeds ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ ] ) ) ) ; let preconstraints = add_bound ( Some empty ) ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ ] ) ) ) in assert_add_bound_succeeds ~ preconstraints ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ ] ) ) ) ; assert_add_bound_fails ~ preconstraints ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ Named { name = " x " ; annotation = Type . integer ; default = false } ] ) ) ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let bound = TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) in assert_add_bound_succeeds ( ` Lower bound ) ; let preconstraints = add_bound ( Some empty ) ( ` Lower bound ) in assert_add_bound_succeeds ~ preconstraints ( ` Lower bound ) ; assert_add_bound_fails ~ preconstraints ( ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . bool ; Type . bool ] ) ) ) ; ( )
let optional_map_compare left right = match left , right with \| Some left , Some right -> TypeConstraints . Solution . equal left right \| None , None -> true \| _ , _ -> false
let optional_map_print map = map >>\| TypeConstraints . Solution . show \|> Option . value ~ default " : None "
let assert_solution ~ sequentially_applied_bounds expected = let result = List . fold sequentially_applied_bounds ~ init ( : Some empty ) ~ f : add_bound >>= DiamondOrderedConstraints . solve ~ order ( ) : in let expected = expected >>\| TypeConstraints . Solution . create in assert_equal ~ cmp : optional_map_compare ~ printer : optional_map_print expected result
let test_single_variable_solution _ = assert_solution ~ sequentially_applied_bounds [ ] : ( Some [ ] ) ; let unconstrained = variable Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( unconstrained , child ) ) ] ( Some [ UnaryPair ( unconstrained , child ) ] ) ; assert_solution ~ sequentially_applied_bounds [ ` : Upper ( UnaryPair ( unconstrained , child ) ) ] ( Some [ UnaryPair ( unconstrained , child ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained , child ) ) ; ` Lower ( UnaryPair ( unconstrained , left_parent ) ) ] ( Some [ UnaryPair ( unconstrained , left_parent ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained , left_parent ) ) ; ` Lower ( UnaryPair ( unconstrained , right_parent ) ) ; ] ( Some [ UnaryPair ( unconstrained , grandparent ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( unconstrained , left_parent ) ) ; ` Lower ( UnaryPair ( unconstrained , grandparent ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds [ ` : Upper ( UnaryPair ( unconstrained , Type . Variable unconstrained ) ) ] ( Some [ ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( unconstrained , Type . list ( Type . Variable unconstrained ) ) ) ] None ; let bounded_by_parent_A = variable ( Type . Variable . Bound left_parent ) in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( bounded_by_parent_A , child ) ) ] ( Some [ UnaryPair ( bounded_by_parent_A , child ) ] ) ; assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( bounded_by_parent_A , right_parent ) ) ] None ; let explicit_int_string_parent_A = variable ( Type . Variable . Explicit [ Type . integer ; Type . string ; left_parent ] ) in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( explicit_int_string_parent_A , child ) ) ] ( Some [ UnaryPair ( explicit_int_string_parent_A , left_parent ) ] ) ; assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( explicit_int_string_parent_A , grandparent ) ) ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ; ] ( Some [ UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ; ] ( Some [ UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( explicit_int_string_parent_A , Type . optional ( Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( explicit_int_string_parent_A , Type . optional ( Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ) ; ] ( Some [ UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ; ] ) ; let parameter_variadic = Type . Variable . Variadic . Parameters . create " T " in let empty_parameters = Type . Callable . Defined [ ] in let one_named_parameter = Type . Callable . Defined [ Named { name = " x " ; annotation = Type . integer ; default = false } ] in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameter_variadic , empty_parameters ) ) ] ( Some [ ParameterVariadicPair ( parameter_variadic , empty_parameters ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameter_variadic , empty_parameters ) ) ; ` Lower ( ParameterVariadicPair ( parameter_variadic , one_named_parameter ) ) ; ] None ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . bool ] ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Child " ; Type . Primitive " Child " ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Grandparent " ; Type . Primitive " Grandparent " ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Grandparent " ; Type . Primitive " Grandparent " ] ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Child " ; Type . Primitive " Grandparent " ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Grandparent " ; Type . Primitive " Child " ] ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Child " ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . string ] ) ) ; ] None ; ( )
let test_multiple_variable_solution _ = let unconstrained_a = variable ~ name " : A " Type . Variable . Unconstrained in let unconstrained_b = variable ~ name " : B " Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , child ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , child ) ; UnaryPair ( unconstrained_b , child ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ] None ; let unconstrained_c = variable ~ name " : C " Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_c ) ) ; ` Lower ( UnaryPair ( unconstrained_c , child ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , child ) ; UnaryPair ( unconstrained_b , child ) ; UnaryPair ( unconstrained_c , child ) ; ] ) ; let unrelated = variable ~ name " : unrelated " Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( unconstrained_a , Type . Variable unrelated ) ) ] ( Some [ UnaryPair ( unconstrained_a , Type . Variable unrelated ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ` Lower ( UnaryPair ( unconstrained_c , child ) ) ; ] None ; let parameters_a = Type . Variable . Variadic . Parameters . create " Ta " in let parameters_b = Type . Variable . Variadic . Parameters . create " Tb " in let empty_parameters = Type . Callable . Defined [ ] in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ) ; ` Lower ( ParameterVariadicPair ( parameters_b , empty_parameters ) ) ; ] ( Some [ ParameterVariadicPair ( parameters_a , empty_parameters ) ; ParameterVariadicPair ( parameters_b , empty_parameters ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ) ; ` Lower ( ParameterVariadicPair ( parameters_b , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_a ) ) ) ; ] None ; let parameters_with_unconstrained_a = Type . Callable . Defined [ Named { name = " x " ; annotation = Type . Variable unconstrained_a ; default = false } ] in let parameters_with_integer = Type . Callable . Defined [ Named { name = " x " ; annotation = Type . integer ; default = false } ] in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , parameters_with_unconstrained_a ) ) ; ` Lower ( UnaryPair ( unconstrained_a , Type . integer ) ) ; ] ( Some [ ParameterVariadicPair ( parameters_a , parameters_with_integer ) ; UnaryPair ( unconstrained_a , Type . integer ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , parameters_with_unconstrained_a ) ) ; ` Lower ( UnaryPair ( unconstrained_a , Type . Callable . create ~ parameters ( : Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_a ) ) ~ annotation : Type . integer ( ) ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Fallback ( Unary unconstrained_b ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . Any ) ; UnaryPair ( unconstrained_b , Type . Any ) ] ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let variadic2 = Type . Variable . Variadic . Tuple . create " Ts2 " in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . integer ] ~ suffix [ : Type . string ] variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . bool ; Type . string ] ) ; TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic ) ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . Variable unconstrained_a ] ~ suffix [ : Type . string ] variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ) ; ` Lower ( UnaryPair ( unconstrained_a , Type . integer ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . integer ) ; TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . bool ; Type . string ] ) ; TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . integer ] ~ suffix [ : Type . string ] variadic2 ) ) ) ; ` Fallback ( TupleVariadic variadic2 ) ; ] ( Some [ TupleVariadicPair ( variadic , Concatenation ( Type . OrderedTypes . Concatenation . create_from_unbounded_element ~ prefix [ : Type . integer ] ~ suffix [ : Type . string ] Type . Any ) ) ; TupleVariadicPair ( variadic2 , Concatenation ( Type . OrderedTypes . Concatenation . create_from_unbounded_element Type . Any ) ) ; ] ) ; ( )
let test_partial_solution _ = let expect_split_solution ~ bounds ~ variables expected_partial_solution expected_remainder_solution = let partial_result , remainder_solution = List . fold bounds ~ init ( : Some empty ) ~ f : add_bound >>= DiamondOrderedConstraints . extract_partial_solution ~ order ( ) : ~ variables >>\| ( fun ( remainder , partial_solution ) -> Some partial_solution , DiamondOrderedConstraints . solve ~ order ( ) : remainder ) \|> Option . value ~ default ( : None , None ) in let parse expected = expected >>\| TypeConstraints . Solution . create in let double_compare ( left_first , left_second ) ( right_first , right_second ) = optional_map_compare left_first right_first && optional_map_compare left_second right_second in let double_print ( first , second ) = Printf . sprintf " % s ; % s " ( optional_map_print first ) ( optional_map_print second ) in assert_equal ~ cmp : double_compare ~ printer : double_print ( parse expected_partial_solution , parse expected_remainder_solution ) ( partial_result , remainder_solution ) in let unconstrained_a = variable ~ name " : A " Type . Variable . Unconstrained in let unconstrained_b = variable ~ name " : B " Type . Variable . Unconstrained in let unconstrained_c = variable ~ name " : C " Type . Variable . Unconstrained in expect_split_solution ~ variables [ : Type . Variable . Unary unconstrained_a ] ~ bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ] ) ( Some [ ] ) ; expect_split_solution ~ variables [ : Type . Variable . Unary unconstrained_a ] ~ bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . list ( Type . Variable unconstrained_b ) ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . list ( Type . Variable unconstrained_b ) ) ] ) None ; expect_split_solution ~ variables [ : Type . Variable . Unary unconstrained_a ] ~ bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_c ) ) ; ` Lower ( UnaryPair ( unconstrained_c , Type . Variable unconstrained_b ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ] ) None ; let parameters_a = Type . Variable . Variadic . Parameters . create " Ta " in let parameters_b = Type . Variable . Variadic . Parameters . create " Tb " in expect_split_solution ~ variables [ : Type . Variable . ParameterVariadic parameters_a ] ~ bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ) ; ` Lower ( ParameterVariadicPair ( parameters_b , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_a ) ) ) ; ] ( Some [ ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ; ] ) ( Some [ ] ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let variadic2 = Type . Variable . Variadic . Tuple . create " Ts2 " in expect_split_solution ~ variables [ : Type . Variable . TupleVariadic variadic ] ~ bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic ) ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ; ] ) ( Some [ ] ) ; expect_split_solution ~ variables [ : Type . Variable . TupleVariadic variadic ] ~ bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . integer ] ~ suffix [ ] : variadic ) ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ; ] ) None ; ( )
let test_exists _ = let order = ( ) in let unconstrained_a = variable ~ name " : A " Type . Variable . Unconstrained in let unconstrained_b = variable ~ name " : B " Type . Variable . Unconstrained in let constraints_with_unconstrained_b = let pair = Type . Variable . UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) in DiamondOrderedConstraints . add_lower_bound TypeConstraints . empty ~ order ~ pair \|> function \| Some constraints -> constraints \| None -> failwith " add bound failed " in assert_true ( TypeConstraints . exists_in_bounds constraints_with_unconstrained_b ~ variables [ : Type . Variable . Unary unconstrained_b ] ) ; assert_false ( TypeConstraints . exists_in_bounds constraints_with_unconstrained_b ~ variables [ : Type . Variable . Unary unconstrained_a ] ) ; let parameters_a = Type . Variable . Variadic . Parameters . create " Ta " in let parameters_b = Type . Variable . Variadic . Parameters . create " Tb " in let constraints_with_parameters_b = let pair = Type . Variable . ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) in DiamondOrderedConstraints . add_lower_bound TypeConstraints . empty ~ order ~ pair \|> fun constraints_option -> Option . value_exn constraints_option in assert_true ( TypeConstraints . exists_in_bounds constraints_with_parameters_b ~ variables [ : Type . Variable . ParameterVariadic parameters_b ] ) ; assert_false ( TypeConstraints . exists_in_bounds constraints_with_parameters_b ~ variables [ : Type . Variable . ParameterVariadic parameters_a ] ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let variadic2 = Type . Variable . Variadic . Tuple . create " Ts2 " in let constraints_with_variadic2_in_bounds = let pair = TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . Variable unconstrained_a ] ~ suffix [ : Type . string ] variadic2 ) ) in DiamondOrderedConstraints . add_lower_bound TypeConstraints . empty ~ order ~ pair \|> fun constraints_option -> Option . value_exn constraints_option in assert_true ( TypeConstraints . exists_in_bounds constraints_with_variadic2_in_bounds ~ variables [ : Type . Variable . TupleVariadic variadic2 ] ) ; assert_false ( TypeConstraints . exists_in_bounds constraints_with_variadic2_in_bounds ~ variables [ : Type . Variable . TupleVariadic variadic ] ) ; assert_true ( TypeConstraints . exists_in_bounds constraints_with_variadic2_in_bounds ~ variables [ : Type . Variable . Unary unconstrained_a ] ) ; ( )
let ( ) = " constraints " >::: [ " add_bound " >:: test_add_bound ; " single_variable " >:: test_single_variable_solution ; " multiple_variables " >:: test_multiple_variable_solution ; " partial_solution " >:: test_partial_solution ; " exists " >:: test_exists ; ] \|> Test . run
type type_forcing_context = \| If_conditional \| If_no_else_branch \| While_loop_conditional \| While_loop_body \| For_loop_start_index \| For_loop_stop_index \| For_loop_body \| Assert_condition \| Sequence_left_hand_side \| When_guard
type type_expected = { ty : type_expr ; explanation : type_forcing_context option ; }
type existential_restriction = \| At_toplevel \| In_group \| In_rec \| With_attributes \| In_class_args \| In_class_def \| In_self_pattern
type error = \| Constructor_arity_mismatch of Longident . t * int * int \| Label_mismatch of Longident . t * Ctype . Unification_trace . t \| Pattern_type_clash of Ctype . Unification_trace . t * pattern_desc option \| Or_pattern_type_clash of Ident . t * Ctype . Unification_trace . t \| Multiply_bound_variable of string \| Orpat_vars of Ident . t * Ident . t list \| Expr_type_clash of Ctype . Unification_trace . t * type_forcing_context option * expression_desc option \| Apply_non_function of type_expr \| Apply_wrong_label of arg_label * type_expr \| Label_multiply_defined of string \| Label_missing of Ident . t list \| Label_not_mutable of Longident . t \| Wrong_name of string * type_expected * string * Path . t * string * string list \| Name_type_mismatch of string * Longident . t * ( Path . t * Path . t ) * ( Path . t * Path . t ) list \| Invalid_format of string \| Undefined_method of type_expr * string * string list option \| Undefined_inherited_method of string * string list \| Virtual_class of Longident . t \| Private_type of type_expr \| Private_label of Longident . t * type_expr \| Private_constructor of constructor_description * type_expr \| Unbound_instance_variable of string * string list \| Instance_variable_not_mutable of string \| Not_subtype of Ctype . Unification_trace . t * Ctype . Unification_trace . t \| Outside_class \| Value_multiply_overridden of string \| Coercion_failure of type_expr * type_expr * Ctype . Unification_trace . t * bool \| Too_many_arguments of bool * type_expr * type_forcing_context option \| Abstract_wrong_label of arg_label * type_expr * type_forcing_context option \| Scoping_let_module of string * type_expr \| Not_a_variant_type of Longident . t \| Incoherent_label_order \| Less_general of string * Ctype . Unification_trace . t \| Modules_not_allowed \| Cannot_infer_signature \| Not_a_packed_module of type_expr \| Unexpected_existential of existential_restriction * string * string list \| Invalid_interval \| Invalid_for_loop_index \| No_value_clauses \| Exception_pattern_disallowed \| Mixed_value_and_exception_patterns_under_guard \| Inlined_record_escape \| Inlined_record_expected \| Unrefuted_pattern of pattern \| Invalid_extension_constructor_payload \| Not_an_extension_constructor \| Literal_overflow of string \| Unknown_literal of string * char \| Illegal_letrec_pat \| Illegal_letrec_expr \| Illegal_class_expr \| Empty_pattern \| Letop_type_clash of string * Ctype . Unification_trace . t \| Andop_type_clash of string * Ctype . Unification_trace . t \| Bindings_type_clash of Ctype . Unification_trace . t
let type_module = ref ( ( fun _env _md -> assert false ) : Env . t -> Parsetree . module_expr -> Typedtree . module_expr )
let type_open : ( ? used_slot : bool ref -> override_flag -> Env . t -> Location . t -> Longident . t loc -> Path . t * Env . t ) ref = ref ( fun ? used_slot : _ _ -> assert false )
let type_open_decl : ( ? used_slot : bool ref -> Env . t -> Parsetree . open_declaration -> open_declaration * Types . signature * Env . t ) ref = ref ( fun ? used_slot : _ _ -> assert false )
let type_package = ref ( fun _ -> assert false )
let type_object = ref ( fun _env _s -> assert false : Env . t -> Location . t -> Parsetree . class_structure -> Typedtree . class_structure * Types . class_signature * string list )
let re node = Cmt_format . add_saved_type ( Cmt_format . Partial_expression node ) ; Stypes . record ( Stypes . Ti_expr node ) ; node ; ;
let rp node = Cmt_format . add_saved_type ( Cmt_format . Partial_pattern node ) ; Stypes . record ( Stypes . Ti_pat node ) ; node ; ;
type recarg = \| Allowed \| Required \| Rejected
let mk_expected ? explanation ty = { ty ; explanation ; }
let case lhs rhs = { c_lhs = lhs ; c_guard = None ; c_rhs = rhs }
let type_constant = function Const_int _ -> instance Predef . type_int \| Const_char _ -> instance Predef . type_char \| Const_string _ -> instance Predef . type_string \| Const_float _ -> instance Predef . type_float \| Const_int32 _ -> instance Predef . type_int32 \| Const_int64 _ -> instance Predef . type_int64 \| Const_nativeint _ -> instance Predef . type_nativeint
let constant : Parsetree . constant -> ( Asttypes . constant , error ) result = function \| Pconst_integer ( i , None ) -> begin try Ok ( Const_int ( Misc . Int_literal_converter . int i ) ) with Failure _ -> Error ( Literal_overflow " int " ) end \| Pconst_integer ( i , Some ' l ' ) -> begin try Ok ( Const_int32 ( Misc . Int_literal_converter . int32 i ) ) with Failure _ -> Error ( Literal_overflow " int32 " ) end \| Pconst_integer ( i , Some ' L ' ) -> begin try Ok ( Const_int64 ( Misc . Int_literal_converter . int64 i ) ) with Failure _ -> Error ( Literal_overflow " int64 " ) end \| Pconst_integer ( i , Some ' n ' ) -> begin try Ok ( Const_nativeint ( Misc . Int_literal_converter . nativeint i ) ) with Failure _ -> Error ( Literal_overflow " nativeint " ) end \| Pconst_integer ( i , Some c ) -> Error ( Unknown_literal ( i , c ) ) \| Pconst_char c -> Ok ( Const_char c ) \| Pconst_string ( s , d ) -> Ok ( Const_string ( s , d ) ) \| Pconst_float ( f , None ) -> Ok ( Const_float f ) \| Pconst_float ( f , Some c ) -> Error ( Unknown_literal ( f , c ) )
let constant_or_raise env loc cst = match constant cst with \| Ok c -> c \| Error err -> raise ( Error ( loc , env , err ) )
let type_option ty = newty ( Tconstr ( Predef . path_option , [ ty ] , ref Mnil ) )
let mkexp exp_desc exp_type exp_loc exp_env = { exp_desc ; exp_type ; exp_loc ; exp_env ; exp_extra = [ ] ; exp_attributes = [ ] }
let option_none env ty loc = let lid = Longident . Lident " None " in let cnone = Env . find_ident_constructor Predef . ident_none env in mkexp ( Texp_construct ( mknoloc lid , cnone , [ ] ) ) ty loc env
let option_some env texp = let lid = Longident . Lident " Some " in let csome = Env . find_ident_constructor Predef . ident_some env in mkexp ( Texp_construct ( mknoloc lid , csome , [ texp ] ) ) ( type_option texp . exp_type ) texp . exp_loc texp . exp_env
let extract_option_type env ty = match expand_head env ty with { desc = Tconstr ( path , [ ty ] , _ ) } when Path . same path Predef . path_option -> ty \| _ -> assert false
let extract_concrete_record env ty = match extract_concrete_typedecl env ty with ( p0 , p , { type_kind = Type_record ( fields , _ ) } ) -> ( p0 , p , fields ) \| _ -> raise Not_found

let extract_constraints cty = let sign = Ctype . signature_of_class_type cty in ( Vars . fold ( fun lab _ vars -> lab :: vars ) sign . csig_vars [ ] , begin let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sign . csig_self ) in List . fold_left ( fun meths ( lab , _ , _ ) -> if lab = dummy_method then meths else lab :: meths ) [ ] fields end , sign . csig_concr )

let rec abbreviate_class_type path params cty = match cty with Cty_constr ( _ , _ , _ ) | Cty_signature _ -> Cty_constr ( path , params , cty ) | Cty_arrow ( l , ty , cty ) -> Cty_arrow ( l , ty , abbreviate_class_type path params cty )

let rec closed_class_type = function Cty_constr ( _ , params , _ ) -> List . for_all ( Ctype . closed_schema Env . empty ) params | Cty_signature sign -> Ctype . closed_schema Env . empty sign . csig_self && Vars . fold ( fun _ ( _ , _ , ty ) cc -> Ctype . closed_schema Env . empty ty && cc ) sign . csig_vars true | Cty_arrow ( _ , ty , cty ) -> Ctype . closed_schema Env . empty ty && closed_class_type cty

let closed_class cty = List . for_all ( Ctype . closed_schema Env . empty ) cty . cty_params && closed_class_type cty . cty_type

let rec limited_generalize rv = function Cty_constr ( _path , params , cty ) -> List . iter ( Ctype . limited_generalize rv ) params ; limited_generalize rv cty | Cty_signature sign -> Ctype . limited_generalize rv sign . csig_self ; Vars . iter ( fun _ ( _ , _ , ty ) -> Ctype . limited_generalize rv ty ) sign . csig_vars ; List . iter ( fun ( _ , tl ) -> List . iter ( Ctype . limited_generalize rv ) tl ) sign . csig_inher | Cty_arrow ( _ , ty , cty ) -> Ctype . limited_generalize rv ty ; limited_generalize rv cty

let rc node = Cmt_format . add_saved_type ( Cmt_format . Partial_class_expr node ) ; Stypes . record ( Stypes . Ti_class node ) ; node

let enter_met_env ? check loc lab kind unbound_kind ty val_env met_env par_env = let val_env = Env . enter_unbound_value lab unbound_kind val_env in let par_env = Env . enter_unbound_value lab unbound_kind par_env in let ( id , met_env ) = Env . enter_value ? check lab { val_type = ty ; val_kind = kind ; val_attributes = [ ] ; Types . val_loc = loc } met_env in ( id , val_env , met_env , par_env )

let enter_val cl_num vars inh lab mut virt ty val_env met_env par_env loc = let ( id , virt ) = try let ( id , mut ' , virt ' , ty ' ) = Vars . find lab ! vars in if mut ' <> mut then raise ( Error ( loc , val_env , Mutability_mismatch ( lab , mut ) ) ) ; Ctype . unify val_env ( Ctype . instance ty ) ( Ctype . instance ty ' ) ; ( if not inh then Some id else None ) , ( if virt ' = Concrete then virt ' else virt ) with Ctype . Unify tr -> raise ( Error ( loc , val_env , Field_type_mismatch ( " instance variable " , lab , tr ) ) ) | Not_found -> None , virt in let ( id , _ , _ , _ ) as result = match id with Some id -> ( id , val_env , met_env , par_env ) | None -> enter_met_env Location . none lab ( Val_ivar ( mut , cl_num ) ) Val_unbound_instance_variable ty val_env met_env par_env in vars := Vars . add lab ( id , mut , virt , ty ) ! vars ; result

let concr_vals vars = Vars . fold ( fun id ( _ , vf , _ ) s -> if vf = Virtual then s else Concr . add id s ) vars Concr . empty

let inheritance self_type env ovf concr_meths warn_vals loc parent = match scrape_class_type parent with Cty_signature cl_sig -> begin try Ctype . unify env self_type cl_sig . csig_self with Ctype . Unify trace -> let open Ctype . Unification_trace in match trace with | Diff _ :: Incompatible_fields { name = n ; _ } :: rem -> raise ( Error ( loc , env , Field_type_mismatch ( " method " , n , rem ) ) ) | _ -> assert false end ; let over_meths = Concr . inter cl_sig . csig_concr concr_meths in let concr_vals = concr_vals cl_sig . csig_vars in let over_vals = Concr . inter concr_vals warn_vals in begin match ovf with Some Fresh -> let cname = match parent with Cty_constr ( p , _ , _ ) -> Path . name p | _ -> " inherited " in if not ( Concr . is_empty over_meths ) then Location . prerr_warning loc ( Warnings . Method_override ( cname :: Concr . elements over_meths ) ) ; if not ( Concr . is_empty over_vals ) then Location . prerr_warning loc ( Warnings . Instance_variable_override ( cname :: Concr . elements over_vals ) ) ; | Some Override when Concr . is_empty over_meths && Concr . is_empty over_vals -> raise ( Error ( loc , env , No_overriding ( " " , " " ) ) ) | _ -> ( ) end ; let concr_meths = Concr . union cl_sig . csig_concr concr_meths and warn_vals = Concr . union concr_vals warn_vals in ( cl_sig , concr_meths , warn_vals ) | _ -> raise ( Error ( loc , env , Structure_expected parent ) )

let virtual_method val_env meths self_type lab priv sty loc = let ( _ , ty ' ) = Ctype . filter_self_method val_env lab priv meths self_type in let sty = Ast_helper . Typ . force_poly sty in let cty = transl_simple_type val_env false sty in let ty = cty . ctyp_type in begin try Ctype . unify val_env ty ty ' with Ctype . Unify trace -> raise ( Error ( loc , val_env , Field_type_mismatch ( " method " , lab , trace ) ) ) ; end ; cty

let delayed_meth_specs = ref [ ]

let declare_method val_env meths self_type lab priv sty loc = let ( _ , ty ' ) = Ctype . filter_self_method val_env lab priv meths self_type in let unif ty = try Ctype . unify val_env ty ty ' with Ctype . Unify trace -> raise ( Error ( loc , val_env , Field_type_mismatch ( " method " , lab , trace ) ) ) in let sty = Ast_helper . Typ . force_poly sty in match sty . ptyp_desc , priv with Ptyp_poly ( [ ] , sty ' ) , Public -> let returned_cty = ctyp Ttyp_any ( Ctype . newty Tnil ) val_env loc in delayed_meth_specs := Warnings . mk_lazy ( fun ( ) -> let cty = transl_simple_type_univars val_env sty ' in let ty = cty . ctyp_type in unif ty ; returned_cty . ctyp_desc <- Ttyp_poly ( [ ] , cty ) ; returned_cty . ctyp_type <- ty ; ) :: ! delayed_meth_specs ; returned_cty | _ -> let cty = transl_simple_type val_env false sty in let ty = cty . ctyp_type in unif ty ; cty

let type_constraint val_env sty sty ' loc = let cty = transl_simple_type val_env false sty in let ty = cty . ctyp_type in let cty ' = transl_simple_type val_env false sty ' in let ty ' = cty ' . ctyp_type in begin try Ctype . unify val_env ty ty ' with Ctype . Unify trace -> raise ( Error ( loc , val_env , Unconsistent_constraint trace ) ) ; end ; ( cty , cty ' )

let make_method loc cl_num expr = let open Ast_helper in let mkid s = mkloc s loc in Exp . fun_ ~ loc : expr . pexp_loc Nolabel None ( Pat . alias ~ loc ( Pat . var ~ loc ( mkid " self " ) ) -* ( mkid ( " self " - ^ cl_num ) ) ) expr

let add_val lab ( mut , virt , ty ) val_sig = let virt = try let ( _mut ' , virt ' , _ty ' ) = Vars . find lab val_sig in if virt ' = Concrete then virt ' else virt with Not_found -> virt in Vars . add lab ( mut , virt , ty ) val_sig

let rec class_type_field env self_type meths arg ctf = Builtin_attributes . warning_scope ctf . pctf_attributes ( fun ( ) -> class_type_field_aux env self_type meths arg ctf ) ( fields , val_sig , concr_meths , inher ) ctf = let loc = ctf . pctf_loc in let mkctf desc = { ctf_desc = desc ; ctf_loc = loc ; ctf_attributes = ctf . pctf_attributes } in match ctf . pctf_desc with Pctf_inherit sparent -> let parent = class_type env sparent in let inher = match parent . cltyp_type with Cty_constr ( p , tl , _ ) -> ( p , tl ) :: inher | _ -> inher in let ( cl_sig , concr_meths , _ ) = inheritance self_type env None concr_meths Concr . empty sparent . pcty_loc parent . cltyp_type in let val_sig = Vars . fold add_val cl_sig . csig_vars val_sig in ( mkctf ( Tctf_inherit parent ) :: fields , val_sig , concr_meths , inher ) | Pctf_val ( { txt = lab } , mut , virt , sty ) -> let cty = transl_simple_type env false sty in let ty = cty . ctyp_type in ( mkctf ( Tctf_val ( lab , mut , virt , cty ) ) :: fields , add_val lab ( mut , virt , ty ) val_sig , concr_meths , inher ) | Pctf_method ( { txt = lab } , priv , virt , sty ) -> let cty = declare_method env meths self_type lab priv sty ctf . pctf_loc in let concr_meths = match virt with | Concrete -> Concr . add lab concr_meths | Virtual -> concr_meths in ( mkctf ( Tctf_method ( lab , priv , virt , cty ) ) :: fields , val_sig , concr_meths , inher ) | Pctf_constraint ( sty , sty ' ) -> let ( cty , cty ' ) = type_constraint env sty sty ' ctf . pctf_loc in ( mkctf ( Tctf_constraint ( cty , cty ' ) ) :: fields , val_sig , concr_meths , inher ) | Pctf_attribute x -> Builtin_attributes . warning_attribute x ; ( mkctf ( Tctf_attribute x ) :: fields , val_sig , concr_meths , inher ) | Pctf_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) ) let meths = ref Meths . empty in let self_cty = transl_simple_type env false sty in let self_cty = { self_cty with ctyp_type = Ctype . expand_head env self_cty . ctyp_type } in let self_type = self_cty . ctyp_type in let dummy_obj = Ctype . newvar ( ) in Ctype . unify env ( Ctype . filter_method env dummy_method Private dummy_obj ) ( Ctype . newty ( Ttuple [ ] ) ) ; begin try Ctype . unify env self_type dummy_obj with Ctype . Unify _ -> raise ( Error ( sty . ptyp_loc , env , Pattern_type_clash self_type ) ) end ; let ( rev_fields , val_sig , concr_meths , inher ) = Builtin_attributes . warning_scope [ ] ( fun ( ) -> List . fold_left ( class_type_field env self_type meths ) ( [ ] , Vars . empty , Concr . empty , [ ] ) sign ) in let cty = { csig_self = self_type ; csig_vars = val_sig ; csig_concr = concr_meths ; csig_inher = inher } in { csig_self = self_cty ; csig_fields = List . rev rev_fields ; csig_type = cty ; } Builtin_attributes . warning_scope scty . pcty_attributes ( fun ( ) -> class_type_aux env scty ) let cltyp desc typ = { cltyp_desc = desc ; cltyp_type = typ ; cltyp_loc = scty . pcty_loc ; cltyp_env = env ; cltyp_attributes = scty . pcty_attributes ; } in match scty . pcty_desc with Pcty_constr ( lid , styl ) -> let ( path , decl ) = Env . lookup_cltype ~ loc : scty . pcty_loc lid . txt env in if Path . same decl . clty_path unbound_class then raise ( Error ( scty . pcty_loc , env , Unbound_class_type_2 lid . txt ) ) ; let ( params , clty ) = Ctype . instance_class decl . clty_params decl . clty_type in if List . length params <> List . length styl then raise ( Error ( scty . pcty_loc , env , Parameter_arity_mismatch ( lid . txt , List . length params , List . length styl ) ) ) ; let ctys = List . map2 ( fun sty ty -> let cty ' = transl_simple_type env false sty in let ty ' = cty ' . ctyp_type in begin try Ctype . unify env ty ' ty with Ctype . Unify trace -> raise ( Error ( sty . ptyp_loc , env , Parameter_mismatch trace ) ) end ; cty ' ) styl params in let typ = Cty_constr ( path , params , clty ) in cltyp ( Tcty_constr ( path , lid , ctys ) ) typ | Pcty_signature pcsig -> let clsig = class_signature env pcsig in let typ = Cty_signature clsig . csig_type in cltyp ( Tcty_signature clsig ) typ | Pcty_arrow ( l , sty , scty ) -> let cty = transl_simple_type env false sty in let ty = cty . ctyp_type in let ty = if Btype . is_optional l then Ctype . newty ( Tconstr ( Predef . path_option , [ ty ] , ref Mnil ) ) else ty in let clty = class_type env scty in let typ = Cty_arrow ( l , ty , clty . cltyp_type ) in cltyp ( Tcty_arrow ( l , cty , clty ) ) typ | Pcty_open ( od , e ) -> let ( od , newenv ) = ! type_open_descr env od in let clty = class_type newenv e in cltyp ( Tcty_open ( od , clty ) ) clty . cltyp_type | Pcty_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) )

let class_type env scty = delayed_meth_specs := [ ] ; let cty = class_type env scty in List . iter Lazy . force ( List . rev ! delayed_meth_specs ) ; delayed_meth_specs := [ ] ; cty

let rec class_field self_loc cl_num self_type meths vars arg cf = Builtin_attributes . warning_scope cf . pcf_attributes ( fun ( ) -> class_field_aux self_loc cl_num self_type meths vars arg cf ) ( val_env , met_env , par_env , fields , concr_meths , warn_vals , inher , local_meths , local_vals ) cf = let loc = cf . pcf_loc in let mkcf desc = { cf_desc = desc ; cf_loc = loc ; cf_attributes = cf . pcf_attributes } in match cf . pcf_desc with Pcf_inherit ( ovf , sparent , super ) -> let parent = class_expr cl_num val_env par_env sparent in let inher = match parent . cl_type with Cty_constr ( p , tl , _ ) -> ( p , tl ) :: inher | _ -> inher in let ( cl_sig , concr_meths , warn_vals ) = inheritance self_type val_env ( Some ovf ) concr_meths warn_vals sparent . pcl_loc parent . cl_type in let ( val_env , met_env , par_env , inh_vars ) = Vars . fold ( fun lab info ( val_env , met_env , par_env , inh_vars ) -> let mut , vr , ty = info in let ( id , val_env , met_env , par_env ) = enter_val cl_num vars true lab mut vr ty val_env met_env par_env sparent . pcl_loc in ( val_env , met_env , par_env , ( lab , id ) :: inh_vars ) ) cl_sig . csig_vars ( val_env , met_env , par_env , [ ] ) in let inh_meths = Concr . fold ( fun lab rem -> ( lab , Ident . create_local lab ) :: rem ) cl_sig . csig_concr [ ] in let ( val_env , met_env , par_env , super ) = match super with None -> ( val_env , met_env , par_env , None ) | Some { txt = name } -> let ( _id , val_env , met_env , par_env ) = enter_met_env ~ check ( : fun s -> Warnings . Unused_ancestor s ) sparent . pcl_loc name ( Val_anc ( inh_meths , cl_num ) ) Val_unbound_ancestor self_type val_env met_env par_env in ( val_env , met_env , par_env , Some name ) in ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_inherit ( ovf , parent , super , inh_vars , inh_meths ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) | Pcf_val ( lab , mut , Cfk_virtual styp ) -> if ! Clflags . principal then Ctype . begin_def ( ) ; let cty = Typetexp . transl_simple_type val_env false styp in let ty = cty . ctyp_type in if ! Clflags . principal then begin Ctype . end_def ( ) ; Ctype . generalize_structure ty end ; let ( id , val_env , met_env ' , par_env ) = enter_val cl_num vars false lab . txt mut Virtual ty val_env met_env par_env loc in ( val_env , met_env ' , par_env , lazy ( mkcf ( Tcf_val ( lab , mut , id , Tcfk_virtual cty , met_env == met_env ' ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) | Pcf_val ( lab , mut , Cfk_concrete ( ovf , sexp ) ) -> if Concr . mem lab . txt local_vals then raise ( Error ( loc , val_env , Duplicate ( " instance variable " , lab . txt ) ) ) ; if Concr . mem lab . txt warn_vals then begin if ovf = Fresh then Location . prerr_warning lab . loc ( Warnings . Instance_variable_override [ lab . txt ] ) end else begin if ovf = Override then raise ( Error ( loc , val_env , No_overriding ( " instance variable " , lab . txt ) ) ) end ; if ! Clflags . principal then Ctype . begin_def ( ) ; let exp = type_exp val_env sexp in if ! Clflags . principal then begin Ctype . end_def ( ) ; Ctype . generalize_structure exp . exp_type end ; let ( id , val_env , met_env ' , par_env ) = enter_val cl_num vars false lab . txt mut Concrete exp . exp_type val_env met_env par_env loc in ( val_env , met_env ' , par_env , lazy ( mkcf ( Tcf_val ( lab , mut , id , Tcfk_concrete ( ovf , exp ) , met_env == met_env ' ) ) ) :: fields , concr_meths , Concr . add lab . txt warn_vals , inher , local_meths , Concr . add lab . txt local_vals ) | Pcf_method ( lab , priv , Cfk_virtual sty ) -> let cty = virtual_method val_env meths self_type lab . txt priv sty loc in ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_method ( lab , priv , Tcfk_virtual cty ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) | Pcf_method ( lab , priv , Cfk_concrete ( ovf , expr ) ) -> let expr = match expr . pexp_desc with | Pexp_poly _ -> expr | _ -> Ast_helper . Exp . poly ~ loc : expr . pexp_loc expr None in if Concr . mem lab . txt local_meths then raise ( Error ( loc , val_env , Duplicate ( " method " , lab . txt ) ) ) ; if Concr . mem lab . txt concr_meths then begin if ovf = Fresh then Location . prerr_warning loc ( Warnings . Method_override [ lab . txt ] ) end else begin if ovf = Override then raise ( Error ( loc , val_env , No_overriding ( " method " , lab . txt ) ) ) end ; let ( _ , ty ) = Ctype . filter_self_method val_env lab . txt priv meths self_type in begin try match expr . pexp_desc with Pexp_poly ( sbody , sty ) -> begin match sty with None -> ( ) | Some sty -> let sty = Ast_helper . Typ . force_poly sty in let cty ' = Typetexp . transl_simple_type val_env false sty in let ty ' = cty ' . ctyp_type in Ctype . unify val_env ty ' ty end ; begin match ( Ctype . repr ty ) . desc with Tvar _ -> let ty ' = Ctype . newvar ( ) in Ctype . unify val_env ( Ctype . newty ( Tpoly ( ty ' , [ ] ) ) ) ty ; Ctype . unify val_env ( type_approx val_env sbody ) ty ' | Tpoly ( ty1 , tl ) -> let _ , ty1 ' = Ctype . instance_poly false tl ty1 in let ty2 = type_approx val_env sbody in Ctype . unify val_env ty2 ty1 ' | _ -> assert false end | _ -> assert false with Ctype . Unify trace -> raise ( Error ( loc , val_env , Field_type_mismatch ( " method " , lab . txt , trace ) ) ) end ; let meth_expr = make_method self_loc cl_num expr in let vars_local = ! vars in let field = Warnings . mk_lazy ( fun ( ) -> let ( _ , ty ) = Meths . find lab . txt ! meths in let meth_type = mk_expected ( Btype . newgenty ( Tarrow ( Nolabel , self_type , ty , Cok ) ) ) in Ctype . raise_nongen_level ( ) ; vars := vars_local ; let texp = type_expect met_env meth_expr meth_type in Ctype . end_def ( ) ; mkcf ( Tcf_method ( lab , priv , Tcfk_concrete ( ovf , texp ) ) ) ) in ( val_env , met_env , par_env , field :: fields , Concr . add lab . txt concr_meths , warn_vals , inher , Concr . add lab . txt local_meths , local_vals ) | Pcf_constraint ( sty , sty ' ) -> let ( cty , cty ' ) = type_constraint val_env sty sty ' loc in ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_constraint ( cty , cty ' ) ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) | Pcf_initializer expr -> let expr = make_method self_loc cl_num expr in let vars_local = ! vars in let field = lazy begin Ctype . raise_nongen_level ( ) ; let meth_type = mk_expected ( Ctype . newty ( Tarrow ( Nolabel , self_type , Ctype . instance Predef . type_unit , Cok ) ) ) in vars := vars_local ; let texp = type_expect met_env expr meth_type in Ctype . end_def ( ) ; mkcf ( Tcf_initializer texp ) end in ( val_env , met_env , par_env , field :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) | Pcf_attribute x -> Builtin_attributes . warning_attribute x ; ( val_env , met_env , par_env , lazy ( mkcf ( Tcf_attribute x ) ) :: fields , concr_meths , warn_vals , inher , local_meths , local_vals ) | Pcf_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) ) { pcstr_self = spat ; pcstr_fields = str } = let par_env = met_env in let self_loc = { spat . ppat_loc with Location . loc_ghost = true } in let self_type = Ctype . newobj ( Ctype . newvar ( ) ) in if not final then Ctype . unify val_env ( Ctype . filter_method val_env dummy_method Private self_type ) ( Ctype . newty ( Ttuple [ ] ) ) ; let private_self = if final then Ctype . newvar ( ) else self_type in let ( pat , meths , vars , val_env , meth_env , par_env ) = type_self_pattern cl_num private_self val_env met_env par_env spat in let public_self = pat . pat_type in let ty = if final then Ctype . newobj ( Ctype . newvar ( ) ) else self_type in begin try Ctype . unify val_env public_self ty with Ctype . Unify _ -> raise ( Error ( spat . ppat_loc , val_env , Pattern_type_clash public_self ) ) end ; let get_methods ty = ( fst ( Ctype . flatten_fields ( Ctype . object_fields ( Ctype . expand_head val_env ty ) ) ) ) in if final then begin List . iter ( fun ( lab , kind , ty ) -> let k = if Btype . field_kind_repr kind = Fpresent then Public else Private in try Ctype . unify val_env ty ( Ctype . filter_method val_env lab k self_type ) with _ -> assert false ) ( get_methods public_self ) end ; let ( _ , _ , _ , fields , concr_meths , _ , inher , _local_meths , _local_vals ) = Builtin_attributes . warning_scope [ ] ( fun ( ) -> List . fold_left ( class_field self_loc cl_num self_type meths vars ) ( val_env , meth_env , par_env , [ ] , Concr . empty , Concr . empty , [ ] , Concr . empty , Concr . empty ) str ) in Ctype . unify val_env self_type ( Ctype . newvar ( ) ) ; let sign = { csig_self = public_self ; csig_vars = Vars . map ( fun ( _id , mut , vr , ty ) -> ( mut , vr , ty ) ) ! vars ; csig_concr = concr_meths ; csig_inher = inher } in let methods = get_methods self_type in let priv_meths = List . filter ( fun ( _ , kind , _ ) -> Btype . field_kind_repr kind <> Fpresent ) methods in List . iter ( fun ( met , _kind , _ty ) -> if Meths . mem met ! meths then ( ) else ignore ( Ctype . filter_self_method val_env met Private meths self_type ) ) methods ; if final then begin if not ( Ctype . close_object self_type ) then raise ( Error ( loc , val_env , Closing_self_type self_type ) ) ; let mets = virtual_methods { sign with csig_self = self_type } in let vals = Vars . fold ( fun name ( _mut , vr , _ty ) l -> if vr = Virtual then name :: l else l ) sign . csig_vars [ ] in if mets <> [ ] || vals <> [ ] then raise ( Error ( loc , val_env , Virtual_class ( true , final , mets , vals ) ) ) ; let self_methods = List . fold_right ( fun ( lab , kind , ty ) rem -> Ctype . newty ( Tfield ( lab , Btype . copy_kind kind , ty , rem ) ) ) methods ( Ctype . newty Tnil ) in begin try Ctype . unify val_env private_self ( Ctype . newty ( Tobject ( self_methods , ref None ) ) ) ; Ctype . unify val_env public_self self_type with Ctype . Unify trace -> raise ( Error ( loc , val_env , Final_self_clash trace ) ) end ; end ; begin let ms = ! meths in Meths . iter ( fun _ ( _ , ty ) -> Ctype . generalize_spine ty ) ms ; meths := Meths . map ( fun ( id , ty ) -> ( id , Ctype . generic_instance ty ) ) ms ; Meths . iter ( fun _ ( _ , ty ) -> Ctype . unify val_env ty ( Ctype . newvar ( ) ) ) ms end ; let fields = List . map Lazy . force ( List . rev fields ) in let meths = Meths . map ( function ( id , _ty ) -> id ) ! meths in let pub_meths ' = List . filter ( fun ( _ , kind , _ ) -> Btype . field_kind_repr kind = Fpresent ) ( get_methods public_self ) in let names = List . map ( fun ( x , _ , _ ) -> x ) in let l1 = names priv_meths and l2 = names pub_meths ' in let added = List . filter ( fun x -> List . mem x l1 ) l2 in if added <> [ ] then Location . prerr_warning loc ( Warnings . Implicit_public_methods added ) ; let sign = if final then sign else { sign with Types . csig_self = Ctype . expand_head val_env public_self } in { cstr_self = pat ; cstr_fields = fields ; cstr_type = sign ; cstr_meths = meths } , sign Builtin_attributes . warning_scope scl . pcl_attributes ( fun ( ) -> class_expr_aux cl_num val_env met_env scl ) match scl . pcl_desc with Pcl_constr ( lid , styl ) -> let ( path , decl ) = Env . lookup_class ~ loc : scl . pcl_loc lid . txt val_env in if Path . same decl . cty_path unbound_class then raise ( Error ( scl . pcl_loc , val_env , Unbound_class_2 lid . txt ) ) ; let tyl = List . map ( fun sty -> transl_simple_type val_env false sty ) styl in let ( params , clty ) = Ctype . instance_class decl . cty_params decl . cty_type in let clty ' = abbreviate_class_type path params clty in if List . length params <> List . length tyl then raise ( Error ( scl . pcl_loc , val_env , Parameter_arity_mismatch ( lid . txt , List . length params , List . length tyl ) ) ) ; List . iter2 ( fun cty ' ty -> let ty ' = cty ' . ctyp_type in try Ctype . unify val_env ty ' ty with Ctype . Unify trace -> raise ( Error ( cty ' . ctyp_loc , val_env , Parameter_mismatch trace ) ) ) tyl params ; let cl = rc { cl_desc = Tcl_ident ( path , lid , tyl ) ; cl_loc = scl . pcl_loc ; cl_type = clty ' ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } in let ( vals , meths , concrs ) = extract_constraints clty in rc { cl_desc = Tcl_constraint ( cl , None , vals , meths , concrs ) ; cl_loc = scl . pcl_loc ; cl_type = clty ' ; cl_env = val_env ; cl_attributes = [ ] ; } | Pcl_structure cl_str -> let ( desc , ty ) = class_structure cl_num false val_env met_env scl . pcl_loc cl_str in rc { cl_desc = Tcl_structure desc ; cl_loc = scl . pcl_loc ; cl_type = Cty_signature ty ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } | Pcl_fun ( l , Some default , spat , sbody ) -> let loc = default . pexp_loc in let open Ast_helper in let scases = [ Exp . case ( Pat . construct ~ loc ( mknoloc ( Longident . ( Ldot ( Lident " * predef " , * " Some " ) ) ) ) ( Some ( Pat . var ~ loc ( mknoloc " * sth " ) ) ) ) * ( Exp . ident ~ loc ( mknoloc ( Longident . Lident " * sth " ) ) ) ; * Exp . case ( Pat . construct ~ loc ( mknoloc ( Longident . ( Ldot ( Lident " * predef " , * " None " ) ) ) ) None ) default ; ] in let smatch = Exp . match_ ~ loc ( Exp . ident ~ loc ( mknoloc ( Longident . Lident " * opt " ) ) ) * scases in let sfun = Cl . fun_ ~ loc : scl . pcl_loc l None ( Pat . var ~ loc ( mknoloc " * opt " ) ) * ( Cl . let_ ~ loc : scl . pcl_loc Nonrecursive [ Vb . mk spat smatch ] sbody ) in class_expr cl_num val_env met_env sfun | Pcl_fun ( l , None , spat , scl ' ) -> if ! Clflags . principal then Ctype . begin_def ( ) ; let ( pat , pv , val_env ' , met_env ) = Typecore . type_class_arg_pattern cl_num val_env met_env l spat in if ! Clflags . principal then begin Ctype . end_def ( ) ; iter_pattern ( fun { pat_type = ty } -> Ctype . generalize_structure ty ) pat end ; let pv = List . map begin fun ( id , id ' , _ty ) -> let path = Pident id ' in let vd = Env . find_value path val_env ' in ( id , { exp_desc = Texp_ident ( path , mknoloc ( Longident . Lident ( Ident . name id ) ) , vd ) ; exp_loc = Location . none ; exp_extra = [ ] ; exp_type = Ctype . instance vd . val_type ; exp_attributes = [ ] ; exp_env = val_env ' } ) end pv in let not_function = function Cty_arrow _ -> false | _ -> true in let partial = let dummy = type_exp val_env ( Ast_helper . Exp . unreachable ( ) ) in Typecore . check_partial val_env pat . pat_type pat . pat_loc [ { c_lhs = pat ; c_guard = None ; c_rhs = dummy } ] in Ctype . raise_nongen_level ( ) ; let cl = class_expr cl_num val_env ' met_env scl ' in Ctype . end_def ( ) ; if Btype . is_optional l && not_function cl . cl_type then Location . prerr_warning pat . pat_loc Warnings . Unerasable_optional_argument ; rc { cl_desc = Tcl_fun ( l , pat , pv , cl , partial ) ; cl_loc = scl . pcl_loc ; cl_type = Cty_arrow ( l , Ctype . instance pat . pat_type , cl . cl_type ) ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } | Pcl_apply ( scl ' , sargs ) -> assert ( sargs <> [ ] ) ; if ! Clflags . principal then Ctype . begin_def ( ) ; let cl = class_expr cl_num val_env met_env scl ' in if ! Clflags . principal then begin Ctype . end_def ( ) ; generalize_class_type false cl . cl_type ; end ; let rec nonopt_labels ls ty_fun = match ty_fun with | Cty_arrow ( l , _ , ty_res ) -> if Btype . is_optional l then nonopt_labels ls ty_res else nonopt_labels ( l :: ls ) ty_res | _ -> ls in let ignore_labels = ! Clflags . classic || let labels = nonopt_labels [ ] cl . cl_type in List . length labels = List . length sargs && List . for_all ( fun ( l , _ ) -> l = Nolabel ) sargs && List . exists ( fun l -> l <> Nolabel ) labels && begin Location . prerr_warning cl . cl_loc ( Warnings . Labels_omitted ( List . map Printtyp . string_of_label ( List . filter ( ( ) <> Nolabel ) labels ) ) ) ; true end in let rec type_args args omitted ty_fun ty_fun0 sargs more_sargs = match ty_fun , ty_fun0 with | Cty_arrow ( l , ty , ty_fun ) , Cty_arrow ( _ , ty0 , ty_fun0 ) when sargs <> [ ] || more_sargs <> [ ] -> let name = Btype . label_name l and optional = Btype . is_optional l in let sargs , more_sargs , arg = if ignore_labels && not ( Btype . is_optional l ) then begin match sargs , more_sargs with ( l ' , sarg0 ) :: _ , _ -> raise ( Error ( sarg0 . pexp_loc , val_env , Apply_wrong_label l ' ) ) | _ , ( l ' , sarg0 ) :: more_sargs -> if l <> l ' && l ' <> Nolabel then raise ( Error ( sarg0 . pexp_loc , val_env , Apply_wrong_label l ' ) ) else ( [ ] , more_sargs , Some ( type_argument val_env sarg0 ty ty0 ) ) | _ -> assert false end else try let ( l ' , sarg0 , sargs , more_sargs ) = try let ( l ' , sarg0 , sargs1 , sargs2 ) = Btype . extract_label name sargs in ( l ' , sarg0 , sargs1 @ sargs2 , more_sargs ) with Not_found -> let ( l ' , sarg0 , sargs1 , sargs2 ) = Btype . extract_label name more_sargs in ( l ' , sarg0 , sargs @ sargs1 , sargs2 ) in if not optional && Btype . is_optional l ' then Location . prerr_warning sarg0 . pexp_loc ( Warnings . Nonoptional_label ( Printtyp . string_of_label l ) ) ; sargs , more_sargs , if not optional || Btype . is_optional l ' then Some ( type_argument val_env sarg0 ty ty0 ) else let ty ' = extract_option_type val_env ty and ty0 ' = extract_option_type val_env ty0 in let arg = type_argument val_env sarg0 ty ' ty0 ' in Some ( option_some val_env arg ) with Not_found -> sargs , more_sargs , if Btype . is_optional l && ( List . mem_assoc Nolabel sargs || List . mem_assoc Nolabel more_sargs ) then Some ( option_none val_env ty0 Location . none ) else None in let omitted = if arg = None then ( l , ty0 ) :: omitted else omitted in type_args ( ( l , arg ) :: args ) omitted ty_fun ty_fun0 sargs more_sargs | _ -> match sargs @ more_sargs with ( l , sarg0 ) :: _ -> if omitted <> [ ] then raise ( Error ( sarg0 . pexp_loc , val_env , Apply_wrong_label l ) ) else raise ( Error ( cl . cl_loc , val_env , Cannot_apply cl . cl_type ) ) | [ ] -> ( List . rev args , List . fold_left ( fun ty_fun ( l , ty ) -> Cty_arrow ( l , ty , ty_fun ) ) ty_fun0 omitted ) in let ( args , cty ) = let ( _ , ty_fun0 ) = Ctype . instance_class [ ] cl . cl_type in if ignore_labels then type_args [ ] [ ] cl . cl_type ty_fun0 [ ] sargs else type_args [ ] [ ] cl . cl_type ty_fun0 sargs [ ] in rc { cl_desc = Tcl_apply ( cl , args ) ; cl_loc = scl . pcl_loc ; cl_type = cty ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } | Pcl_let ( rec_flag , sdefs , scl ' ) -> let ( defs , val_env ) = Typecore . type_let In_class_def val_env rec_flag sdefs None in let ( vals , met_env ) = List . fold_right ( fun ( id , _id_loc , _typ ) ( vals , met_env ) -> let path = Pident id in let vd = Env . find_value path val_env in Ctype . begin_def ( ) ; let expr = { exp_desc = Texp_ident ( path , mknoloc ( Longident . Lident ( Ident . name id ) ) , vd ) ; exp_loc = Location . none ; exp_extra = [ ] ; exp_type = Ctype . instance vd . val_type ; exp_attributes = [ ] ; exp_env = val_env ; } in Ctype . end_def ( ) ; Ctype . generalize expr . exp_type ; let desc = { val_type = expr . exp_type ; val_kind = Val_ivar ( Immutable , cl_num ) ; val_attributes = [ ] ; Types . val_loc = vd . Types . val_loc ; } in let id ' = Ident . create_local ( Ident . name id ) in ( ( id ' , expr ) :: vals , Env . add_value id ' desc met_env ) ) ( let_bound_idents_full defs ) ( [ ] , met_env ) in let cl = class_expr cl_num val_env met_env scl ' in let ( ) = if rec_flag = Recursive then check_recursive_bindings val_env defs in rc { cl_desc = Tcl_let ( rec_flag , defs , vals , cl ) ; cl_loc = scl . pcl_loc ; cl_type = cl . cl_type ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } | Pcl_constraint ( scl ' , scty ) -> Ctype . begin_class_def ( ) ; let context = Typetexp . narrow ( ) in let cl = class_expr cl_num val_env met_env scl ' in Typetexp . widen context ; let context = Typetexp . narrow ( ) in let clty = class_type val_env scty in Typetexp . widen context ; Ctype . end_def ( ) ; limited_generalize ( Ctype . row_variable ( Ctype . self_type cl . cl_type ) ) cl . cl_type ; limited_generalize ( Ctype . row_variable ( Ctype . self_type clty . cltyp_type ) ) clty . cltyp_type ; begin match Includeclass . class_types val_env cl . cl_type clty . cltyp_type with [ ] -> ( ) | error -> raise ( Error ( cl . cl_loc , val_env , Class_match_failure error ) ) end ; let ( vals , meths , concrs ) = extract_constraints clty . cltyp_type in rc { cl_desc = Tcl_constraint ( cl , Some clty , vals , meths , concrs ) ; cl_loc = scl . pcl_loc ; cl_type = snd ( Ctype . instance_class [ ] clty . cltyp_type ) ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } | Pcl_open ( pod , e ) -> let used_slot = ref false in let ( od , new_val_env ) = ! type_open_descr ~ used_slot val_env pod in let ( _ , new_met_env ) = ! type_open_descr ~ used_slot met_env pod in let cl = class_expr cl_num new_val_env new_met_env e in rc { cl_desc = Tcl_open ( od , cl ) ; cl_loc = scl . pcl_loc ; cl_type = cl . cl_type ; cl_env = val_env ; cl_attributes = scl . pcl_attributes ; } | Pcl_extension ext -> raise ( Error_forward ( Builtin_attributes . error_of_extension ext ) )

let var_option = Predef . type_option ( Btype . newgenvar ( ) )

let rec approx_declaration cl = match cl . pcl_desc with Pcl_fun ( l , _ , _ , cl ) -> let arg = if Btype . is_optional l then Ctype . instance var_option else Ctype . newvar ( ) in Ctype . newty ( Tarrow ( l , arg , approx_declaration cl , Cok ) ) | Pcl_let ( _ , _ , cl ) -> approx_declaration cl | Pcl_constraint ( cl , _ ) -> approx_declaration cl | _ -> Ctype . newvar ( )

let rec approx_description ct = match ct . pcty_desc with Pcty_arrow ( l , _ , ct ) -> let arg = if Btype . is_optional l then Ctype . instance var_option else Ctype . newvar ( ) in Ctype . newty ( Tarrow ( l , arg , approx_description ct , Cok ) ) | _ -> Ctype . newvar ( )

let temp_abbrev loc env id arity = let params = ref [ ] in for _i = 1 to arity do params := Ctype . newvar ( ) :: ! params done ; let ty = Ctype . newobj ( Ctype . newvar ( ) ) in let env = Env . add_type ~ check : true id { type_params = ! params ; type_arity = arity ; type_kind = Type_abstract ; type_private = Public ; type_manifest = Some ty ; type_variance = Misc . replicate_list Variance . full arity ; type_is_newtype = false ; type_expansion_scope = Btype . lowest_level ; type_loc = loc ; type_attributes = [ ] ; type_immediate = Unknown ; type_unboxed = unboxed_false_default_false ; } env in ( ! params , ty , env )

let initial_env define_class approx ( res , env ) ( cl , id , ty_id , obj_id , cl_id ) = let arity = List . length cl . pci_params in let ( obj_params , obj_ty , env ) = temp_abbrev cl . pci_loc env obj_id arity in let ( cl_params , cl_ty , env ) = temp_abbrev cl . pci_loc env cl_id arity in let constr_type = approx cl . pci_expr in if ! Clflags . principal then Ctype . generalize_spine constr_type ; let dummy_cty = Cty_signature { csig_self = Ctype . newvar ( ) ; csig_vars = Vars . empty ; csig_concr = Concr . empty ; csig_inher = [ ] } in let dummy_class = { Types . cty_params = [ ] ; cty_variance = [ ] ; cty_type = dummy_cty ; cty_path = unbound_class ; cty_new = begin match cl . pci_virt with | Virtual -> None | Concrete -> Some constr_type end ; cty_loc = Location . none ; cty_attributes = [ ] ; } in let env = Env . add_cltype ty_id { clty_params = [ ] ; clty_variance = [ ] ; clty_type = dummy_cty ; clty_path = unbound_class ; clty_loc = Location . none ; clty_attributes = [ ] ; } ( if define_class then Env . add_class id dummy_class env else env ) in ( ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) :: res , env )

let class_infos define_class kind ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) ( res , env ) = reset_type_variables ( ) ; Ctype . begin_class_def ( ) ; let ci_params = let make_param ( sty , v ) = try ( transl_type_param env sty , v ) with Already_bound -> raise ( Error ( sty . ptyp_loc , env , Repeated_parameter ) ) in List . map make_param cl . pci_params in let params = List . map ( fun ( cty , _ ) -> cty . ctyp_type ) ci_params in let coercion_locs = ref [ ] in let ( expr , typ ) = try Typecore . self_coercion := ( Path . Pident obj_id , coercion_locs ) :: ! Typecore . self_coercion ; let res = kind env cl . pci_expr in Typecore . self_coercion := List . tl ! Typecore . self_coercion ; res with exn -> Typecore . self_coercion := [ ] ; raise exn in Ctype . end_def ( ) ; let sty = Ctype . self_type typ in let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sty ) in List . iter ( fun ( met , _ , ty ) -> if met = dummy_method then Ctype . generalize ty ) fields ; let rv = Ctype . row_variable sty in List . iter ( Ctype . limited_generalize rv ) params ; limited_generalize rv typ ; let ( obj_params ' , obj_type ) = Ctype . instance_class params typ in let constr = Ctype . newconstr ( Path . Pident obj_id ) obj_params in begin let ty = Ctype . self_type obj_type in Ctype . hide_private_methods ty ; if not ( Ctype . close_object ty ) then raise ( Error ( cl . pci_loc , env , Closing_self_type ty ) ) ; begin try List . iter2 ( Ctype . unify env ) obj_params obj_params ' with Ctype . Unify _ -> raise ( Error ( cl . pci_loc , env , Bad_parameters ( obj_id , constr , Ctype . newconstr ( Path . Pident obj_id ) obj_params ' ) ) ) end ; begin try Ctype . unify env ty constr with Ctype . Unify _ -> raise ( Error ( cl . pci_loc , env , Abbrev_type_clash ( constr , ty , Ctype . expand_head env constr ) ) ) end end ; begin let ( cl_params ' , cl_type ) = Ctype . instance_class params typ in let ty = Ctype . self_type cl_type in Ctype . hide_private_methods ty ; Ctype . set_object_name obj_id ( Ctype . row_variable ty ) cl_params ty ; begin try List . iter2 ( Ctype . unify env ) cl_params cl_params ' with Ctype . Unify _ -> raise ( Error ( cl . pci_loc , env , Bad_parameters ( cl_id , Ctype . newconstr ( Path . Pident cl_id ) cl_params , Ctype . newconstr ( Path . Pident cl_id ) cl_params ' ) ) ) end ; begin try Ctype . unify env ty cl_ty with Ctype . Unify _ -> let constr = Ctype . newconstr ( Path . Pident cl_id ) params in raise ( Error ( cl . pci_loc , env , Abbrev_type_clash ( constr , ty , cl_ty ) ) ) end end ; begin try Ctype . unify env ( constructor_type constr obj_type ) ( Ctype . instance constr_type ) with Ctype . Unify trace -> raise ( Error ( cl . pci_loc , env , Constructor_type_mismatch ( cl . pci_name . txt , trace ) ) ) end ; let cty_variance = List . map ( fun _ -> Variance . full ) params in let cltydef = { clty_params = params ; clty_type = class_body typ ; clty_variance = cty_variance ; clty_path = Path . Pident obj_id ; clty_loc = cl . pci_loc ; clty_attributes = cl . pci_attributes ; } and clty = { cty_params = params ; cty_type = typ ; cty_variance = cty_variance ; cty_path = Path . Pident obj_id ; cty_new = begin match cl . pci_virt with | Virtual -> None | Concrete -> Some constr_type end ; cty_loc = cl . pci_loc ; cty_attributes = cl . pci_attributes ; } in dummy_class . cty_type <- typ ; let env = Env . add_cltype ty_id cltydef ( if define_class then Env . add_class id clty env else env ) in if cl . pci_virt = Concrete then begin let sign = Ctype . signature_of_class_type typ in let mets = virtual_methods sign in let vals = Vars . fold ( fun name ( _mut , vr , _ty ) l -> if vr = Virtual then name :: l else l ) sign . csig_vars [ ] in if mets <> [ ] || vals <> [ ] then raise ( Error ( cl . pci_loc , env , Virtual_class ( define_class , false , mets , vals ) ) ) ; end ; let arity = Ctype . class_type_arity typ in let pub_meths = let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields ( Ctype . expand_head env obj_ty ) ) in List . map ( function ( lab , _ , _ ) -> lab ) fields in let ( params ' , typ ' ) = Ctype . instance_class params typ in let cltydef = { clty_params = params ' ; clty_type = class_body typ ' ; clty_variance = cty_variance ; clty_path = Path . Pident obj_id ; clty_loc = cl . pci_loc ; clty_attributes = cl . pci_attributes ; } and clty = { cty_params = params ' ; cty_type = typ ' ; cty_variance = cty_variance ; cty_path = Path . Pident obj_id ; cty_new = begin match cl . pci_virt with | Virtual -> None | Concrete -> Some ( Ctype . instance constr_type ) end ; cty_loc = cl . pci_loc ; cty_attributes = cl . pci_attributes ; } in let obj_abbr = { type_params = obj_params ; type_arity = List . length obj_params ; type_kind = Type_abstract ; type_private = Public ; type_manifest = Some obj_ty ; type_variance = List . map ( fun _ -> Variance . full ) obj_params ; type_is_newtype = false ; type_expansion_scope = Btype . lowest_level ; type_loc = cl . pci_loc ; type_attributes = [ ] ; type_immediate = Unknown ; type_unboxed = unboxed_false_default_false ; } in let ( cl_params , cl_ty ) = Ctype . instance_parameterized_type params ( Ctype . self_type typ ) in Ctype . hide_private_methods cl_ty ; Ctype . set_object_name obj_id ( Ctype . row_variable cl_ty ) cl_params cl_ty ; let cl_abbr = { type_params = cl_params ; type_arity = List . length cl_params ; type_kind = Type_abstract ; type_private = Public ; type_manifest = Some cl_ty ; type_variance = List . map ( fun _ -> Variance . full ) cl_params ; type_is_newtype = false ; type_expansion_scope = Btype . lowest_level ; type_loc = cl . pci_loc ; type_attributes = [ ] ; type_immediate = Unknown ; type_unboxed = unboxed_false_default_false ; } in ( ( cl , id , clty , ty_id , cltydef , obj_id , obj_abbr , cl_id , cl_abbr , ci_params , arity , pub_meths , List . rev ! coercion_locs , expr ) :: res , env )

let final_decl env define_class ( cl , id , clty , ty_id , cltydef , obj_id , obj_abbr , cl_id , cl_abbr , ci_params , arity , pub_meths , coe , expr ) = begin try Ctype . collapse_conj_params env clty . cty_params with Ctype . Unify trace -> raise ( Error ( cl . pci_loc , env , Non_collapsable_conjunction ( id , clty , trace ) ) ) end ; begin let self_type = Ctype . self_type clty . cty_type in let methods , _ = Ctype . flatten_fields ( Ctype . object_fields ( Ctype . expand_head env self_type ) ) in List . iter ( fun ( lab , kind , _ ) -> if lab = dummy_method then match Btype . field_kind_repr kind with Fvar r -> Btype . set_kind r Fabsent | _ -> ( ) ) methods end ; List . iter Ctype . generalize clty . cty_params ; generalize_class_type true clty . cty_type ; Option . iter Ctype . generalize clty . cty_new ; List . iter Ctype . generalize obj_abbr . type_params ; Option . iter Ctype . generalize obj_abbr . type_manifest ; List . iter Ctype . generalize cl_abbr . type_params ; Option . iter Ctype . generalize cl_abbr . type_manifest ; if not ( closed_class clty ) then raise ( Error ( cl . pci_loc , env , Non_generalizable_class ( id , clty ) ) ) ; begin match Ctype . closed_class clty . cty_params ( Ctype . signature_of_class_type clty . cty_type ) with None -> ( ) | Some reason -> let printer = if define_class then function ppf -> Printtyp . class_declaration id ppf clty else function ppf -> Printtyp . cltype_declaration id ppf cltydef in raise ( Error ( cl . pci_loc , env , Unbound_type_var ( printer , reason ) ) ) end ; { id ; clty ; ty_id ; cltydef ; obj_id ; obj_abbr ; cl_id ; cl_abbr ; arity ; pub_meths ; coe ; expr ; id_loc = cl . pci_name ; req = { ci_loc = cl . pci_loc ; ci_virt = cl . pci_virt ; ci_params = ci_params ; ci_id_name = cl . pci_name ; ci_id_class = id ; ci_id_class_type = ty_id ; ci_id_object = obj_id ; ci_id_typehash = cl_id ; ci_expr = expr ; ci_decl = clty ; ci_type_decl = cltydef ; ci_attributes = cl . pci_attributes ; } }

let class_infos define_class kind ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) ( res , env ) = Builtin_attributes . warning_scope cl . pci_attributes ( fun ( ) -> class_infos define_class kind ( cl , id , ty_id , obj_id , obj_params , obj_ty , cl_id , cl_params , cl_ty , constr_type , dummy_class ) ( res , env ) )

let extract_type_decls { clty ; cltydef ; obj_id ; obj_abbr ; cl_abbr ; req } decls = ( obj_id , obj_abbr , cl_abbr , clty , cltydef , req ) :: decls

let merge_type_decls decl ( obj_abbr , cl_abbr , clty , cltydef ) = { decl with obj_abbr ; cl_abbr ; clty ; cltydef }

let final_env define_class env { id ; clty ; ty_id ; cltydef ; obj_id ; obj_abbr ; cl_id ; cl_abbr } = Env . add_type ~ check : true obj_id ( Subst . type_declaration Subst . identity obj_abbr ) ( Env . add_type ~ check : true cl_id ( Subst . type_declaration Subst . identity cl_abbr ) ( Env . add_cltype ty_id ( Subst . cltype_declaration Subst . identity cltydef ) ( if define_class then Env . add_class id ( Subst . class_declaration Subst . identity clty ) env else env ) ) )

let check_coercions env { id ; id_loc ; clty ; ty_id ; cltydef ; obj_id ; obj_abbr ; cl_id ; cl_abbr ; arity ; pub_meths ; coe ; req } = begin match coe with [ ] -> ( ) | loc :: _ -> let cl_ty , obj_ty = match cl_abbr . type_manifest , obj_abbr . type_manifest with Some cl_ab , Some obj_ab -> let cl_params , cl_ty = Ctype . instance_parameterized_type cl_abbr . type_params cl_ab and obj_params , obj_ty = Ctype . instance_parameterized_type obj_abbr . type_params obj_ab in List . iter2 ( Ctype . unify env ) cl_params obj_params ; cl_ty , obj_ty | _ -> assert false in begin try Ctype . subtype env cl_ty obj_ty ( ) with Ctype . Subtype ( tr1 , tr2 ) -> raise ( Typecore . Error ( loc , env , Typecore . Not_subtype ( tr1 , tr2 ) ) ) end ; if not ( Ctype . opened_object cl_ty ) then raise ( Error ( loc , env , Cannot_coerce_self obj_ty ) ) end ; { cls_id = id ; cls_id_loc = id_loc ; cls_decl = clty ; cls_ty_id = ty_id ; cls_ty_decl = cltydef ; cls_obj_id = obj_id ; cls_obj_abbr = obj_abbr ; cls_typesharp_id = cl_id ; cls_abbr = cl_abbr ; cls_arity = arity ; cls_pub_methods = pub_meths ; cls_info = req }

let type_classes define_class approx kind env cls = let scope = Ctype . create_scope ( ) in let cls = List . map ( function cl -> ( cl , Ident . create_scoped ~ scope cl . pci_name . txt , Ident . create_scoped ~ scope cl . pci_name . txt , Ident . create_scoped ~ scope cl . pci_name . txt , Ident . create_scoped ~ scope ( " " # ^ cl . pci_name . txt ) ) ) cls in Ctype . begin_class_def ( ) ; let ( res , env ) = List . fold_left ( initial_env define_class approx ) ( [ ] , env ) cls in let ( res , env ) = List . fold_right ( class_infos define_class kind ) res ( [ ] , env ) in Ctype . end_def ( ) ; let res = List . rev_map ( final_decl env define_class ) res in let decls = List . fold_right extract_type_decls res [ ] in let decls = try Typedecl_variance . update_class_decls env decls with Typedecl_variance . Error ( loc , err ) -> raise ( Typedecl . Error ( loc , Typedecl . Variance err ) ) in let res = List . map2 merge_type_decls res decls in let env = List . fold_left ( final_env define_class ) env res in let res = List . map ( check_coercions env ) res in ( res , env )

let class_num = ref 0

let class_declaration env sexpr = incr class_num ; let expr = class_expr ( Int . to_string ! class_num ) env env sexpr in ( expr , expr . cl_type )

let class_description env sexpr = let expr = class_type env sexpr in ( expr , expr . cltyp_type )

let class_declarations env cls = let info , env = type_classes true approx_declaration class_declaration env cls in let ids , exprs = List . split ( List . map ( fun ci -> ci . cls_id , ci . cls_info . ci_expr ) info ) in check_recursive_class_bindings env ids exprs ; info , env

let class_descriptions env cls = type_classes true approx_description class_description env cls

let class_type_declarations env cls = let ( decls , env ) = type_classes false approx_description class_description env cls in ( List . map ( fun decl -> { clsty_ty_id = decl . cls_ty_id ; clsty_id_loc = decl . cls_id_loc ; clsty_ty_decl = decl . cls_ty_decl ; clsty_obj_id = decl . cls_obj_id ; clsty_obj_abbr = decl . cls_obj_abbr ; clsty_typesharp_id = decl . cls_typesharp_id ; clsty_abbr = decl . cls_abbr ; clsty_info = decl . cls_info } ) decls , env )

let rec unify_parents env ty cl = match cl . cl_desc with Tcl_ident ( p , _ , _ ) -> begin try let decl = Env . find_class p env in let _ , body = Ctype . find_cltype_for_path env decl . cty_path in Ctype . unify env ty ( Ctype . instance body ) with Not_found -> ( ) | _exn -> assert false end | Tcl_structure st -> unify_parents_struct env ty st | Tcl_open ( _ , cl ) | Tcl_fun ( _ , _ , _ , cl , _ ) | Tcl_apply ( cl , _ ) | Tcl_let ( _ , _ , _ , cl ) | Tcl_constraint ( cl , _ , _ , _ , _ ) -> unify_parents env ty cl List . iter ( function | { cf_desc = Tcf_inherit ( _ , cl , _ , _ , _ ) } -> unify_parents env ty cl | _ -> ( ) ) st . cstr_fields

let type_object env loc s = incr class_num ; let ( desc , sign ) = class_structure ( Int . to_string ! class_num ) true env env loc s in let sty = Ctype . expand_head env sign . csig_self in Ctype . hide_private_methods sty ; let ( fields , _ ) = Ctype . flatten_fields ( Ctype . object_fields sty ) in let meths = List . map ( fun ( s , _ , _ ) -> s ) fields in unify_parents_struct env sign . csig_self desc ; ( desc , sign , meths )

let ( ) = Typecore . type_object := type_object

let approx_class sdecl = let open Ast_helper in let self ' = Typ . any ( ) in let clty ' = Cty . signature ~ loc : sdecl . pci_expr . pcty_loc ( Csig . mk self ' [ ] ) in { sdecl with pci_expr = clty ' }

let approx_class_declarations env sdecls = fst ( class_type_declarations env ( List . map approx_class sdecls ) )

let report_error env ppf = function | Repeated_parameter -> fprintf ppf " A type parameter occurs several times " | Unconsistent_constraint trace -> fprintf ppf " The class constraints are not consistent . . " ; @ Printtyp . report_unification_error ppf env trace ( fun ppf -> fprintf ppf " Type " ) ( fun ppf -> fprintf ppf " is not compatible with type " ) | Field_type_mismatch ( k , m , trace ) -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " The % s % s @ has type " k m ) ( function ppf -> fprintf ppf " but is expected to have type " ) | Structure_expected clty -> fprintf ppf " [ @ This class expression is not a class structure ; it has type @ % a ] " @ Printtyp . class_type clty | Cannot_apply _ -> fprintf ppf " This class expression is not a class function , it cannot be applied " | Apply_wrong_label l -> let mark_label = function | Nolabel -> " out label " | l -> sprintf " label % s " ( Btype . prefixed_label_name l ) in fprintf ppf " This argument cannot be applied with % s " ( mark_label l ) | Pattern_type_clash ty -> fprintf ppf " [ @% s @ % a ] " @ " This pattern cannot match self : it only matches values of type " Printtyp . type_expr ty | Unbound_class_2 cl -> fprintf ppf " [ @ The class @ % a @ is not yet completely defined ] " @ Printtyp . longident cl | Unbound_class_type_2 cl -> fprintf ppf " [ @ The class type @ % a @ is not yet completely defined ] " @ Printtyp . longident cl | Abbrev_type_clash ( abbrev , actual , expected ) -> Printtyp . reset_and_mark_loops_list [ abbrev ; actual ; expected ] ; fprintf ppf " [ @ The abbreviation @ % a @ expands to type @ % a @ \ but is used with type @ % a ] " @ ! Oprint . out_type ( Printtyp . tree_of_typexp false abbrev ) ! Oprint . out_type ( Printtyp . tree_of_typexp false actual ) ! Oprint . out_type ( Printtyp . tree_of_typexp false expected ) | Constructor_type_mismatch ( c , trace ) -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " The expression " \ new % s " \ has type " c ) ( function ppf -> fprintf ppf " but is used with type " ) | Virtual_class ( cl , imm , mets , vals ) -> let print_mets ppf mets = List . iter ( function met -> fprintf ppf " @ % s " met ) mets in let missings = match mets , vals with [ ] , _ -> " variables " | _ , [ ] -> " methods " | _ -> " methods and variables " in let print_msg ppf = if imm then fprintf ppf " This object has virtual % s " missings else if cl then fprintf ppf " This class should be virtual " else fprintf ppf " This class type should be virtual " in fprintf ppf " [ @% t . @ [ @< 2 > The following % s are undefined :% a ] ] " @@ print_msg missings print_mets ( mets @ vals ) | Parameter_arity_mismatch ( lid , expected , provided ) -> fprintf ppf " [ @ The class constructor % a @ expects % i type argument ( s ) , @ \ but is here applied to % i type argument ( s ) ] " @ Printtyp . longident lid expected provided | Parameter_mismatch trace -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " The type parameter " ) ( function ppf -> fprintf ppf " does not meet its constraint : it should be " ) | Bad_parameters ( id , params , cstrs ) -> Printtyp . reset_and_mark_loops_list [ params ; cstrs ] ; fprintf ppf " [ @ The abbreviation % a @ is used with parameters @ % a @ \ which are incompatible with constraints @ % a ] " @ Printtyp . ident id ! Oprint . out_type ( Printtyp . tree_of_typexp false params ) ! Oprint . out_type ( Printtyp . tree_of_typexp false cstrs ) | Class_match_failure error -> Includeclass . report_error ppf error | Unbound_val lab -> fprintf ppf " Unbound instance variable % s " lab | Unbound_type_var ( printer , reason ) -> let print_common ppf kind ty0 real lab ty = let ty1 = if real then ty0 else Btype . newgenty ( Tobject ( ty0 , ref None ) ) in List . iter Printtyp . mark_loops [ ty ; ty1 ] ; fprintf ppf " The % s % s @ has type ; @< 1 2 >% a @ where @ % a @ is unbound " kind lab ! Oprint . out_type ( Printtyp . tree_of_typexp false ty ) ! Oprint . out_type ( Printtyp . tree_of_typexp false ty0 ) in let print_reason ppf = function | Ctype . CC_Method ( ty0 , real , lab , ty ) -> print_common ppf " method " ty0 real lab ty | Ctype . CC_Value ( ty0 , real , lab , ty ) -> print_common ppf " instance variable " ty0 real lab ty in Printtyp . reset ( ) ; fprintf ppf " [ @< v [ >@ Some type variables are unbound in this type ; :@< 1 2 >% t ] @@ \ [ @% a ] ] " @@ printer print_reason reason | Non_generalizable_class ( id , clty ) -> fprintf ppf " [ @ The type of this class , @ % a , @ \ contains type variables that cannot be generalized ] " @ ( Printtyp . class_declaration id ) clty | Cannot_coerce_self ty -> fprintf ppf " [ @ The type of self cannot be coerced to @ \ the type of the current class :@ % a . . @\ Some occurrences are contravariant ] " @ Printtyp . type_scheme ty | Non_collapsable_conjunction ( id , clty , trace ) -> fprintf ppf " [ @ The type of this class , @ % a , @ \ contains non - collapsible conjunctive types in constraints . @ % t ] " @ ( Printtyp . class_declaration id ) clty ( fun ppf -> Printtyp . report_unification_error ppf env trace ( fun ppf -> fprintf ppf " Type " ) ( fun ppf -> fprintf ppf " is not compatible with type " ) ) | Final_self_clash trace -> Printtyp . report_unification_error ppf env trace ( function ppf -> fprintf ppf " This object is expected to have type " ) ( function ppf -> fprintf ppf " but actually has type " ) | Mutability_mismatch ( _lab , mut ) -> let mut1 , mut2 = if mut = Immutable then " mutable " , " immutable " else " immutable " , " mutable " in fprintf ppf " [ @ The instance variable is % s ; @ it cannot be redefined as % s ] " @ mut1 mut2 | No_overriding ( _ , " " ) -> fprintf ppf " [ @ This inheritance does not override any method @ % s ] " @ " instance variable " | No_overriding ( kind , name ) -> fprintf ppf " [ @ The % s ` % s ' @ has no previous definition ] " @ kind name | Duplicate ( kind , name ) -> fprintf ppf " [ @ The % s ` % s ' @ has multiple definitions in this object ] " @ kind name | Closing_self_type self -> fprintf ppf " [ @ Cannot close type of object literal :@ % a , @\ it has been unified with the self type of a class that is not yet @ \ completely defined . ] " @ Printtyp . type_scheme self

let report_error env ppf err = Printtyp . wrap_printing_env ~ error : true env ( fun ( ) -> report_error env ppf err )

let ( ) = Location . register_error_of_exn ( function | Error ( loc , env , err ) -> Some ( Location . error_of_printer ~ loc ( report_error env ) err ) | Error_forward err -> Some err | _ -> None )

type unary_interval = { upper_bound : Type . t ; lower_bound : Type . t ; }

type callable_parameter_interval = | Top | Singleton of Type . Callable . parameters | Bottom

type tuple_interval = | TopTuple | BottomTuple | SingletonTuple of Type . t Type . OrderedTypes . record

type t = { unaries : unary_interval UnaryVariable . Map . t ; callable_parameters : callable_parameter_interval ParameterVariable . Map . t ; tuple_variadics : tuple_interval TupleVariable . Map . t ; have_fallbacks : Type . Variable . Set . t ; }

let show_map map ~ show_key ~ show_data ~ short_name = if Map . is_empty map then " " else let show ~ key ~ data sofar = Printf . sprintf " % s => % s " ( show_key key ) ( show_data data ) :: sofar in Map . fold map ~ init [ ] : ~ f : show |> String . concat ~ sep " :\ n " |> Format . sprintf " % s : [ % s ] " short_name

let pp format { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } = let unaries = show_map unaries ~ show_key : UnaryVariable . show ~ show_data : show_unary_interval ~ short_name " : un " in let callable_parameters = show_map callable_parameters ~ show_key : ParameterVariable . show ~ show_data : show_callable_parameter_interval ~ short_name " : cb " in let tuple_variadics = show_map tuple_variadics ~ show_key : TupleVariable . show ~ show_data : show_tuple_interval ~ short_name " : variadic_tuple " in let have_fallbacks = Set . to_list have_fallbacks |> List . to_string ~ f : Type . Variable . show |> Format . sprintf " \ nHave Fallbacks to Any : % s " in Format . fprintf format " { % s % s % s % s } " unaries callable_parameters tuple_variadics have_fallbacks

let show annotation = Format . asprintf " % a " pp annotation

let empty = { unaries = UnaryVariable . Map . empty ; callable_parameters = ParameterVariable . Map . empty ; tuple_variadics = TupleVariable . Map . empty ; have_fallbacks = Type . Variable . Set . empty ; }

let exists_in_bounds { unaries ; callable_parameters ; tuple_variadics ; _ } ~ variables = let contains_variable annotation = let contains_unary = Type . Variable . GlobalTransforms . Unary . collect_all annotation |> List . exists ~ f ( : fun variable -> List . mem variables ( Type . Variable . Unary variable ) ~ equal : Type . Variable . equal ) in let contains_parameter_variadic = let parameter_variadic_contained_in_list variable = List . mem variables ( Type . Variable . ParameterVariadic variable ) ~ equal : Type . Variable . equal in Type . Variable . GlobalTransforms . ParameterVariadic . collect_all annotation |> List . exists ~ f : parameter_variadic_contained_in_list in let contains_tuple_variadic = Type . Variable . GlobalTransforms . TupleVariadic . collect_all annotation |> List . exists ~ f ( : fun variable -> List . mem variables ( Type . Variable . TupleVariadic variable ) ~ equal : Type . Variable . equal ) in contains_unary || contains_parameter_variadic || contains_tuple_variadic in let exists_in_interval_bounds { upper_bound ; lower_bound } = contains_variable upper_bound || contains_variable lower_bound in let exists_in_callable_parameter_interval_bounds = function | Singleton parameters -> Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) |> contains_variable | _ -> false in let exists_in_tuple_interval_bound = function | SingletonTuple ordered_type -> Type . Tuple ordered_type |> contains_variable | _ -> false in UnaryVariable . Map . exists unaries ~ f : exists_in_interval_bounds || ParameterVariable . Map . exists callable_parameters ~ f : exists_in_callable_parameter_interval_bounds || TupleVariable . Map . exists tuple_variadics ~ f : exists_in_tuple_interval_bound

module Solution = struct type t = { unaries : Type . t UnaryVariable . Map . t ; callable_parameters : Type . Callable . parameters ParameterVariable . Map . t ; tuple_variadics : Type . t Type . OrderedTypes . record TupleVariable . Map . t ; } let equal left right = UnaryVariable . Map . equal Type . equal left . unaries right . unaries && ParameterVariable . Map . equal Type . Callable . equal_parameters left . callable_parameters right . callable_parameters && TupleVariable . Map . equal ( Type . OrderedTypes . equal_record Type . equal ) left . tuple_variadics right . tuple_variadics let show { unaries ; callable_parameters ; tuple_variadics } = let unaries = show_map unaries ~ show_key : UnaryVariable . show ~ show_data : Type . show ~ short_name " : un " in let callable_parameters = show_map callable_parameters ~ show_key : ParameterVariable . show ~ show_data : Type . Callable . show_parameters ~ short_name " : cb " in let tuple_variadics = show_map tuple_variadics ~ show_key : TupleVariable . show ~ show_data ( : Type . OrderedTypes . show_record Type . pp ) ~ short_name " : variadic_tuple " in Format . sprintf " { % s % s % s } " unaries callable_parameters tuple_variadics let pp format solution = Format . fprintf format " % s " ( show solution ) let empty = { unaries = UnaryVariable . Map . empty ; callable_parameters = ParameterVariable . Map . empty ; tuple_variadics = TupleVariable . Map . empty ; } let instantiate { unaries ; callable_parameters ; tuple_variadics } annotation = let annotation = if UnaryVariable . Map . is_empty unaries then annotation else Type . Variable . GlobalTransforms . Unary . replace_all ( fun variable -> UnaryVariable . Map . find unaries variable ) annotation in let annotation = if ParameterVariable . Map . is_empty callable_parameters then annotation else Type . Variable . GlobalTransforms . ParameterVariadic . replace_all ( fun variable -> ParameterVariable . Map . find callable_parameters variable ) annotation in let annotation = if TupleVariable . Map . is_empty tuple_variadics then annotation else Type . Variable . GlobalTransforms . TupleVariadic . replace_all ( fun variable -> TupleVariable . Map . find tuple_variadics variable ) annotation in annotation let instantiate_single_variable { unaries ; _ } = UnaryVariable . Map . find unaries let instantiate_single_parameter_variadic { callable_parameters ; _ } = ParameterVariable . Map . find callable_parameters let instantiate_ordered_types solution ordered_type = match instantiate solution ( Type . Tuple ordered_type ) with | Type . Tuple instantiated_ordered_type -> instantiated_ordered_type | _ -> failwith " expected Tuple " let instantiate_callable_parameters solution parameters = match instantiate solution ( Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) ) with | Type . Callable { implementation = { parameters ; _ } ; _ } -> parameters | _ -> failwith " instantiate is not preserving callables " let set ( { unaries ; callable_parameters ; tuple_variadics } as solution ) = function | Type . Variable . UnaryPair ( key , data ) -> { solution with unaries = UnaryVariable . Map . set unaries ~ key ~ data } | Type . Variable . ParameterVariadicPair ( key , data ) -> { solution with callable_parameters = ParameterVariable . Map . set callable_parameters ~ key ~ data ; } | Type . Variable . TupleVariadicPair ( key , data ) -> { solution with tuple_variadics = TupleVariable . Map . set tuple_variadics ~ key ~ data } let create = List . fold ~ f : set ~ init : empty end

module type OrderedConstraintsType = sig type order val add_lower_bound : t -> order : order -> pair : Type . Variable . pair -> t option val add_upper_bound : t -> order : order -> pair : Type . Variable . pair -> t option val add_fallback_to_any : t -> Type . Variable . t -> t val solve : t -> order : order -> Solution . t option val extract_partial_solution : t -> order : order -> variables : Type . Variable . t list -> ( t * Solution . t ) option end

module type OrderType = sig type t val always_less_or_equal : t -> left : Type . t -> right : Type . t -> bool val meet : t -> Type . t -> Type . t -> Type . t val join : t -> Type . t -> Type . t -> Type . t end

module OrderedConstraints ( Order : OrderType ) = struct module IntervalContainer = struct module type Interval = sig module Variable : Type . Variable . VariableKind type t val create : ? upper_bound : Variable . domain -> ? lower_bound : Variable . domain -> unit -> t val intersection : t -> t -> order : Order . t -> t option val narrowest_valid_value : t -> order : Order . t -> variable : Variable . t -> Variable . domain option val merge_solution_in : t -> variable : Variable . t -> solution : Solution . t -> t val is_trivial : t -> variable : Variable . t -> bool val free_variables : t -> Type . Variable . t list end module Make ( Interval : Interval ) = struct let add_bound container ~ order ~ variable ~ bound ~ is_lower_bound = if Interval . Variable . equal_domain bound ( Interval . Variable . self_reference variable ) then Some container else let new_constraint = if is_lower_bound then Interval . create ~ lower_bound : bound ( ) else Interval . create ~ upper_bound : bound ( ) in let existing = Map . find container variable |> Option . value ~ default ( : Interval . create ( ) ) in Interval . intersection existing new_constraint ~ order >>= fun intersection -> Interval . narrowest_valid_value intersection ~ order ~ variable >>| fun _ -> Map . set container ~ key : variable ~ data : intersection let merge_solution container ~ solution = Map . mapi container ~ f ( : fun ~ key ~ data -> Interval . merge_solution_in data ~ variable : key ~ solution ) |> Map . filteri ~ f ( : fun ~ key ~ data -> not ( Interval . is_trivial data ~ variable : key ) ) let partition_independent_dependent container ~ with_regards_to = let contains_key { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } key = let has_constraints = match key with | Type . Variable . Unary unary -> Map . mem unaries unary | Type . Variable . ParameterVariadic parameters -> Map . mem callable_parameters parameters | Type . Variable . TupleVariadic variadic -> Map . mem tuple_variadics variadic in has_constraints || Set . mem have_fallbacks key in let is_independent target = Interval . free_variables target |> List . exists ~ f ( : contains_key with_regards_to ) |> not in Map . partition_tf container ~ f : is_independent let add_solution container partial_solution ~ order = let add_solution ~ key : variable ~ data : target = function | Some partial_solution -> Interval . narrowest_valid_value target ~ order ~ variable >>| ( fun value -> Interval . Variable . pair variable value ) >>| Solution . set partial_solution | None -> None in Map . fold container ~ f : add_solution ~ init ( : Some partial_solution ) end end module UnaryTypeInterval = struct module Variable = UnaryVariable type t = unary_interval let lower_bound { lower_bound ; _ } = lower_bound let upper_bound { upper_bound ; _ } = upper_bound let create ( ? upper_bound = Type . Top ) ( ? lower_bound = Type . Bottom ) ( ) = { upper_bound ; lower_bound } let intersection left right ~ order = Some { upper_bound = Order . meet order left . upper_bound right . upper_bound ; lower_bound = Order . join order left . lower_bound right . lower_bound ; } let narrowest_valid_value interval ~ order ~ variable { : UnaryVariable . constraints = exogenous_constraint ; _ } = let lowest_non_bottom_member interval ~ order = let non_empty { upper_bound ; lower_bound } ~ order = Order . always_less_or_equal order ~ left : lower_bound ~ right : upper_bound in Option . some_if ( non_empty interval ~ order ) ( lower_bound interval ) >>| function | Type . Bottom -> upper_bound interval | other -> other in match exogenous_constraint with | Explicit explicits -> let collect annotation sofar = let add_to_explicits_if_safe sofar candidate = match candidate with | { Type . Variable . Unary . constraints = Explicit left_constraints ; _ } as candidate -> let exists_in_explicits left_constraint = List . exists explicits ~ f ( : Type . equal left_constraint ) in if List . for_all left_constraints ~ f : exists_in_explicits then Type . Variable candidate :: sofar else sofar | _ -> sofar in Type . Variable . GlobalTransforms . Unary . collect_all annotation |> List . fold ~ f : add_to_explicits_if_safe ~ init : sofar in let explicits = collect ( lower_bound interval ) explicits |> collect ( upper_bound interval ) in let contains { upper_bound ; lower_bound } candidate ~ order = Order . always_less_or_equal order ~ left : candidate ~ right : upper_bound && Order . always_less_or_equal order ~ left : lower_bound ~ right : candidate in List . find ~ f ( : contains interval ~ order ) explicits | Bound exogenous_bound -> intersection interval ( create ~ upper_bound : exogenous_bound ( ) ) ~ order >>= lowest_non_bottom_member ~ order | Unconstrained -> lowest_non_bottom_member interval ~ order | LiteralIntegers -> ( let is_literal_integer = function | Type . Literal ( Type . Integer _ ) -> true | Variable { constraints = LiteralIntegers ; _ } -> true | _ -> false in let member = lowest_non_bottom_member interval ~ order in match member with | Some found_member when is_literal_integer found_member -> member | Some ( Type . Union union ) when List . for_all union ~ f : is_literal_integer -> member | _ -> None ) let merge_solution_in { upper_bound ; lower_bound } ~ variable ~ solution = let smart_instantiate annotation = let instantiated = Solution . instantiate solution annotation in Option . some_if ( not ( Type . equal instantiated ( Type . Variable variable ) ) ) instantiated in let upper_bound = smart_instantiate upper_bound in let lower_bound = smart_instantiate lower_bound in create ? upper_bound ? lower_bound ( ) let is_trivial interval ~ variable : _ = match interval with | { upper_bound = Type . Top ; lower_bound = Type . Bottom } -> true | _ -> false let free_variables { upper_bound ; lower_bound } = Type . Variable . all_free_variables upper_bound @ Type . Variable . all_free_variables lower_bound end module CallableParametersInterval = struct module Variable = ParameterVariable type t = callable_parameter_interval let create ? upper_bound ? lower_bound ( ) = match upper_bound , lower_bound with | None , None -> Bottom | Some only , None | None , Some only -> Singleton only | Some left , Some right when Type . Callable . equal_parameters left right -> Singleton left | Some _ , Some _ -> Top let narrowest_valid_value interval ~ order : _ ~ variable : _ = match interval with | Top | Bottom -> None | Singleton parameters -> Some parameters let intersection left right ~ order : _ = match left , right with | Top , _ | _ , Top -> Some Top | other , Bottom | Bottom , other -> Some other | Singleton left , Singleton right when Type . Callable . equal_parameters left right -> Some ( Singleton left ) | _ , _ -> Some Top let merge_solution_in target ~ variable : _ ~ solution = match target with | Top | Bottom -> target | Singleton parameters -> ( let callable = Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) in match Solution . instantiate solution callable with | Type . Callable { implementation = { parameters = instantiated_parameters ; _ } ; _ } -> Singleton instantiated_parameters | _ -> failwith " impossible " ) let is_trivial interval ~ variable = match interval with | Singleton ( Type . Callable . ParameterVariadicTypeVariable { head = [ ] ; variable = target_variable } ) -> ParameterVariable . equal variable target_variable | _ -> false let free_variables = function | Top | Bottom -> [ ] | Singleton parameters -> Type . Callable . create ~ parameters ~ annotation : Type . Any ( ) |> Type . Variable . all_free_variables end module TupleInterval = struct module Variable = TupleVariable type t = tuple_interval let create ? upper_bound ? lower_bound ( ) = match lower_bound , upper_bound with | None , None -> BottomTuple | None , Some only | Some only , None -> SingletonTuple only | Some left , Some right when Type . OrderedTypes . equal_record Type . equal left right -> SingletonTuple left | _ -> TopTuple let intersection left right ~ order = match left , right with | TopTuple , _ | _ , TopTuple -> Some TopTuple | other , BottomTuple | BottomTuple , other -> Some other | SingletonTuple left , SingletonTuple right -> if Order . always_less_or_equal order ~ left ( : Type . Tuple left ) ~ right ( : Type . Tuple right ) then Some ( SingletonTuple right ) else if Order . always_less_or_equal order ~ left ( : Type . Tuple right ) ~ right ( : Type . Tuple left ) then Some ( SingletonTuple left ) else None let narrowest_valid_value interval ~ order : _ ~ variable : _ = match interval with | TopTuple | BottomTuple -> None | SingletonTuple ordered_type -> Some ordered_type let merge_solution_in target ~ variable : _ ~ solution = match target with | TopTuple | BottomTuple -> target | SingletonTuple ordered_type -> ( match Solution . instantiate solution ( Type . Tuple ordered_type ) with | Type . Tuple instantiated_ordered_type -> SingletonTuple instantiated_ordered_type | _ -> failwith " impossible " ) let is_trivial interval ~ variable = match interval with | SingletonTuple ( Type . OrderedTypes . Concatenation concatenation ) -> Type . OrderedTypes . Concatenation . extract_sole_variadic concatenation >>| ( fun variadic -> TupleVariable . equal variadic variable ) |> Option . value ~ default : false | _ -> false let free_variables = function | TopTuple | BottomTuple -> [ ] | SingletonTuple ordered_type -> Type . Variable . all_free_variables ( Type . Tuple ordered_type ) end module CallableParametersIntervalContainer = IntervalContainer . Make ( CallableParametersInterval ) module UnaryIntervalContainer = IntervalContainer . Make ( UnaryTypeInterval ) module TupleIntervalContainer = IntervalContainer . Make ( TupleInterval ) type order = Order . t let add_bound ( { unaries ; callable_parameters ; tuple_variadics ; _ } as constraints ) ~ order ~ pair ~ is_lower_bound = match pair with | Type . Variable . UnaryPair ( variable , bound ) -> UnaryIntervalContainer . add_bound unaries ~ order ~ variable ~ bound ~ is_lower_bound >>| fun unaries -> { constraints with unaries } | Type . Variable . ParameterVariadicPair ( variable , bound ) -> CallableParametersIntervalContainer . add_bound callable_parameters ~ order ~ variable ~ bound ~ is_lower_bound >>| fun callable_parameters -> { constraints with callable_parameters } | Type . Variable . TupleVariadicPair ( variable , bound ) -> TupleIntervalContainer . add_bound tuple_variadics ~ order ~ variable ~ bound ~ is_lower_bound >>| fun tuple_variadics -> { constraints with tuple_variadics } let add_lower_bound = add_bound ~ is_lower_bound : true let add_upper_bound = add_bound ~ is_lower_bound : false let add_fallback_to_any ( { have_fallbacks ; _ } as constraints ) addition = { constraints with have_fallbacks = Set . add have_fallbacks addition } let merge_solution { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } solution = { unaries = UnaryIntervalContainer . merge_solution unaries ~ solution ; callable_parameters = CallableParametersIntervalContainer . merge_solution callable_parameters ~ solution ; tuple_variadics = TupleIntervalContainer . merge_solution tuple_variadics ~ solution ; have_fallbacks ; } let apply_fallbacks solution ~ have_fallbacks = let optional_add map key data = match Map . add map ~ key ~ data with | ` Ok map -> map | ` Duplicate -> map in let add_fallback ( { Solution . unaries ; callable_parameters ; tuple_variadics } as solution ) = function | Type . Variable . Unary variable -> { solution with unaries = optional_add unaries variable Type . Any } | Type . Variable . ParameterVariadic variable -> { solution with callable_parameters = optional_add callable_parameters variable Type . Callable . Undefined ; } | Type . Variable . TupleVariadic variadic -> { solution with tuple_variadics = optional_add tuple_variadics variadic TupleVariable . any ; } in Set . to_list have_fallbacks |> List . fold ~ init : solution ~ f : add_fallback let solve constraints ~ order = let rec build_solution ~ remaining_constraints ~ partial_solution = let independent_constraints , dependent_constraints = let independent_unaries , dependent_unaries = UnaryIntervalContainer . partition_independent_dependent remaining_constraints . unaries ~ with_regards_to : remaining_constraints in let independent_tuple_variadics , dependent_tuple_variadics = TupleIntervalContainer . partition_independent_dependent remaining_constraints . tuple_variadics ~ with_regards_to : remaining_constraints in let independent_parameters , dependent_parameters = CallableParametersIntervalContainer . partition_independent_dependent remaining_constraints . callable_parameters ~ with_regards_to : remaining_constraints in let independent_fallbacks , dependent_fallbacks = let matches = function | Type . Variable . Unary key -> not ( Map . mem dependent_unaries key ) | ParameterVariadic key -> not ( Map . mem dependent_parameters key ) | TupleVariadic key -> not ( Map . mem dependent_tuple_variadics key ) in Set . partition_tf remaining_constraints . have_fallbacks ~ f : matches in ( { unaries = independent_unaries ; callable_parameters = independent_parameters ; tuple_variadics = independent_tuple_variadics ; have_fallbacks = independent_fallbacks ; } , { unaries = dependent_unaries ; callable_parameters = dependent_parameters ; tuple_variadics = dependent_tuple_variadics ; have_fallbacks = dependent_fallbacks ; } ) in let handle_dependent_constraints partial_solution = let is_empty { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } = UnaryVariable . Map . is_empty unaries && ParameterVariable . Map . is_empty callable_parameters && TupleVariable . Map . is_empty tuple_variadics && Set . is_empty have_fallbacks in if is_empty dependent_constraints then Some partial_solution else if is_empty independent_constraints then None else let remaining_constraints = merge_solution dependent_constraints partial_solution in build_solution ~ remaining_constraints ~ partial_solution in UnaryIntervalContainer . add_solution independent_constraints . unaries partial_solution ~ order >>= CallableParametersIntervalContainer . add_solution independent_constraints . callable_parameters ~ order >>= TupleIntervalContainer . add_solution independent_constraints . tuple_variadics ~ order >>| apply_fallbacks ~ have_fallbacks : independent_constraints . have_fallbacks >>= handle_dependent_constraints in build_solution ~ remaining_constraints : constraints ~ partial_solution : Solution . empty let extract_partial_solution { unaries ; callable_parameters ; tuple_variadics ; have_fallbacks } ~ order ~ variables = let extracted_constraints , remaining_constraints = let unary_matches ~ key ~ data : _ = List . exists variables ~ f ( : Type . Variable . equal ( Type . Variable . Unary key ) ) in let callable_parameters_matches ~ key ~ data : _ = List . exists variables ~ f ( : Type . Variable . equal ( Type . Variable . ParameterVariadic key ) ) in let tuple_variadic_matches ~ key ~ data : _ = List . exists variables ~ f ( : Type . Variable . equal ( Type . Variable . TupleVariadic key ) ) in let extracted_unaries , remaining_unaries = UnaryVariable . Map . partitioni_tf unaries ~ f : unary_matches in let extracted_variadics , remaining_variadics = ParameterVariable . Map . partitioni_tf callable_parameters ~ f : callable_parameters_matches in let extracted_tuple_variadics , remaining_tuple_variadics = TupleVariable . Map . partitioni_tf tuple_variadics ~ f : tuple_variadic_matches in let extracted_fallbacks , remaining_fallbacks = let matches = function | Type . Variable . Unary key -> unary_matches ~ key ~ data ( ) : | ParameterVariadic key -> callable_parameters_matches ~ key ~ data ( ) : | TupleVariadic key -> tuple_variadic_matches ~ key ~ data ( ) : in Set . partition_tf have_fallbacks ~ f : matches in ( { unaries = extracted_unaries ; callable_parameters = extracted_variadics ; tuple_variadics = extracted_tuple_variadics ; have_fallbacks = extracted_fallbacks ; } , { unaries = remaining_unaries ; callable_parameters = remaining_variadics ; tuple_variadics = remaining_tuple_variadics ; have_fallbacks = remaining_fallbacks ; } ) in solve extracted_constraints ~ order >>| fun solution -> merge_solution remaining_constraints solution , solution end

let empty_head variable = { Type . Callable . head = [ ] ; variable }

let child = Type . Primitive " Child "

let left_parent = Type . Primitive " left_parent "

let right_parent = Type . Primitive " right_parent "

let grandparent = Type . Primitive " Grandparent "

module DiamondOrder = struct type t = unit let rec always_less_or_equal _ ~ left ~ right = match left , right with | _ , _ when Type . equal left right -> true | _ , Type . Top -> true | Type . Bottom , _ -> true | Type . Primitive " Child " , Type . Primitive " left_parent " -> true | Type . Primitive " Child " , Type . Primitive " right_parent " -> true | Type . Primitive " Child " , Type . Primitive " Grandparent " -> true | Type . Primitive " left_parent " , Type . Primitive " Grandparent " -> true | Type . Primitive " right_parent " , Type . Primitive " Grandparent " -> true | left , Union rights -> List . exists rights ~ f ( : fun right -> always_less_or_equal ( ) ~ left ~ right ) | Tuple ( Concrete left ) , Tuple ( Concrete right ) -> ( match List . for_all2 left right ~ f ( : fun left right -> always_less_or_equal ( ) ~ left ~ right ) with | Ok result -> result | _ -> false ) | _ -> false let meet _ left right = match left , right with | left , right when always_less_or_equal ( ) ~ left ~ right -> left | right , left when always_less_or_equal ( ) ~ left ~ right -> left | Type . Primitive " left_parent " , Type . Primitive " right_parent " -> Type . Primitive " Child " | _ -> Type . Bottom let join _ left right = match left , right with | left , right when always_less_or_equal ( ) ~ left ~ right -> right | right , left when always_less_or_equal ( ) ~ left ~ right -> right | Type . Primitive " left_parent " , Type . Primitive " right_parent " -> Type . Primitive " Grandparent " | _ -> Type . Top end

module DiamondOrderedConstraints = OrderedConstraints ( DiamondOrder )

let variable ( ? name = " _V " ) constraints = Type . Variable . Unary . create name ~ constraints

let add_bound constraints bound = let order = ( ) in constraints >>= fun constraints -> match bound with | ` Lower pair -> DiamondOrderedConstraints . add_lower_bound constraints ~ order ~ pair | ` Upper pair -> DiamondOrderedConstraints . add_upper_bound constraints ~ order ~ pair | ` Fallback variable -> DiamondOrderedConstraints . add_fallback_to_any constraints variable |> Option . some

let test_add_bound _ = let assert_add_bound_has_result ( ? preconstraints = Some empty ) bound ~ expected_is_some = let result = add_bound preconstraints bound |> Option . is_some in assert_equal ~ printer ( : Printf . sprintf " % B " ) expected_is_some result in let assert_add_bound_succeeds = assert_add_bound_has_result ~ expected_is_some : true in let assert_add_bound_fails = assert_add_bound_has_result ~ expected_is_some : false in let unconstrained = variable Type . Variable . Unconstrained in assert_add_bound_succeeds ( ` Lower ( UnaryPair ( unconstrained , child ) ) ) ; assert_add_bound_fails ~ preconstraints ( : add_bound ( Some empty ) ( ` Lower ( UnaryPair ( unconstrained , left_parent ) ) ) ) ( ` Upper ( UnaryPair ( unconstrained , right_parent ) ) ) ; assert_add_bound_fails ( ` Lower ( UnaryPair ( variable ( Type . Variable . Bound child ) , left_parent ) ) ) ; assert_add_bound_succeeds ( ` Lower ( UnaryPair ( variable ( Type . Variable . Bound child ) , child ) ) ) ; assert_add_bound_succeeds ( ` Upper ( UnaryPair ( variable ( Type . Variable . Bound child ) , left_parent ) ) ) ; let explicit_parent_a_parent_b = variable ( Type . Variable . Explicit [ left_parent ; right_parent ] ) in assert_add_bound_succeeds ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , left_parent ) ) ) ; assert_add_bound_succeeds ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , right_parent ) ) ) ; assert_add_bound_succeeds ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , Variable ( Type . Variable . Unary . mark_as_bound explicit_parent_a_parent_b ) ) ) ) ; assert_add_bound_succeeds ( ` Upper ( UnaryPair ( explicit_parent_a_parent_b , Variable ( Type . Variable . Unary . mark_as_bound explicit_parent_a_parent_b ) ) ) ) ; assert_add_bound_fails ~ preconstraints : ( add_bound ( Some empty ) ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , left_parent ) ) ) ) ( ` Lower ( UnaryPair ( explicit_parent_a_parent_b , right_parent ) ) ) ; let parameter_variadic = Type . Variable . Variadic . Parameters . create " T " in assert_add_bound_succeeds ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ ] ) ) ) ; let preconstraints = add_bound ( Some empty ) ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ ] ) ) ) in assert_add_bound_succeeds ~ preconstraints ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ ] ) ) ) ; assert_add_bound_fails ~ preconstraints ( ` Lower ( ParameterVariadicPair ( parameter_variadic , Type . Callable . Defined [ Named { name = " x " ; annotation = Type . integer ; default = false } ] ) ) ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let bound = TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) in assert_add_bound_succeeds ( ` Lower bound ) ; let preconstraints = add_bound ( Some empty ) ( ` Lower bound ) in assert_add_bound_succeeds ~ preconstraints ( ` Lower bound ) ; assert_add_bound_fails ~ preconstraints ( ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . bool ; Type . bool ] ) ) ) ; ( )

let optional_map_compare left right = match left , right with | Some left , Some right -> TypeConstraints . Solution . equal left right | None , None -> true | _ , _ -> false

let optional_map_print map = map >>| TypeConstraints . Solution . show |> Option . value ~ default " : None "

let assert_solution ~ sequentially_applied_bounds expected = let result = List . fold sequentially_applied_bounds ~ init ( : Some empty ) ~ f : add_bound >>= DiamondOrderedConstraints . solve ~ order ( ) : in let expected = expected >>| TypeConstraints . Solution . create in assert_equal ~ cmp : optional_map_compare ~ printer : optional_map_print expected result

let test_single_variable_solution _ = assert_solution ~ sequentially_applied_bounds [ ] : ( Some [ ] ) ; let unconstrained = variable Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( unconstrained , child ) ) ] ( Some [ UnaryPair ( unconstrained , child ) ] ) ; assert_solution ~ sequentially_applied_bounds [ ` : Upper ( UnaryPair ( unconstrained , child ) ) ] ( Some [ UnaryPair ( unconstrained , child ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained , child ) ) ; ` Lower ( UnaryPair ( unconstrained , left_parent ) ) ] ( Some [ UnaryPair ( unconstrained , left_parent ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained , left_parent ) ) ; ` Lower ( UnaryPair ( unconstrained , right_parent ) ) ; ] ( Some [ UnaryPair ( unconstrained , grandparent ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( unconstrained , left_parent ) ) ; ` Lower ( UnaryPair ( unconstrained , grandparent ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds [ ` : Upper ( UnaryPair ( unconstrained , Type . Variable unconstrained ) ) ] ( Some [ ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( unconstrained , Type . list ( Type . Variable unconstrained ) ) ) ] None ; let bounded_by_parent_A = variable ( Type . Variable . Bound left_parent ) in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( bounded_by_parent_A , child ) ) ] ( Some [ UnaryPair ( bounded_by_parent_A , child ) ] ) ; assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( bounded_by_parent_A , right_parent ) ) ] None ; let explicit_int_string_parent_A = variable ( Type . Variable . Explicit [ Type . integer ; Type . string ; left_parent ] ) in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( explicit_int_string_parent_A , child ) ) ] ( Some [ UnaryPair ( explicit_int_string_parent_A , left_parent ) ] ) ; assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( explicit_int_string_parent_A , grandparent ) ) ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ; ] ( Some [ UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ; ] ( Some [ UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( explicit_int_string_parent_A , Type . optional ( Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Upper ( UnaryPair ( explicit_int_string_parent_A , Type . optional ( Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ) ) ; ] ( Some [ UnaryPair ( explicit_int_string_parent_A , Variable ( Type . Variable . Unary . mark_as_bound explicit_int_string_parent_A ) ) ; ] ) ; let parameter_variadic = Type . Variable . Variadic . Parameters . create " T " in let empty_parameters = Type . Callable . Defined [ ] in let one_named_parameter = Type . Callable . Defined [ Named { name = " x " ; annotation = Type . integer ; default = false } ] in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameter_variadic , empty_parameters ) ) ] ( Some [ ParameterVariadicPair ( parameter_variadic , empty_parameters ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameter_variadic , empty_parameters ) ) ; ` Lower ( ParameterVariadicPair ( parameter_variadic , one_named_parameter ) ) ; ] None ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . string ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . bool ] ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Child " ; Type . Primitive " Child " ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Grandparent " ; Type . Primitive " Grandparent " ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Grandparent " ; Type . Primitive " Grandparent " ] ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Child " ; Type . Primitive " Grandparent " ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Grandparent " ; Type . Primitive " Child " ] ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . Primitive " Child " ] ) ) ; ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . string ] ) ) ; ] None ; ( )

let test_multiple_variable_solution _ = let unconstrained_a = variable ~ name " : A " Type . Variable . Unconstrained in let unconstrained_b = variable ~ name " : B " Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , child ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , child ) ; UnaryPair ( unconstrained_b , child ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ] None ; let unconstrained_c = variable ~ name " : C " Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_c ) ) ; ` Lower ( UnaryPair ( unconstrained_c , child ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , child ) ; UnaryPair ( unconstrained_b , child ) ; UnaryPair ( unconstrained_c , child ) ; ] ) ; let unrelated = variable ~ name " : unrelated " Type . Variable . Unconstrained in assert_solution ~ sequentially_applied_bounds [ ` : Lower ( UnaryPair ( unconstrained_a , Type . Variable unrelated ) ) ] ( Some [ UnaryPair ( unconstrained_a , Type . Variable unrelated ) ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ` Lower ( UnaryPair ( unconstrained_c , child ) ) ; ] None ; let parameters_a = Type . Variable . Variadic . Parameters . create " Ta " in let parameters_b = Type . Variable . Variadic . Parameters . create " Tb " in let empty_parameters = Type . Callable . Defined [ ] in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ) ; ` Lower ( ParameterVariadicPair ( parameters_b , empty_parameters ) ) ; ] ( Some [ ParameterVariadicPair ( parameters_a , empty_parameters ) ; ParameterVariadicPair ( parameters_b , empty_parameters ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ) ; ` Lower ( ParameterVariadicPair ( parameters_b , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_a ) ) ) ; ] None ; let parameters_with_unconstrained_a = Type . Callable . Defined [ Named { name = " x " ; annotation = Type . Variable unconstrained_a ; default = false } ] in let parameters_with_integer = Type . Callable . Defined [ Named { name = " x " ; annotation = Type . integer ; default = false } ] in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , parameters_with_unconstrained_a ) ) ; ` Lower ( UnaryPair ( unconstrained_a , Type . integer ) ) ; ] ( Some [ ParameterVariadicPair ( parameters_a , parameters_with_integer ) ; UnaryPair ( unconstrained_a , Type . integer ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , parameters_with_unconstrained_a ) ) ; ` Lower ( UnaryPair ( unconstrained_a , Type . Callable . create ~ parameters ( : Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_a ) ) ~ annotation : Type . integer ( ) ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Fallback ( Unary unconstrained_b ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . Any ) ; UnaryPair ( unconstrained_b , Type . Any ) ] ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let variadic2 = Type . Variable . Variadic . Tuple . create " Ts2 " in assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . integer ] ~ suffix [ : Type . string ] variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . bool ; Type . string ] ) ; TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic ) ) ) ; ] None ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . Variable unconstrained_a ] ~ suffix [ : Type . string ] variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ) ; ` Lower ( UnaryPair ( unconstrained_a , Type . integer ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . integer ) ; TupleVariadicPair ( variadic , Type . OrderedTypes . Concrete [ Type . integer ; Type . bool ; Type . string ] ) ; TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concrete [ Type . bool ] ) ; ] ) ; assert_solution ~ sequentially_applied_bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . integer ] ~ suffix [ : Type . string ] variadic2 ) ) ) ; ` Fallback ( TupleVariadic variadic2 ) ; ] ( Some [ TupleVariadicPair ( variadic , Concatenation ( Type . OrderedTypes . Concatenation . create_from_unbounded_element ~ prefix [ : Type . integer ] ~ suffix [ : Type . string ] Type . Any ) ) ; TupleVariadicPair ( variadic2 , Concatenation ( Type . OrderedTypes . Concatenation . create_from_unbounded_element Type . Any ) ) ; ] ) ; ( )

let test_partial_solution _ = let expect_split_solution ~ bounds ~ variables expected_partial_solution expected_remainder_solution = let partial_result , remainder_solution = List . fold bounds ~ init ( : Some empty ) ~ f : add_bound >>= DiamondOrderedConstraints . extract_partial_solution ~ order ( ) : ~ variables >>| ( fun ( remainder , partial_solution ) -> Some partial_solution , DiamondOrderedConstraints . solve ~ order ( ) : remainder ) |> Option . value ~ default ( : None , None ) in let parse expected = expected >>| TypeConstraints . Solution . create in let double_compare ( left_first , left_second ) ( right_first , right_second ) = optional_map_compare left_first right_first && optional_map_compare left_second right_second in let double_print ( first , second ) = Printf . sprintf " % s ; % s " ( optional_map_print first ) ( optional_map_print second ) in assert_equal ~ cmp : double_compare ~ printer : double_print ( parse expected_partial_solution , parse expected_remainder_solution ) ( partial_result , remainder_solution ) in let unconstrained_a = variable ~ name " : A " Type . Variable . Unconstrained in let unconstrained_b = variable ~ name " : B " Type . Variable . Unconstrained in let unconstrained_c = variable ~ name " : C " Type . Variable . Unconstrained in expect_split_solution ~ variables [ : Type . Variable . Unary unconstrained_a ] ~ bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ] ) ( Some [ ] ) ; expect_split_solution ~ variables [ : Type . Variable . Unary unconstrained_a ] ~ bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . list ( Type . Variable unconstrained_b ) ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_a ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . list ( Type . Variable unconstrained_b ) ) ] ) None ; expect_split_solution ~ variables [ : Type . Variable . Unary unconstrained_a ] ~ bounds : [ ` Lower ( UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ) ; ` Lower ( UnaryPair ( unconstrained_b , Type . Variable unconstrained_c ) ) ; ` Lower ( UnaryPair ( unconstrained_c , Type . Variable unconstrained_b ) ) ; ] ( Some [ UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) ] ) None ; let parameters_a = Type . Variable . Variadic . Parameters . create " Ta " in let parameters_b = Type . Variable . Variadic . Parameters . create " Tb " in expect_split_solution ~ variables [ : Type . Variable . ParameterVariadic parameters_a ] ~ bounds : [ ` Lower ( ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ) ; ` Lower ( ParameterVariadicPair ( parameters_b , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_a ) ) ) ; ] ( Some [ ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) ; ] ) ( Some [ ] ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let variadic2 = Type . Variable . Variadic . Tuple . create " Ts2 " in expect_split_solution ~ variables [ : Type . Variable . TupleVariadic variadic ] ~ bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic ) ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ; ] ) ( Some [ ] ) ; expect_split_solution ~ variables [ : Type . Variable . TupleVariadic variadic ] ~ bounds : [ ` Lower ( TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ) ; ` Lower ( TupleVariadicPair ( variadic2 , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . integer ] ~ suffix [ ] : variadic ) ) ) ; ] ( Some [ TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ ] : ~ suffix [ ] : variadic2 ) ) ; ] ) None ; ( )

let test_exists _ = let order = ( ) in let unconstrained_a = variable ~ name " : A " Type . Variable . Unconstrained in let unconstrained_b = variable ~ name " : B " Type . Variable . Unconstrained in let constraints_with_unconstrained_b = let pair = Type . Variable . UnaryPair ( unconstrained_a , Type . Variable unconstrained_b ) in DiamondOrderedConstraints . add_lower_bound TypeConstraints . empty ~ order ~ pair |> function | Some constraints -> constraints | None -> failwith " add bound failed " in assert_true ( TypeConstraints . exists_in_bounds constraints_with_unconstrained_b ~ variables [ : Type . Variable . Unary unconstrained_b ] ) ; assert_false ( TypeConstraints . exists_in_bounds constraints_with_unconstrained_b ~ variables [ : Type . Variable . Unary unconstrained_a ] ) ; let parameters_a = Type . Variable . Variadic . Parameters . create " Ta " in let parameters_b = Type . Variable . Variadic . Parameters . create " Tb " in let constraints_with_parameters_b = let pair = Type . Variable . ParameterVariadicPair ( parameters_a , Type . Callable . ParameterVariadicTypeVariable ( empty_head parameters_b ) ) in DiamondOrderedConstraints . add_lower_bound TypeConstraints . empty ~ order ~ pair |> fun constraints_option -> Option . value_exn constraints_option in assert_true ( TypeConstraints . exists_in_bounds constraints_with_parameters_b ~ variables [ : Type . Variable . ParameterVariadic parameters_b ] ) ; assert_false ( TypeConstraints . exists_in_bounds constraints_with_parameters_b ~ variables [ : Type . Variable . ParameterVariadic parameters_a ] ) ; let variadic = Type . Variable . Variadic . Tuple . create " Ts " in let variadic2 = Type . Variable . Variadic . Tuple . create " Ts2 " in let constraints_with_variadic2_in_bounds = let pair = TupleVariadicPair ( variadic , Type . OrderedTypes . Concatenation ( Type . OrderedTypes . Concatenation . create ~ prefix [ : Type . Variable unconstrained_a ] ~ suffix [ : Type . string ] variadic2 ) ) in DiamondOrderedConstraints . add_lower_bound TypeConstraints . empty ~ order ~ pair |> fun constraints_option -> Option . value_exn constraints_option in assert_true ( TypeConstraints . exists_in_bounds constraints_with_variadic2_in_bounds ~ variables [ : Type . Variable . TupleVariadic variadic2 ] ) ; assert_false ( TypeConstraints . exists_in_bounds constraints_with_variadic2_in_bounds ~ variables [ : Type . Variable . TupleVariadic variadic ] ) ; assert_true ( TypeConstraints . exists_in_bounds constraints_with_variadic2_in_bounds ~ variables [ : Type . Variable . Unary unconstrained_a ] ) ; ( )

let ( ) = " constraints " >::: [ " add_bound " >:: test_add_bound ; " single_variable " >:: test_single_variable_solution ; " multiple_variables " >:: test_multiple_variable_solution ; " partial_solution " >:: test_partial_solution ; " exists " >:: test_exists ; ] |> Test . run

type type_expected = { ty : type_expr ; explanation : type_forcing_context option ; }

type error = | Constructor_arity_mismatch of Longident . t * int * int | Label_mismatch of Longident . t * Ctype . Unification_trace . t | Pattern_type_clash of Ctype . Unification_trace . t * pattern_desc option | Or_pattern_type_clash of Ident . t * Ctype . Unification_trace . t | Multiply_bound_variable of string | Orpat_vars of Ident . t * Ident . t list | Expr_type_clash of Ctype . Unification_trace . t * type_forcing_context option * expression_desc option | Apply_non_function of type_expr | Apply_wrong_label of arg_label * type_expr | Label_multiply_defined of string | Label_missing of Ident . t list | Label_not_mutable of Longident . t | Wrong_name of string * type_expected * string * Path . t * string * string list | Name_type_mismatch of string * Longident . t * ( Path . t * Path . t ) * ( Path . t * Path . t ) list | Invalid_format of string | Undefined_method of type_expr * string * string list option | Undefined_inherited_method of string * string list | Virtual_class of Longident . t | Private_type of type_expr | Private_label of Longident . t * type_expr | Private_constructor of constructor_description * type_expr | Unbound_instance_variable of string * string list | Instance_variable_not_mutable of string | Not_subtype of Ctype . Unification_trace . t * Ctype . Unification_trace . t | Outside_class | Value_multiply_overridden of string | Coercion_failure of type_expr * type_expr * Ctype . Unification_trace . t * bool | Too_many_arguments of bool * type_expr * type_forcing_context option | Abstract_wrong_label of arg_label * type_expr * type_forcing_context option | Scoping_let_module of string * type_expr | Not_a_variant_type of Longident . t | Incoherent_label_order | Less_general of string * Ctype . Unification_trace . t | Modules_not_allowed | Cannot_infer_signature | Not_a_packed_module of type_expr | Unexpected_existential of existential_restriction * string * string list | Invalid_interval | Invalid_for_loop_index | No_value_clauses | Exception_pattern_disallowed | Mixed_value_and_exception_patterns_under_guard | Inlined_record_escape | Inlined_record_expected | Unrefuted_pattern of pattern | Invalid_extension_constructor_payload | Not_an_extension_constructor | Literal_overflow of string | Unknown_literal of string * char | Illegal_letrec_pat | Illegal_letrec_expr | Illegal_class_expr | Empty_pattern | Letop_type_clash of string * Ctype . Unification_trace . t | Andop_type_clash of string * Ctype . Unification_trace . t | Bindings_type_clash of Ctype . Unification_trace . t

let type_module = ref ( ( fun _env _md -> assert false ) : Env . t -> Parsetree . module_expr -> Typedtree . module_expr )

let type_open : ( ? used_slot : bool ref -> override_flag -> Env . t -> Location . t -> Longident . t loc -> Path . t * Env . t ) ref = ref ( fun ? used_slot : _ _ -> assert false )

let type_open_decl : ( ? used_slot : bool ref -> Env . t -> Parsetree . open_declaration -> open_declaration * Types . signature * Env . t ) ref = ref ( fun ? used_slot : _ _ -> assert false )

let type_package = ref ( fun _ -> assert false )

let type_object = ref ( fun _env _s -> assert false : Env . t -> Location . t -> Parsetree . class_structure -> Typedtree . class_structure * Types . class_signature * string list )

let re node = Cmt_format . add_saved_type ( Cmt_format . Partial_expression node ) ; Stypes . record ( Stypes . Ti_expr node ) ; node ; ;

let rp node = Cmt_format . add_saved_type ( Cmt_format . Partial_pattern node ) ; Stypes . record ( Stypes . Ti_pat node ) ; node ; ;

type recarg = | Allowed | Required | Rejected

let mk_expected ? explanation ty = { ty ; explanation ; }

let case lhs rhs = { c_lhs = lhs ; c_guard = None ; c_rhs = rhs }

let type_constant = function Const_int _ -> instance Predef . type_int | Const_char _ -> instance Predef . type_char | Const_string _ -> instance Predef . type_string | Const_float _ -> instance Predef . type_float | Const_int32 _ -> instance Predef . type_int32 | Const_int64 _ -> instance Predef . type_int64 | Const_nativeint _ -> instance Predef . type_nativeint

let constant : Parsetree . constant -> ( Asttypes . constant , error ) result = function | Pconst_integer ( i , None ) -> begin try Ok ( Const_int ( Misc . Int_literal_converter . int i ) ) with Failure _ -> Error ( Literal_overflow " int " ) end | Pconst_integer ( i , Some ' l ' ) -> begin try Ok ( Const_int32 ( Misc . Int_literal_converter . int32 i ) ) with Failure _ -> Error ( Literal_overflow " int32 " ) end | Pconst_integer ( i , Some ' L ' ) -> begin try Ok ( Const_int64 ( Misc . Int_literal_converter . int64 i ) ) with Failure _ -> Error ( Literal_overflow " int64 " ) end | Pconst_integer ( i , Some ' n ' ) -> begin try Ok ( Const_nativeint ( Misc . Int_literal_converter . nativeint i ) ) with Failure _ -> Error ( Literal_overflow " nativeint " ) end | Pconst_integer ( i , Some c ) -> Error ( Unknown_literal ( i , c ) ) | Pconst_char c -> Ok ( Const_char c ) | Pconst_string ( s , d ) -> Ok ( Const_string ( s , d ) ) | Pconst_float ( f , None ) -> Ok ( Const_float f ) | Pconst_float ( f , Some c ) -> Error ( Unknown_literal ( f , c ) )

let constant_or_raise env loc cst = match constant cst with | Ok c -> c | Error err -> raise ( Error ( loc , env , err ) )

let type_option ty = newty ( Tconstr ( Predef . path_option , [ ty ] , ref Mnil ) )

let mkexp exp_desc exp_type exp_loc exp_env = { exp_desc ; exp_type ; exp_loc ; exp_env ; exp_extra = [ ] ; exp_attributes = [ ] }

let option_none env ty loc = let lid = Longident . Lident " None " in let cnone = Env . find_ident_constructor Predef . ident_none env in mkexp ( Texp_construct ( mknoloc lid , cnone , [ ] ) ) ty loc env

let option_some env texp = let lid = Longident . Lident " Some " in let csome = Env . find_ident_constructor Predef . ident_some env in mkexp ( Texp_construct ( mknoloc lid , csome , [ texp ] ) ) ( type_option texp . exp_type ) texp . exp_loc texp . exp_env

let extract_option_type env ty = match expand_head env ty with { desc = Tconstr ( path , [ ty ] , _ ) } when Path . same path Predef . path_option -> ty | _ -> assert false

let extract_concrete_record env ty = match extract_concrete_typedecl env ty with ( p0 , p , { type_kind = Type_record ( fields , _ ) } ) -> ( p0 , p , fields ) | _ -> raise Not_found