text stringlengths 12 786k |
|---|
let ctor_args iter = function | Tctor_tuple typs -> List . iter ~ f ( : iter . type_expr iter ) typs | Tctor_record fields -> List . iter ~ f ( : iter . field_decl iter ) fields |
let ctor_decl iter { ctor_ident ; ctor_args ; ctor_ret ; ctor_loc ; ctor_ctor } = iter . location iter ctor_loc ; ident iter ctor_ident ; iter . ctor_args iter ctor_args ; Option . iter ~ f ( : iter . type_expr iter ) ctor_ret ; ignore ctor_ctor |
let type_decl iter { tdec_ident ; tdec_params ; tdec_desc ; tdec_loc ; tdec_tdec } = iter . location iter tdec_loc ; ident iter tdec_ident ; List . iter ~ f ( : iter . type_expr iter ) tdec_params ; iter . type_decl_desc iter tdec_desc ; ignore tdec_tdec |
let type_decl_desc iter = function | Tdec_abstract -> ( ) | Tdec_alias typ -> iter . type_expr iter typ | Tdec_record fields -> List . iter ~ f ( : iter . field_decl iter ) fields | Tdec_variant ctors -> List . iter ~ f ( : iter . ctor_decl iter ) ctors | Tdec_open -> ( ) | Tde... |
let literal ( _iter : iterator ) ( _ : literal ) = ( ) |
let pattern iter { pat_desc ; pat_loc ; pat_type } = iter . location iter pat_loc ; iter . type0_expr iter pat_type ; iter . pattern_desc iter pat_desc |
let pattern_desc iter = function | Tpat_any -> ( ) | Tpat_variable name -> ident iter name | Tpat_constraint ( pat , typ ) -> iter . type_expr iter typ ; iter . pattern iter pat | Tpat_tuple pats -> List . iter ~ f ( : iter . pattern iter ) pats | Tpat_or ( p1 , p2 ) -> iter .... |
let expression iter { exp_desc ; exp_loc ; exp_type } = iter . location iter exp_loc ; iter . type0_expr iter exp_type ; iter . expression_desc iter exp_desc |
let expression_desc iter = function | Texp_apply ( e , args ) -> iter . expression iter e ; List . iter args ~ f ( : fun ( _explicit , _label , e ) -> iter . expression iter e ) | Texp_variable name -> path iter name | Texp_literal l -> iter . literal iter l | Texp_fun ( _labe... |
let convert_body iter { conv_body_desc ; conv_body_loc ; conv_body_type } = iter . location iter conv_body_loc ; iter . type0_expr iter conv_body_type ; iter . convert_body_desc iter conv_body_desc |
let convert_body_desc iter = function | Tconv_record fields -> List . iter fields ~ f ( : fun ( field , conv ) -> path iter field ; iter . convert_body iter conv ) | Tconv_ctor ( name , args ) -> path iter name ; List . iter args ~ f ( : fun ( _label , conv ) -> iter . co... |
let convert iter { conv_desc ; conv_loc ; conv_type } = iter . location iter conv_loc ; iter . type0_expr iter conv_type ; iter . convert_desc iter conv_desc |
let convert_desc iter = function | Tconv_fun ( name , body ) -> ident iter name ; iter . convert iter body | Tconv_body body -> iter . convert_body iter body |
let type_conv iter = function | Ttconv_with ( _mode , decl ) -> iter . type_decl iter decl | Ttconv_to typ -> iter . type_expr iter typ |
let signature iter = List . iter ~ f ( : iter . signature_item iter ) |
let signature_item iter { sig_desc ; sig_loc } = iter . location iter sig_loc ; iter . signature_desc iter sig_desc |
let signature_desc iter = function | Tsig_value ( name , typ ) | Tsig_instance ( name , typ ) -> ident iter name ; iter . type_expr iter typ | Tsig_type decl -> iter . type_decl iter decl | Tsig_convtype ( decl , tconv , convname , typ ) -> iter . type_decl iter decl ; type_conv ... |
let module_sig iter { msig_desc ; msig_loc } = iter . location iter msig_loc ; iter . module_sig_desc iter msig_desc |
let module_sig_desc iter = function | Tmty_sig sigs -> iter . signature iter sigs | Tmty_name name -> path iter name | Tmty_alias name -> path iter name | Tmty_abstract -> ( ) | Tmty_functor ( name , fsig , msig ) -> str iter name ; iter . module_sig iter fsig ; iter . module_sig iter m... |
let statements iter = List . iter ~ f ( : iter . statement iter ) |
let statement iter { stmt_desc ; stmt_loc } = iter . location iter stmt_loc ; iter . statement_desc iter stmt_desc |
let statement_desc iter = function | Tstmt_value ( p , e ) -> iter . pattern iter p ; iter . expression iter e | Tstmt_instance ( name , e ) -> ident iter name ; iter . expression iter e | Tstmt_type decl -> iter . type_decl iter decl | Tstmt_convtype ( decl , tconv , convname , ... |
let module_expr iter { mod_desc ; mod_loc } = iter . location iter mod_loc ; iter . module_desc iter mod_desc |
let module_desc iter = function | Tmod_struct stmts -> iter . statements iter stmts | Tmod_name name -> path iter name | Tmod_functor ( name , fsig , me ) -> str iter name ; iter . module_sig iter fsig ; iter . module_expr iter me |
let location ( _iter : iterator ) ( _ : Location . t ) = ( ) |
let longident iter = function | Longident . Lident _ -> ( ) | Ldot ( l , _ ) -> iter . longident iter l | Lapply ( l1 , l2 ) -> iter . longident iter l1 ; iter . longident iter l2 |
let path iter = function | Path . Pident ident -> iter . ident iter ident | Path . Pdot ( path , _ , _ ) | Path . Pocamldot ( path , _ , _ , _ ) -> iter . path iter path | Path . Papply ( path1 , path2 ) -> iter . path iter path1 ; iter . path iter path2 |
let ident ( _iter : iterator ) ( _ : Ident . t ) = ( ) |
let type0_decl ( _iter : iterator ) ( _ : Type0 . type_decl ) = ( ) |
let type0_expr ( _iter : iterator ) ( _ : Type0 . type_expr ) = ( ) |
let default_iterator = { type_expr ; type_desc ; variant ; row_tag ; field_decl ; ctor_args ; ctor_decl ; type_decl ; type_decl_desc ; literal ; pattern ; pattern_desc ; expression ; expression_desc ; convert_body ; convert_body_desc ; convert ; convert_desc ; signature_item ; s... |
type mapper = { type_expr : mapper -> type_expr -> type_expr ; type_desc : mapper -> type_desc -> type_desc ; variant : mapper -> variant -> variant ; row_tag : mapper -> row_tag -> row_tag ; field_decl : mapper -> field_decl -> field_decl ; ctor_args : mapper -> ctor_args -> ctor_args ; ... |
let with_backtrack_replace f = let snap = Type1 . Snapshot . create ( ) in let ret = f ( ) in Type1 . backtrack_replace snap ; ret |
let lid mapper { Location . txt ; loc } = { Location . txt = mapper . longident mapper txt ; loc = mapper . location mapper loc } |
let str mapper ( { Location . txt ; loc } : str ) = { Location . txt ; loc = mapper . location mapper loc } |
let ident mapper ( { Location . txt ; loc } : Ident . t Location . loc ) = { Location . txt = mapper . ident mapper txt ; loc = mapper . location mapper loc } |
let path mapper ( { Location . txt ; loc } : Path . t Location . loc ) = { Location . txt = mapper . path mapper txt ; loc = mapper . location mapper loc } |
let type_expr mapper { type_desc ; type_loc ; type_type } = let type_loc = mapper . location mapper type_loc in let type_desc = mapper . type_desc mapper type_desc in let type_type = with_backtrack_replace ( fun ( ) -> mapper . type0 . type_expr mapper . type0 type_type ) in { type_desc... |
let type_desc mapper typ = match typ with | Ttyp_var name -> Ttyp_var ( Option . map ~ f ( : str mapper ) name ) | Ttyp_tuple typs -> Ttyp_tuple ( List . map ~ f ( : mapper . type_expr mapper ) typs ) | Ttyp_arrow ( typ1 , typ2 , explicit , label ) -> Ttyp_arrow ( mapper . ... |
let variant mapper { var_ident ; var_params } = { var_ident = path mapper var_ident ; var_params = List . map ~ f ( : mapper . type_expr mapper ) var_params } |
let row_tag mapper { rtag_ident ; rtag_arg ; rtag_loc } = { rtag_ident = ident mapper rtag_ident ; rtag_arg = List . map ~ f ( : mapper . type_expr mapper ) rtag_arg ; rtag_loc = mapper . location mapper rtag_loc } |
let field_decl mapper { fld_ident ; fld_type ; fld_loc ; fld_fld } = { fld_loc = mapper . location mapper fld_loc ; fld_ident = ident mapper fld_ident ; fld_type = mapper . type_expr mapper fld_type ; fld_fld = with_backtrack_replace ( fun ( ) -> mapper . type0 . field_decl mapper ... |
let ctor_args mapper = function | Tctor_tuple typs -> Tctor_tuple ( List . map ~ f ( : mapper . type_expr mapper ) typs ) | Tctor_record fields -> Tctor_record ( List . map ~ f ( : mapper . field_decl mapper ) fields ) |
let ctor_decl mapper { ctor_ident ; ctor_args ; ctor_ret ; ctor_loc ; ctor_ctor } = { ctor_loc = mapper . location mapper ctor_loc ; ctor_ident = ident mapper ctor_ident ; ctor_args = mapper . ctor_args mapper ctor_args ; ctor_ret = Option . map ~ f ( : mapper . type_expr mapper ) ... |
let type_decl mapper { tdec_ident ; tdec_params ; tdec_desc ; tdec_loc ; tdec_tdec } = { tdec_loc = mapper . location mapper tdec_loc ; tdec_ident = ident mapper tdec_ident ; tdec_params = List . map ~ f ( : mapper . type_expr mapper ) tdec_params ; tdec_desc = mapper . type_decl_... |
let type_decl_desc mapper = function | Tdec_abstract -> Tdec_abstract | Tdec_alias typ -> Tdec_alias ( mapper . type_expr mapper typ ) | Tdec_record fields -> Tdec_record ( List . map ~ f ( : mapper . field_decl mapper ) fields ) | Tdec_variant ctors -> Tdec_variant ( List . map ~ f ( ... |
let literal ( _iter : mapper ) ( l : literal ) = l |
let pattern mapper { pat_desc ; pat_loc ; pat_type } = { pat_loc = mapper . location mapper pat_loc ; pat_desc = mapper . pattern_desc mapper pat_desc ; pat_type = with_backtrack_replace ( fun ( ) -> mapper . type0 . type_expr mapper . type0 pat_type ) } |
let pattern_desc mapper = function | Tpat_any -> Tpat_any | Tpat_variable name -> Tpat_variable ( ident mapper name ) | Tpat_constraint ( pat , typ ) -> Tpat_constraint ( mapper . pattern mapper pat , mapper . type_expr mapper typ ) | Tpat_tuple pats -> Tpat_tuple ( List . map ~ f ( ... |
let convert_body mapper { conv_body_desc ; conv_body_loc ; conv_body_type } = { conv_body_loc = mapper . location mapper conv_body_loc ; conv_body_desc = mapper . convert_body_desc mapper conv_body_desc ; conv_body_type = mapper . type0 . type_expr mapper . type0 conv_body_type } |
let convert_body_desc mapper = function | Tconv_record fields -> Tconv_record ( List . map fields ~ f ( : fun ( name , conv ) -> ( path mapper name , mapper . convert_body mapper conv ) ) ) | Tconv_ctor ( name , args ) -> Tconv_ctor ( path mapper name , List . map args ~ f (... |
let convert mapper { conv_desc ; conv_loc ; conv_type } = { conv_loc = mapper . location mapper conv_loc ; conv_desc = mapper . convert_desc mapper conv_desc ; conv_type = mapper . type0 . type_expr mapper . type0 conv_type } |
let convert_desc mapper = function | Tconv_fun ( name , conv ) -> Tconv_fun ( ident mapper name , mapper . convert mapper conv ) | Tconv_body conv -> Tconv_body ( mapper . convert_body mapper conv ) |
let expression mapper { exp_desc ; exp_loc ; exp_type } = { exp_loc = mapper . location mapper exp_loc ; exp_desc = mapper . expression_desc mapper exp_desc ; exp_type = with_backtrack_replace ( fun ( ) -> mapper . type0 . type_expr mapper . type0 exp_type ) } |
let expression_desc mapper = function | Texp_apply ( e , args ) -> Texp_apply ( mapper . expression mapper e , List . map args ~ f ( : fun ( explicit , label , e ) -> ( explicit , label , mapper . expression mapper e ) ) ) | Texp_variable name -> Texp_variable ( path mapp... |
let type_conv mapper = function | Ttconv_with ( mode , decl ) -> Ttconv_with ( mode , mapper . type_decl mapper decl ) | Ttconv_to typ -> Ttconv_to ( mapper . type_expr mapper typ ) |
let signature mapper = List . map ~ f ( : mapper . signature_item mapper ) |
let signature_item mapper { sig_desc ; sig_loc } = { sig_loc = mapper . location mapper sig_loc ; sig_desc = mapper . signature_desc mapper sig_desc } |
let signature_desc mapper = function | Tsig_value ( name , typ ) -> Tsig_value ( ident mapper name , mapper . type_expr mapper typ ) | Tsig_instance ( name , typ ) -> Tsig_instance ( ident mapper name , mapper . type_expr mapper typ ) | Tsig_type decl -> Tsig_type ( mapper . type_... |
let module_sig mapper { msig_desc ; msig_loc } = { msig_loc = mapper . location mapper msig_loc ; msig_desc = mapper . module_sig_desc mapper msig_desc } |
let module_sig_desc mapper = function | Tmty_sig sigs -> Tmty_sig ( mapper . signature mapper sigs ) | Tmty_name name -> Tmty_name ( path mapper name ) | Tmty_alias name -> Tmty_alias ( path mapper name ) | Tmty_abstract -> Tmty_abstract | Tmty_functor ( name , fsig , msig ) -> Tmty_fun... |
let statements mapper = List . map ~ f ( : mapper . statement mapper ) |
let statement mapper { stmt_desc ; stmt_loc } = { stmt_loc = mapper . location mapper stmt_loc ; stmt_desc = mapper . statement_desc mapper stmt_desc } |
let statement_desc mapper = function | Tstmt_value ( p , e ) -> Tstmt_value ( mapper . pattern mapper p , mapper . expression mapper e ) | Tstmt_instance ( name , e ) -> Tstmt_instance ( ident mapper name , mapper . expression mapper e ) | Tstmt_type decl -> Tstmt_type ( mapper . ... |
let module_expr mapper { mod_desc ; mod_loc } = { mod_loc = mapper . location mapper mod_loc ; mod_desc = mapper . module_desc mapper mod_desc } |
let module_desc mapper = function | Tmod_struct stmts -> Tmod_struct ( mapper . statements mapper stmts ) | Tmod_name name -> Tmod_name ( path mapper name ) | Tmod_functor ( name , fsig , me ) -> Tmod_functor ( str mapper name , mapper . module_sig mapper fsig , mapper . module_expr m... |
let location ( _mapper : mapper ) ( loc : Location . t ) = loc |
let longident mapper = function | Longident . Lident str -> Longident . Lident str | Ldot ( l , str ) -> Ldot ( mapper . longident mapper l , str ) | Lapply ( l1 , l2 ) -> Lapply ( mapper . longident mapper l1 , mapper . longident mapper l2 ) |
let path mapper = function | Path . Pident ident -> Path . Pident ( mapper . ident mapper ident ) | Path . Pdot ( path , mode , str ) -> Path . Pdot ( mapper . path mapper path , mode , str ) | Path . Pocamldot ( path , mode , str , ocaml_name ) -> Path . Pocamldot (... |
let ident ( _mapper : mapper ) ( ident : Ident . t ) = ident |
let default_iterator = { type_expr ; type_desc ; variant ; row_tag ; field_decl ; ctor_args ; ctor_decl ; type_decl ; type_decl_desc ; literal ; pattern ; pattern_desc ; expression ; expression_desc ; convert_body ; convert_body_desc ; convert ; convert_desc ; signature_item ; s... |
let test_check_typed_dictionaries context = let assert_test_typed_dictionary source = let mypy_extensions_stub = { handle = " mypy_extensions . pyi " ; source = { | import typing def TypedDict ( typename : str , fields : typing . Dict [ str , typing . Type [ _T ] ] , total : bo... |
let test_check_typed_dictionary_inference context = let assert_test_typed_dictionary source = let mypy_extensions_stub = { handle = " mypy_extensions . pyi " ; source = { | import typing def TypedDict ( typename : str , fields : typing . Dict [ str , typing . Type [ _T ] ] , tot... |
let test_check_typed_dictionary_inheritance context = let assert_test_typed_dictionary source = let mypy_extensions_stub = { handle = " mypy_extensions . pyi " ; source = { | import typing def TypedDict ( typename : str , fields : typing . Dict [ str , typing . Type [ _T ] ] , t... |
let test_check_typed_dictionary_in_alias context = let assert_test_typed_dictionary source = let mypy_extensions_stub = { handle = " mypy_extensions . pyi " ; source = { | import typing def TypedDict ( typename : str , fields : typing . Dict [ str , typing . Type [ _T ] ] , tota... |
let test_check_optional_typed_dictionary context = assert_type_errors ~ context { | from typing import Any , TypedDict , Optional class MyDict ( TypedDict ) : a : str b : str def foo ( b : bool ) -> Optional [ MyDict ] : if b : return None return { " a " : str ( 1 ) , " b " ... |
let ( ) = " typed_dictionary " >::: [ " check_typed_dictionaries " >:: test_check_typed_dictionaries ; " check_typed_dictionary_inference " >:: test_check_typed_dictionary_inference ; " check_typed_dictionary_inheritance " >:: test_check_typed_dictionary_inheritance ; " check_typed_di... |
type native_repr_kind = Unboxed | Untagged |
type error = Repeated_parameter | Duplicate_constructor of string | Too_many_constructors | Duplicate_label of string | Recursive_abbrev of string | Cycle_in_def of string * type_expr | Definition_mismatch of type_expr * Includecore . type_mismatch option | Constraint_failed of type_expr * type_expr | Inc... |
let get_unboxed_from_attributes sdecl = let unboxed = Builtin_attributes . has_unboxed sdecl . ptype_attributes in let boxed = Builtin_attributes . has_boxed sdecl . ptype_attributes in match boxed , unboxed , ! Clflags . unboxed_types with | true , true , _ -> raise ( Error ( sdecl . pty... |
let add_type ~ check id decl env = Builtin_attributes . warning_scope ~ ppwarning : false decl . type_attributes ( fun ( ) -> Env . add_type ~ check id decl env ) |
let enter_type rec_flag env sdecl id = let needed = match rec_flag with | Asttypes . Nonrecursive -> begin match sdecl . ptype_kind with | Ptype_variant scds -> List . iter ( fun cd -> if cd . pcd_res <> None then raise ( Error ( cd . pcd_loc , Nonrec_gadt ) ) ) scds | _ -> ( ) en... |
let update_type temp_env env id loc = let path = Path . Pident id in let decl = Env . find_type path temp_env in match decl . type_manifest with None -> ( ) | Some ty -> let params = List . map ( fun _ -> Ctype . newvar ( ) ) decl . type_params in try Ctype . unify env ( Ctype . n... |
let get_unboxed_type_representation env ty = match Typedecl_unboxed . get_unboxed_type_representation env ty with | Typedecl_unboxed . This x -> Some x | _ -> None |
let is_float env ty = match get_unboxed_type_representation env ty with Some { desc = Tconstr ( p , _ , _ ) ; _ } -> Path . same p Predef . path_float | _ -> false |
let is_fixed_type sd = let rec has_row_var sty = match sty . ptyp_desc with Ptyp_alias ( sty , _ ) -> has_row_var sty | Ptyp_class _ | Ptyp_object ( _ , Open ) | Ptyp_variant ( _ , Open , _ ) | Ptyp_variant ( _ , Closed , Some _ ) -> true | _ -> false in match sd . ptyp... |
let set_fixed_row env loc p decl = let tm = match decl . type_manifest with None -> assert false | Some t -> Ctype . expand_head env t in let rv = match tm . desc with Tvariant row -> let row = Btype . row_repr row in tm . desc <- Tvariant { row with row_fixed = Some Fixed_private } ; if Btype... |
let make_params env params = let make_param ( sty , v ) = try ( transl_type_param env sty , v ) with Already_bound -> raise ( Error ( sty . ptyp_loc , Repeated_parameter ) ) in List . map make_param params |
let transl_labels env closed lbls = assert ( lbls <> [ ] ) ; let all_labels = ref String . Set . empty in List . iter ( fun { pld_name = { txt = name ; loc } } -> if String . Set . mem name ! all_labels then raise ( Error ( loc , Duplicate_label name ) ) ; all_labels ... |
let transl_constructor_arguments env closed = function | Pcstr_tuple l -> let l = List . map ( transl_simple_type env closed ) l in Types . Cstr_tuple ( List . map ( fun t -> t . ctyp_type ) l ) , Cstr_tuple l | Pcstr_record l -> let lbls , lbls ' = transl_labels env closed l in Types ... |
let make_constructor env type_path type_params sargs sret_type = match sret_type with | None -> let args , targs = transl_constructor_arguments env true sargs in targs , None , args , None , type_params | Some sret_type -> let z = narrow ( ) in reset_type_variables ( ) ; let args , targs =... |
let check_type_var loc univ id = let f t = ( Btype . repr t ) . id = id in if not ( List . exists f univ ) then raise ( Error ( loc , Wrong_unboxed_type_float ) ) |
let rec check_unboxed_abstract_arg loc univ ty = match ty . desc with | Tvar _ -> check_type_var loc univ ty . id | Tarrow ( _ , t1 , t2 , _ ) | Tfield ( _ , _ , t1 , t2 ) -> check_unboxed_abstract_arg loc univ t1 ; check_unboxed_abstract_arg loc univ t2 | Ttuple args | Tconstr ( ... |
let rec check_unboxed_gadt_arg loc univ env ty = match get_unboxed_type_representation env ty with | Some { desc = Tvar _ ; id } -> check_type_var loc univ id | Some { desc = Tarrow _ | Ttuple _ | Tpackage _ | Tobject _ | Tnil | Tvariant _ ; _ } -> ( ) | Some { desc = Tconstr ( ... |
let transl_declaration env sdecl id = reset_type_variables ( ) ; Ctype . begin_def ( ) ; let tparams = make_params env sdecl . ptype_params in let params = List . map ( fun ( cty , _ ) -> cty . ctyp_type ) tparams in let cstrs = List . map ( fun ( sty , sty ' , loc ) -... |
let generalize_decl decl = List . iter Ctype . generalize decl . type_params ; Btype . iter_type_expr_kind Ctype . generalize decl . type_kind ; begin match decl . type_manifest with | None -> ( ) | Some ty -> Ctype . generalize ty end |
let rec check_constraints_rec env loc visited ty = let ty = Ctype . repr ty in if TypeSet . mem ty ! visited then ( ) else begin visited := TypeSet . add ty ! visited ; match ty . desc with | Tconstr ( path , args , _ ) -> let args ' = List . map ( fun _ -> Ctype . newvar ( ) ... |
let check_constraints_labels env visited l pl = let rec get_loc name = function [ ] -> assert false | pld :: tl -> if name = pld . pld_name . txt then pld . pld_type . ptyp_loc else get_loc name tl in List . iter ( fun { Types . ld_id = name ; ld_type = ty } -> check_constraints_rec en... |
let check_constraints env sdecl ( _ , decl ) = let visited = ref TypeSet . empty in begin match decl . type_kind with | Type_abstract -> ( ) | Type_variant l -> let find_pl = function Ptype_variant pl -> pl | Ptype_record _ | Ptype_abstract | Ptype_open -> assert false in let pl = find_pl s... |
let check_coherence env loc dpath decl = match decl with { type_kind = ( Type_variant _ | Type_record _ | Type_open ) ; type_manifest = Some ty } -> begin match ( Ctype . repr ty ) . desc with Tconstr ( path , args , _ ) -> begin try let decl ' = Env . find_type path env in let ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.