+12

Changes

reviewed

··· 86 86 Types 87 87 (Nicolas Chataing, review by Jacques Garrigue) 88 88 89 89 + - #10555: Do not use ghost locations for type constraints 90 90 + (Nicolás Ojeda Bär, report by Anton Bachin, review by Thomas Refis) 91 91 + 89 92 ### Build system: 90 93 91 94 - #10471: Fix detection of arm32 architectures with musl in the configure ··· 103 106 Moreover, poll point insertion must be disabled for `caml_send*`, 104 107 otherwise the derived pointer is live across a poll point. 105 108 (Vincent Laviron and Xavier Leroy, review by Xavier Leroy and Sadiq Jaffer) 109 109 + 110 110 + - #10539: Field kinds should be kept when copying types 111 111 + Losing the sharing meant that one could desynchronize them between several 112 112 + occurences of self, allowing a method to be both public and hidden, 113 113 + which broke type soundness. 114 114 + (Jacques Garrigue, review by Leo White) 106 115 107 116 - #10542: Fix detection of immediate64 types through unboxed types. 108 117 (Leo White, review by Stephen Dolan and Gabriel Scherer) ··· 700 709 - #10468: Correctly pretty print local type substitution, e.g. type t := ..., 701 710 with -dsource 702 711 (Matt Else, review by Florian Angeletti) 712 712 + 713 713 + - #10550, #10551: fix pretty-print of gadt-pattern-with-type-vars 714 714 + (Chet Murthy, review by Gabriel Scherer) 703 715 704 716 OCaml 4.12, maintenance version 705 717 -------------------------------

+959 -971

boot/menhir/parser.ml

reviewed

··· 415 415 416 416 let mkexp_constraint ~loc e (t1, t2) = 417 417 match t1, t2 with 418 418 - | Some t, None -> ghexp ~loc (Pexp_constraint(e, t)) 419 419 - | _, Some t -> ghexp ~loc (Pexp_coerce(e, t1, t)) 418 418 + | Some t, None -> mkexp ~loc (Pexp_constraint(e, t)) 419 419 + | _, Some t -> mkexp ~loc (Pexp_coerce(e, t1, t)) 420 420 | None, None -> assert false 421 421 422 422 let mkexp_opt_constraint ~loc e = function ··· 425 425 426 426 let mkpat_opt_constraint ~loc p = function 427 427 | None -> p 428 428 - | Some typ -> ghpat ~loc (Ppat_constraint(p, typ)) 428 428 + | Some typ -> mkpat ~loc (Ppat_constraint(p, typ)) 429 429 430 430 let syntax_error () = 431 431 raise Syntaxerr.Escape_error ··· 596 596 let loc_lident (id : string Location.loc) : Longident.t Location.loc = 597 597 loc_map (fun x -> Lident x) id 598 598 599 599 - let exp_of_longident ~loc lid = 600 600 - let lid = make_ghost (loc_map (fun id -> Lident (Longident.last id)) lid) in 601 601 - ghexp ~loc (Pexp_ident lid) 599 599 + let exp_of_longident lid = 600 600 + let lid = loc_map (fun id -> Lident (Longident.last id)) lid in 601 601 + Exp.mk ~loc:lid.loc (Pexp_ident lid) 602 602 603 603 - let exp_of_label ~loc lbl = 604 604 - mkexp ~loc (Pexp_ident (loc_lident lbl)) 603 603 + let exp_of_label lbl = 604 604 + Exp.mk ~loc:lbl.loc (Pexp_ident (loc_lident lbl)) 605 605 606 606 let pat_of_label lbl = 607 607 Pat.mk ~loc:lbl.loc (Ppat_var (loc_last lbl)) ··· 18669 18669 let _sloc = (_symbolstartpos, _endpos) in 18670 18670 18671 18671 # 2846 "parsing/parser.mly" 18672 18672 - ( let label, pat = 18672 18672 + ( let constraint_loc, label, pat = 18673 18673 match opat with 18674 18674 | None -> 18675 18675 (* No pattern; this is a pun. Desugar it. 18676 18676 But that the pattern was there and the label reconstructed (which 18677 18677 piece of AST is marked as ghost is important for warning 18678 18678 emission). *) 18679 18679 - make_ghost label, pat_of_label label 18679 18679 + _sloc, make_ghost label, pat_of_label label 18680 18680 | Some pat -> 18681 18681 - label, pat 18681 18681 + (_startpos_octy_, _endpos), label, pat 18682 18682 in 18683 18683 - label, mkpat_opt_constraint ~loc:_sloc pat octy 18683 18683 + label, mkpat_opt_constraint ~loc:constraint_loc pat octy 18684 18684 ) 18685 18685 # 18686 "parsing/parser.ml" 18686 18686 ··· 18753 18753 let _sloc = (_symbolstartpos, _endpos) in 18754 18754 18755 18755 # 2846 "parsing/parser.mly" 18756 18756 - ( let label, pat = 18756 18756 + ( let constraint_loc, label, pat = 18757 18757 match opat with 18758 18758 | None -> 18759 18759 (* No pattern; this is a pun. Desugar it. 18760 18760 But that the pattern was there and the label reconstructed (which 18761 18761 piece of AST is marked as ghost is important for warning 18762 18762 emission). *) 18763 18763 - make_ghost label, pat_of_label label 18763 18763 + _sloc, make_ghost label, pat_of_label label 18764 18764 | Some pat -> 18765 18765 - label, pat 18765 18765 + (_startpos_octy_, _endpos), label, pat 18766 18766 in 18767 18767 - label, mkpat_opt_constraint ~loc:_sloc pat octy 18767 18767 + label, mkpat_opt_constraint ~loc:constraint_loc pat octy 18768 18768 ) 18769 18769 # 18770 "parsing/parser.ml" 18770 18770 ··· 18846 18846 let _sloc = (_symbolstartpos, _endpos) in 18847 18847 18848 18848 # 2846 "parsing/parser.mly" 18849 18849 - ( let label, pat = 18849 18849 + ( let constraint_loc, label, pat = 18850 18850 match opat with 18851 18851 | None -> 18852 18852 (* No pattern; this is a pun. Desugar it. 18853 18853 But that the pattern was there and the label reconstructed (which 18854 18854 piece of AST is marked as ghost is important for warning 18855 18855 emission). *) 18856 18856 - make_ghost label, pat_of_label label 18856 18856 + _sloc, make_ghost label, pat_of_label label 18857 18857 | Some pat -> 18858 18858 - label, pat 18858 18858 + (_startpos_octy_, _endpos), label, pat 18859 18859 in 18860 18860 - label, mkpat_opt_constraint ~loc:_sloc pat octy 18860 18860 + label, mkpat_opt_constraint ~loc:constraint_loc pat octy 18861 18861 ) 18862 18862 # 18863 "parsing/parser.ml" 18863 18863 ··· 18932 18932 let _sloc = (_symbolstartpos, _endpos) in 18933 18933 18934 18934 # 2846 "parsing/parser.mly" 18935 18935 - ( let label, pat = 18935 18935 + ( let constraint_loc, label, pat = 18936 18936 match opat with 18937 18937 | None -> 18938 18938 (* No pattern; this is a pun. Desugar it. 18939 18939 But that the pattern was there and the label reconstructed (which 18940 18940 piece of AST is marked as ghost is important for warning 18941 18941 emission). *) 18942 18942 - make_ghost label, pat_of_label label 18942 18942 + _sloc, make_ghost label, pat_of_label label 18943 18943 | Some pat -> 18944 18944 - label, pat 18944 18944 + (_startpos_octy_, _endpos), label, pat 18945 18945 in 18946 18946 - label, mkpat_opt_constraint ~loc:_sloc pat octy 18946 18946 + label, mkpat_opt_constraint ~loc:constraint_loc pat octy 18947 18947 ) 18948 18948 # 18949 "parsing/parser.ml" 18949 18949 ··· 31616 31616 # 31617 "parsing/parser.ml" 31617 31617 31618 31618 in 31619 31619 - let _startpos_label_ = _startpos__1_ in 31620 31620 - let _endpos = _endpos_oe_ in 31621 31621 - let _symbolstartpos = _startpos_label_ in 31622 31622 - let _sloc = (_symbolstartpos, _endpos) in 31623 31619 31624 31620 # 2652 "parsing/parser.mly" 31625 31625 - ( let e = 31621 31621 + ( let label, e = 31626 31622 match oe with 31627 31623 | None -> 31628 31624 (* No expression; this is a pun. Desugar it. *) 31629 31629 - exp_of_label ~loc:_sloc label 31625 31625 + make_ghost label, exp_of_label label 31630 31626 | Some e -> 31631 31631 - e 31627 31627 + label, e 31632 31628 in 31633 31629 label, e ) 31634 31634 - # 31635 "parsing/parser.ml" 31630 31630 + # 31631 "parsing/parser.ml" 31635 31631 31636 31632 in 31637 31633 31638 31634 # 1053 "parsing/parser.mly" 31639 31635 ( [x] ) 31640 31640 - # 31641 "parsing/parser.ml" 31636 31636 + # 31637 "parsing/parser.ml" 31641 31637 in 31642 31638 { 31643 31639 MenhirLib.EngineTypes.state = _menhir_s; ··· 31672 31668 let _1 : ( 31673 31669 # 705 "parsing/parser.mly" 31674 31670 (string) 31675 31675 - # 31676 "parsing/parser.ml" 31671 31671 + # 31672 "parsing/parser.ml" 31676 31672 ) = Obj.magic _1 in 31677 31673 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 31678 31674 let _startpos = _startpos__1_ in ··· 31680 31676 let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let _2 = 31681 31677 # 126 "<standard.mly>" 31682 31678 ( Some x ) 31683 31683 - # 31684 "parsing/parser.ml" 31679 31679 + # 31680 "parsing/parser.ml" 31684 31680 in 31685 31681 let x = 31686 31682 let label = 31687 31683 let _1 = 31688 31684 # 3498 "parsing/parser.mly" 31689 31685 ( _1 ) 31690 31690 - # 31691 "parsing/parser.ml" 31686 31686 + # 31687 "parsing/parser.ml" 31691 31687 in 31692 31688 let _endpos = _endpos__1_ in 31693 31689 let _symbolstartpos = _startpos__1_ in ··· 31695 31691 31696 31692 # 883 "parsing/parser.mly" 31697 31693 ( mkrhs _1 _sloc ) 31698 31698 - # 31699 "parsing/parser.ml" 31694 31694 + # 31695 "parsing/parser.ml" 31699 31695 31700 31696 in 31701 31701 - let _startpos_label_ = _startpos__1_ in 31702 31702 - let _endpos = _endpos_oe_ in 31703 31703 - let _symbolstartpos = _startpos_label_ in 31704 31704 - let _sloc = (_symbolstartpos, _endpos) in 31705 31697 31706 31698 # 2652 "parsing/parser.mly" 31707 31707 - ( let e = 31699 31699 + ( let label, e = 31708 31700 match oe with 31709 31701 | None -> 31710 31702 (* No expression; this is a pun. Desugar it. *) 31711 31711 - exp_of_label ~loc:_sloc label 31703 31703 + make_ghost label, exp_of_label label 31712 31704 | Some e -> 31713 31713 - e 31705 31705 + label, e 31714 31706 in 31715 31707 label, e ) 31716 31716 - # 31717 "parsing/parser.ml" 31708 31708 + # 31709 "parsing/parser.ml" 31717 31709 31718 31710 in 31719 31711 31720 31712 # 1053 "parsing/parser.mly" 31721 31713 ( [x] ) 31722 31722 - # 31723 "parsing/parser.ml" 31714 31714 + # 31715 "parsing/parser.ml" 31723 31715 in 31724 31716 { 31725 31717 MenhirLib.EngineTypes.state = _menhir_s; ··· 31761 31753 let _1 : ( 31762 31754 # 705 "parsing/parser.mly" 31763 31755 (string) 31764 31764 - # 31765 "parsing/parser.ml" 31756 31756 + # 31757 "parsing/parser.ml" 31765 31757 ) = Obj.magic _1 in 31766 31758 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 31767 31759 let _startpos = _startpos__1_ in ··· 31771 31763 let _1 = 31772 31764 # 3498 "parsing/parser.mly" 31773 31765 ( _1 ) 31774 31774 - # 31775 "parsing/parser.ml" 31766 31766 + # 31767 "parsing/parser.ml" 31775 31767 in 31776 31768 let _endpos = _endpos__1_ in 31777 31769 let _symbolstartpos = _startpos__1_ in ··· 31779 31771 31780 31772 # 883 "parsing/parser.mly" 31781 31773 ( mkrhs _1 _sloc ) 31782 31782 - # 31783 "parsing/parser.ml" 31774 31774 + # 31775 "parsing/parser.ml" 31783 31775 31784 31776 in 31785 31785 - let _startpos_label_ = _startpos__1_ in 31786 31786 - let _endpos = _endpos_oe_ in 31787 31787 - let _symbolstartpos = _startpos_label_ in 31788 31788 - let _sloc = (_symbolstartpos, _endpos) in 31789 31777 31790 31778 # 2652 "parsing/parser.mly" 31791 31791 - ( let e = 31779 31779 + ( let label, e = 31792 31780 match oe with 31793 31781 | None -> 31794 31782 (* No expression; this is a pun. Desugar it. *) 31795 31795 - exp_of_label ~loc:_sloc label 31783 31783 + make_ghost label, exp_of_label label 31796 31784 | Some e -> 31797 31797 - e 31785 31785 + label, e 31798 31786 in 31799 31787 label, e ) 31800 31800 - # 31801 "parsing/parser.ml" 31788 31788 + # 31789 "parsing/parser.ml" 31801 31789 31802 31790 in 31803 31791 31804 31792 # 1057 "parsing/parser.mly" 31805 31793 ( x :: xs ) 31806 31806 - # 31807 "parsing/parser.ml" 31794 31794 + # 31795 "parsing/parser.ml" 31807 31795 in 31808 31796 { 31809 31797 MenhirLib.EngineTypes.state = _menhir_s; ··· 31828 31816 let _v : (Parsetree.pattern list) = let _2 = 31829 31817 # 124 "<standard.mly>" 31830 31818 ( None ) 31831 31831 - # 31832 "parsing/parser.ml" 31819 31819 + # 31820 "parsing/parser.ml" 31832 31820 in 31833 31821 31834 31822 # 1053 "parsing/parser.mly" 31835 31823 ( [x] ) 31836 31836 - # 31837 "parsing/parser.ml" 31824 31824 + # 31825 "parsing/parser.ml" 31837 31825 in 31838 31826 { 31839 31827 MenhirLib.EngineTypes.state = _menhir_s; ··· 31867 31855 31868 31856 # 126 "<standard.mly>" 31869 31857 ( Some x ) 31870 31870 - # 31871 "parsing/parser.ml" 31858 31858 + # 31859 "parsing/parser.ml" 31871 31859 31872 31860 in 31873 31861 31874 31862 # 1053 "parsing/parser.mly" 31875 31863 ( [x] ) 31876 31876 - # 31877 "parsing/parser.ml" 31864 31864 + # 31865 "parsing/parser.ml" 31877 31865 in 31878 31866 { 31879 31867 MenhirLib.EngineTypes.state = _menhir_s; ··· 31912 31900 let _v : (Parsetree.pattern list) = 31913 31901 # 1057 "parsing/parser.mly" 31914 31902 ( x :: xs ) 31915 31915 - # 31916 "parsing/parser.ml" 31903 31903 + # 31904 "parsing/parser.ml" 31916 31904 in 31917 31905 { 31918 31906 MenhirLib.EngineTypes.state = _menhir_s; ··· 31951 31939 let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 = 31952 31940 # 124 "<standard.mly>" 31953 31941 ( None ) 31954 31954 - # 31955 "parsing/parser.ml" 31942 31942 + # 31943 "parsing/parser.ml" 31955 31943 in 31956 31944 let x = 31957 31945 let label = ··· 31961 31949 31962 31950 # 883 "parsing/parser.mly" 31963 31951 ( mkrhs _1 _sloc ) 31964 31964 - # 31965 "parsing/parser.ml" 31952 31952 + # 31953 "parsing/parser.ml" 31965 31953 31966 31954 in 31967 31955 let _startpos_label_ = _startpos__1_ in ··· 31970 31958 let _sloc = (_symbolstartpos, _endpos) in 31971 31959 31972 31960 # 2635 "parsing/parser.mly" 31973 31973 - ( let e = 31961 31961 + ( let constraint_loc, label, e = 31974 31962 match eo with 31975 31963 | None -> 31976 31964 (* No pattern; this is a pun. Desugar it. *) 31977 31977 - exp_of_longident ~loc:_sloc label 31965 31965 + _sloc, make_ghost label, exp_of_longident label 31978 31966 | Some e -> 31979 31979 - e 31967 31967 + (_startpos_c_, _endpos), label, e 31980 31968 in 31981 31981 - label, mkexp_opt_constraint ~loc:_sloc e c ) 31982 31982 - # 31983 "parsing/parser.ml" 31969 31969 + label, mkexp_opt_constraint ~loc:constraint_loc e c ) 31970 31970 + # 31971 "parsing/parser.ml" 31983 31971 31984 31972 in 31985 31973 31986 31974 # 1053 "parsing/parser.mly" 31987 31975 ( [x] ) 31988 31988 - # 31989 "parsing/parser.ml" 31976 31976 + # 31977 "parsing/parser.ml" 31989 31977 in 31990 31978 { 31991 31979 MenhirLib.EngineTypes.state = _menhir_s; ··· 32031 32019 let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 = 32032 32020 # 126 "<standard.mly>" 32033 32021 ( Some x ) 32034 32034 - # 32035 "parsing/parser.ml" 32022 32022 + # 32023 "parsing/parser.ml" 32035 32023 in 32036 32024 let x = 32037 32025 let label = ··· 32041 32029 32042 32030 # 883 "parsing/parser.mly" 32043 32031 ( mkrhs _1 _sloc ) 32044 32044 - # 32045 "parsing/parser.ml" 32032 32032 + # 32033 "parsing/parser.ml" 32045 32033 32046 32034 in 32047 32035 let _startpos_label_ = _startpos__1_ in ··· 32050 32038 let _sloc = (_symbolstartpos, _endpos) in 32051 32039 32052 32040 # 2635 "parsing/parser.mly" 32053 32053 - ( let e = 32041 32041 + ( let constraint_loc, label, e = 32054 32042 match eo with 32055 32043 | None -> 32056 32044 (* No pattern; this is a pun. Desugar it. *) 32057 32057 - exp_of_longident ~loc:_sloc label 32045 32045 + _sloc, make_ghost label, exp_of_longident label 32058 32046 | Some e -> 32059 32059 - e 32047 32047 + (_startpos_c_, _endpos), label, e 32060 32048 in 32061 32061 - label, mkexp_opt_constraint ~loc:_sloc e c ) 32062 32062 - # 32063 "parsing/parser.ml" 32049 32049 + label, mkexp_opt_constraint ~loc:constraint_loc e c ) 32050 32050 + # 32051 "parsing/parser.ml" 32063 32051 32064 32052 in 32065 32053 32066 32054 # 1053 "parsing/parser.mly" 32067 32055 ( [x] ) 32068 32068 - # 32069 "parsing/parser.ml" 32056 32056 + # 32057 "parsing/parser.ml" 32069 32057 in 32070 32058 { 32071 32059 MenhirLib.EngineTypes.state = _menhir_s; ··· 32123 32111 32124 32112 # 883 "parsing/parser.mly" 32125 32113 ( mkrhs _1 _sloc ) 32126 32126 - # 32127 "parsing/parser.ml" 32114 32114 + # 32115 "parsing/parser.ml" 32127 32115 32128 32116 in 32129 32117 let _startpos_label_ = _startpos__1_ in ··· 32132 32120 let _sloc = (_symbolstartpos, _endpos) in 32133 32121 32134 32122 # 2635 "parsing/parser.mly" 32135 32135 - ( let e = 32123 32123 + ( let constraint_loc, label, e = 32136 32124 match eo with 32137 32125 | None -> 32138 32126 (* No pattern; this is a pun. Desugar it. *) 32139 32139 - exp_of_longident ~loc:_sloc label 32127 32127 + _sloc, make_ghost label, exp_of_longident label 32140 32128 | Some e -> 32141 32141 - e 32129 32129 + (_startpos_c_, _endpos), label, e 32142 32130 in 32143 32143 - label, mkexp_opt_constraint ~loc:_sloc e c ) 32144 32144 - # 32145 "parsing/parser.ml" 32131 32131 + label, mkexp_opt_constraint ~loc:constraint_loc e c ) 32132 32132 + # 32133 "parsing/parser.ml" 32145 32133 32146 32134 in 32147 32135 32148 32136 # 1057 "parsing/parser.mly" 32149 32137 ( x :: xs ) 32150 32150 - # 32151 "parsing/parser.ml" 32138 32138 + # 32139 "parsing/parser.ml" 32151 32139 in 32152 32140 { 32153 32141 MenhirLib.EngineTypes.state = _menhir_s; ··· 32172 32160 let _v : (Parsetree.expression) = 32173 32161 # 2169 "parsing/parser.mly" 32174 32162 ( _1 ) 32175 32175 - # 32176 "parsing/parser.ml" 32163 32163 + # 32164 "parsing/parser.ml" 32176 32164 in 32177 32165 { 32178 32166 MenhirLib.EngineTypes.state = _menhir_s; ··· 32204 32192 let _v : (Parsetree.expression) = 32205 32193 # 2170 "parsing/parser.mly" 32206 32194 ( _1 ) 32207 32207 - # 32208 "parsing/parser.ml" 32195 32195 + # 32196 "parsing/parser.ml" 32208 32196 in 32209 32197 { 32210 32198 MenhirLib.EngineTypes.state = _menhir_s; ··· 32244 32232 let _1 = 32245 32233 # 2172 "parsing/parser.mly" 32246 32234 ( Pexp_sequence(_1, _3) ) 32247 32247 - # 32248 "parsing/parser.ml" 32235 32235 + # 32236 "parsing/parser.ml" 32248 32236 in 32249 32237 let _endpos__1_ = _endpos__3_ in 32250 32238 let _endpos = _endpos__1_ in ··· 32253 32241 32254 32242 # 916 "parsing/parser.mly" 32255 32243 ( mkexp ~loc:_sloc _1 ) 32256 32256 - # 32257 "parsing/parser.ml" 32244 32244 + # 32245 "parsing/parser.ml" 32257 32245 32258 32246 in 32259 32247 32260 32248 # 2173 "parsing/parser.mly" 32261 32249 ( _1 ) 32262 32262 - # 32263 "parsing/parser.ml" 32250 32250 + # 32251 "parsing/parser.ml" 32263 32251 in 32264 32252 { 32265 32253 MenhirLib.EngineTypes.state = _menhir_s; ··· 32317 32305 ( let seq = mkexp ~loc:_sloc (Pexp_sequence (_1, _5)) in 32318 32306 let payload = PStr [mkstrexp seq []] in 32319 32307 mkexp ~loc:_sloc (Pexp_extension (_4, payload)) ) 32320 32320 - # 32321 "parsing/parser.ml" 32308 32308 + # 32309 "parsing/parser.ml" 32321 32309 in 32322 32310 { 32323 32311 MenhirLib.EngineTypes.state = _menhir_s; ··· 32387 32375 32388 32376 # 3836 "parsing/parser.mly" 32389 32377 ( _1 ) 32390 32390 - # 32391 "parsing/parser.ml" 32378 32378 + # 32379 "parsing/parser.ml" 32391 32379 32392 32380 in 32393 32381 let _endpos_attrs_ = _endpos__1_inlined4_ in ··· 32396 32384 32397 32385 # 3840 "parsing/parser.mly" 32398 32386 ( _1 ) 32399 32399 - # 32400 "parsing/parser.ml" 32387 32387 + # 32388 "parsing/parser.ml" 32400 32388 32401 32389 in 32402 32390 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 32408 32396 32409 32397 # 883 "parsing/parser.mly" 32410 32398 ( mkrhs _1 _sloc ) 32411 32411 - # 32412 "parsing/parser.ml" 32399 32399 + # 32400 "parsing/parser.ml" 32412 32400 32413 32401 in 32414 32402 let attrs1 = ··· 32416 32404 32417 32405 # 3840 "parsing/parser.mly" 32418 32406 ( _1 ) 32419 32419 - # 32420 "parsing/parser.ml" 32407 32407 + # 32408 "parsing/parser.ml" 32420 32408 32421 32409 in 32422 32410 let _endpos = _endpos_attrs_ in ··· 32431 32419 Te.mk_exception ~attrs 32432 32420 (Te.decl id ~vars ~args ?res ~attrs:(attrs1 @ attrs2) ~loc ~docs) 32433 32421 , ext ) 32434 32434 - # 32435 "parsing/parser.ml" 32422 32422 + # 32423 "parsing/parser.ml" 32435 32423 in 32436 32424 { 32437 32425 MenhirLib.EngineTypes.state = _menhir_s; ··· 32457 32445 let _1 = 32458 32446 # 260 "<standard.mly>" 32459 32447 ( List.flatten xss ) 32460 32460 - # 32461 "parsing/parser.ml" 32448 32448 + # 32449 "parsing/parser.ml" 32461 32449 in 32462 32450 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in 32463 32451 let _endpos = _endpos__1_ in ··· 32465 32453 32466 32454 # 876 "parsing/parser.mly" 32467 32455 ( extra_sig _startpos _endpos _1 ) 32468 32468 - # 32469 "parsing/parser.ml" 32456 32456 + # 32457 "parsing/parser.ml" 32469 32457 32470 32458 in 32471 32459 32472 32460 # 1618 "parsing/parser.mly" 32473 32461 ( _1 ) 32474 32474 - # 32475 "parsing/parser.ml" 32462 32462 + # 32463 "parsing/parser.ml" 32475 32463 in 32476 32464 { 32477 32465 MenhirLib.EngineTypes.state = _menhir_s; ··· 32505 32493 32506 32494 # 3836 "parsing/parser.mly" 32507 32495 ( _1 ) 32508 32508 - # 32509 "parsing/parser.ml" 32496 32496 + # 32497 "parsing/parser.ml" 32509 32497 32510 32498 in 32511 32499 let _endpos__2_ = _endpos__1_inlined1_ in ··· 32516 32504 # 1633 "parsing/parser.mly" 32517 32505 ( let docs = symbol_docs _sloc in 32518 32506 mksig ~loc:_sloc (Psig_extension (_1, (add_docs_attrs docs _2))) ) 32519 32519 - # 32520 "parsing/parser.ml" 32507 32507 + # 32508 "parsing/parser.ml" 32520 32508 in 32521 32509 { 32522 32510 MenhirLib.EngineTypes.state = _menhir_s; ··· 32542 32530 let _1 = 32543 32531 # 1637 "parsing/parser.mly" 32544 32532 ( Psig_attribute _1 ) 32545 32545 - # 32546 "parsing/parser.ml" 32533 32533 + # 32534 "parsing/parser.ml" 32546 32534 in 32547 32535 let _endpos = _endpos__1_ in 32548 32536 let _symbolstartpos = _startpos__1_ in ··· 32550 32538 32551 32539 # 924 "parsing/parser.mly" 32552 32540 ( mksig ~loc:_sloc _1 ) 32553 32553 - # 32554 "parsing/parser.ml" 32541 32541 + # 32542 "parsing/parser.ml" 32554 32542 32555 32543 in 32556 32544 32557 32545 # 1639 "parsing/parser.mly" 32558 32546 ( _1 ) 32559 32559 - # 32560 "parsing/parser.ml" 32547 32547 + # 32548 "parsing/parser.ml" 32560 32548 in 32561 32549 { 32562 32550 MenhirLib.EngineTypes.state = _menhir_s; ··· 32582 32570 let _1 = 32583 32571 # 1642 "parsing/parser.mly" 32584 32572 ( psig_value _1 ) 32585 32585 - # 32586 "parsing/parser.ml" 32573 32573 + # 32574 "parsing/parser.ml" 32586 32574 in 32587 32575 let _endpos = _endpos__1_ in 32588 32576 let _symbolstartpos = _startpos__1_ in ··· 32590 32578 32591 32579 # 941 "parsing/parser.mly" 32592 32580 ( wrap_mksig_ext ~loc:_sloc _1 ) 32593 32593 - # 32594 "parsing/parser.ml" 32581 32581 + # 32582 "parsing/parser.ml" 32594 32582 32595 32583 in 32596 32584 32597 32585 # 1674 "parsing/parser.mly" 32598 32586 ( _1 ) 32599 32599 - # 32600 "parsing/parser.ml" 32587 32587 + # 32588 "parsing/parser.ml" 32600 32588 in 32601 32589 { 32602 32590 MenhirLib.EngineTypes.state = _menhir_s; ··· 32622 32610 let _1 = 32623 32611 # 1644 "parsing/parser.mly" 32624 32612 ( psig_value _1 ) 32625 32625 - # 32626 "parsing/parser.ml" 32613 32613 + # 32614 "parsing/parser.ml" 32626 32614 in 32627 32615 let _endpos = _endpos__1_ in 32628 32616 let _symbolstartpos = _startpos__1_ in ··· 32630 32618 32631 32619 # 941 "parsing/parser.mly" 32632 32620 ( wrap_mksig_ext ~loc:_sloc _1 ) 32633 32633 - # 32634 "parsing/parser.ml" 32621 32621 + # 32622 "parsing/parser.ml" 32634 32622 32635 32623 in 32636 32624 32637 32625 # 1674 "parsing/parser.mly" 32638 32626 ( _1 ) 32639 32639 - # 32640 "parsing/parser.ml" 32627 32627 + # 32628 "parsing/parser.ml" 32640 32628 in 32641 32629 { 32642 32630 MenhirLib.EngineTypes.state = _menhir_s; ··· 32673 32661 let _1 = 32674 32662 # 1114 "parsing/parser.mly" 32675 32663 ( let (x, b) = a in x, b :: bs ) 32676 32676 - # 32677 "parsing/parser.ml" 32664 32664 + # 32665 "parsing/parser.ml" 32677 32665 in 32678 32666 32679 32667 # 2926 "parsing/parser.mly" 32680 32668 ( _1 ) 32681 32681 - # 32682 "parsing/parser.ml" 32669 32669 + # 32670 "parsing/parser.ml" 32682 32670 32683 32671 in 32684 32672 32685 32673 # 2909 "parsing/parser.mly" 32686 32674 ( _1 ) 32687 32687 - # 32688 "parsing/parser.ml" 32675 32675 + # 32676 "parsing/parser.ml" 32688 32676 32689 32677 in 32690 32678 32691 32679 # 1646 "parsing/parser.mly" 32692 32680 ( psig_type _1 ) 32693 32693 - # 32694 "parsing/parser.ml" 32681 32681 + # 32682 "parsing/parser.ml" 32694 32682 32695 32683 in 32696 32684 let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in ··· 32700 32688 32701 32689 # 941 "parsing/parser.mly" 32702 32690 ( wrap_mksig_ext ~loc:_sloc _1 ) 32703 32703 - # 32704 "parsing/parser.ml" 32691 32691 + # 32692 "parsing/parser.ml" 32704 32692 32705 32693 in 32706 32694 32707 32695 # 1674 "parsing/parser.mly" 32708 32696 ( _1 ) 32709 32709 - # 32710 "parsing/parser.ml" 32697 32697 + # 32698 "parsing/parser.ml" 32710 32698 in 32711 32699 { 32712 32700 MenhirLib.EngineTypes.state = _menhir_s; ··· 32743 32731 let _1 = 32744 32732 # 1114 "parsing/parser.mly" 32745 32733 ( let (x, b) = a in x, b :: bs ) 32746 32746 - # 32747 "parsing/parser.ml" 32734 32734 + # 32735 "parsing/parser.ml" 32747 32735 in 32748 32736 32749 32737 # 2926 "parsing/parser.mly" 32750 32738 ( _1 ) 32751 32751 - # 32752 "parsing/parser.ml" 32739 32739 + # 32740 "parsing/parser.ml" 32752 32740 32753 32741 in 32754 32742 32755 32743 # 2914 "parsing/parser.mly" 32756 32744 ( _1 ) 32757 32757 - # 32758 "parsing/parser.ml" 32745 32745 + # 32746 "parsing/parser.ml" 32758 32746 32759 32747 in 32760 32748 32761 32749 # 1648 "parsing/parser.mly" 32762 32750 ( psig_typesubst _1 ) 32763 32763 - # 32764 "parsing/parser.ml" 32751 32751 + # 32752 "parsing/parser.ml" 32764 32752 32765 32753 in 32766 32754 let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in ··· 32770 32758 32771 32759 # 941 "parsing/parser.mly" 32772 32760 ( wrap_mksig_ext ~loc:_sloc _1 ) 32773 32773 - # 32774 "parsing/parser.ml" 32761 32761 + # 32762 "parsing/parser.ml" 32774 32762 32775 32763 in 32776 32764 32777 32765 # 1674 "parsing/parser.mly" 32778 32766 ( _1 ) 32779 32779 - # 32780 "parsing/parser.ml" 32767 32767 + # 32768 "parsing/parser.ml" 32780 32768 in 32781 32769 { 32782 32770 MenhirLib.EngineTypes.state = _menhir_s; ··· 32863 32851 32864 32852 # 3836 "parsing/parser.mly" 32865 32853 ( _1 ) 32866 32866 - # 32867 "parsing/parser.ml" 32854 32854 + # 32855 "parsing/parser.ml" 32867 32855 32868 32856 in 32869 32857 let _endpos_attrs2_ = _endpos__1_inlined3_ in 32870 32858 let cs = 32871 32859 # 1106 "parsing/parser.mly" 32872 32860 ( List.rev xs ) 32873 32873 - # 32874 "parsing/parser.ml" 32861 32861 + # 32862 "parsing/parser.ml" 32874 32862 in 32875 32863 let tid = 32876 32864 let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in ··· 32880 32868 32881 32869 # 883 "parsing/parser.mly" 32882 32870 ( mkrhs _1 _sloc ) 32883 32883 - # 32884 "parsing/parser.ml" 32871 32871 + # 32872 "parsing/parser.ml" 32884 32872 32885 32873 in 32886 32874 let _4 = 32887 32875 # 3681 "parsing/parser.mly" 32888 32876 ( Recursive ) 32889 32889 - # 32890 "parsing/parser.ml" 32877 32877 + # 32878 "parsing/parser.ml" 32890 32878 in 32891 32879 let attrs1 = 32892 32880 let _1 = _1_inlined1 in 32893 32881 32894 32882 # 3840 "parsing/parser.mly" 32895 32883 ( _1 ) 32896 32896 - # 32897 "parsing/parser.ml" 32884 32884 + # 32885 "parsing/parser.ml" 32897 32885 32898 32886 in 32899 32887 let _endpos = _endpos_attrs2_ in ··· 32905 32893 let attrs = attrs1 @ attrs2 in 32906 32894 Te.mk tid cs ~params ~priv ~attrs ~docs, 32907 32895 ext ) 32908 32908 - # 32909 "parsing/parser.ml" 32896 32896 + # 32897 "parsing/parser.ml" 32909 32897 32910 32898 in 32911 32899 32912 32900 # 3167 "parsing/parser.mly" 32913 32901 ( _1 ) 32914 32914 - # 32915 "parsing/parser.ml" 32902 32902 + # 32903 "parsing/parser.ml" 32915 32903 32916 32904 in 32917 32905 32918 32906 # 1650 "parsing/parser.mly" 32919 32907 ( psig_typext _1 ) 32920 32920 - # 32921 "parsing/parser.ml" 32908 32908 + # 32909 "parsing/parser.ml" 32921 32909 32922 32910 in 32923 32911 let _endpos__1_ = _endpos__1_inlined3_ in ··· 32927 32915 32928 32916 # 941 "parsing/parser.mly" 32929 32917 ( wrap_mksig_ext ~loc:_sloc _1 ) 32930 32930 - # 32931 "parsing/parser.ml" 32918 32918 + # 32919 "parsing/parser.ml" 32931 32919 32932 32920 in 32933 32921 32934 32922 # 1674 "parsing/parser.mly" 32935 32923 ( _1 ) 32936 32936 - # 32937 "parsing/parser.ml" 32924 32924 + # 32925 "parsing/parser.ml" 32937 32925 in 32938 32926 { 32939 32927 MenhirLib.EngineTypes.state = _menhir_s; ··· 33027 33015 33028 33016 # 3836 "parsing/parser.mly" 33029 33017 ( _1 ) 33030 33030 - # 33031 "parsing/parser.ml" 33018 33018 + # 33019 "parsing/parser.ml" 33031 33019 33032 33020 in 33033 33021 let _endpos_attrs2_ = _endpos__1_inlined4_ in 33034 33022 let cs = 33035 33023 # 1106 "parsing/parser.mly" 33036 33024 ( List.rev xs ) 33037 33037 - # 33038 "parsing/parser.ml" 33025 33025 + # 33026 "parsing/parser.ml" 33038 33026 in 33039 33027 let tid = 33040 33028 let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in ··· 33044 33032 33045 33033 # 883 "parsing/parser.mly" 33046 33034 ( mkrhs _1 _sloc ) 33047 33047 - # 33048 "parsing/parser.ml" 33035 33035 + # 33036 "parsing/parser.ml" 33048 33036 33049 33037 in 33050 33038 let _4 = ··· 33055 33043 33056 33044 # 3683 "parsing/parser.mly" 33057 33045 ( not_expecting _loc "nonrec flag" ) 33058 33058 - # 33059 "parsing/parser.ml" 33046 33046 + # 33047 "parsing/parser.ml" 33059 33047 33060 33048 in 33061 33049 let attrs1 = ··· 33063 33051 33064 33052 # 3840 "parsing/parser.mly" 33065 33053 ( _1 ) 33066 33066 - # 33067 "parsing/parser.ml" 33054 33054 + # 33055 "parsing/parser.ml" 33067 33055 33068 33056 in 33069 33057 let _endpos = _endpos_attrs2_ in ··· 33075 33063 let attrs = attrs1 @ attrs2 in 33076 33064 Te.mk tid cs ~params ~priv ~attrs ~docs, 33077 33065 ext ) 33078 33078 - # 33079 "parsing/parser.ml" 33066 33066 + # 33067 "parsing/parser.ml" 33079 33067 33080 33068 in 33081 33069 33082 33070 # 3167 "parsing/parser.mly" 33083 33071 ( _1 ) 33084 33084 - # 33085 "parsing/parser.ml" 33072 33072 + # 33073 "parsing/parser.ml" 33085 33073 33086 33074 in 33087 33075 33088 33076 # 1650 "parsing/parser.mly" 33089 33077 ( psig_typext _1 ) 33090 33090 - # 33091 "parsing/parser.ml" 33078 33078 + # 33079 "parsing/parser.ml" 33091 33079 33092 33080 in 33093 33081 let _endpos__1_ = _endpos__1_inlined4_ in ··· 33097 33085 33098 33086 # 941 "parsing/parser.mly" 33099 33087 ( wrap_mksig_ext ~loc:_sloc _1 ) 33100 33100 - # 33101 "parsing/parser.ml" 33088 33088 + # 33089 "parsing/parser.ml" 33101 33089 33102 33090 in 33103 33091 33104 33092 # 1674 "parsing/parser.mly" 33105 33093 ( _1 ) 33106 33106 - # 33107 "parsing/parser.ml" 33094 33094 + # 33095 "parsing/parser.ml" 33107 33095 in 33108 33096 { 33109 33097 MenhirLib.EngineTypes.state = _menhir_s; ··· 33129 33117 let _1 = 33130 33118 # 1652 "parsing/parser.mly" 33131 33119 ( psig_exception _1 ) 33132 33132 - # 33133 "parsing/parser.ml" 33120 33120 + # 33121 "parsing/parser.ml" 33133 33121 in 33134 33122 let _endpos = _endpos__1_ in 33135 33123 let _symbolstartpos = _startpos__1_ in ··· 33137 33125 33138 33126 # 941 "parsing/parser.mly" 33139 33127 ( wrap_mksig_ext ~loc:_sloc _1 ) 33140 33140 - # 33141 "parsing/parser.ml" 33128 33128 + # 33129 "parsing/parser.ml" 33141 33129 33142 33130 in 33143 33131 33144 33132 # 1674 "parsing/parser.mly" 33145 33133 ( _1 ) 33146 33146 - # 33147 "parsing/parser.ml" 33134 33134 + # 33135 "parsing/parser.ml" 33147 33135 in 33148 33136 { 33149 33137 MenhirLib.EngineTypes.state = _menhir_s; ··· 33208 33196 33209 33197 # 3836 "parsing/parser.mly" 33210 33198 ( _1 ) 33211 33211 - # 33212 "parsing/parser.ml" 33199 33199 + # 33200 "parsing/parser.ml" 33212 33200 33213 33201 in 33214 33202 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 33220 33208 33221 33209 # 883 "parsing/parser.mly" 33222 33210 ( mkrhs _1 _sloc ) 33223 33223 - # 33224 "parsing/parser.ml" 33211 33211 + # 33212 "parsing/parser.ml" 33224 33212 33225 33213 in 33226 33214 let attrs1 = ··· 33228 33216 33229 33217 # 3840 "parsing/parser.mly" 33230 33218 ( _1 ) 33231 33231 - # 33232 "parsing/parser.ml" 33219 33219 + # 33220 "parsing/parser.ml" 33232 33220 33233 33221 in 33234 33222 let _endpos = _endpos_attrs2_ in ··· 33242 33230 let docs = symbol_docs _sloc in 33243 33231 Md.mk name body ~attrs ~loc ~docs, ext 33244 33232 ) 33245 33245 - # 33246 "parsing/parser.ml" 33233 33233 + # 33234 "parsing/parser.ml" 33246 33234 33247 33235 in 33248 33236 33249 33237 # 1654 "parsing/parser.mly" 33250 33238 ( let (body, ext) = _1 in (Psig_module body, ext) ) 33251 33251 - # 33252 "parsing/parser.ml" 33239 33239 + # 33240 "parsing/parser.ml" 33252 33240 33253 33241 in 33254 33242 let _endpos__1_ = _endpos__1_inlined3_ in ··· 33258 33246 33259 33247 # 941 "parsing/parser.mly" 33260 33248 ( wrap_mksig_ext ~loc:_sloc _1 ) 33261 33261 - # 33262 "parsing/parser.ml" 33249 33249 + # 33250 "parsing/parser.ml" 33262 33250 33263 33251 in 33264 33252 33265 33253 # 1674 "parsing/parser.mly" 33266 33254 ( _1 ) 33267 33267 - # 33268 "parsing/parser.ml" 33255 33255 + # 33256 "parsing/parser.ml" 33268 33256 in 33269 33257 { 33270 33258 MenhirLib.EngineTypes.state = _menhir_s; ··· 33336 33324 33337 33325 # 3836 "parsing/parser.mly" 33338 33326 ( _1 ) 33339 33339 - # 33340 "parsing/parser.ml" 33327 33327 + # 33328 "parsing/parser.ml" 33340 33328 33341 33329 in 33342 33330 let _endpos_attrs2_ = _endpos__1_inlined4_ in ··· 33349 33337 33350 33338 # 883 "parsing/parser.mly" 33351 33339 ( mkrhs _1 _sloc ) 33352 33352 - # 33353 "parsing/parser.ml" 33340 33340 + # 33341 "parsing/parser.ml" 33353 33341 33354 33342 in 33355 33343 let (_endpos_id_, _startpos_id_) = (_endpos__1_, _startpos__1_) in ··· 33359 33347 33360 33348 # 1720 "parsing/parser.mly" 33361 33349 ( Mty.alias ~loc:(make_loc _sloc) id ) 33362 33362 - # 33363 "parsing/parser.ml" 33350 33350 + # 33351 "parsing/parser.ml" 33363 33351 33364 33352 in 33365 33353 let name = ··· 33370 33358 33371 33359 # 883 "parsing/parser.mly" 33372 33360 ( mkrhs _1 _sloc ) 33373 33373 - # 33374 "parsing/parser.ml" 33361 33361 + # 33362 "parsing/parser.ml" 33374 33362 33375 33363 in 33376 33364 let attrs1 = ··· 33378 33366 33379 33367 # 3840 "parsing/parser.mly" 33380 33368 ( _1 ) 33381 33381 - # 33382 "parsing/parser.ml" 33369 33369 + # 33370 "parsing/parser.ml" 33382 33370 33383 33371 in 33384 33372 let _endpos = _endpos_attrs2_ in ··· 33392 33380 let docs = symbol_docs _sloc in 33393 33381 Md.mk name body ~attrs ~loc ~docs, ext 33394 33382 ) 33395 33395 - # 33396 "parsing/parser.ml" 33383 33383 + # 33384 "parsing/parser.ml" 33396 33384 33397 33385 in 33398 33386 33399 33387 # 1656 "parsing/parser.mly" 33400 33388 ( let (body, ext) = _1 in (Psig_module body, ext) ) 33401 33401 - # 33402 "parsing/parser.ml" 33389 33389 + # 33390 "parsing/parser.ml" 33402 33390 33403 33391 in 33404 33392 let _endpos__1_ = _endpos__1_inlined4_ in ··· 33408 33396 33409 33397 # 941 "parsing/parser.mly" 33410 33398 ( wrap_mksig_ext ~loc:_sloc _1 ) 33411 33411 - # 33412 "parsing/parser.ml" 33399 33399 + # 33400 "parsing/parser.ml" 33412 33400 33413 33401 in 33414 33402 33415 33403 # 1674 "parsing/parser.mly" 33416 33404 ( _1 ) 33417 33417 - # 33418 "parsing/parser.ml" 33405 33405 + # 33406 "parsing/parser.ml" 33418 33406 in 33419 33407 { 33420 33408 MenhirLib.EngineTypes.state = _menhir_s; ··· 33440 33428 let _1 = 33441 33429 # 1658 "parsing/parser.mly" 33442 33430 ( let (body, ext) = _1 in (Psig_modsubst body, ext) ) 33443 33443 - # 33444 "parsing/parser.ml" 33431 33431 + # 33432 "parsing/parser.ml" 33444 33432 in 33445 33433 let _endpos = _endpos__1_ in 33446 33434 let _symbolstartpos = _startpos__1_ in ··· 33448 33436 33449 33437 # 941 "parsing/parser.mly" 33450 33438 ( wrap_mksig_ext ~loc:_sloc _1 ) 33451 33451 - # 33452 "parsing/parser.ml" 33439 33439 + # 33440 "parsing/parser.ml" 33452 33440 33453 33441 in 33454 33442 33455 33443 # 1674 "parsing/parser.mly" 33456 33444 ( _1 ) 33457 33457 - # 33458 "parsing/parser.ml" 33445 33445 + # 33446 "parsing/parser.ml" 33458 33446 in 33459 33447 { 33460 33448 MenhirLib.EngineTypes.state = _menhir_s; ··· 33542 33530 33543 33531 # 3836 "parsing/parser.mly" 33544 33532 ( _1 ) 33545 33545 - # 33546 "parsing/parser.ml" 33533 33533 + # 33534 "parsing/parser.ml" 33546 33534 33547 33535 in 33548 33536 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 33554 33542 33555 33543 # 883 "parsing/parser.mly" 33556 33544 ( mkrhs _1 _sloc ) 33557 33557 - # 33558 "parsing/parser.ml" 33545 33545 + # 33546 "parsing/parser.ml" 33558 33546 33559 33547 in 33560 33548 let attrs1 = ··· 33562 33550 33563 33551 # 3840 "parsing/parser.mly" 33564 33552 ( _1 ) 33565 33565 - # 33566 "parsing/parser.ml" 33553 33553 + # 33554 "parsing/parser.ml" 33566 33554 33567 33555 in 33568 33556 let _endpos = _endpos_attrs2_ in ··· 33576 33564 let docs = symbol_docs _sloc in 33577 33565 ext, Md.mk name mty ~attrs ~loc ~docs 33578 33566 ) 33579 33579 - # 33580 "parsing/parser.ml" 33567 33567 + # 33568 "parsing/parser.ml" 33580 33568 33581 33569 in 33582 33570 33583 33571 # 1114 "parsing/parser.mly" 33584 33572 ( let (x, b) = a in x, b :: bs ) 33585 33585 - # 33586 "parsing/parser.ml" 33573 33573 + # 33574 "parsing/parser.ml" 33586 33574 33587 33575 in 33588 33576 33589 33577 # 1743 "parsing/parser.mly" 33590 33578 ( _1 ) 33591 33591 - # 33592 "parsing/parser.ml" 33579 33579 + # 33580 "parsing/parser.ml" 33592 33580 33593 33581 in 33594 33582 33595 33583 # 1660 "parsing/parser.mly" 33596 33584 ( let (ext, l) = _1 in (Psig_recmodule l, ext) ) 33597 33597 - # 33598 "parsing/parser.ml" 33585 33585 + # 33586 "parsing/parser.ml" 33598 33586 33599 33587 in 33600 33588 let _endpos__1_ = _endpos_bs_ in ··· 33604 33592 33605 33593 # 941 "parsing/parser.mly" 33606 33594 ( wrap_mksig_ext ~loc:_sloc _1 ) 33607 33607 - # 33608 "parsing/parser.ml" 33595 33595 + # 33596 "parsing/parser.ml" 33608 33596 33609 33597 in 33610 33598 33611 33599 # 1674 "parsing/parser.mly" 33612 33600 ( _1 ) 33613 33613 - # 33614 "parsing/parser.ml" 33601 33601 + # 33602 "parsing/parser.ml" 33614 33602 in 33615 33603 { 33616 33604 MenhirLib.EngineTypes.state = _menhir_s; ··· 33636 33624 let _1 = 33637 33625 # 1662 "parsing/parser.mly" 33638 33626 ( let (body, ext) = _1 in (Psig_modtype body, ext) ) 33639 33639 - # 33640 "parsing/parser.ml" 33627 33627 + # 33628 "parsing/parser.ml" 33640 33628 in 33641 33629 let _endpos = _endpos__1_ in 33642 33630 let _symbolstartpos = _startpos__1_ in ··· 33644 33632 33645 33633 # 941 "parsing/parser.mly" 33646 33634 ( wrap_mksig_ext ~loc:_sloc _1 ) 33647 33647 - # 33648 "parsing/parser.ml" 33635 33635 + # 33636 "parsing/parser.ml" 33648 33636 33649 33637 in 33650 33638 33651 33639 # 1674 "parsing/parser.mly" 33652 33640 ( _1 ) 33653 33653 - # 33654 "parsing/parser.ml" 33641 33641 + # 33642 "parsing/parser.ml" 33654 33642 in 33655 33643 { 33656 33644 MenhirLib.EngineTypes.state = _menhir_s; ··· 33676 33664 let _1 = 33677 33665 # 1664 "parsing/parser.mly" 33678 33666 ( let (body, ext) = _1 in (Psig_modtypesubst body, ext) ) 33679 33679 - # 33680 "parsing/parser.ml" 33667 33667 + # 33668 "parsing/parser.ml" 33680 33668 in 33681 33669 let _endpos = _endpos__1_ in 33682 33670 let _symbolstartpos = _startpos__1_ in ··· 33684 33672 33685 33673 # 941 "parsing/parser.mly" 33686 33674 ( wrap_mksig_ext ~loc:_sloc _1 ) 33687 33687 - # 33688 "parsing/parser.ml" 33675 33675 + # 33676 "parsing/parser.ml" 33688 33676 33689 33677 in 33690 33678 33691 33679 # 1674 "parsing/parser.mly" 33692 33680 ( _1 ) 33693 33693 - # 33694 "parsing/parser.ml" 33681 33681 + # 33682 "parsing/parser.ml" 33694 33682 in 33695 33683 { 33696 33684 MenhirLib.EngineTypes.state = _menhir_s; ··· 33716 33704 let _1 = 33717 33705 # 1666 "parsing/parser.mly" 33718 33706 ( let (body, ext) = _1 in (Psig_open body, ext) ) 33719 33719 - # 33720 "parsing/parser.ml" 33707 33707 + # 33708 "parsing/parser.ml" 33720 33708 in 33721 33709 let _endpos = _endpos__1_ in 33722 33710 let _symbolstartpos = _startpos__1_ in ··· 33724 33712 33725 33713 # 941 "parsing/parser.mly" 33726 33714 ( wrap_mksig_ext ~loc:_sloc _1 ) 33727 33727 - # 33728 "parsing/parser.ml" 33715 33715 + # 33716 "parsing/parser.ml" 33728 33716 33729 33717 in 33730 33718 33731 33719 # 1674 "parsing/parser.mly" 33732 33720 ( _1 ) 33733 33733 - # 33734 "parsing/parser.ml" 33721 33721 + # 33722 "parsing/parser.ml" 33734 33722 in 33735 33723 { 33736 33724 MenhirLib.EngineTypes.state = _menhir_s; ··· 33788 33776 33789 33777 # 3836 "parsing/parser.mly" 33790 33778 ( _1 ) 33791 33791 - # 33792 "parsing/parser.ml" 33779 33779 + # 33780 "parsing/parser.ml" 33792 33780 33793 33781 in 33794 33782 let _endpos_attrs2_ = _endpos__1_inlined2_ in ··· 33797 33785 33798 33786 # 3840 "parsing/parser.mly" 33799 33787 ( _1 ) 33800 33800 - # 33801 "parsing/parser.ml" 33788 33788 + # 33789 "parsing/parser.ml" 33801 33789 33802 33790 in 33803 33791 let _endpos = _endpos_attrs2_ in ··· 33811 33799 let docs = symbol_docs _sloc in 33812 33800 Incl.mk thing ~attrs ~loc ~docs, ext 33813 33801 ) 33814 33814 - # 33815 "parsing/parser.ml" 33802 33802 + # 33803 "parsing/parser.ml" 33815 33803 33816 33804 in 33817 33805 33818 33806 # 1668 "parsing/parser.mly" 33819 33807 ( psig_include _1 ) 33820 33820 - # 33821 "parsing/parser.ml" 33808 33808 + # 33809 "parsing/parser.ml" 33821 33809 33822 33810 in 33823 33811 let _endpos__1_ = _endpos__1_inlined2_ in ··· 33827 33815 33828 33816 # 941 "parsing/parser.mly" 33829 33817 ( wrap_mksig_ext ~loc:_sloc _1 ) 33830 33830 - # 33831 "parsing/parser.ml" 33818 33818 + # 33819 "parsing/parser.ml" 33831 33819 33832 33820 in 33833 33821 33834 33822 # 1674 "parsing/parser.mly" 33835 33823 ( _1 ) 33836 33836 - # 33837 "parsing/parser.ml" 33824 33824 + # 33825 "parsing/parser.ml" 33837 33825 in 33838 33826 { 33839 33827 MenhirLib.EngineTypes.state = _menhir_s; ··· 33912 33900 let _1_inlined2 : ( 33913 33901 # 705 "parsing/parser.mly" 33914 33902 (string) 33915 33915 - # 33916 "parsing/parser.ml" 33903 33903 + # 33904 "parsing/parser.ml" 33916 33904 ) = Obj.magic _1_inlined2 in 33917 33905 let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in 33918 33906 let virt : (Asttypes.virtual_flag) = Obj.magic virt in ··· 33932 33920 33933 33921 # 3836 "parsing/parser.mly" 33934 33922 ( _1 ) 33935 33935 - # 33936 "parsing/parser.ml" 33923 33923 + # 33924 "parsing/parser.ml" 33936 33924 33937 33925 in 33938 33926 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 33944 33932 33945 33933 # 883 "parsing/parser.mly" 33946 33934 ( mkrhs _1 _sloc ) 33947 33947 - # 33948 "parsing/parser.ml" 33935 33935 + # 33936 "parsing/parser.ml" 33948 33936 33949 33937 in 33950 33938 let attrs1 = ··· 33952 33940 33953 33941 # 3840 "parsing/parser.mly" 33954 33942 ( _1 ) 33955 33955 - # 33956 "parsing/parser.ml" 33943 33943 + # 33944 "parsing/parser.ml" 33956 33944 33957 33945 in 33958 33946 let _endpos = _endpos_attrs2_ in ··· 33967 33955 ext, 33968 33956 Ci.mk id cty ~virt ~params ~attrs ~loc ~docs 33969 33957 ) 33970 33970 - # 33971 "parsing/parser.ml" 33958 33958 + # 33959 "parsing/parser.ml" 33971 33959 33972 33960 in 33973 33961 33974 33962 # 1114 "parsing/parser.mly" 33975 33963 ( let (x, b) = a in x, b :: bs ) 33976 33976 - # 33977 "parsing/parser.ml" 33964 33964 + # 33965 "parsing/parser.ml" 33977 33965 33978 33966 in 33979 33967 33980 33968 # 2089 "parsing/parser.mly" 33981 33969 ( _1 ) 33982 33982 - # 33983 "parsing/parser.ml" 33970 33970 + # 33971 "parsing/parser.ml" 33983 33971 33984 33972 in 33985 33973 33986 33974 # 1670 "parsing/parser.mly" 33987 33975 ( let (ext, l) = _1 in (Psig_class l, ext) ) 33988 33988 - # 33989 "parsing/parser.ml" 33976 33976 + # 33977 "parsing/parser.ml" 33989 33977 33990 33978 in 33991 33979 let _endpos__1_ = _endpos_bs_ in ··· 33995 33983 33996 33984 # 941 "parsing/parser.mly" 33997 33985 ( wrap_mksig_ext ~loc:_sloc _1 ) 33998 33998 - # 33999 "parsing/parser.ml" 33986 33986 + # 33987 "parsing/parser.ml" 33999 33987 34000 33988 in 34001 33989 34002 33990 # 1674 "parsing/parser.mly" 34003 33991 ( _1 ) 34004 34004 - # 34005 "parsing/parser.ml" 33992 33992 + # 33993 "parsing/parser.ml" 34005 33993 in 34006 33994 { 34007 33995 MenhirLib.EngineTypes.state = _menhir_s; ··· 34027 34015 let _1 = 34028 34016 # 1672 "parsing/parser.mly" 34029 34017 ( let (ext, l) = _1 in (Psig_class_type l, ext) ) 34030 34030 - # 34031 "parsing/parser.ml" 34018 34018 + # 34019 "parsing/parser.ml" 34031 34019 in 34032 34020 let _endpos = _endpos__1_ in 34033 34021 let _symbolstartpos = _startpos__1_ in ··· 34035 34023 34036 34024 # 941 "parsing/parser.mly" 34037 34025 ( wrap_mksig_ext ~loc:_sloc _1 ) 34038 34038 - # 34039 "parsing/parser.ml" 34026 34026 + # 34027 "parsing/parser.ml" 34039 34027 34040 34028 in 34041 34029 34042 34030 # 1674 "parsing/parser.mly" 34043 34031 ( _1 ) 34044 34044 - # 34045 "parsing/parser.ml" 34032 34032 + # 34033 "parsing/parser.ml" 34045 34033 in 34046 34034 { 34047 34035 MenhirLib.EngineTypes.state = _menhir_s; ··· 34066 34054 let _v : (Parsetree.constant) = 34067 34055 # 3510 "parsing/parser.mly" 34068 34056 ( _1 ) 34069 34069 - # 34070 "parsing/parser.ml" 34057 34057 + # 34058 "parsing/parser.ml" 34070 34058 in 34071 34059 { 34072 34060 MenhirLib.EngineTypes.state = _menhir_s; ··· 34093 34081 let _2 : ( 34094 34082 # 691 "parsing/parser.mly" 34095 34083 (string * char option) 34096 34096 - # 34097 "parsing/parser.ml" 34084 34084 + # 34085 "parsing/parser.ml" 34097 34085 ) = Obj.magic _2 in 34098 34086 let _1 : unit = Obj.magic _1 in 34099 34087 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 34102 34090 let _v : (Parsetree.constant) = 34103 34091 # 3511 "parsing/parser.mly" 34104 34092 ( let (n, m) = _2 in Pconst_integer("-" ^ n, m) ) 34105 34105 - # 34106 "parsing/parser.ml" 34093 34093 + # 34094 "parsing/parser.ml" 34106 34094 in 34107 34095 { 34108 34096 MenhirLib.EngineTypes.state = _menhir_s; ··· 34129 34117 let _2 : ( 34130 34118 # 670 "parsing/parser.mly" 34131 34119 (string * char option) 34132 34132 - # 34133 "parsing/parser.ml" 34120 34120 + # 34121 "parsing/parser.ml" 34133 34121 ) = Obj.magic _2 in 34134 34122 let _1 : unit = Obj.magic _1 in 34135 34123 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 34138 34126 let _v : (Parsetree.constant) = 34139 34127 # 3512 "parsing/parser.mly" 34140 34128 ( let (f, m) = _2 in Pconst_float("-" ^ f, m) ) 34141 34141 - # 34142 "parsing/parser.ml" 34129 34129 + # 34130 "parsing/parser.ml" 34142 34130 in 34143 34131 { 34144 34132 MenhirLib.EngineTypes.state = _menhir_s; ··· 34165 34153 let _2 : ( 34166 34154 # 691 "parsing/parser.mly" 34167 34155 (string * char option) 34168 34168 - # 34169 "parsing/parser.ml" 34156 34156 + # 34157 "parsing/parser.ml" 34169 34157 ) = Obj.magic _2 in 34170 34158 let _1 : unit = Obj.magic _1 in 34171 34159 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 34174 34162 let _v : (Parsetree.constant) = 34175 34163 # 3513 "parsing/parser.mly" 34176 34164 ( let (n, m) = _2 in Pconst_integer (n, m) ) 34177 34177 - # 34178 "parsing/parser.ml" 34165 34165 + # 34166 "parsing/parser.ml" 34178 34166 in 34179 34167 { 34180 34168 MenhirLib.EngineTypes.state = _menhir_s; ··· 34201 34189 let _2 : ( 34202 34190 # 670 "parsing/parser.mly" 34203 34191 (string * char option) 34204 34204 - # 34205 "parsing/parser.ml" 34192 34192 + # 34193 "parsing/parser.ml" 34205 34193 ) = Obj.magic _2 in 34206 34194 let _1 : unit = Obj.magic _1 in 34207 34195 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 34210 34198 let _v : (Parsetree.constant) = 34211 34199 # 3514 "parsing/parser.mly" 34212 34200 ( let (f, m) = _2 in Pconst_float(f, m) ) 34213 34213 - # 34214 "parsing/parser.ml" 34201 34201 + # 34202 "parsing/parser.ml" 34214 34202 in 34215 34203 { 34216 34204 MenhirLib.EngineTypes.state = _menhir_s; ··· 34255 34243 ( let fields, closed = _1 in 34256 34244 let closed = match closed with Some () -> Open | None -> Closed in 34257 34245 fields, closed ) 34258 34258 - # 34259 "parsing/parser.ml" 34246 34246 + # 34247 "parsing/parser.ml" 34259 34247 34260 34248 in 34261 34249 34262 34250 # 2809 "parsing/parser.mly" 34263 34251 ( let (fields, closed) = _2 in 34264 34252 Ppat_record(fields, closed) ) 34265 34265 - # 34266 "parsing/parser.ml" 34253 34253 + # 34254 "parsing/parser.ml" 34266 34254 34267 34255 in 34268 34256 let _endpos__1_ = _endpos__3_ in ··· 34272 34260 34273 34261 # 918 "parsing/parser.mly" 34274 34262 ( mkpat ~loc:_sloc _1 ) 34275 34275 - # 34276 "parsing/parser.ml" 34263 34263 + # 34264 "parsing/parser.ml" 34276 34264 34277 34265 in 34278 34266 34279 34267 # 2823 "parsing/parser.mly" 34280 34268 ( _1 ) 34281 34281 - # 34282 "parsing/parser.ml" 34269 34269 + # 34270 "parsing/parser.ml" 34282 34270 in 34283 34271 { 34284 34272 MenhirLib.EngineTypes.state = _menhir_s; ··· 34323 34311 ( let fields, closed = _1 in 34324 34312 let closed = match closed with Some () -> Open | None -> Closed in 34325 34313 fields, closed ) 34326 34326 - # 34327 "parsing/parser.ml" 34314 34314 + # 34315 "parsing/parser.ml" 34327 34315 34328 34316 in 34329 34317 let _loc__3_ = (_startpos__3_, _endpos__3_) in ··· 34331 34319 34332 34320 # 2812 "parsing/parser.mly" 34333 34321 ( unclosed "{" _loc__1_ "}" _loc__3_ ) 34334 34334 - # 34335 "parsing/parser.ml" 34322 34322 + # 34323 "parsing/parser.ml" 34335 34323 34336 34324 in 34337 34325 let _endpos__1_ = _endpos__3_ in ··· 34341 34329 34342 34330 # 918 "parsing/parser.mly" 34343 34331 ( mkpat ~loc:_sloc _1 ) 34344 34344 - # 34345 "parsing/parser.ml" 34332 34332 + # 34333 "parsing/parser.ml" 34345 34333 34346 34334 in 34347 34335 34348 34336 # 2823 "parsing/parser.mly" 34349 34337 ( _1 ) 34350 34350 - # 34351 "parsing/parser.ml" 34338 34338 + # 34339 "parsing/parser.ml" 34351 34339 in 34352 34340 { 34353 34341 MenhirLib.EngineTypes.state = _menhir_s; ··· 34388 34376 let _2 = 34389 34377 # 2832 "parsing/parser.mly" 34390 34378 ( ps ) 34391 34391 - # 34392 "parsing/parser.ml" 34379 34379 + # 34380 "parsing/parser.ml" 34392 34380 in 34393 34381 let _loc__3_ = (_startpos__3_, _endpos__3_) in 34394 34382 34395 34383 # 2814 "parsing/parser.mly" 34396 34384 ( fst (mktailpat _loc__3_ _2) ) 34397 34397 - # 34398 "parsing/parser.ml" 34385 34385 + # 34386 "parsing/parser.ml" 34398 34386 34399 34387 in 34400 34388 let _endpos__1_ = _endpos__3_ in ··· 34404 34392 34405 34393 # 918 "parsing/parser.mly" 34406 34394 ( mkpat ~loc:_sloc _1 ) 34407 34407 - # 34408 "parsing/parser.ml" 34395 34395 + # 34396 "parsing/parser.ml" 34408 34396 34409 34397 in 34410 34398 34411 34399 # 2823 "parsing/parser.mly" 34412 34400 ( _1 ) 34413 34413 - # 34414 "parsing/parser.ml" 34401 34401 + # 34402 "parsing/parser.ml" 34414 34402 in 34415 34403 { 34416 34404 MenhirLib.EngineTypes.state = _menhir_s; ··· 34451 34439 let _2 = 34452 34440 # 2832 "parsing/parser.mly" 34453 34441 ( ps ) 34454 34454 - # 34455 "parsing/parser.ml" 34442 34442 + # 34443 "parsing/parser.ml" 34455 34443 in 34456 34444 let _loc__3_ = (_startpos__3_, _endpos__3_) in 34457 34445 let _loc__1_ = (_startpos__1_, _endpos__1_) in 34458 34446 34459 34447 # 2816 "parsing/parser.mly" 34460 34448 ( unclosed "[" _loc__1_ "]" _loc__3_ ) 34461 34461 - # 34462 "parsing/parser.ml" 34449 34449 + # 34450 "parsing/parser.ml" 34462 34450 34463 34451 in 34464 34452 let _endpos__1_ = _endpos__3_ in ··· 34468 34456 34469 34457 # 918 "parsing/parser.mly" 34470 34458 ( mkpat ~loc:_sloc _1 ) 34471 34471 - # 34472 "parsing/parser.ml" 34459 34459 + # 34460 "parsing/parser.ml" 34472 34460 34473 34461 in 34474 34462 34475 34463 # 2823 "parsing/parser.mly" 34476 34464 ( _1 ) 34477 34477 - # 34478 "parsing/parser.ml" 34465 34465 + # 34466 "parsing/parser.ml" 34478 34466 in 34479 34467 { 34480 34468 MenhirLib.EngineTypes.state = _menhir_s; ··· 34515 34503 let _2 = 34516 34504 # 2832 "parsing/parser.mly" 34517 34505 ( ps ) 34518 34518 - # 34519 "parsing/parser.ml" 34506 34506 + # 34507 "parsing/parser.ml" 34519 34507 in 34520 34508 34521 34509 # 2818 "parsing/parser.mly" 34522 34510 ( Ppat_array _2 ) 34523 34523 - # 34524 "parsing/parser.ml" 34511 34511 + # 34512 "parsing/parser.ml" 34524 34512 34525 34513 in 34526 34514 let _endpos__1_ = _endpos__3_ in ··· 34530 34518 34531 34519 # 918 "parsing/parser.mly" 34532 34520 ( mkpat ~loc:_sloc _1 ) 34533 34533 - # 34534 "parsing/parser.ml" 34521 34521 + # 34522 "parsing/parser.ml" 34534 34522 34535 34523 in 34536 34524 34537 34525 # 2823 "parsing/parser.mly" 34538 34526 ( _1 ) 34539 34539 - # 34540 "parsing/parser.ml" 34527 34527 + # 34528 "parsing/parser.ml" 34540 34528 in 34541 34529 { 34542 34530 MenhirLib.EngineTypes.state = _menhir_s; ··· 34569 34557 let _1 = 34570 34558 # 2820 "parsing/parser.mly" 34571 34559 ( Ppat_array [] ) 34572 34572 - # 34573 "parsing/parser.ml" 34560 34560 + # 34561 "parsing/parser.ml" 34573 34561 in 34574 34562 let _endpos__1_ = _endpos__2_ in 34575 34563 let _endpos = _endpos__1_ in ··· 34578 34566 34579 34567 # 918 "parsing/parser.mly" 34580 34568 ( mkpat ~loc:_sloc _1 ) 34581 34581 - # 34582 "parsing/parser.ml" 34569 34569 + # 34570 "parsing/parser.ml" 34582 34570 34583 34571 in 34584 34572 34585 34573 # 2823 "parsing/parser.mly" 34586 34574 ( _1 ) 34587 34587 - # 34588 "parsing/parser.ml" 34575 34575 + # 34576 "parsing/parser.ml" 34588 34576 in 34589 34577 { 34590 34578 MenhirLib.EngineTypes.state = _menhir_s; ··· 34625 34613 let _2 = 34626 34614 # 2832 "parsing/parser.mly" 34627 34615 ( ps ) 34628 34628 - # 34629 "parsing/parser.ml" 34616 34616 + # 34617 "parsing/parser.ml" 34629 34617 in 34630 34618 let _loc__3_ = (_startpos__3_, _endpos__3_) in 34631 34619 let _loc__1_ = (_startpos__1_, _endpos__1_) in 34632 34620 34633 34621 # 2822 "parsing/parser.mly" 34634 34622 ( unclosed "[|" _loc__1_ "|]" _loc__3_ ) 34635 34635 - # 34636 "parsing/parser.ml" 34623 34623 + # 34624 "parsing/parser.ml" 34636 34624 34637 34625 in 34638 34626 let _endpos__1_ = _endpos__3_ in ··· 34642 34630 34643 34631 # 918 "parsing/parser.mly" 34644 34632 ( mkpat ~loc:_sloc _1 ) 34645 34645 - # 34646 "parsing/parser.ml" 34633 34633 + # 34634 "parsing/parser.ml" 34646 34634 34647 34635 in 34648 34636 34649 34637 # 2823 "parsing/parser.mly" 34650 34638 ( _1 ) 34651 34651 - # 34652 "parsing/parser.ml" 34639 34639 + # 34640 "parsing/parser.ml" 34652 34640 in 34653 34641 { 34654 34642 MenhirLib.EngineTypes.state = _menhir_s; ··· 34690 34678 34691 34679 # 2337 "parsing/parser.mly" 34692 34680 ( reloc_exp ~loc:_sloc _2 ) 34693 34693 - # 34694 "parsing/parser.ml" 34681 34681 + # 34682 "parsing/parser.ml" 34694 34682 in 34695 34683 { 34696 34684 MenhirLib.EngineTypes.state = _menhir_s; ··· 34731 34719 34732 34720 # 2339 "parsing/parser.mly" 34733 34721 ( unclosed "(" _loc__1_ ")" _loc__3_ ) 34734 34734 - # 34735 "parsing/parser.ml" 34722 34722 + # 34723 "parsing/parser.ml" 34735 34723 in 34736 34724 { 34737 34725 MenhirLib.EngineTypes.state = _menhir_s; ··· 34780 34768 34781 34769 # 2341 "parsing/parser.mly" 34782 34770 ( mkexp_constraint ~loc:_sloc _2 _3 ) 34783 34783 - # 34784 "parsing/parser.ml" 34771 34771 + # 34772 "parsing/parser.ml" 34784 34772 in 34785 34773 { 34786 34774 MenhirLib.EngineTypes.state = _menhir_s; ··· 34834 34822 let r = 34835 34823 # 2342 "parsing/parser.mly" 34836 34824 ( None ) 34837 34837 - # 34838 "parsing/parser.ml" 34825 34825 + # 34826 "parsing/parser.ml" 34838 34826 in 34839 34827 34840 34828 # 2231 "parsing/parser.mly" 34841 34829 ( array, d, Paren, i, r ) 34842 34842 - # 34843 "parsing/parser.ml" 34830 34830 + # 34831 "parsing/parser.ml" 34843 34831 34844 34832 in 34845 34833 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 34849 34837 34850 34838 # 2343 "parsing/parser.mly" 34851 34839 ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) 34852 34852 - # 34853 "parsing/parser.ml" 34840 34840 + # 34841 "parsing/parser.ml" 34853 34841 in 34854 34842 { 34855 34843 MenhirLib.EngineTypes.state = _menhir_s; ··· 34903 34891 let r = 34904 34892 # 2342 "parsing/parser.mly" 34905 34893 ( None ) 34906 34906 - # 34907 "parsing/parser.ml" 34894 34894 + # 34895 "parsing/parser.ml" 34907 34895 in 34908 34896 34909 34897 # 2233 "parsing/parser.mly" 34910 34898 ( array, d, Brace, i, r ) 34911 34911 - # 34912 "parsing/parser.ml" 34899 34899 + # 34900 "parsing/parser.ml" 34912 34900 34913 34901 in 34914 34902 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 34918 34906 34919 34907 # 2343 "parsing/parser.mly" 34920 34908 ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) 34921 34921 - # 34922 "parsing/parser.ml" 34909 34909 + # 34910 "parsing/parser.ml" 34922 34910 in 34923 34911 { 34924 34912 MenhirLib.EngineTypes.state = _menhir_s; ··· 34972 34960 let r = 34973 34961 # 2342 "parsing/parser.mly" 34974 34962 ( None ) 34975 34975 - # 34976 "parsing/parser.ml" 34963 34963 + # 34964 "parsing/parser.ml" 34976 34964 in 34977 34965 34978 34966 # 2235 "parsing/parser.mly" 34979 34967 ( array, d, Bracket, i, r ) 34980 34980 - # 34981 "parsing/parser.ml" 34968 34968 + # 34969 "parsing/parser.ml" 34981 34969 34982 34970 in 34983 34971 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 34987 34975 34988 34976 # 2343 "parsing/parser.mly" 34989 34977 ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) 34990 34990 - # 34991 "parsing/parser.ml" 34978 34978 + # 34979 "parsing/parser.ml" 34991 34979 in 34992 34980 { 34993 34981 MenhirLib.EngineTypes.state = _menhir_s; ··· 35035 35023 let _2 : ( 35036 35024 # 686 "parsing/parser.mly" 35037 35025 (string) 35038 35038 - # 35039 "parsing/parser.ml" 35026 35026 + # 35027 "parsing/parser.ml" 35039 35027 ) = Obj.magic _2 in 35040 35028 let array : (Parsetree.expression) = Obj.magic array in 35041 35029 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 35045 35033 let r = 35046 35034 # 2344 "parsing/parser.mly" 35047 35035 ( None ) 35048 35048 - # 35049 "parsing/parser.ml" 35036 35036 + # 35037 "parsing/parser.ml" 35049 35037 in 35050 35038 let i = 35051 35039 # 2664 "parsing/parser.mly" 35052 35040 ( es ) 35053 35053 - # 35054 "parsing/parser.ml" 35041 35041 + # 35042 "parsing/parser.ml" 35054 35042 in 35055 35043 let d = 35056 35044 let _1 = 35057 35045 # 124 "<standard.mly>" 35058 35046 ( None ) 35059 35059 - # 35060 "parsing/parser.ml" 35047 35047 + # 35048 "parsing/parser.ml" 35060 35048 in 35061 35049 35062 35050 # 2247 "parsing/parser.mly" 35063 35051 ( _1, _2 ) 35064 35064 - # 35065 "parsing/parser.ml" 35052 35052 + # 35053 "parsing/parser.ml" 35065 35053 35066 35054 in 35067 35055 35068 35056 # 2231 "parsing/parser.mly" 35069 35057 ( array, d, Paren, i, r ) 35070 35070 - # 35071 "parsing/parser.ml" 35058 35058 + # 35059 "parsing/parser.ml" 35071 35059 35072 35060 in 35073 35061 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 35077 35065 35078 35066 # 2345 "parsing/parser.mly" 35079 35067 ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) 35080 35080 - # 35081 "parsing/parser.ml" 35068 35068 + # 35069 "parsing/parser.ml" 35081 35069 in 35082 35070 { 35083 35071 MenhirLib.EngineTypes.state = _menhir_s; ··· 35137 35125 let _2 : ( 35138 35126 # 686 "parsing/parser.mly" 35139 35127 (string) 35140 35140 - # 35141 "parsing/parser.ml" 35128 35128 + # 35129 "parsing/parser.ml" 35141 35129 ) = Obj.magic _2 in 35142 35130 let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in 35143 35131 let _1 : unit = Obj.magic _1 in ··· 35149 35137 let r = 35150 35138 # 2344 "parsing/parser.mly" 35151 35139 ( None ) 35152 35152 - # 35153 "parsing/parser.ml" 35140 35140 + # 35141 "parsing/parser.ml" 35153 35141 in 35154 35142 let i = 35155 35143 # 2664 "parsing/parser.mly" 35156 35144 ( es ) 35157 35157 - # 35158 "parsing/parser.ml" 35145 35145 + # 35146 "parsing/parser.ml" 35158 35146 in 35159 35147 let d = 35160 35148 let _1 = ··· 35162 35150 let x = 35163 35151 # 2247 "parsing/parser.mly" 35164 35152 (_2) 35165 35165 - # 35166 "parsing/parser.ml" 35153 35153 + # 35154 "parsing/parser.ml" 35166 35154 in 35167 35155 35168 35156 # 126 "<standard.mly>" 35169 35157 ( Some x ) 35170 35170 - # 35171 "parsing/parser.ml" 35158 35158 + # 35159 "parsing/parser.ml" 35171 35159 35172 35160 in 35173 35161 35174 35162 # 2247 "parsing/parser.mly" 35175 35163 ( _1, _2 ) 35176 35176 - # 35177 "parsing/parser.ml" 35164 35164 + # 35165 "parsing/parser.ml" 35177 35165 35178 35166 in 35179 35167 35180 35168 # 2231 "parsing/parser.mly" 35181 35169 ( array, d, Paren, i, r ) 35182 35182 - # 35183 "parsing/parser.ml" 35170 35170 + # 35171 "parsing/parser.ml" 35183 35171 35184 35172 in 35185 35173 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 35189 35177 35190 35178 # 2345 "parsing/parser.mly" 35191 35179 ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) 35192 35192 - # 35193 "parsing/parser.ml" 35180 35180 + # 35181 "parsing/parser.ml" 35193 35181 in 35194 35182 { 35195 35183 MenhirLib.EngineTypes.state = _menhir_s; ··· 35237 35225 let _2 : ( 35238 35226 # 686 "parsing/parser.mly" 35239 35227 (string) 35240 35240 - # 35241 "parsing/parser.ml" 35228 35228 + # 35229 "parsing/parser.ml" 35241 35229 ) = Obj.magic _2 in 35242 35230 let array : (Parsetree.expression) = Obj.magic array in 35243 35231 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 35247 35235 let r = 35248 35236 # 2344 "parsing/parser.mly" 35249 35237 ( None ) 35250 35250 - # 35251 "parsing/parser.ml" 35238 35238 + # 35239 "parsing/parser.ml" 35251 35239 in 35252 35240 let i = 35253 35241 # 2664 "parsing/parser.mly" 35254 35242 ( es ) 35255 35255 - # 35256 "parsing/parser.ml" 35243 35243 + # 35244 "parsing/parser.ml" 35256 35244 in 35257 35245 let d = 35258 35246 let _1 = 35259 35247 # 124 "<standard.mly>" 35260 35248 ( None ) 35261 35261 - # 35262 "parsing/parser.ml" 35249 35249 + # 35250 "parsing/parser.ml" 35262 35250 in 35263 35251 35264 35252 # 2247 "parsing/parser.mly" 35265 35253 ( _1, _2 ) 35266 35266 - # 35267 "parsing/parser.ml" 35254 35254 + # 35255 "parsing/parser.ml" 35267 35255 35268 35256 in 35269 35257 35270 35258 # 2233 "parsing/parser.mly" 35271 35259 ( array, d, Brace, i, r ) 35272 35272 - # 35273 "parsing/parser.ml" 35260 35260 + # 35261 "parsing/parser.ml" 35273 35261 35274 35262 in 35275 35263 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 35279 35267 35280 35268 # 2345 "parsing/parser.mly" 35281 35269 ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) 35282 35282 - # 35283 "parsing/parser.ml" 35270 35270 + # 35271 "parsing/parser.ml" 35283 35271 in 35284 35272 { 35285 35273 MenhirLib.EngineTypes.state = _menhir_s; ··· 35339 35327 let _2 : ( 35340 35328 # 686 "parsing/parser.mly" 35341 35329 (string) 35342 35342 - # 35343 "parsing/parser.ml" 35330 35330 + # 35331 "parsing/parser.ml" 35343 35331 ) = Obj.magic _2 in 35344 35332 let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in 35345 35333 let _1 : unit = Obj.magic _1 in ··· 35351 35339 let r = 35352 35340 # 2344 "parsing/parser.mly" 35353 35341 ( None ) 35354 35354 - # 35355 "parsing/parser.ml" 35342 35342 + # 35343 "parsing/parser.ml" 35355 35343 in 35356 35344 let i = 35357 35345 # 2664 "parsing/parser.mly" 35358 35346 ( es ) 35359 35359 - # 35360 "parsing/parser.ml" 35347 35347 + # 35348 "parsing/parser.ml" 35360 35348 in 35361 35349 let d = 35362 35350 let _1 = ··· 35364 35352 let x = 35365 35353 # 2247 "parsing/parser.mly" 35366 35354 (_2) 35367 35367 - # 35368 "parsing/parser.ml" 35355 35355 + # 35356 "parsing/parser.ml" 35368 35356 in 35369 35357 35370 35358 # 126 "<standard.mly>" 35371 35359 ( Some x ) 35372 35372 - # 35373 "parsing/parser.ml" 35360 35360 + # 35361 "parsing/parser.ml" 35373 35361 35374 35362 in 35375 35363 35376 35364 # 2247 "parsing/parser.mly" 35377 35365 ( _1, _2 ) 35378 35378 - # 35379 "parsing/parser.ml" 35366 35366 + # 35367 "parsing/parser.ml" 35379 35367 35380 35368 in 35381 35369 35382 35370 # 2233 "parsing/parser.mly" 35383 35371 ( array, d, Brace, i, r ) 35384 35384 - # 35385 "parsing/parser.ml" 35372 35372 + # 35373 "parsing/parser.ml" 35385 35373 35386 35374 in 35387 35375 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 35391 35379 35392 35380 # 2345 "parsing/parser.mly" 35393 35381 ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) 35394 35394 - # 35395 "parsing/parser.ml" 35382 35382 + # 35383 "parsing/parser.ml" 35395 35383 in 35396 35384 { 35397 35385 MenhirLib.EngineTypes.state = _menhir_s; ··· 35439 35427 let _2 : ( 35440 35428 # 686 "parsing/parser.mly" 35441 35429 (string) 35442 35442 - # 35443 "parsing/parser.ml" 35430 35430 + # 35431 "parsing/parser.ml" 35443 35431 ) = Obj.magic _2 in 35444 35432 let array : (Parsetree.expression) = Obj.magic array in 35445 35433 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 35449 35437 let r = 35450 35438 # 2344 "parsing/parser.mly" 35451 35439 ( None ) 35452 35452 - # 35453 "parsing/parser.ml" 35440 35440 + # 35441 "parsing/parser.ml" 35453 35441 in 35454 35442 let i = 35455 35443 # 2664 "parsing/parser.mly" 35456 35444 ( es ) 35457 35457 - # 35458 "parsing/parser.ml" 35445 35445 + # 35446 "parsing/parser.ml" 35458 35446 in 35459 35447 let d = 35460 35448 let _1 = 35461 35449 # 124 "<standard.mly>" 35462 35450 ( None ) 35463 35463 - # 35464 "parsing/parser.ml" 35451 35451 + # 35452 "parsing/parser.ml" 35464 35452 in 35465 35453 35466 35454 # 2247 "parsing/parser.mly" 35467 35455 ( _1, _2 ) 35468 35468 - # 35469 "parsing/parser.ml" 35456 35456 + # 35457 "parsing/parser.ml" 35469 35457 35470 35458 in 35471 35459 35472 35460 # 2235 "parsing/parser.mly" 35473 35461 ( array, d, Bracket, i, r ) 35474 35474 - # 35475 "parsing/parser.ml" 35462 35462 + # 35463 "parsing/parser.ml" 35475 35463 35476 35464 in 35477 35465 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 35481 35469 35482 35470 # 2345 "parsing/parser.mly" 35483 35471 ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) 35484 35484 - # 35485 "parsing/parser.ml" 35472 35472 + # 35473 "parsing/parser.ml" 35485 35473 in 35486 35474 { 35487 35475 MenhirLib.EngineTypes.state = _menhir_s; ··· 35541 35529 let _2 : ( 35542 35530 # 686 "parsing/parser.mly" 35543 35531 (string) 35544 35544 - # 35545 "parsing/parser.ml" 35532 35532 + # 35533 "parsing/parser.ml" 35545 35533 ) = Obj.magic _2 in 35546 35534 let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in 35547 35535 let _1 : unit = Obj.magic _1 in ··· 35553 35541 let r = 35554 35542 # 2344 "parsing/parser.mly" 35555 35543 ( None ) 35556 35556 - # 35557 "parsing/parser.ml" 35544 35544 + # 35545 "parsing/parser.ml" 35557 35545 in 35558 35546 let i = 35559 35547 # 2664 "parsing/parser.mly" 35560 35548 ( es ) 35561 35561 - # 35562 "parsing/parser.ml" 35549 35549 + # 35550 "parsing/parser.ml" 35562 35550 in 35563 35551 let d = 35564 35552 let _1 = ··· 35566 35554 let x = 35567 35555 # 2247 "parsing/parser.mly" 35568 35556 (_2) 35569 35569 - # 35570 "parsing/parser.ml" 35557 35557 + # 35558 "parsing/parser.ml" 35570 35558 in 35571 35559 35572 35560 # 126 "<standard.mly>" 35573 35561 ( Some x ) 35574 35574 - # 35575 "parsing/parser.ml" 35562 35562 + # 35563 "parsing/parser.ml" 35575 35563 35576 35564 in 35577 35565 35578 35566 # 2247 "parsing/parser.mly" 35579 35567 ( _1, _2 ) 35580 35580 - # 35581 "parsing/parser.ml" 35568 35568 + # 35569 "parsing/parser.ml" 35581 35569 35582 35570 in 35583 35571 35584 35572 # 2235 "parsing/parser.mly" 35585 35573 ( array, d, Bracket, i, r ) 35586 35586 - # 35587 "parsing/parser.ml" 35574 35574 + # 35575 "parsing/parser.ml" 35587 35575 35588 35576 in 35589 35577 let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in ··· 35593 35581 35594 35582 # 2345 "parsing/parser.mly" 35595 35583 ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) 35596 35596 - # 35597 "parsing/parser.ml" 35584 35584 + # 35585 "parsing/parser.ml" 35597 35585 in 35598 35586 { 35599 35587 MenhirLib.EngineTypes.state = _menhir_s; ··· 35649 35637 35650 35638 # 2240 "parsing/parser.mly" 35651 35639 ( indexop_unclosed_error _loc__p_ Paren _loc__e_ ) 35652 35652 - # 35653 "parsing/parser.ml" 35640 35640 + # 35641 "parsing/parser.ml" 35653 35641 35654 35642 in 35655 35643 35656 35644 # 2346 "parsing/parser.mly" 35657 35645 ( _1 ) 35658 35658 - # 35659 "parsing/parser.ml" 35646 35646 + # 35647 "parsing/parser.ml" 35659 35647 in 35660 35648 { 35661 35649 MenhirLib.EngineTypes.state = _menhir_s; ··· 35711 35699 35712 35700 # 2242 "parsing/parser.mly" 35713 35701 ( indexop_unclosed_error _loc__p_ Brace _loc__e_ ) 35714 35714 - # 35715 "parsing/parser.ml" 35702 35702 + # 35703 "parsing/parser.ml" 35715 35703 35716 35704 in 35717 35705 35718 35706 # 2346 "parsing/parser.mly" 35719 35707 ( _1 ) 35720 35720 - # 35721 "parsing/parser.ml" 35708 35708 + # 35709 "parsing/parser.ml" 35721 35709 in 35722 35710 { 35723 35711 MenhirLib.EngineTypes.state = _menhir_s; ··· 35773 35761 35774 35762 # 2244 "parsing/parser.mly" 35775 35763 ( indexop_unclosed_error _loc__p_ Bracket _loc__e_ ) 35776 35776 - # 35777 "parsing/parser.ml" 35764 35764 + # 35765 "parsing/parser.ml" 35777 35765 35778 35766 in 35779 35767 35780 35768 # 2346 "parsing/parser.mly" 35781 35769 ( _1 ) 35782 35782 - # 35783 "parsing/parser.ml" 35770 35770 + # 35771 "parsing/parser.ml" 35783 35771 in 35784 35772 { 35785 35773 MenhirLib.EngineTypes.state = _menhir_s; ··· 35827 35815 let _2 : ( 35828 35816 # 686 "parsing/parser.mly" 35829 35817 (string) 35830 35830 - # 35831 "parsing/parser.ml" 35818 35818 + # 35819 "parsing/parser.ml" 35831 35819 ) = Obj.magic _2 in 35832 35820 let _1 : (Parsetree.expression) = Obj.magic _1 in 35833 35821 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 35837 35825 let _4 = 35838 35826 # 2664 "parsing/parser.mly" 35839 35827 ( es ) 35840 35840 - # 35841 "parsing/parser.ml" 35828 35828 + # 35829 "parsing/parser.ml" 35841 35829 in 35842 35830 let _2 = 35843 35831 let _1 = 35844 35832 # 124 "<standard.mly>" 35845 35833 ( None ) 35846 35846 - # 35847 "parsing/parser.ml" 35834 35834 + # 35835 "parsing/parser.ml" 35847 35835 in 35848 35836 35849 35837 # 2247 "parsing/parser.mly" 35850 35838 ( _1, _2 ) 35851 35851 - # 35852 "parsing/parser.ml" 35839 35839 + # 35840 "parsing/parser.ml" 35852 35840 35853 35841 in 35854 35842 let _loc__p_ = (_startpos__p_, _endpos__p_) in ··· 35856 35844 35857 35845 # 2240 "parsing/parser.mly" 35858 35846 ( indexop_unclosed_error _loc__p_ Paren _loc__e_ ) 35859 35859 - # 35860 "parsing/parser.ml" 35847 35847 + # 35848 "parsing/parser.ml" 35860 35848 35861 35849 in 35862 35850 35863 35851 # 2347 "parsing/parser.mly" 35864 35852 ( _1 ) 35865 35865 - # 35866 "parsing/parser.ml" 35853 35853 + # 35854 "parsing/parser.ml" 35866 35854 in 35867 35855 { 35868 35856 MenhirLib.EngineTypes.state = _menhir_s; ··· 35922 35910 let _2 : ( 35923 35911 # 686 "parsing/parser.mly" 35924 35912 (string) 35925 35925 - # 35926 "parsing/parser.ml" 35913 35913 + # 35914 "parsing/parser.ml" 35926 35914 ) = Obj.magic _2 in 35927 35915 let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in 35928 35916 let _1_inlined1 : unit = Obj.magic _1_inlined1 in ··· 35934 35922 let _4 = 35935 35923 # 2664 "parsing/parser.mly" 35936 35924 ( es ) 35937 35937 - # 35938 "parsing/parser.ml" 35925 35925 + # 35926 "parsing/parser.ml" 35938 35926 in 35939 35927 let _2 = 35940 35928 let _1 = ··· 35942 35930 let x = 35943 35931 # 2247 "parsing/parser.mly" 35944 35932 (_2) 35945 35945 - # 35946 "parsing/parser.ml" 35933 35933 + # 35934 "parsing/parser.ml" 35946 35934 in 35947 35935 35948 35936 # 126 "<standard.mly>" 35949 35937 ( Some x ) 35950 35950 - # 35951 "parsing/parser.ml" 35938 35938 + # 35939 "parsing/parser.ml" 35951 35939 35952 35940 in 35953 35941 35954 35942 # 2247 "parsing/parser.mly" 35955 35943 ( _1, _2 ) 35956 35956 - # 35957 "parsing/parser.ml" 35944 35944 + # 35945 "parsing/parser.ml" 35957 35945 35958 35946 in 35959 35947 let _loc__p_ = (_startpos__p_, _endpos__p_) in ··· 35961 35949 35962 35950 # 2240 "parsing/parser.mly" 35963 35951 ( indexop_unclosed_error _loc__p_ Paren _loc__e_ ) 35964 35964 - # 35965 "parsing/parser.ml" 35952 35952 + # 35953 "parsing/parser.ml" 35965 35953 35966 35954 in 35967 35955 35968 35956 # 2347 "parsing/parser.mly" 35969 35957 ( _1 ) 35970 35970 - # 35971 "parsing/parser.ml" 35958 35958 + # 35959 "parsing/parser.ml" 35971 35959 in 35972 35960 { 35973 35961 MenhirLib.EngineTypes.state = _menhir_s; ··· 36015 36003 let _2 : ( 36016 36004 # 686 "parsing/parser.mly" 36017 36005 (string) 36018 36018 - # 36019 "parsing/parser.ml" 36006 36006 + # 36007 "parsing/parser.ml" 36019 36007 ) = Obj.magic _2 in 36020 36008 let _1 : (Parsetree.expression) = Obj.magic _1 in 36021 36009 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 36025 36013 let _4 = 36026 36014 # 2664 "parsing/parser.mly" 36027 36015 ( es ) 36028 36028 - # 36029 "parsing/parser.ml" 36016 36016 + # 36017 "parsing/parser.ml" 36029 36017 in 36030 36018 let _2 = 36031 36019 let _1 = 36032 36020 # 124 "<standard.mly>" 36033 36021 ( None ) 36034 36034 - # 36035 "parsing/parser.ml" 36022 36022 + # 36023 "parsing/parser.ml" 36035 36023 in 36036 36024 36037 36025 # 2247 "parsing/parser.mly" 36038 36026 ( _1, _2 ) 36039 36039 - # 36040 "parsing/parser.ml" 36027 36027 + # 36028 "parsing/parser.ml" 36040 36028 36041 36029 in 36042 36030 let _loc__p_ = (_startpos__p_, _endpos__p_) in ··· 36044 36032 36045 36033 # 2242 "parsing/parser.mly" 36046 36034 ( indexop_unclosed_error _loc__p_ Brace _loc__e_ ) 36047 36047 - # 36048 "parsing/parser.ml" 36035 36035 + # 36036 "parsing/parser.ml" 36048 36036 36049 36037 in 36050 36038 36051 36039 # 2347 "parsing/parser.mly" 36052 36040 ( _1 ) 36053 36053 - # 36054 "parsing/parser.ml" 36041 36041 + # 36042 "parsing/parser.ml" 36054 36042 in 36055 36043 { 36056 36044 MenhirLib.EngineTypes.state = _menhir_s; ··· 36110 36098 let _2 : ( 36111 36099 # 686 "parsing/parser.mly" 36112 36100 (string) 36113 36113 - # 36114 "parsing/parser.ml" 36101 36101 + # 36102 "parsing/parser.ml" 36114 36102 ) = Obj.magic _2 in 36115 36103 let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in 36116 36104 let _1_inlined1 : unit = Obj.magic _1_inlined1 in ··· 36122 36110 let _4 = 36123 36111 # 2664 "parsing/parser.mly" 36124 36112 ( es ) 36125 36125 - # 36126 "parsing/parser.ml" 36113 36113 + # 36114 "parsing/parser.ml" 36126 36114 in 36127 36115 let _2 = 36128 36116 let _1 = ··· 36130 36118 let x = 36131 36119 # 2247 "parsing/parser.mly" 36132 36120 (_2) 36133 36133 - # 36134 "parsing/parser.ml" 36121 36121 + # 36122 "parsing/parser.ml" 36134 36122 in 36135 36123 36136 36124 # 126 "<standard.mly>" 36137 36125 ( Some x ) 36138 36138 - # 36139 "parsing/parser.ml" 36126 36126 + # 36127 "parsing/parser.ml" 36139 36127 36140 36128 in 36141 36129 36142 36130 # 2247 "parsing/parser.mly" 36143 36131 ( _1, _2 ) 36144 36144 - # 36145 "parsing/parser.ml" 36132 36132 + # 36133 "parsing/parser.ml" 36145 36133 36146 36134 in 36147 36135 let _loc__p_ = (_startpos__p_, _endpos__p_) in ··· 36149 36137 36150 36138 # 2242 "parsing/parser.mly" 36151 36139 ( indexop_unclosed_error _loc__p_ Brace _loc__e_ ) 36152 36152 - # 36153 "parsing/parser.ml" 36140 36140 + # 36141 "parsing/parser.ml" 36153 36141 36154 36142 in 36155 36143 36156 36144 # 2347 "parsing/parser.mly" 36157 36145 ( _1 ) 36158 36158 - # 36159 "parsing/parser.ml" 36146 36146 + # 36147 "parsing/parser.ml" 36159 36147 in 36160 36148 { 36161 36149 MenhirLib.EngineTypes.state = _menhir_s; ··· 36203 36191 let _2 : ( 36204 36192 # 686 "parsing/parser.mly" 36205 36193 (string) 36206 36206 - # 36207 "parsing/parser.ml" 36194 36194 + # 36195 "parsing/parser.ml" 36207 36195 ) = Obj.magic _2 in 36208 36196 let _1 : (Parsetree.expression) = Obj.magic _1 in 36209 36197 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 36213 36201 let _4 = 36214 36202 # 2664 "parsing/parser.mly" 36215 36203 ( es ) 36216 36216 - # 36217 "parsing/parser.ml" 36204 36204 + # 36205 "parsing/parser.ml" 36217 36205 in 36218 36206 let _2 = 36219 36207 let _1 = 36220 36208 # 124 "<standard.mly>" 36221 36209 ( None ) 36222 36222 - # 36223 "parsing/parser.ml" 36210 36210 + # 36211 "parsing/parser.ml" 36223 36211 in 36224 36212 36225 36213 # 2247 "parsing/parser.mly" 36226 36214 ( _1, _2 ) 36227 36227 - # 36228 "parsing/parser.ml" 36215 36215 + # 36216 "parsing/parser.ml" 36228 36216 36229 36217 in 36230 36218 let _loc__p_ = (_startpos__p_, _endpos__p_) in ··· 36232 36220 36233 36221 # 2244 "parsing/parser.mly" 36234 36222 ( indexop_unclosed_error _loc__p_ Bracket _loc__e_ ) 36235 36235 - # 36236 "parsing/parser.ml" 36223 36223 + # 36224 "parsing/parser.ml" 36236 36224 36237 36225 in 36238 36226 36239 36227 # 2347 "parsing/parser.mly" 36240 36228 ( _1 ) 36241 36241 - # 36242 "parsing/parser.ml" 36229 36229 + # 36230 "parsing/parser.ml" 36242 36230 in 36243 36231 { 36244 36232 MenhirLib.EngineTypes.state = _menhir_s; ··· 36298 36286 let _2 : ( 36299 36287 # 686 "parsing/parser.mly" 36300 36288 (string) 36301 36301 - # 36302 "parsing/parser.ml" 36289 36289 + # 36290 "parsing/parser.ml" 36302 36290 ) = Obj.magic _2 in 36303 36291 let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in 36304 36292 let _1_inlined1 : unit = Obj.magic _1_inlined1 in ··· 36310 36298 let _4 = 36311 36299 # 2664 "parsing/parser.mly" 36312 36300 ( es ) 36313 36313 - # 36314 "parsing/parser.ml" 36301 36301 + # 36302 "parsing/parser.ml" 36314 36302 in 36315 36303 let _2 = 36316 36304 let _1 = ··· 36318 36306 let x = 36319 36307 # 2247 "parsing/parser.mly" 36320 36308 (_2) 36321 36321 - # 36322 "parsing/parser.ml" 36309 36309 + # 36310 "parsing/parser.ml" 36322 36310 in 36323 36311 36324 36312 # 126 "<standard.mly>" 36325 36313 ( Some x ) 36326 36326 - # 36327 "parsing/parser.ml" 36314 36314 + # 36315 "parsing/parser.ml" 36327 36315 36328 36316 in 36329 36317 36330 36318 # 2247 "parsing/parser.mly" 36331 36319 ( _1, _2 ) 36332 36332 - # 36333 "parsing/parser.ml" 36320 36320 + # 36321 "parsing/parser.ml" 36333 36321 36334 36322 in 36335 36323 let _loc__p_ = (_startpos__p_, _endpos__p_) in ··· 36337 36325 36338 36326 # 2244 "parsing/parser.mly" 36339 36327 ( indexop_unclosed_error _loc__p_ Bracket _loc__e_ ) 36340 36340 - # 36341 "parsing/parser.ml" 36328 36328 + # 36329 "parsing/parser.ml" 36341 36329 36342 36330 in 36343 36331 36344 36332 # 2347 "parsing/parser.mly" 36345 36333 ( _1 ) 36346 36346 - # 36347 "parsing/parser.ml" 36334 36334 + # 36335 "parsing/parser.ml" 36347 36335 in 36348 36336 { 36349 36337 MenhirLib.EngineTypes.state = _menhir_s; ··· 36399 36387 36400 36388 # 3840 "parsing/parser.mly" 36401 36389 ( _1 ) 36402 36402 - # 36403 "parsing/parser.ml" 36390 36390 + # 36391 "parsing/parser.ml" 36403 36391 36404 36392 in 36405 36393 36406 36394 # 2356 "parsing/parser.mly" 36407 36395 ( e.pexp_desc, (ext, attrs @ e.pexp_attributes) ) 36408 36408 - # 36409 "parsing/parser.ml" 36396 36396 + # 36397 "parsing/parser.ml" 36409 36397 36410 36398 in 36411 36399 let _endpos__1_ = _endpos__5_ in ··· 36416 36404 # 2349 "parsing/parser.mly" 36417 36405 ( let desc, attrs = _1 in 36418 36406 mkexp_attrs ~loc:_sloc desc attrs ) 36419 36419 - # 36420 "parsing/parser.ml" 36407 36407 + # 36408 "parsing/parser.ml" 36420 36408 in 36421 36409 { 36422 36410 MenhirLib.EngineTypes.state = _menhir_s; ··· 36467 36455 36468 36456 # 3840 "parsing/parser.mly" 36469 36457 ( _1 ) 36470 36470 - # 36471 "parsing/parser.ml" 36458 36458 + # 36459 "parsing/parser.ml" 36471 36459 36472 36460 in 36473 36461 36474 36462 # 3853 "parsing/parser.mly" 36475 36463 ( _1, _2 ) 36476 36476 - # 36477 "parsing/parser.ml" 36464 36464 + # 36465 "parsing/parser.ml" 36477 36465 36478 36466 in 36479 36467 let _endpos = _endpos__3_ in ··· 36482 36470 36483 36471 # 2358 "parsing/parser.mly" 36484 36472 ( Pexp_construct (mkloc (Lident "()") (make_loc _sloc), None), _2 ) 36485 36485 - # 36486 "parsing/parser.ml" 36473 36473 + # 36474 "parsing/parser.ml" 36486 36474 36487 36475 in 36488 36476 let _endpos__1_ = _endpos__3_ in ··· 36493 36481 # 2349 "parsing/parser.mly" 36494 36482 ( let desc, attrs = _1 in 36495 36483 mkexp_attrs ~loc:_sloc desc attrs ) 36496 36496 - # 36497 "parsing/parser.ml" 36484 36484 + # 36485 "parsing/parser.ml" 36497 36485 in 36498 36486 { 36499 36487 MenhirLib.EngineTypes.state = _menhir_s; ··· 36551 36539 36552 36540 # 3840 "parsing/parser.mly" 36553 36541 ( _1 ) 36554 36554 - # 36555 "parsing/parser.ml" 36542 36542 + # 36543 "parsing/parser.ml" 36555 36543 36556 36544 in 36557 36545 36558 36546 # 3853 "parsing/parser.mly" 36559 36547 ( _1, _2 ) 36560 36560 - # 36561 "parsing/parser.ml" 36548 36548 + # 36549 "parsing/parser.ml" 36561 36549 36562 36550 in 36563 36551 let _loc__4_ = (_startpos__4_, _endpos__4_) in ··· 36565 36553 36566 36554 # 2360 "parsing/parser.mly" 36567 36555 ( unclosed "begin" _loc__1_ "end" _loc__4_ ) 36568 36568 - # 36569 "parsing/parser.ml" 36556 36556 + # 36557 "parsing/parser.ml" 36569 36557 36570 36558 in 36571 36559 let _endpos__1_ = _endpos__4_ in ··· 36576 36564 # 2349 "parsing/parser.mly" 36577 36565 ( let desc, attrs = _1 in 36578 36566 mkexp_attrs ~loc:_sloc desc attrs ) 36579 36579 - # 36580 "parsing/parser.ml" 36567 36567 + # 36568 "parsing/parser.ml" 36580 36568 in 36581 36569 { 36582 36570 MenhirLib.EngineTypes.state = _menhir_s; ··· 36628 36616 36629 36617 # 883 "parsing/parser.mly" 36630 36618 ( mkrhs _1 _sloc ) 36631 36631 - # 36632 "parsing/parser.ml" 36619 36619 + # 36620 "parsing/parser.ml" 36632 36620 36633 36621 in 36634 36622 let _2 = ··· 36638 36626 36639 36627 # 3840 "parsing/parser.mly" 36640 36628 ( _1 ) 36641 36641 - # 36642 "parsing/parser.ml" 36629 36629 + # 36630 "parsing/parser.ml" 36642 36630 36643 36631 in 36644 36632 36645 36633 # 3853 "parsing/parser.mly" 36646 36634 ( _1, _2 ) 36647 36647 - # 36648 "parsing/parser.ml" 36635 36635 + # 36636 "parsing/parser.ml" 36648 36636 36649 36637 in 36650 36638 36651 36639 # 2362 "parsing/parser.mly" 36652 36640 ( Pexp_new(_3), _2 ) 36653 36653 - # 36654 "parsing/parser.ml" 36641 36641 + # 36642 "parsing/parser.ml" 36654 36642 36655 36643 in 36656 36644 let _endpos__1_ = _endpos__1_inlined3_ in ··· 36661 36649 # 2349 "parsing/parser.mly" 36662 36650 ( let desc, attrs = _1 in 36663 36651 mkexp_attrs ~loc:_sloc desc attrs ) 36664 36664 - # 36665 "parsing/parser.ml" 36652 36652 + # 36653 "parsing/parser.ml" 36665 36653 in 36666 36654 { 36667 36655 MenhirLib.EngineTypes.state = _menhir_s; ··· 36726 36714 36727 36715 # 3840 "parsing/parser.mly" 36728 36716 ( _1 ) 36729 36729 - # 36730 "parsing/parser.ml" 36717 36717 + # 36718 "parsing/parser.ml" 36730 36718 36731 36719 in 36732 36720 36733 36721 # 3853 "parsing/parser.mly" 36734 36722 ( _1, _2 ) 36735 36735 - # 36736 "parsing/parser.ml" 36723 36723 + # 36724 "parsing/parser.ml" 36736 36724 36737 36725 in 36738 36726 36739 36727 # 2364 "parsing/parser.mly" 36740 36728 ( Pexp_pack _4, _3 ) 36741 36741 - # 36742 "parsing/parser.ml" 36729 36729 + # 36730 "parsing/parser.ml" 36742 36730 36743 36731 in 36744 36732 let _endpos__1_ = _endpos__5_ in ··· 36749 36737 # 2349 "parsing/parser.mly" 36750 36738 ( let desc, attrs = _1 in 36751 36739 mkexp_attrs ~loc:_sloc desc attrs ) 36752 36752 - # 36753 "parsing/parser.ml" 36740 36740 + # 36741 "parsing/parser.ml" 36753 36741 in 36754 36742 { 36755 36743 MenhirLib.EngineTypes.state = _menhir_s; ··· 36831 36819 ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in 36832 36820 let descr = Ptyp_package (lid, cstrs) in 36833 36821 mktyp ~loc:_sloc ~attrs descr ) 36834 36834 - # 36835 "parsing/parser.ml" 36822 36822 + # 36823 "parsing/parser.ml" 36835 36823 36836 36824 in 36837 36825 let _3 = ··· 36841 36829 36842 36830 # 3840 "parsing/parser.mly" 36843 36831 ( _1 ) 36844 36844 - # 36845 "parsing/parser.ml" 36832 36832 + # 36833 "parsing/parser.ml" 36845 36833 36846 36834 in 36847 36835 36848 36836 # 3853 "parsing/parser.mly" 36849 36837 ( _1, _2 ) 36850 36850 - # 36851 "parsing/parser.ml" 36838 36838 + # 36839 "parsing/parser.ml" 36851 36839 36852 36840 in 36853 36841 let _endpos = _endpos__7_ in ··· 36856 36844 36857 36845 # 2366 "parsing/parser.mly" 36858 36846 ( Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _4), _6), _3 ) 36859 36859 - # 36860 "parsing/parser.ml" 36847 36847 + # 36848 "parsing/parser.ml" 36860 36848 36861 36849 in 36862 36850 let _endpos__1_ = _endpos__7_ in ··· 36867 36855 # 2349 "parsing/parser.mly" 36868 36856 ( let desc, attrs = _1 in 36869 36857 mkexp_attrs ~loc:_sloc desc attrs ) 36870 36870 - # 36871 "parsing/parser.ml" 36858 36858 + # 36859 "parsing/parser.ml" 36871 36859 in 36872 36860 { 36873 36861 MenhirLib.EngineTypes.state = _menhir_s; ··· 36939 36927 36940 36928 # 3840 "parsing/parser.mly" 36941 36929 ( _1 ) 36942 36942 - # 36943 "parsing/parser.ml" 36930 36930 + # 36931 "parsing/parser.ml" 36943 36931 36944 36932 in 36945 36933 36946 36934 # 3853 "parsing/parser.mly" 36947 36935 ( _1, _2 ) 36948 36948 - # 36949 "parsing/parser.ml" 36936 36936 + # 36937 "parsing/parser.ml" 36949 36937 36950 36938 in 36951 36939 let _loc__6_ = (_startpos__6_, _endpos__6_) in ··· 36953 36941 36954 36942 # 2368 "parsing/parser.mly" 36955 36943 ( unclosed "(" _loc__1_ ")" _loc__6_ ) 36956 36956 - # 36957 "parsing/parser.ml" 36944 36944 + # 36945 "parsing/parser.ml" 36957 36945 36958 36946 in 36959 36947 let _endpos__1_ = _endpos__6_ in ··· 36964 36952 # 2349 "parsing/parser.mly" 36965 36953 ( let desc, attrs = _1 in 36966 36954 mkexp_attrs ~loc:_sloc desc attrs ) 36967 36967 - # 36968 "parsing/parser.ml" 36955 36955 + # 36956 "parsing/parser.ml" 36968 36956 in 36969 36957 { 36970 36958 MenhirLib.EngineTypes.state = _menhir_s; ··· 37029 37017 let _1 = 37030 37018 # 260 "<standard.mly>" 37031 37019 ( List.flatten xss ) 37032 37032 - # 37033 "parsing/parser.ml" 37020 37020 + # 37021 "parsing/parser.ml" 37033 37021 in 37034 37022 37035 37023 # 1917 "parsing/parser.mly" 37036 37024 ( _1 ) 37037 37037 - # 37038 "parsing/parser.ml" 37025 37025 + # 37026 "parsing/parser.ml" 37038 37026 37039 37027 in 37040 37028 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in ··· 37043 37031 37044 37032 # 877 "parsing/parser.mly" 37045 37033 ( extra_cstr _startpos _endpos _1 ) 37046 37046 - # 37047 "parsing/parser.ml" 37034 37034 + # 37035 "parsing/parser.ml" 37047 37035 37048 37036 in 37049 37037 37050 37038 # 1904 "parsing/parser.mly" 37051 37039 ( Cstr.mk _1 _2 ) 37052 37052 - # 37053 "parsing/parser.ml" 37040 37040 + # 37041 "parsing/parser.ml" 37053 37041 37054 37042 in 37055 37043 let _2 = ··· 37059 37047 37060 37048 # 3840 "parsing/parser.mly" 37061 37049 ( _1 ) 37062 37062 - # 37063 "parsing/parser.ml" 37050 37050 + # 37051 "parsing/parser.ml" 37063 37051 37064 37052 in 37065 37053 37066 37054 # 3853 "parsing/parser.mly" 37067 37055 ( _1, _2 ) 37068 37068 - # 37069 "parsing/parser.ml" 37056 37056 + # 37057 "parsing/parser.ml" 37069 37057 37070 37058 in 37071 37059 37072 37060 # 2370 "parsing/parser.mly" 37073 37061 ( Pexp_object _3, _2 ) 37074 37074 - # 37075 "parsing/parser.ml" 37062 37062 + # 37063 "parsing/parser.ml" 37075 37063 37076 37064 in 37077 37065 let _endpos__1_ = _endpos__4_ in ··· 37082 37070 # 2349 "parsing/parser.mly" 37083 37071 ( let desc, attrs = _1 in 37084 37072 mkexp_attrs ~loc:_sloc desc attrs ) 37085 37085 - # 37086 "parsing/parser.ml" 37073 37073 + # 37074 "parsing/parser.ml" 37086 37074 in 37087 37075 { 37088 37076 MenhirLib.EngineTypes.state = _menhir_s; ··· 37147 37135 let _1 = 37148 37136 # 260 "<standard.mly>" 37149 37137 ( List.flatten xss ) 37150 37150 - # 37151 "parsing/parser.ml" 37138 37138 + # 37139 "parsing/parser.ml" 37151 37139 in 37152 37140 37153 37141 # 1917 "parsing/parser.mly" 37154 37142 ( _1 ) 37155 37155 - # 37156 "parsing/parser.ml" 37143 37143 + # 37144 "parsing/parser.ml" 37156 37144 37157 37145 in 37158 37146 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in ··· 37161 37149 37162 37150 # 877 "parsing/parser.mly" 37163 37151 ( extra_cstr _startpos _endpos _1 ) 37164 37164 - # 37165 "parsing/parser.ml" 37152 37152 + # 37153 "parsing/parser.ml" 37165 37153 37166 37154 in 37167 37155 37168 37156 # 1904 "parsing/parser.mly" 37169 37157 ( Cstr.mk _1 _2 ) 37170 37170 - # 37171 "parsing/parser.ml" 37158 37158 + # 37159 "parsing/parser.ml" 37171 37159 37172 37160 in 37173 37161 let _2 = ··· 37177 37165 37178 37166 # 3840 "parsing/parser.mly" 37179 37167 ( _1 ) 37180 37180 - # 37181 "parsing/parser.ml" 37168 37168 + # 37169 "parsing/parser.ml" 37181 37169 37182 37170 in 37183 37171 37184 37172 # 3853 "parsing/parser.mly" 37185 37173 ( _1, _2 ) 37186 37186 - # 37187 "parsing/parser.ml" 37174 37174 + # 37175 "parsing/parser.ml" 37187 37175 37188 37176 in 37189 37177 let _loc__4_ = (_startpos__4_, _endpos__4_) in ··· 37191 37179 37192 37180 # 2372 "parsing/parser.mly" 37193 37181 ( unclosed "object" _loc__1_ "end" _loc__4_ ) 37194 37194 - # 37195 "parsing/parser.ml" 37182 37182 + # 37183 "parsing/parser.ml" 37195 37183 37196 37184 in 37197 37185 let _endpos__1_ = _endpos__4_ in ··· 37202 37190 # 2349 "parsing/parser.mly" 37203 37191 ( let desc, attrs = _1 in 37204 37192 mkexp_attrs ~loc:_sloc desc attrs ) 37205 37205 - # 37206 "parsing/parser.ml" 37193 37193 + # 37194 "parsing/parser.ml" 37206 37194 in 37207 37195 { 37208 37196 MenhirLib.EngineTypes.state = _menhir_s; ··· 37233 37221 37234 37222 # 883 "parsing/parser.mly" 37235 37223 ( mkrhs _1 _sloc ) 37236 37236 - # 37237 "parsing/parser.ml" 37224 37224 + # 37225 "parsing/parser.ml" 37237 37225 37238 37226 in 37239 37227 37240 37228 # 2376 "parsing/parser.mly" 37241 37229 ( Pexp_ident (_1) ) 37242 37242 - # 37243 "parsing/parser.ml" 37230 37230 + # 37231 "parsing/parser.ml" 37243 37231 37244 37232 in 37245 37233 let _endpos = _endpos__1_ in ··· 37248 37236 37249 37237 # 916 "parsing/parser.mly" 37250 37238 ( mkexp ~loc:_sloc _1 ) 37251 37251 - # 37252 "parsing/parser.ml" 37239 37239 + # 37240 "parsing/parser.ml" 37252 37240 37253 37241 in 37254 37242 37255 37243 # 2352 "parsing/parser.mly" 37256 37244 ( _1 ) 37257 37257 - # 37258 "parsing/parser.ml" 37245 37245 + # 37246 "parsing/parser.ml" 37258 37246 in 37259 37247 { 37260 37248 MenhirLib.EngineTypes.state = _menhir_s; ··· 37280 37268 let _1 = 37281 37269 # 2378 "parsing/parser.mly" 37282 37270 ( Pexp_constant _1 ) 37283 37283 - # 37284 "parsing/parser.ml" 37271 37271 + # 37272 "parsing/parser.ml" 37284 37272 in 37285 37273 let _endpos = _endpos__1_ in 37286 37274 let _symbolstartpos = _startpos__1_ in ··· 37288 37276 37289 37277 # 916 "parsing/parser.mly" 37290 37278 ( mkexp ~loc:_sloc _1 ) 37291 37291 - # 37292 "parsing/parser.ml" 37279 37279 + # 37280 "parsing/parser.ml" 37292 37280 37293 37281 in 37294 37282 37295 37283 # 2352 "parsing/parser.mly" 37296 37284 ( _1 ) 37297 37297 - # 37298 "parsing/parser.ml" 37285 37285 + # 37286 "parsing/parser.ml" 37298 37286 in 37299 37287 { 37300 37288 MenhirLib.EngineTypes.state = _menhir_s; ··· 37325 37313 37326 37314 # 883 "parsing/parser.mly" 37327 37315 ( mkrhs _1 _sloc ) 37328 37328 - # 37329 "parsing/parser.ml" 37316 37316 + # 37317 "parsing/parser.ml" 37329 37317 37330 37318 in 37331 37319 37332 37320 # 2380 "parsing/parser.mly" 37333 37321 ( Pexp_construct(_1, None) ) 37334 37334 - # 37335 "parsing/parser.ml" 37322 37322 + # 37323 "parsing/parser.ml" 37335 37323 37336 37324 in 37337 37325 let _endpos = _endpos__1_ in ··· 37340 37328 37341 37329 # 916 "parsing/parser.mly" 37342 37330 ( mkexp ~loc:_sloc _1 ) 37343 37343 - # 37344 "parsing/parser.ml" 37331 37331 + # 37332 "parsing/parser.ml" 37344 37332 37345 37333 in 37346 37334 37347 37335 # 2352 "parsing/parser.mly" 37348 37336 ( _1 ) 37349 37349 - # 37350 "parsing/parser.ml" 37337 37337 + # 37338 "parsing/parser.ml" 37350 37338 in 37351 37339 { 37352 37340 MenhirLib.EngineTypes.state = _menhir_s; ··· 37372 37360 let _1 = 37373 37361 # 2382 "parsing/parser.mly" 37374 37362 ( Pexp_variant(_1, None) ) 37375 37375 - # 37376 "parsing/parser.ml" 37363 37363 + # 37364 "parsing/parser.ml" 37376 37364 in 37377 37365 let _endpos = _endpos__1_ in 37378 37366 let _symbolstartpos = _startpos__1_ in ··· 37380 37368 37381 37369 # 916 "parsing/parser.mly" 37382 37370 ( mkexp ~loc:_sloc _1 ) 37383 37383 - # 37384 "parsing/parser.ml" 37371 37371 + # 37372 "parsing/parser.ml" 37384 37372 37385 37373 in 37386 37374 37387 37375 # 2352 "parsing/parser.mly" 37388 37376 ( _1 ) 37389 37389 - # 37390 "parsing/parser.ml" 37377 37377 + # 37378 "parsing/parser.ml" 37390 37378 in 37391 37379 { 37392 37380 MenhirLib.EngineTypes.state = _menhir_s; ··· 37414 37402 let _1 : ( 37415 37403 # 729 "parsing/parser.mly" 37416 37404 (string) 37417 37417 - # 37418 "parsing/parser.ml" 37405 37405 + # 37406 "parsing/parser.ml" 37418 37406 ) = Obj.magic _1 in 37419 37407 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 37420 37408 let _startpos = _startpos__1_ in ··· 37428 37416 37429 37417 # 910 "parsing/parser.mly" 37430 37418 ( mkoperator ~loc:_sloc _1 ) 37431 37431 - # 37432 "parsing/parser.ml" 37419 37419 + # 37420 "parsing/parser.ml" 37432 37420 37433 37421 in 37434 37422 37435 37423 # 2384 "parsing/parser.mly" 37436 37424 ( Pexp_apply(_1, [Nolabel,_2]) ) 37437 37437 - # 37438 "parsing/parser.ml" 37425 37425 + # 37426 "parsing/parser.ml" 37438 37426 37439 37427 in 37440 37428 let _endpos__1_ = _endpos__2_ in ··· 37444 37432 37445 37433 # 916 "parsing/parser.mly" 37446 37434 ( mkexp ~loc:_sloc _1 ) 37447 37447 - # 37448 "parsing/parser.ml" 37435 37435 + # 37436 "parsing/parser.ml" 37448 37436 37449 37437 in 37450 37438 37451 37439 # 2352 "parsing/parser.mly" 37452 37440 ( _1 ) 37453 37453 - # 37454 "parsing/parser.ml" 37441 37441 + # 37442 "parsing/parser.ml" 37454 37442 in 37455 37443 { 37456 37444 MenhirLib.EngineTypes.state = _menhir_s; ··· 37485 37473 let _1 = 37486 37474 # 2385 "parsing/parser.mly" 37487 37475 ("!") 37488 37488 - # 37489 "parsing/parser.ml" 37476 37476 + # 37477 "parsing/parser.ml" 37489 37477 in 37490 37478 let _endpos = _endpos__1_ in 37491 37479 let _symbolstartpos = _startpos__1_ in ··· 37493 37481 37494 37482 # 910 "parsing/parser.mly" 37495 37483 ( mkoperator ~loc:_sloc _1 ) 37496 37496 - # 37497 "parsing/parser.ml" 37484 37484 + # 37485 "parsing/parser.ml" 37497 37485 37498 37486 in 37499 37487 37500 37488 # 2386 "parsing/parser.mly" 37501 37489 ( Pexp_apply(_1, [Nolabel,_2]) ) 37502 37502 - # 37503 "parsing/parser.ml" 37490 37490 + # 37491 "parsing/parser.ml" 37503 37491 37504 37492 in 37505 37493 let _endpos__1_ = _endpos__2_ in ··· 37509 37497 37510 37498 # 916 "parsing/parser.mly" 37511 37499 ( mkexp ~loc:_sloc _1 ) 37512 37512 - # 37513 "parsing/parser.ml" 37500 37500 + # 37501 "parsing/parser.ml" 37513 37501 37514 37502 in 37515 37503 37516 37504 # 2352 "parsing/parser.mly" 37517 37505 ( _1 ) 37518 37518 - # 37519 "parsing/parser.ml" 37506 37506 + # 37507 "parsing/parser.ml" 37519 37507 in 37520 37508 { 37521 37509 MenhirLib.EngineTypes.state = _menhir_s; ··· 37556 37544 let _2 = 37557 37545 # 2647 "parsing/parser.mly" 37558 37546 ( xs ) 37559 37559 - # 37560 "parsing/parser.ml" 37547 37547 + # 37548 "parsing/parser.ml" 37560 37548 in 37561 37549 37562 37550 # 2388 "parsing/parser.mly" 37563 37551 ( Pexp_override _2 ) 37564 37564 - # 37565 "parsing/parser.ml" 37552 37552 + # 37553 "parsing/parser.ml" 37565 37553 37566 37554 in 37567 37555 let _endpos__1_ = _endpos__3_ in ··· 37571 37559 37572 37560 # 916 "parsing/parser.mly" 37573 37561 ( mkexp ~loc:_sloc _1 ) 37574 37574 - # 37575 "parsing/parser.ml" 37562 37562 + # 37563 "parsing/parser.ml" 37575 37563 37576 37564 in 37577 37565 37578 37566 # 2352 "parsing/parser.mly" 37579 37567 ( _1 ) 37580 37580 - # 37581 "parsing/parser.ml" 37568 37568 + # 37569 "parsing/parser.ml" 37581 37569 in 37582 37570 { 37583 37571 MenhirLib.EngineTypes.state = _menhir_s; ··· 37618 37606 let _2 = 37619 37607 # 2647 "parsing/parser.mly" 37620 37608 ( xs ) 37621 37621 - # 37622 "parsing/parser.ml" 37609 37609 + # 37610 "parsing/parser.ml" 37622 37610 in 37623 37611 let _loc__3_ = (_startpos__3_, _endpos__3_) in 37624 37612 let _loc__1_ = (_startpos__1_, _endpos__1_) in 37625 37613 37626 37614 # 2390 "parsing/parser.mly" 37627 37615 ( unclosed "{<" _loc__1_ ">}" _loc__3_ ) 37628 37628 - # 37629 "parsing/parser.ml" 37616 37616 + # 37617 "parsing/parser.ml" 37629 37617 37630 37618 in 37631 37619 let _endpos__1_ = _endpos__3_ in ··· 37635 37623 37636 37624 # 916 "parsing/parser.mly" 37637 37625 ( mkexp ~loc:_sloc _1 ) 37638 37638 - # 37639 "parsing/parser.ml" 37626 37626 + # 37627 "parsing/parser.ml" 37639 37627 37640 37628 in 37641 37629 37642 37630 # 2352 "parsing/parser.mly" 37643 37631 ( _1 ) 37644 37644 - # 37645 "parsing/parser.ml" 37632 37632 + # 37633 "parsing/parser.ml" 37645 37633 in 37646 37634 { 37647 37635 MenhirLib.EngineTypes.state = _menhir_s; ··· 37674 37662 let _1 = 37675 37663 # 2392 "parsing/parser.mly" 37676 37664 ( Pexp_override [] ) 37677 37677 - # 37678 "parsing/parser.ml" 37665 37665 + # 37666 "parsing/parser.ml" 37678 37666 in 37679 37667 let _endpos__1_ = _endpos__2_ in 37680 37668 let _endpos = _endpos__1_ in ··· 37683 37671 37684 37672 # 916 "parsing/parser.mly" 37685 37673 ( mkexp ~loc:_sloc _1 ) 37686 37686 - # 37687 "parsing/parser.ml" 37674 37674 + # 37675 "parsing/parser.ml" 37687 37675 37688 37676 in 37689 37677 37690 37678 # 2352 "parsing/parser.mly" 37691 37679 ( _1 ) 37692 37692 - # 37693 "parsing/parser.ml" 37680 37680 + # 37681 "parsing/parser.ml" 37693 37681 in 37694 37682 { 37695 37683 MenhirLib.EngineTypes.state = _menhir_s; ··· 37735 37723 37736 37724 # 883 "parsing/parser.mly" 37737 37725 ( mkrhs _1 _sloc ) 37738 37738 - # 37739 "parsing/parser.ml" 37726 37726 + # 37727 "parsing/parser.ml" 37739 37727 37740 37728 in 37741 37729 37742 37730 # 2394 "parsing/parser.mly" 37743 37731 ( Pexp_field(_1, _3) ) 37744 37744 - # 37745 "parsing/parser.ml" 37732 37732 + # 37733 "parsing/parser.ml" 37745 37733 37746 37734 in 37747 37735 let _endpos__1_ = _endpos__1_inlined1_ in ··· 37751 37739 37752 37740 # 916 "parsing/parser.mly" 37753 37741 ( mkexp ~loc:_sloc _1 ) 37754 37754 - # 37755 "parsing/parser.ml" 37742 37742 + # 37743 "parsing/parser.ml" 37755 37743 37756 37744 in 37757 37745 37758 37746 # 2352 "parsing/parser.mly" 37759 37747 ( _1 ) 37760 37760 - # 37761 "parsing/parser.ml" 37748 37748 + # 37749 "parsing/parser.ml" 37761 37749 in 37762 37750 { 37763 37751 MenhirLib.EngineTypes.state = _menhir_s; ··· 37817 37805 37818 37806 # 883 "parsing/parser.mly" 37819 37807 ( mkrhs _1 _sloc ) 37820 37820 - # 37821 "parsing/parser.ml" 37808 37808 + # 37809 "parsing/parser.ml" 37821 37809 37822 37810 in 37823 37811 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 37826 37814 ( let loc = make_loc _loc__1_ in 37827 37815 let me = Mod.ident ~loc _1 in 37828 37816 Opn.mk ~loc me ) 37829 37829 - # 37830 "parsing/parser.ml" 37817 37817 + # 37818 "parsing/parser.ml" 37830 37818 37831 37819 in 37832 37820 37833 37821 # 2396 "parsing/parser.mly" 37834 37822 ( Pexp_open(od, _4) ) 37835 37835 - # 37836 "parsing/parser.ml" 37823 37823 + # 37824 "parsing/parser.ml" 37836 37824 37837 37825 in 37838 37826 let _endpos__1_ = _endpos__5_ in ··· 37842 37830 37843 37831 # 916 "parsing/parser.mly" 37844 37832 ( mkexp ~loc:_sloc _1 ) 37845 37845 - # 37846 "parsing/parser.ml" 37833 37833 + # 37834 "parsing/parser.ml" 37846 37834 37847 37835 in 37848 37836 37849 37837 # 2352 "parsing/parser.mly" 37850 37838 ( _1 ) 37851 37851 - # 37852 "parsing/parser.ml" 37839 37839 + # 37840 "parsing/parser.ml" 37852 37840 in 37853 37841 { 37854 37842 MenhirLib.EngineTypes.state = _menhir_s; ··· 37903 37891 let _4 = 37904 37892 # 2647 "parsing/parser.mly" 37905 37893 ( xs ) 37906 37906 - # 37907 "parsing/parser.ml" 37894 37894 + # 37895 "parsing/parser.ml" 37907 37895 in 37908 37896 let od = 37909 37897 let _1 = ··· 37913 37901 37914 37902 # 883 "parsing/parser.mly" 37915 37903 ( mkrhs _1 _sloc ) 37916 37916 - # 37917 "parsing/parser.ml" 37904 37904 + # 37905 "parsing/parser.ml" 37917 37905 37918 37906 in 37919 37907 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 37922 37910 ( let loc = make_loc _loc__1_ in 37923 37911 let me = Mod.ident ~loc _1 in 37924 37912 Opn.mk ~loc me ) 37925 37925 - # 37926 "parsing/parser.ml" 37913 37913 + # 37914 "parsing/parser.ml" 37926 37914 37927 37915 in 37928 37916 let _startpos_od_ = _startpos__1_ in ··· 37933 37921 # 2398 "parsing/parser.mly" 37934 37922 ( (* TODO: review the location of Pexp_override *) 37935 37923 Pexp_open(od, mkexp ~loc:_sloc (Pexp_override _4)) ) 37936 37936 - # 37937 "parsing/parser.ml" 37924 37924 + # 37925 "parsing/parser.ml" 37937 37925 37938 37926 in 37939 37927 let _endpos__1_ = _endpos__5_ in ··· 37943 37931 37944 37932 # 916 "parsing/parser.mly" 37945 37933 ( mkexp ~loc:_sloc _1 ) 37946 37946 - # 37947 "parsing/parser.ml" 37934 37934 + # 37935 "parsing/parser.ml" 37947 37935 37948 37936 in 37949 37937 37950 37938 # 2352 "parsing/parser.mly" 37951 37939 ( _1 ) 37952 37952 - # 37953 "parsing/parser.ml" 37940 37940 + # 37941 "parsing/parser.ml" 37953 37941 in 37954 37942 { 37955 37943 MenhirLib.EngineTypes.state = _menhir_s; ··· 38004 37992 let _4 = 38005 37993 # 2647 "parsing/parser.mly" 38006 37994 ( xs ) 38007 38007 - # 38008 "parsing/parser.ml" 37995 37995 + # 37996 "parsing/parser.ml" 38008 37996 in 38009 37997 let _loc__5_ = (_startpos__5_, _endpos__5_) in 38010 37998 let _loc__3_ = (_startpos__3_, _endpos__3_) in 38011 37999 38012 38000 # 2401 "parsing/parser.mly" 38013 38001 ( unclosed "{<" _loc__3_ ">}" _loc__5_ ) 38014 38014 - # 38015 "parsing/parser.ml" 38002 38002 + # 38003 "parsing/parser.ml" 38015 38003 38016 38004 in 38017 38005 let _endpos__1_ = _endpos__5_ in ··· 38021 38009 38022 38010 # 916 "parsing/parser.mly" 38023 38011 ( mkexp ~loc:_sloc _1 ) 38024 38024 - # 38025 "parsing/parser.ml" 38012 38012 + # 38013 "parsing/parser.ml" 38025 38013 38026 38014 in 38027 38015 38028 38016 # 2352 "parsing/parser.mly" 38029 38017 ( _1 ) 38030 38030 - # 38031 "parsing/parser.ml" 38018 38018 + # 38019 "parsing/parser.ml" 38031 38019 in 38032 38020 { 38033 38021 MenhirLib.EngineTypes.state = _menhir_s; ··· 38060 38048 let _1_inlined1 : ( 38061 38049 # 705 "parsing/parser.mly" 38062 38050 (string) 38063 38063 - # 38064 "parsing/parser.ml" 38051 38051 + # 38052 "parsing/parser.ml" 38064 38052 ) = Obj.magic _1_inlined1 in 38065 38053 let _2 : unit = Obj.magic _2 in 38066 38054 let _1 : (Parsetree.expression) = Obj.magic _1 in ··· 38074 38062 let _1 = 38075 38063 # 3498 "parsing/parser.mly" 38076 38064 ( _1 ) 38077 38077 - # 38078 "parsing/parser.ml" 38065 38065 + # 38066 "parsing/parser.ml" 38078 38066 in 38079 38067 let _endpos = _endpos__1_ in 38080 38068 let _symbolstartpos = _startpos__1_ in ··· 38082 38070 38083 38071 # 883 "parsing/parser.mly" 38084 38072 ( mkrhs _1 _sloc ) 38085 38085 - # 38086 "parsing/parser.ml" 38073 38073 + # 38074 "parsing/parser.ml" 38086 38074 38087 38075 in 38088 38076 38089 38077 # 2403 "parsing/parser.mly" 38090 38078 ( Pexp_send(_1, _3) ) 38091 38091 - # 38092 "parsing/parser.ml" 38079 38079 + # 38080 "parsing/parser.ml" 38092 38080 38093 38081 in 38094 38082 let _endpos__1_ = _endpos__1_inlined1_ in ··· 38098 38086 38099 38087 # 916 "parsing/parser.mly" 38100 38088 ( mkexp ~loc:_sloc _1 ) 38101 38101 - # 38102 "parsing/parser.ml" 38089 38089 + # 38090 "parsing/parser.ml" 38102 38090 38103 38091 in 38104 38092 38105 38093 # 2352 "parsing/parser.mly" 38106 38094 ( _1 ) 38107 38107 - # 38108 "parsing/parser.ml" 38095 38095 + # 38096 "parsing/parser.ml" 38108 38096 in 38109 38097 { 38110 38098 MenhirLib.EngineTypes.state = _menhir_s; ··· 38138 38126 let _1_inlined1 : ( 38139 38127 # 740 "parsing/parser.mly" 38140 38128 (string) 38141 38141 - # 38142 "parsing/parser.ml" 38129 38129 + # 38130 "parsing/parser.ml" 38142 38130 ) = Obj.magic _1_inlined1 in 38143 38131 let _1 : (Parsetree.expression) = Obj.magic _1 in 38144 38132 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in ··· 38154 38142 38155 38143 # 910 "parsing/parser.mly" 38156 38144 ( mkoperator ~loc:_sloc _1 ) 38157 38157 - # 38158 "parsing/parser.ml" 38145 38145 + # 38146 "parsing/parser.ml" 38158 38146 38159 38147 in 38160 38148 38161 38149 # 2405 "parsing/parser.mly" 38162 38150 ( mkinfix _1 _2 _3 ) 38163 38163 - # 38164 "parsing/parser.ml" 38151 38151 + # 38152 "parsing/parser.ml" 38164 38152 38165 38153 in 38166 38154 let _endpos__1_ = _endpos__3_ in ··· 38170 38158 38171 38159 # 916 "parsing/parser.mly" 38172 38160 ( mkexp ~loc:_sloc _1 ) 38173 38173 - # 38174 "parsing/parser.ml" 38161 38161 + # 38162 "parsing/parser.ml" 38174 38162 38175 38163 in 38176 38164 38177 38165 # 2352 "parsing/parser.mly" 38178 38166 ( _1 ) 38179 38179 - # 38180 "parsing/parser.ml" 38167 38167 + # 38168 "parsing/parser.ml" 38180 38168 in 38181 38169 { 38182 38170 MenhirLib.EngineTypes.state = _menhir_s; ··· 38202 38190 let _1 = 38203 38191 # 2407 "parsing/parser.mly" 38204 38192 ( Pexp_extension _1 ) 38205 38205 - # 38206 "parsing/parser.ml" 38193 38193 + # 38194 "parsing/parser.ml" 38206 38194 in 38207 38195 let _endpos = _endpos__1_ in 38208 38196 let _symbolstartpos = _startpos__1_ in ··· 38210 38198 38211 38199 # 916 "parsing/parser.mly" 38212 38200 ( mkexp ~loc:_sloc _1 ) 38213 38213 - # 38214 "parsing/parser.ml" 38201 38201 + # 38202 "parsing/parser.ml" 38214 38202 38215 38203 in 38216 38204 38217 38205 # 2352 "parsing/parser.mly" 38218 38206 ( _1 ) 38219 38219 - # 38220 "parsing/parser.ml" 38207 38207 + # 38208 "parsing/parser.ml" 38220 38208 in 38221 38209 { 38222 38210 MenhirLib.EngineTypes.state = _menhir_s; ··· 38266 38254 let _1 = 38267 38255 # 2408 "parsing/parser.mly" 38268 38256 (Lident "()") 38269 38269 - # 38270 "parsing/parser.ml" 38257 38257 + # 38258 "parsing/parser.ml" 38270 38258 in 38271 38259 let _endpos__1_ = _endpos__2_ in 38272 38260 let _endpos = _endpos__1_ in ··· 38275 38263 38276 38264 # 883 "parsing/parser.mly" 38277 38265 ( mkrhs _1 _sloc ) 38278 38278 - # 38279 "parsing/parser.ml" 38266 38266 + # 38267 "parsing/parser.ml" 38279 38267 38280 38268 in 38281 38269 let (_endpos__3_, _startpos__3_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in ··· 38287 38275 38288 38276 # 883 "parsing/parser.mly" 38289 38277 ( mkrhs _1 _sloc ) 38290 38290 - # 38291 "parsing/parser.ml" 38278 38278 + # 38279 "parsing/parser.ml" 38291 38279 38292 38280 in 38293 38281 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 38296 38284 ( let loc = make_loc _loc__1_ in 38297 38285 let me = Mod.ident ~loc _1 in 38298 38286 Opn.mk ~loc me ) 38299 38299 - # 38300 "parsing/parser.ml" 38287 38287 + # 38288 "parsing/parser.ml" 38300 38288 38301 38289 in 38302 38290 let _loc__3_ = (_startpos__3_, _endpos__3_) in 38303 38291 38304 38292 # 2409 "parsing/parser.mly" 38305 38293 ( Pexp_open(od, mkexp ~loc:(_loc__3_) (Pexp_construct(_3, None))) ) 38306 38306 - # 38307 "parsing/parser.ml" 38294 38294 + # 38295 "parsing/parser.ml" 38307 38295 38308 38296 in 38309 38297 let _endpos__1_ = _endpos__2_inlined1_ in ··· 38313 38301 38314 38302 # 916 "parsing/parser.mly" 38315 38303 ( mkexp ~loc:_sloc _1 ) 38316 38316 - # 38317 "parsing/parser.ml" 38304 38304 + # 38305 "parsing/parser.ml" 38317 38305 38318 38306 in 38319 38307 38320 38308 # 2352 "parsing/parser.mly" 38321 38309 ( _1 ) 38322 38322 - # 38323 "parsing/parser.ml" 38310 38310 + # 38311 "parsing/parser.ml" 38323 38311 in 38324 38312 { 38325 38313 MenhirLib.EngineTypes.state = _menhir_s; ··· 38376 38364 38377 38365 # 2411 "parsing/parser.mly" 38378 38366 ( unclosed "(" _loc__3_ ")" _loc__5_ ) 38379 38379 - # 38380 "parsing/parser.ml" 38367 38367 + # 38368 "parsing/parser.ml" 38380 38368 38381 38369 in 38382 38370 let _endpos__1_ = _endpos__5_ in ··· 38386 38374 38387 38375 # 916 "parsing/parser.mly" 38388 38376 ( mkexp ~loc:_sloc _1 ) 38389 38389 - # 38390 "parsing/parser.ml" 38377 38377 + # 38378 "parsing/parser.ml" 38390 38378 38391 38379 in 38392 38380 38393 38381 # 2352 "parsing/parser.mly" 38394 38382 ( _1 ) 38395 38395 - # 38396 "parsing/parser.ml" 38383 38383 + # 38384 "parsing/parser.ml" 38396 38384 in 38397 38385 { 38398 38386 MenhirLib.EngineTypes.state = _menhir_s; ··· 38434 38422 # 2413 "parsing/parser.mly" 38435 38423 ( let (exten, fields) = _2 in 38436 38424 Pexp_record(fields, exten) ) 38437 38437 - # 38438 "parsing/parser.ml" 38425 38425 + # 38426 "parsing/parser.ml" 38438 38426 in 38439 38427 let _endpos__1_ = _endpos__3_ in 38440 38428 let _endpos = _endpos__1_ in ··· 38443 38431 38444 38432 # 916 "parsing/parser.mly" 38445 38433 ( mkexp ~loc:_sloc _1 ) 38446 38446 - # 38447 "parsing/parser.ml" 38434 38434 + # 38435 "parsing/parser.ml" 38447 38435 38448 38436 in 38449 38437 38450 38438 # 2352 "parsing/parser.mly" 38451 38439 ( _1 ) 38452 38452 - # 38453 "parsing/parser.ml" 38440 38440 + # 38441 "parsing/parser.ml" 38453 38441 in 38454 38442 { 38455 38443 MenhirLib.EngineTypes.state = _menhir_s; ··· 38493 38481 38494 38482 # 2416 "parsing/parser.mly" 38495 38483 ( unclosed "{" _loc__1_ "}" _loc__3_ ) 38496 38496 - # 38497 "parsing/parser.ml" 38484 38484 + # 38485 "parsing/parser.ml" 38497 38485 38498 38486 in 38499 38487 let _endpos__1_ = _endpos__3_ in ··· 38503 38491 38504 38492 # 916 "parsing/parser.mly" 38505 38493 ( mkexp ~loc:_sloc _1 ) 38506 38506 - # 38507 "parsing/parser.ml" 38494 38494 + # 38495 "parsing/parser.ml" 38507 38495 38508 38496 in 38509 38497 38510 38498 # 2352 "parsing/parser.mly" 38511 38499 ( _1 ) 38512 38512 - # 38513 "parsing/parser.ml" 38500 38500 + # 38501 "parsing/parser.ml" 38513 38501 in 38514 38502 { 38515 38503 MenhirLib.EngineTypes.state = _menhir_s; ··· 38570 38558 38571 38559 # 883 "parsing/parser.mly" 38572 38560 ( mkrhs _1 _sloc ) 38573 38573 - # 38574 "parsing/parser.ml" 38561 38561 + # 38562 "parsing/parser.ml" 38574 38562 38575 38563 in 38576 38564 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 38579 38567 ( let loc = make_loc _loc__1_ in 38580 38568 let me = Mod.ident ~loc _1 in 38581 38569 Opn.mk ~loc me ) 38582 38582 - # 38583 "parsing/parser.ml" 38570 38570 + # 38571 "parsing/parser.ml" 38583 38571 38584 38572 in 38585 38573 let _endpos = _endpos__5_ in ··· 38588 38576 ( let (exten, fields) = _4 in 38589 38577 Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) 38590 38578 (Pexp_record(fields, exten))) ) 38591 38591 - # 38592 "parsing/parser.ml" 38579 38579 + # 38580 "parsing/parser.ml" 38592 38580 38593 38581 in 38594 38582 let _endpos__1_ = _endpos__5_ in ··· 38598 38586 38599 38587 # 916 "parsing/parser.mly" 38600 38588 ( mkexp ~loc:_sloc _1 ) 38601 38601 - # 38602 "parsing/parser.ml" 38589 38589 + # 38590 "parsing/parser.ml" 38602 38590 38603 38591 in 38604 38592 38605 38593 # 2352 "parsing/parser.mly" 38606 38594 ( _1 ) 38607 38607 - # 38608 "parsing/parser.ml" 38595 38595 + # 38596 "parsing/parser.ml" 38608 38596 in 38609 38597 { 38610 38598 MenhirLib.EngineTypes.state = _menhir_s; ··· 38662 38650 38663 38651 # 2422 "parsing/parser.mly" 38664 38652 ( unclosed "{" _loc__3_ "}" _loc__5_ ) 38665 38665 - # 38666 "parsing/parser.ml" 38653 38653 + # 38654 "parsing/parser.ml" 38666 38654 38667 38655 in 38668 38656 let _endpos__1_ = _endpos__5_ in ··· 38672 38660 38673 38661 # 916 "parsing/parser.mly" 38674 38662 ( mkexp ~loc:_sloc _1 ) 38675 38675 - # 38676 "parsing/parser.ml" 38663 38663 + # 38664 "parsing/parser.ml" 38676 38664 38677 38665 in 38678 38666 38679 38667 # 2352 "parsing/parser.mly" 38680 38668 ( _1 ) 38681 38681 - # 38682 "parsing/parser.ml" 38669 38669 + # 38670 "parsing/parser.ml" 38682 38670 in 38683 38671 { 38684 38672 MenhirLib.EngineTypes.state = _menhir_s; ··· 38719 38707 let _2 = 38720 38708 # 2664 "parsing/parser.mly" 38721 38709 ( es ) 38722 38722 - # 38723 "parsing/parser.ml" 38710 38710 + # 38711 "parsing/parser.ml" 38723 38711 in 38724 38712 38725 38713 # 2424 "parsing/parser.mly" 38726 38714 ( Pexp_array(_2) ) 38727 38727 - # 38728 "parsing/parser.ml" 38715 38715 + # 38716 "parsing/parser.ml" 38728 38716 38729 38717 in 38730 38718 let _endpos__1_ = _endpos__3_ in ··· 38734 38722 38735 38723 # 916 "parsing/parser.mly" 38736 38724 ( mkexp ~loc:_sloc _1 ) 38737 38737 - # 38738 "parsing/parser.ml" 38725 38725 + # 38726 "parsing/parser.ml" 38738 38726 38739 38727 in 38740 38728 38741 38729 # 2352 "parsing/parser.mly" 38742 38730 ( _1 ) 38743 38743 - # 38744 "parsing/parser.ml" 38731 38731 + # 38732 "parsing/parser.ml" 38744 38732 in 38745 38733 { 38746 38734 MenhirLib.EngineTypes.state = _menhir_s; ··· 38781 38769 let _2 = 38782 38770 # 2664 "parsing/parser.mly" 38783 38771 ( es ) 38784 38784 - # 38785 "parsing/parser.ml" 38772 38772 + # 38773 "parsing/parser.ml" 38785 38773 in 38786 38774 let _loc__3_ = (_startpos__3_, _endpos__3_) in 38787 38775 let _loc__1_ = (_startpos__1_, _endpos__1_) in 38788 38776 38789 38777 # 2426 "parsing/parser.mly" 38790 38778 ( unclosed "[|" _loc__1_ "|]" _loc__3_ ) 38791 38791 - # 38792 "parsing/parser.ml" 38779 38779 + # 38780 "parsing/parser.ml" 38792 38780 38793 38781 in 38794 38782 let _endpos__1_ = _endpos__3_ in ··· 38798 38786 38799 38787 # 916 "parsing/parser.mly" 38800 38788 ( mkexp ~loc:_sloc _1 ) 38801 38801 - # 38802 "parsing/parser.ml" 38789 38789 + # 38790 "parsing/parser.ml" 38802 38790 38803 38791 in 38804 38792 38805 38793 # 2352 "parsing/parser.mly" 38806 38794 ( _1 ) 38807 38807 - # 38808 "parsing/parser.ml" 38795 38795 + # 38796 "parsing/parser.ml" 38808 38796 in 38809 38797 { 38810 38798 MenhirLib.EngineTypes.state = _menhir_s; ··· 38837 38825 let _1 = 38838 38826 # 2428 "parsing/parser.mly" 38839 38827 ( Pexp_array [] ) 38840 38840 - # 38841 "parsing/parser.ml" 38828 38828 + # 38829 "parsing/parser.ml" 38841 38829 in 38842 38830 let _endpos__1_ = _endpos__2_ in 38843 38831 let _endpos = _endpos__1_ in ··· 38846 38834 38847 38835 # 916 "parsing/parser.mly" 38848 38836 ( mkexp ~loc:_sloc _1 ) 38849 38849 - # 38850 "parsing/parser.ml" 38837 38837 + # 38838 "parsing/parser.ml" 38850 38838 38851 38839 in 38852 38840 38853 38841 # 2352 "parsing/parser.mly" 38854 38842 ( _1 ) 38855 38855 - # 38856 "parsing/parser.ml" 38843 38843 + # 38844 "parsing/parser.ml" 38856 38844 in 38857 38845 { 38858 38846 MenhirLib.EngineTypes.state = _menhir_s; ··· 38907 38895 let _4 = 38908 38896 # 2664 "parsing/parser.mly" 38909 38897 ( es ) 38910 38910 - # 38911 "parsing/parser.ml" 38898 38898 + # 38899 "parsing/parser.ml" 38911 38899 in 38912 38900 let od = 38913 38901 let _1 = ··· 38917 38905 38918 38906 # 883 "parsing/parser.mly" 38919 38907 ( mkrhs _1 _sloc ) 38920 38920 - # 38921 "parsing/parser.ml" 38908 38908 + # 38909 "parsing/parser.ml" 38921 38909 38922 38910 in 38923 38911 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 38926 38914 ( let loc = make_loc _loc__1_ in 38927 38915 let me = Mod.ident ~loc _1 in 38928 38916 Opn.mk ~loc me ) 38929 38929 - # 38930 "parsing/parser.ml" 38917 38917 + # 38918 "parsing/parser.ml" 38930 38918 38931 38919 in 38932 38920 let _endpos = _endpos__5_ in 38933 38921 38934 38922 # 2430 "parsing/parser.mly" 38935 38923 ( Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) (Pexp_array(_4))) ) 38936 38936 - # 38937 "parsing/parser.ml" 38924 38924 + # 38925 "parsing/parser.ml" 38937 38925 38938 38926 in 38939 38927 let _endpos__1_ = _endpos__5_ in ··· 38943 38931 38944 38932 # 916 "parsing/parser.mly" 38945 38933 ( mkexp ~loc:_sloc _1 ) 38946 38946 - # 38947 "parsing/parser.ml" 38934 38934 + # 38935 "parsing/parser.ml" 38947 38935 38948 38936 in 38949 38937 38950 38938 # 2352 "parsing/parser.mly" 38951 38939 ( _1 ) 38952 38952 - # 38953 "parsing/parser.ml" 38940 38940 + # 38941 "parsing/parser.ml" 38953 38941 in 38954 38942 { 38955 38943 MenhirLib.EngineTypes.state = _menhir_s; ··· 39002 38990 39003 38991 # 883 "parsing/parser.mly" 39004 38992 ( mkrhs _1 _sloc ) 39005 39005 - # 39006 "parsing/parser.ml" 38993 38993 + # 38994 "parsing/parser.ml" 39006 38994 39007 38995 in 39008 38996 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 39011 38999 ( let loc = make_loc _loc__1_ in 39012 39000 let me = Mod.ident ~loc _1 in 39013 39001 Opn.mk ~loc me ) 39014 39014 - # 39015 "parsing/parser.ml" 39002 39002 + # 39003 "parsing/parser.ml" 39015 39003 39016 39004 in 39017 39005 let _endpos = _endpos__4_ in ··· 39019 39007 # 2432 "parsing/parser.mly" 39020 39008 ( (* TODO: review the location of Pexp_array *) 39021 39009 Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) (Pexp_array [])) ) 39022 39022 - # 39023 "parsing/parser.ml" 39010 39010 + # 39011 "parsing/parser.ml" 39023 39011 39024 39012 in 39025 39013 let _endpos__1_ = _endpos__4_ in ··· 39029 39017 39030 39018 # 916 "parsing/parser.mly" 39031 39019 ( mkexp ~loc:_sloc _1 ) 39032 39032 - # 39033 "parsing/parser.ml" 39020 39020 + # 39021 "parsing/parser.ml" 39033 39021 39034 39022 in 39035 39023 39036 39024 # 2352 "parsing/parser.mly" 39037 39025 ( _1 ) 39038 39038 - # 39039 "parsing/parser.ml" 39026 39026 + # 39027 "parsing/parser.ml" 39039 39027 in 39040 39028 { 39041 39029 MenhirLib.EngineTypes.state = _menhir_s; ··· 39090 39078 let _4 = 39091 39079 # 2664 "parsing/parser.mly" 39092 39080 ( es ) 39093 39093 - # 39094 "parsing/parser.ml" 39081 39081 + # 39082 "parsing/parser.ml" 39094 39082 in 39095 39083 let _loc__5_ = (_startpos__5_, _endpos__5_) in 39096 39084 let _loc__3_ = (_startpos__3_, _endpos__3_) in 39097 39085 39098 39086 # 2436 "parsing/parser.mly" 39099 39087 ( unclosed "[|" _loc__3_ "|]" _loc__5_ ) 39100 39100 - # 39101 "parsing/parser.ml" 39088 39088 + # 39089 "parsing/parser.ml" 39101 39089 39102 39090 in 39103 39091 let _endpos__1_ = _endpos__5_ in ··· 39107 39095 39108 39096 # 916 "parsing/parser.mly" 39109 39097 ( mkexp ~loc:_sloc _1 ) 39110 39110 - # 39111 "parsing/parser.ml" 39098 39098 + # 39099 "parsing/parser.ml" 39111 39099 39112 39100 in 39113 39101 39114 39102 # 2352 "parsing/parser.mly" 39115 39103 ( _1 ) 39116 39116 - # 39117 "parsing/parser.ml" 39104 39104 + # 39105 "parsing/parser.ml" 39117 39105 in 39118 39106 { 39119 39107 MenhirLib.EngineTypes.state = _menhir_s; ··· 39154 39142 let _2 = 39155 39143 # 2664 "parsing/parser.mly" 39156 39144 ( es ) 39157 39157 - # 39158 "parsing/parser.ml" 39145 39145 + # 39146 "parsing/parser.ml" 39158 39146 in 39159 39147 let _loc__3_ = (_startpos__3_, _endpos__3_) in 39160 39148 39161 39149 # 2438 "parsing/parser.mly" 39162 39150 ( fst (mktailexp _loc__3_ _2) ) 39163 39163 - # 39164 "parsing/parser.ml" 39151 39151 + # 39152 "parsing/parser.ml" 39164 39152 39165 39153 in 39166 39154 let _endpos__1_ = _endpos__3_ in ··· 39170 39158 39171 39159 # 916 "parsing/parser.mly" 39172 39160 ( mkexp ~loc:_sloc _1 ) 39173 39173 - # 39174 "parsing/parser.ml" 39161 39161 + # 39162 "parsing/parser.ml" 39174 39162 39175 39163 in 39176 39164 39177 39165 # 2352 "parsing/parser.mly" 39178 39166 ( _1 ) 39179 39179 - # 39180 "parsing/parser.ml" 39167 39167 + # 39168 "parsing/parser.ml" 39180 39168 in 39181 39169 { 39182 39170 MenhirLib.EngineTypes.state = _menhir_s; ··· 39217 39205 let _2 = 39218 39206 # 2664 "parsing/parser.mly" 39219 39207 ( es ) 39220 39220 - # 39221 "parsing/parser.ml" 39208 39208 + # 39209 "parsing/parser.ml" 39221 39209 in 39222 39210 let _loc__3_ = (_startpos__3_, _endpos__3_) in 39223 39211 let _loc__1_ = (_startpos__1_, _endpos__1_) in 39224 39212 39225 39213 # 2440 "parsing/parser.mly" 39226 39214 ( unclosed "[" _loc__1_ "]" _loc__3_ ) 39227 39227 - # 39228 "parsing/parser.ml" 39215 39215 + # 39216 "parsing/parser.ml" 39228 39216 39229 39217 in 39230 39218 let _endpos__1_ = _endpos__3_ in ··· 39234 39222 39235 39223 # 916 "parsing/parser.mly" 39236 39224 ( mkexp ~loc:_sloc _1 ) 39237 39237 - # 39238 "parsing/parser.ml" 39225 39225 + # 39226 "parsing/parser.ml" 39238 39226 39239 39227 in 39240 39228 39241 39229 # 2352 "parsing/parser.mly" 39242 39230 ( _1 ) 39243 39243 - # 39244 "parsing/parser.ml" 39231 39231 + # 39232 "parsing/parser.ml" 39244 39232 in 39245 39233 { 39246 39234 MenhirLib.EngineTypes.state = _menhir_s; ··· 39295 39283 let _4 = 39296 39284 # 2664 "parsing/parser.mly" 39297 39285 ( es ) 39298 39298 - # 39299 "parsing/parser.ml" 39286 39286 + # 39287 "parsing/parser.ml" 39299 39287 in 39300 39288 let od = 39301 39289 let _1 = ··· 39305 39293 39306 39294 # 883 "parsing/parser.mly" 39307 39295 ( mkrhs _1 _sloc ) 39308 39308 - # 39309 "parsing/parser.ml" 39296 39296 + # 39297 "parsing/parser.ml" 39309 39297 39310 39298 in 39311 39299 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 39314 39302 ( let loc = make_loc _loc__1_ in 39315 39303 let me = Mod.ident ~loc _1 in 39316 39304 Opn.mk ~loc me ) 39317 39317 - # 39318 "parsing/parser.ml" 39305 39305 + # 39306 "parsing/parser.ml" 39318 39306 39319 39307 in 39320 39308 let _endpos = _endpos__5_ in ··· 39326 39314 let tail_exp, _tail_loc = mktailexp _loc__5_ _4 in 39327 39315 mkexp ~loc:(_startpos__3_, _endpos) tail_exp in 39328 39316 Pexp_open(od, list_exp) ) 39329 39329 - # 39330 "parsing/parser.ml" 39317 39317 + # 39318 "parsing/parser.ml" 39330 39318 39331 39319 in 39332 39320 let _endpos__1_ = _endpos__5_ in ··· 39336 39324 39337 39325 # 916 "parsing/parser.mly" 39338 39326 ( mkexp ~loc:_sloc _1 ) 39339 39339 - # 39340 "parsing/parser.ml" 39327 39327 + # 39328 "parsing/parser.ml" 39340 39328 39341 39329 in 39342 39330 39343 39331 # 2352 "parsing/parser.mly" 39344 39332 ( _1 ) 39345 39345 - # 39346 "parsing/parser.ml" 39333 39333 + # 39334 "parsing/parser.ml" 39346 39334 in 39347 39335 { 39348 39336 MenhirLib.EngineTypes.state = _menhir_s; ··· 39392 39380 let _1 = 39393 39381 # 2447 "parsing/parser.mly" 39394 39382 (Lident "[]") 39395 39395 - # 39396 "parsing/parser.ml" 39383 39383 + # 39384 "parsing/parser.ml" 39396 39384 in 39397 39385 let _endpos__1_ = _endpos__2_ in 39398 39386 let _endpos = _endpos__1_ in ··· 39401 39389 39402 39390 # 883 "parsing/parser.mly" 39403 39391 ( mkrhs _1 _sloc ) 39404 39404 - # 39405 "parsing/parser.ml" 39392 39392 + # 39393 "parsing/parser.ml" 39405 39393 39406 39394 in 39407 39395 let (_endpos__3_, _startpos__3_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in ··· 39413 39401 39414 39402 # 883 "parsing/parser.mly" 39415 39403 ( mkrhs _1 _sloc ) 39416 39416 - # 39417 "parsing/parser.ml" 39404 39404 + # 39405 "parsing/parser.ml" 39417 39405 39418 39406 in 39419 39407 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 39422 39410 ( let loc = make_loc _loc__1_ in 39423 39411 let me = Mod.ident ~loc _1 in 39424 39412 Opn.mk ~loc me ) 39425 39425 - # 39426 "parsing/parser.ml" 39413 39413 + # 39414 "parsing/parser.ml" 39426 39414 39427 39415 in 39428 39416 let _loc__3_ = (_startpos__3_, _endpos__3_) in 39429 39417 39430 39418 # 2448 "parsing/parser.mly" 39431 39419 ( Pexp_open(od, mkexp ~loc:_loc__3_ (Pexp_construct(_3, None))) ) 39432 39432 - # 39433 "parsing/parser.ml" 39420 39420 + # 39421 "parsing/parser.ml" 39433 39421 39434 39422 in 39435 39423 let _endpos__1_ = _endpos__2_inlined1_ in ··· 39439 39427 39440 39428 # 916 "parsing/parser.mly" 39441 39429 ( mkexp ~loc:_sloc _1 ) 39442 39442 - # 39443 "parsing/parser.ml" 39430 39430 + # 39431 "parsing/parser.ml" 39443 39431 39444 39432 in 39445 39433 39446 39434 # 2352 "parsing/parser.mly" 39447 39435 ( _1 ) 39448 39448 - # 39449 "parsing/parser.ml" 39436 39436 + # 39437 "parsing/parser.ml" 39449 39437 in 39450 39438 { 39451 39439 MenhirLib.EngineTypes.state = _menhir_s; ··· 39500 39488 let _4 = 39501 39489 # 2664 "parsing/parser.mly" 39502 39490 ( es ) 39503 39503 - # 39504 "parsing/parser.ml" 39491 39491 + # 39492 "parsing/parser.ml" 39504 39492 in 39505 39493 let _loc__5_ = (_startpos__5_, _endpos__5_) in 39506 39494 let _loc__3_ = (_startpos__3_, _endpos__3_) in 39507 39495 39508 39496 # 2451 "parsing/parser.mly" 39509 39497 ( unclosed "[" _loc__3_ "]" _loc__5_ ) 39510 39510 - # 39511 "parsing/parser.ml" 39498 39498 + # 39499 "parsing/parser.ml" 39511 39499 39512 39500 in 39513 39501 let _endpos__1_ = _endpos__5_ in ··· 39517 39505 39518 39506 # 916 "parsing/parser.mly" 39519 39507 ( mkexp ~loc:_sloc _1 ) 39520 39520 - # 39521 "parsing/parser.ml" 39508 39508 + # 39509 "parsing/parser.ml" 39521 39509 39522 39510 in 39523 39511 39524 39512 # 2352 "parsing/parser.mly" 39525 39513 ( _1 ) 39526 39526 - # 39527 "parsing/parser.ml" 39514 39514 + # 39515 "parsing/parser.ml" 39527 39515 in 39528 39516 { 39529 39517 MenhirLib.EngineTypes.state = _menhir_s; ··· 39620 39608 ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in 39621 39609 let descr = Ptyp_package (lid, cstrs) in 39622 39610 mktyp ~loc:_sloc ~attrs descr ) 39623 39623 - # 39624 "parsing/parser.ml" 39611 39611 + # 39612 "parsing/parser.ml" 39624 39612 39625 39613 in 39626 39614 let _5 = ··· 39630 39618 39631 39619 # 3840 "parsing/parser.mly" 39632 39620 ( _1 ) 39633 39633 - # 39634 "parsing/parser.ml" 39621 39621 + # 39622 "parsing/parser.ml" 39634 39622 39635 39623 in 39636 39624 39637 39625 # 3853 "parsing/parser.mly" 39638 39626 ( _1, _2 ) 39639 39639 - # 39640 "parsing/parser.ml" 39627 39627 + # 39628 "parsing/parser.ml" 39640 39628 39641 39629 in 39642 39630 let od = ··· 39647 39635 39648 39636 # 883 "parsing/parser.mly" 39649 39637 ( mkrhs _1 _sloc ) 39650 39650 - # 39651 "parsing/parser.ml" 39638 39638 + # 39639 "parsing/parser.ml" 39651 39639 39652 39640 in 39653 39641 let _loc__1_ = (_startpos__1_, _endpos__1_) in ··· 39656 39644 ( let loc = make_loc _loc__1_ in 39657 39645 let me = Mod.ident ~loc _1 in 39658 39646 Opn.mk ~loc me ) 39659 39659 - # 39660 "parsing/parser.ml" 39647 39647 + # 39648 "parsing/parser.ml" 39660 39648 39661 39649 in 39662 39650 let _startpos_od_ = _startpos__1_ in ··· 39669 39657 mkexp_attrs ~loc:(_startpos__3_, _endpos) 39670 39658 (Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _6), _8)) _5 in 39671 39659 Pexp_open(od, modexp) ) 39672 39672 - # 39673 "parsing/parser.ml" 39660 39660 + # 39661 "parsing/parser.ml" 39673 39661 39674 39662 in 39675 39663 let _endpos__1_ = _endpos__9_ in ··· 39679 39667 39680 39668 # 916 "parsing/parser.mly" 39681 39669 ( mkexp ~loc:_sloc _1 ) 39682 39682 - # 39683 "parsing/parser.ml" 39670 39670 + # 39671 "parsing/parser.ml" 39683 39671 39684 39672 in 39685 39673 39686 39674 # 2352 "parsing/parser.mly" 39687 39675 ( _1 ) 39688 39688 - # 39689 "parsing/parser.ml" 39676 39676 + # 39677 "parsing/parser.ml" 39689 39677 in 39690 39678 { 39691 39679 MenhirLib.EngineTypes.state = _menhir_s; ··· 39772 39760 39773 39761 # 3840 "parsing/parser.mly" 39774 39762 ( _1 ) 39775 39775 - # 39776 "parsing/parser.ml" 39763 39763 + # 39764 "parsing/parser.ml" 39776 39764 39777 39765 in 39778 39766 39779 39767 # 3853 "parsing/parser.mly" 39780 39768 ( _1, _2 ) 39781 39781 - # 39782 "parsing/parser.ml" 39769 39769 + # 39770 "parsing/parser.ml" 39782 39770 39783 39771 in 39784 39772 let _loc__8_ = (_startpos__8_, _endpos__8_) in ··· 39786 39774 39787 39775 # 2460 "parsing/parser.mly" 39788 39776 ( unclosed "(" _loc__3_ ")" _loc__8_ ) 39789 39789 - # 39790 "parsing/parser.ml" 39777 39777 + # 39778 "parsing/parser.ml" 39790 39778 39791 39779 in 39792 39780 let _endpos__1_ = _endpos__8_ in ··· 39796 39784 39797 39785 # 916 "parsing/parser.mly" 39798 39786 ( mkexp ~loc:_sloc _1 ) 39799 39799 - # 39800 "parsing/parser.ml" 39787 39787 + # 39788 "parsing/parser.ml" 39800 39788 39801 39789 in 39802 39790 39803 39791 # 2352 "parsing/parser.mly" 39804 39792 ( _1 ) 39805 39805 - # 39806 "parsing/parser.ml" 39793 39793 + # 39794 "parsing/parser.ml" 39806 39794 in 39807 39795 { 39808 39796 MenhirLib.EngineTypes.state = _menhir_s; ··· 39833 39821 39834 39822 # 883 "parsing/parser.mly" 39835 39823 ( mkrhs _1 _sloc ) 39836 39836 - # 39837 "parsing/parser.ml" 39824 39824 + # 39825 "parsing/parser.ml" 39837 39825 39838 39826 in 39839 39827 39840 39828 # 2747 "parsing/parser.mly" 39841 39829 ( Ppat_var (_1) ) 39842 39842 - # 39843 "parsing/parser.ml" 39830 39830 + # 39831 "parsing/parser.ml" 39843 39831 39844 39832 in 39845 39833 let _endpos = _endpos__1_ in ··· 39848 39836 39849 39837 # 918 "parsing/parser.mly" 39850 39838 ( mkpat ~loc:_sloc _1 ) 39851 39851 - # 39852 "parsing/parser.ml" 39839 39839 + # 39840 "parsing/parser.ml" 39852 39840 39853 39841 in 39854 39842 39855 39843 # 2748 "parsing/parser.mly" 39856 39844 ( _1 ) 39857 39857 - # 39858 "parsing/parser.ml" 39845 39845 + # 39846 "parsing/parser.ml" 39858 39846 in 39859 39847 { 39860 39848 MenhirLib.EngineTypes.state = _menhir_s; ··· 39879 39867 let _v : (Parsetree.pattern) = 39880 39868 # 2749 "parsing/parser.mly" 39881 39869 ( _1 ) 39882 39882 - # 39883 "parsing/parser.ml" 39870 39870 + # 39871 "parsing/parser.ml" 39883 39871 in 39884 39872 { 39885 39873 MenhirLib.EngineTypes.state = _menhir_s; ··· 39921 39909 39922 39910 # 2754 "parsing/parser.mly" 39923 39911 ( reloc_pat ~loc:_sloc _2 ) 39924 39924 - # 39925 "parsing/parser.ml" 39912 39912 + # 39913 "parsing/parser.ml" 39925 39913 in 39926 39914 { 39927 39915 MenhirLib.EngineTypes.state = _menhir_s; ··· 39946 39934 let _v : (Parsetree.pattern) = 39947 39935 # 2756 "parsing/parser.mly" 39948 39936 ( _1 ) 39949 39949 - # 39950 "parsing/parser.ml" 39937 39937 + # 39938 "parsing/parser.ml" 39950 39938 in 39951 39939 { 39952 39940 MenhirLib.EngineTypes.state = _menhir_s; ··· 40011 39999 40012 40000 # 883 "parsing/parser.mly" 40013 40001 ( mkrhs _1 _sloc ) 40014 40014 - # 40015 "parsing/parser.ml" 40002 40002 + # 40003 "parsing/parser.ml" 40015 40003 40016 40004 in 40017 40005 let _3 = ··· 40021 40009 40022 40010 # 3840 "parsing/parser.mly" 40023 40011 ( _1 ) 40024 40024 - # 40025 "parsing/parser.ml" 40012 40012 + # 40013 "parsing/parser.ml" 40025 40013 40026 40014 in 40027 40015 40028 40016 # 3853 "parsing/parser.mly" 40029 40017 ( _1, _2 ) 40030 40030 - # 40031 "parsing/parser.ml" 40018 40018 + # 40019 "parsing/parser.ml" 40031 40019 40032 40020 in 40033 40021 let _endpos = _endpos__5_ in ··· 40036 40024 40037 40025 # 2758 "parsing/parser.mly" 40038 40026 ( mkpat_attrs ~loc:_sloc (Ppat_unpack _4) _3 ) 40039 40039 - # 40040 "parsing/parser.ml" 40027 40027 + # 40028 "parsing/parser.ml" 40040 40028 in 40041 40029 { 40042 40030 MenhirLib.EngineTypes.state = _menhir_s; ··· 40117 40105 ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in 40118 40106 let descr = Ptyp_package (lid, cstrs) in 40119 40107 mktyp ~loc:_sloc ~attrs descr ) 40120 40120 - # 40121 "parsing/parser.ml" 40108 40108 + # 40109 "parsing/parser.ml" 40121 40109 40122 40110 in 40123 40111 let _4 = ··· 40128 40116 40129 40117 # 883 "parsing/parser.mly" 40130 40118 ( mkrhs _1 _sloc ) 40131 40131 - # 40132 "parsing/parser.ml" 40119 40119 + # 40120 "parsing/parser.ml" 40132 40120 40133 40121 in 40134 40122 let (_endpos__4_, _startpos__4_) = (_endpos__1_inlined3_, _startpos__1_inlined3_) in ··· 40139 40127 40140 40128 # 3840 "parsing/parser.mly" 40141 40129 ( _1 ) 40142 40142 - # 40143 "parsing/parser.ml" 40130 40130 + # 40131 "parsing/parser.ml" 40143 40131 40144 40132 in 40145 40133 40146 40134 # 3853 "parsing/parser.mly" 40147 40135 ( _1, _2 ) 40148 40148 - # 40149 "parsing/parser.ml" 40136 40136 + # 40137 "parsing/parser.ml" 40149 40137 40150 40138 in 40151 40139 let _endpos = _endpos__7_ in ··· 40157 40145 ( mkpat_attrs ~loc:_sloc 40158 40146 (Ppat_constraint(mkpat ~loc:_loc__4_ (Ppat_unpack _4), _6)) 40159 40147 _3 ) 40160 40160 - # 40161 "parsing/parser.ml" 40148 40148 + # 40149 "parsing/parser.ml" 40161 40149 in 40162 40150 { 40163 40151 MenhirLib.EngineTypes.state = _menhir_s; ··· 40183 40171 let _1 = 40184 40172 # 2768 "parsing/parser.mly" 40185 40173 ( Ppat_any ) 40186 40186 - # 40187 "parsing/parser.ml" 40174 40174 + # 40175 "parsing/parser.ml" 40187 40175 in 40188 40176 let _endpos = _endpos__1_ in 40189 40177 let _symbolstartpos = _startpos__1_ in ··· 40191 40179 40192 40180 # 918 "parsing/parser.mly" 40193 40181 ( mkpat ~loc:_sloc _1 ) 40194 40194 - # 40195 "parsing/parser.ml" 40182 40182 + # 40183 "parsing/parser.ml" 40195 40183 40196 40184 in 40197 40185 40198 40186 # 2764 "parsing/parser.mly" 40199 40187 ( _1 ) 40200 40200 - # 40201 "parsing/parser.ml" 40188 40188 + # 40189 "parsing/parser.ml" 40201 40189 in 40202 40190 { 40203 40191 MenhirLib.EngineTypes.state = _menhir_s; ··· 40223 40211 let _1 = 40224 40212 # 2770 "parsing/parser.mly" 40225 40213 ( Ppat_constant _1 ) 40226 40226 - # 40227 "parsing/parser.ml" 40214 40214 + # 40215 "parsing/parser.ml" 40227 40215 in 40228 40216 let _endpos = _endpos__1_ in 40229 40217 let _symbolstartpos = _startpos__1_ in ··· 40231 40219 40232 40220 # 918 "parsing/parser.mly" 40233 40221 ( mkpat ~loc:_sloc _1 ) 40234 40234 - # 40235 "parsing/parser.ml" 40222 40222 + # 40223 "parsing/parser.ml" 40235 40223 40236 40224 in 40237 40225 40238 40226 # 2764 "parsing/parser.mly" 40239 40227 ( _1 ) 40240 40240 - # 40241 "parsing/parser.ml" 40228 40228 + # 40229 "parsing/parser.ml" 40241 40229 in 40242 40230 { 40243 40231 MenhirLib.EngineTypes.state = _menhir_s; ··· 40277 40265 let _1 = 40278 40266 # 2772 "parsing/parser.mly" 40279 40267 ( Ppat_interval (_1, _3) ) 40280 40280 - # 40281 "parsing/parser.ml" 40268 40268 + # 40269 "parsing/parser.ml" 40281 40269 in 40282 40270 let _endpos__1_ = _endpos__3_ in 40283 40271 let _endpos = _endpos__1_ in ··· 40286 40274 40287 40275 # 918 "parsing/parser.mly" 40288 40276 ( mkpat ~loc:_sloc _1 ) 40289 40289 - # 40290 "parsing/parser.ml" 40277 40277 + # 40278 "parsing/parser.ml" 40290 40278 40291 40279 in 40292 40280 40293 40281 # 2764 "parsing/parser.mly" 40294 40282 ( _1 ) 40295 40295 - # 40296 "parsing/parser.ml" 40283 40283 + # 40284 "parsing/parser.ml" 40296 40284 in 40297 40285 { 40298 40286 MenhirLib.EngineTypes.state = _menhir_s; ··· 40323 40311 40324 40312 # 883 "parsing/parser.mly" 40325 40313 ( mkrhs _1 _sloc ) 40326 40326 - # 40327 "parsing/parser.ml" 40314 40314 + # 40315 "parsing/parser.ml" 40327 40315 40328 40316 in 40329 40317 40330 40318 # 2774 "parsing/parser.mly" 40331 40319 ( Ppat_construct(_1, None) ) 40332 40332 - # 40333 "parsing/parser.ml" 40320 40320 + # 40321 "parsing/parser.ml" 40333 40321 40334 40322 in 40335 40323 let _endpos = _endpos__1_ in ··· 40338 40326 40339 40327 # 918 "parsing/parser.mly" 40340 40328 ( mkpat ~loc:_sloc _1 ) 40341 40341 - # 40342 "parsing/parser.ml" 40329 40329 + # 40330 "parsing/parser.ml" 40342 40330 40343 40331 in 40344 40332 40345 40333 # 2764 "parsing/parser.mly" 40346 40334 ( _1 ) 40347 40347 - # 40348 "parsing/parser.ml" 40335 40335 + # 40336 "parsing/parser.ml" 40348 40336 in 40349 40337 { 40350 40338 MenhirLib.EngineTypes.state = _menhir_s; ··· 40370 40358 let _1 = 40371 40359 # 2776 "parsing/parser.mly" 40372 40360 ( Ppat_variant(_1, None) ) 40373 40373 - # 40374 "parsing/parser.ml" 40361 40361 + # 40362 "parsing/parser.ml" 40374 40362 in 40375 40363 let _endpos = _endpos__1_ in 40376 40364 let _symbolstartpos = _startpos__1_ in ··· 40378 40366 40379 40367 # 918 "parsing/parser.mly" 40380 40368 ( mkpat ~loc:_sloc _1 ) 40381 40381 - # 40382 "parsing/parser.ml" 40369 40369 + # 40370 "parsing/parser.ml" 40382 40370 40383 40371 in 40384 40372 40385 40373 # 2764 "parsing/parser.mly" 40386 40374 ( _1 ) 40387 40387 - # 40388 "parsing/parser.ml" 40375 40375 + # 40376 "parsing/parser.ml" 40388 40376 in 40389 40377 { 40390 40378 MenhirLib.EngineTypes.state = _menhir_s; ··· 40423 40411 40424 40412 # 883 "parsing/parser.mly" 40425 40413 ( mkrhs _1 _sloc ) 40426 40426 - # 40427 "parsing/parser.ml" 40414 40414 + # 40415 "parsing/parser.ml" 40427 40415 40428 40416 in 40429 40417 40430 40418 # 2778 "parsing/parser.mly" 40431 40419 ( Ppat_type (_2) ) 40432 40432 - # 40433 "parsing/parser.ml" 40420 40420 + # 40421 "parsing/parser.ml" 40433 40421 40434 40422 in 40435 40423 let _endpos__1_ = _endpos__1_inlined1_ in ··· 40439 40427 40440 40428 # 918 "parsing/parser.mly" 40441 40429 ( mkpat ~loc:_sloc _1 ) 40442 40442 - # 40443 "parsing/parser.ml" 40430 40430 + # 40431 "parsing/parser.ml" 40443 40431 40444 40432 in 40445 40433 40446 40434 # 2764 "parsing/parser.mly" 40447 40435 ( _1 ) 40448 40448 - # 40449 "parsing/parser.ml" 40436 40436 + # 40437 "parsing/parser.ml" 40449 40437 in 40450 40438 { 40451 40439 MenhirLib.EngineTypes.state = _menhir_s; ··· 40490 40478 40491 40479 # 883 "parsing/parser.mly" 40492 40480 ( mkrhs _1 _sloc ) 40493 40493 - # 40494 "parsing/parser.ml" 40481 40481 + # 40482 "parsing/parser.ml" 40494 40482 40495 40483 in 40496 40484 40497 40485 # 2780 "parsing/parser.mly" 40498 40486 ( Ppat_open(_1, _3) ) 40499 40499 - # 40500 "parsing/parser.ml" 40487 40487 + # 40488 "parsing/parser.ml" 40500 40488 40501 40489 in 40502 40490 let _endpos__1_ = _endpos__3_ in ··· 40506 40494 40507 40495 # 918 "parsing/parser.mly" 40508 40496 ( mkpat ~loc:_sloc _1 ) 40509 40509 - # 40510 "parsing/parser.ml" 40497 40497 + # 40498 "parsing/parser.ml" 40510 40498 40511 40499 in 40512 40500 40513 40501 # 2764 "parsing/parser.mly" 40514 40502 ( _1 ) 40515 40515 - # 40516 "parsing/parser.ml" 40503 40503 + # 40504 "parsing/parser.ml" 40516 40504 in 40517 40505 { 40518 40506 MenhirLib.EngineTypes.state = _menhir_s; ··· 40562 40550 let _1 = 40563 40551 # 2781 "parsing/parser.mly" 40564 40552 (Lident "[]") 40565 40565 - # 40566 "parsing/parser.ml" 40553 40553 + # 40554 "parsing/parser.ml" 40566 40554 in 40567 40555 let _endpos__1_ = _endpos__2_ in 40568 40556 let _endpos = _endpos__1_ in ··· 40571 40559 40572 40560 # 883 "parsing/parser.mly" 40573 40561 ( mkrhs _1 _sloc ) 40574 40574 - # 40575 "parsing/parser.ml" 40562 40562 + # 40563 "parsing/parser.ml" 40575 40563 40576 40564 in 40577 40565 let _endpos__3_ = _endpos__2_inlined1_ in ··· 40582 40570 40583 40571 # 883 "parsing/parser.mly" 40584 40572 ( mkrhs _1 _sloc ) 40585 40585 - # 40586 "parsing/parser.ml" 40573 40573 + # 40574 "parsing/parser.ml" 40586 40574 40587 40575 in 40588 40576 let _endpos = _endpos__3_ in ··· 40591 40579 40592 40580 # 2782 "parsing/parser.mly" 40593 40581 ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) ) 40594 40594 - # 40595 "parsing/parser.ml" 40582 40582 + # 40583 "parsing/parser.ml" 40595 40583 40596 40584 in 40597 40585 let _endpos__1_ = _endpos__2_inlined1_ in ··· 40601 40589 40602 40590 # 918 "parsing/parser.mly" 40603 40591 ( mkpat ~loc:_sloc _1 ) 40604 40604 - # 40605 "parsing/parser.ml" 40592 40592 + # 40593 "parsing/parser.ml" 40605 40593 40606 40594 in 40607 40595 40608 40596 # 2764 "parsing/parser.mly" 40609 40597 ( _1 ) 40610 40610 - # 40611 "parsing/parser.ml" 40598 40598 + # 40599 "parsing/parser.ml" 40611 40599 in 40612 40600 { 40613 40601 MenhirLib.EngineTypes.state = _menhir_s; ··· 40657 40645 let _1 = 40658 40646 # 2783 "parsing/parser.mly" 40659 40647 (Lident "()") 40660 40660 - # 40661 "parsing/parser.ml" 40648 40648 + # 40649 "parsing/parser.ml" 40661 40649 in 40662 40650 let _endpos__1_ = _endpos__2_ in 40663 40651 let _endpos = _endpos__1_ in ··· 40666 40654 40667 40655 # 883 "parsing/parser.mly" 40668 40656 ( mkrhs _1 _sloc ) 40669 40669 - # 40670 "parsing/parser.ml" 40657 40657 + # 40658 "parsing/parser.ml" 40670 40658 40671 40659 in 40672 40660 let _endpos__3_ = _endpos__2_inlined1_ in ··· 40677 40665 40678 40666 # 883 "parsing/parser.mly" 40679 40667 ( mkrhs _1 _sloc ) 40680 40680 - # 40681 "parsing/parser.ml" 40668 40668 + # 40669 "parsing/parser.ml" 40681 40669 40682 40670 in 40683 40671 let _endpos = _endpos__3_ in ··· 40686 40674 40687 40675 # 2784 "parsing/parser.mly" 40688 40676 ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) ) 40689 40689 - # 40690 "parsing/parser.ml" 40677 40677 + # 40678 "parsing/parser.ml" 40690 40678 40691 40679 in 40692 40680 let _endpos__1_ = _endpos__2_inlined1_ in ··· 40696 40684 40697 40685 # 918 "parsing/parser.mly" 40698 40686 ( mkpat ~loc:_sloc _1 ) 40699 40699 - # 40700 "parsing/parser.ml" 40687 40687 + # 40688 "parsing/parser.ml" 40700 40688 40701 40689 in 40702 40690 40703 40691 # 2764 "parsing/parser.mly" 40704 40692 ( _1 ) 40705 40705 - # 40706 "parsing/parser.ml" 40693 40693 + # 40694 "parsing/parser.ml" 40706 40694 in 40707 40695 { 40708 40696 MenhirLib.EngineTypes.state = _menhir_s; ··· 40761 40749 40762 40750 # 883 "parsing/parser.mly" 40763 40751 ( mkrhs _1 _sloc ) 40764 40764 - # 40765 "parsing/parser.ml" 40752 40752 + # 40753 "parsing/parser.ml" 40765 40753 40766 40754 in 40767 40755 40768 40756 # 2786 "parsing/parser.mly" 40769 40757 ( Ppat_open (_1, _4) ) 40770 40770 - # 40771 "parsing/parser.ml" 40758 40758 + # 40759 "parsing/parser.ml" 40771 40759 40772 40760 in 40773 40761 let _endpos__1_ = _endpos__5_ in ··· 40777 40765 40778 40766 # 918 "parsing/parser.mly" 40779 40767 ( mkpat ~loc:_sloc _1 ) 40780 40780 - # 40781 "parsing/parser.ml" 40768 40768 + # 40769 "parsing/parser.ml" 40781 40769 40782 40770 in 40783 40771 40784 40772 # 2764 "parsing/parser.mly" 40785 40773 ( _1 ) 40786 40786 - # 40787 "parsing/parser.ml" 40774 40774 + # 40775 "parsing/parser.ml" 40787 40775 in 40788 40776 { 40789 40777 MenhirLib.EngineTypes.state = _menhir_s; ··· 40840 40828 40841 40829 # 2788 "parsing/parser.mly" 40842 40830 ( unclosed "(" _loc__3_ ")" _loc__5_ ) 40843 40843 - # 40844 "parsing/parser.ml" 40831 40831 + # 40832 "parsing/parser.ml" 40844 40832 40845 40833 in 40846 40834 let _endpos__1_ = _endpos__5_ in ··· 40850 40838 40851 40839 # 918 "parsing/parser.mly" 40852 40840 ( mkpat ~loc:_sloc _1 ) 40853 40853 - # 40854 "parsing/parser.ml" 40841 40841 + # 40842 "parsing/parser.ml" 40854 40842 40855 40843 in 40856 40844 40857 40845 # 2764 "parsing/parser.mly" 40858 40846 ( _1 ) 40859 40859 - # 40860 "parsing/parser.ml" 40847 40847 + # 40848 "parsing/parser.ml" 40860 40848 in 40861 40849 { 40862 40850 MenhirLib.EngineTypes.state = _menhir_s; ··· 40905 40893 40906 40894 # 2790 "parsing/parser.mly" 40907 40895 ( expecting _loc__4_ "pattern" ) 40908 40908 - # 40909 "parsing/parser.ml" 40896 40896 + # 40897 "parsing/parser.ml" 40909 40897 40910 40898 in 40911 40899 let _endpos__1_ = _endpos__4_ in ··· 40915 40903 40916 40904 # 918 "parsing/parser.mly" 40917 40905 ( mkpat ~loc:_sloc _1 ) 40918 40918 - # 40919 "parsing/parser.ml" 40906 40906 + # 40907 "parsing/parser.ml" 40919 40907 40920 40908 in 40921 40909 40922 40910 # 2764 "parsing/parser.mly" 40923 40911 ( _1 ) 40924 40924 - # 40925 "parsing/parser.ml" 40912 40912 + # 40913 "parsing/parser.ml" 40925 40913 in 40926 40914 { 40927 40915 MenhirLib.EngineTypes.state = _menhir_s; ··· 40964 40952 40965 40953 # 2792 "parsing/parser.mly" 40966 40954 ( unclosed "(" _loc__1_ ")" _loc__3_ ) 40967 40967 - # 40968 "parsing/parser.ml" 40955 40955 + # 40956 "parsing/parser.ml" 40968 40956 40969 40957 in 40970 40958 let _endpos__1_ = _endpos__3_ in ··· 40974 40962 40975 40963 # 918 "parsing/parser.mly" 40976 40964 ( mkpat ~loc:_sloc _1 ) 40977 40977 - # 40978 "parsing/parser.ml" 40965 40965 + # 40966 "parsing/parser.ml" 40978 40966 40979 40967 in 40980 40968 40981 40969 # 2764 "parsing/parser.mly" 40982 40970 ( _1 ) 40983 40983 - # 40984 "parsing/parser.ml" 40971 40971 + # 40972 "parsing/parser.ml" 40984 40972 in 40985 40973 { 40986 40974 MenhirLib.EngineTypes.state = _menhir_s; ··· 41034 41022 let _1 = 41035 41023 # 2794 "parsing/parser.mly" 41036 41024 ( Ppat_constraint(_2, _4) ) 41037 41037 - # 41038 "parsing/parser.ml" 41025 41025 + # 41026 "parsing/parser.ml" 41038 41026 in 41039 41027 let _endpos__1_ = _endpos__5_ in 41040 41028 let _endpos = _endpos__1_ in ··· 41043 41031 41044 41032 # 918 "parsing/parser.mly" 41045 41033 ( mkpat ~loc:_sloc _1 ) 41046 41046 - # 41047 "parsing/parser.ml" 41034 41034 + # 41035 "parsing/parser.ml" 41047 41035 41048 41036 in 41049 41037 41050 41038 # 2764 "parsing/parser.mly" 41051 41039 ( _1 ) 41052 41052 - # 41053 "parsing/parser.ml" 41040 41040 + # 41041 "parsing/parser.ml" 41053 41041 in 41054 41042 { 41055 41043 MenhirLib.EngineTypes.state = _menhir_s; ··· 41106 41094 41107 41095 # 2796 "parsing/parser.mly" 41108 41096 ( unclosed "(" _loc__1_ ")" _loc__5_ ) 41109 41109 - # 41110 "parsing/parser.ml" 41097 41097 + # 41098 "parsing/parser.ml" 41110 41098 41111 41099 in 41112 41100 let _endpos__1_ = _endpos__5_ in ··· 41116 41104 41117 41105 # 918 "parsing/parser.mly" 41118 41106 ( mkpat ~loc:_sloc _1 ) 41119 41119 - # 41120 "parsing/parser.ml" 41107 41107 + # 41108 "parsing/parser.ml" 41120 41108 41121 41109 in 41122 41110 41123 41111 # 2764 "parsing/parser.mly" 41124 41112 ( _1 ) 41125 41125 - # 41126 "parsing/parser.ml" 41113 41113 + # 41114 "parsing/parser.ml" 41126 41114 in 41127 41115 { 41128 41116 MenhirLib.EngineTypes.state = _menhir_s; ··· 41171 41159 41172 41160 # 2798 "parsing/parser.mly" 41173 41161 ( expecting _loc__4_ "type" ) 41174 41174 - # 41175 "parsing/parser.ml" 41162 41162 + # 41163 "parsing/parser.ml" 41175 41163 41176 41164 in 41177 41165 let _endpos__1_ = _endpos__4_ in ··· 41181 41169 41182 41170 # 918 "parsing/parser.mly" 41183 41171 ( mkpat ~loc:_sloc _1 ) 41184 41184 - # 41185 "parsing/parser.ml" 41172 41172 + # 41173 "parsing/parser.ml" 41185 41173 41186 41174 in 41187 41175 41188 41176 # 2764 "parsing/parser.mly" 41189 41177 ( _1 ) 41190 41190 - # 41191 "parsing/parser.ml" 41178 41178 + # 41179 "parsing/parser.ml" 41191 41179 in 41192 41180 { 41193 41181 MenhirLib.EngineTypes.state = _menhir_s; ··· 41270 41258 ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in 41271 41259 let descr = Ptyp_package (lid, cstrs) in 41272 41260 mktyp ~loc:_sloc ~attrs descr ) 41273 41273 - # 41274 "parsing/parser.ml" 41261 41261 + # 41262 "parsing/parser.ml" 41274 41262 41275 41263 in 41276 41264 let _3 = ··· 41280 41268 41281 41269 # 3840 "parsing/parser.mly" 41282 41270 ( _1 ) 41283 41283 - # 41284 "parsing/parser.ml" 41271 41271 + # 41272 "parsing/parser.ml" 41284 41272 41285 41273 in 41286 41274 41287 41275 # 3853 "parsing/parser.mly" 41288 41276 ( _1, _2 ) 41289 41289 - # 41290 "parsing/parser.ml" 41277 41277 + # 41278 "parsing/parser.ml" 41290 41278 41291 41279 in 41292 41280 let _loc__7_ = (_startpos__7_, _endpos__7_) in ··· 41294 41282 41295 41283 # 2801 "parsing/parser.mly" 41296 41284 ( unclosed "(" _loc__1_ ")" _loc__7_ ) 41297 41297 - # 41298 "parsing/parser.ml" 41285 41285 + # 41286 "parsing/parser.ml" 41298 41286 41299 41287 in 41300 41288 let _endpos__1_ = _endpos__7_ in ··· 41304 41292 41305 41293 # 918 "parsing/parser.mly" 41306 41294 ( mkpat ~loc:_sloc _1 ) 41307 41307 - # 41308 "parsing/parser.ml" 41295 41295 + # 41296 "parsing/parser.ml" 41308 41296 41309 41297 in 41310 41298 41311 41299 # 2764 "parsing/parser.mly" 41312 41300 ( _1 ) 41313 41313 - # 41314 "parsing/parser.ml" 41301 41301 + # 41302 "parsing/parser.ml" 41314 41302 in 41315 41303 { 41316 41304 MenhirLib.EngineTypes.state = _menhir_s; ··· 41336 41324 let _1 = 41337 41325 # 2803 "parsing/parser.mly" 41338 41326 ( Ppat_extension _1 ) 41339 41339 - # 41340 "parsing/parser.ml" 41327 41327 + # 41328 "parsing/parser.ml" 41340 41328 in 41341 41329 let _endpos = _endpos__1_ in 41342 41330 let _symbolstartpos = _startpos__1_ in ··· 41344 41332 41345 41333 # 918 "parsing/parser.mly" 41346 41334 ( mkpat ~loc:_sloc _1 ) 41347 41347 - # 41348 "parsing/parser.ml" 41335 41335 + # 41336 "parsing/parser.ml" 41348 41336 41349 41337 in 41350 41338 41351 41339 # 2764 "parsing/parser.mly" 41352 41340 ( _1 ) 41353 41353 - # 41354 "parsing/parser.ml" 41341 41341 + # 41342 "parsing/parser.ml" 41354 41342 in 41355 41343 { 41356 41344 MenhirLib.EngineTypes.state = _menhir_s; ··· 41371 41359 let _1 : ( 41372 41360 # 705 "parsing/parser.mly" 41373 41361 (string) 41374 41374 - # 41375 "parsing/parser.ml" 41362 41362 + # 41363 "parsing/parser.ml" 41375 41363 ) = Obj.magic _1 in 41376 41364 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 41377 41365 let _startpos = _startpos__1_ in ··· 41379 41367 let _v : (string) = 41380 41368 # 3761 "parsing/parser.mly" 41381 41369 ( _1 ) 41382 41382 - # 41383 "parsing/parser.ml" 41370 41370 + # 41371 "parsing/parser.ml" 41383 41371 in 41384 41372 { 41385 41373 MenhirLib.EngineTypes.state = _menhir_s; ··· 41400 41388 let _1 : ( 41401 41389 # 756 "parsing/parser.mly" 41402 41390 (string) 41403 41403 - # 41404 "parsing/parser.ml" 41391 41391 + # 41392 "parsing/parser.ml" 41404 41392 ) = Obj.magic _1 in 41405 41393 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 41406 41394 let _startpos = _startpos__1_ in ··· 41408 41396 let _v : (string) = 41409 41397 # 3762 "parsing/parser.mly" 41410 41398 ( _1 ) 41411 41411 - # 41412 "parsing/parser.ml" 41399 41399 + # 41400 "parsing/parser.ml" 41412 41400 in 41413 41401 { 41414 41402 MenhirLib.EngineTypes.state = _menhir_s; ··· 41433 41421 let _v : (string) = 41434 41422 # 3763 "parsing/parser.mly" 41435 41423 ( "and" ) 41436 41436 - # 41437 "parsing/parser.ml" 41424 41424 + # 41425 "parsing/parser.ml" 41437 41425 in 41438 41426 { 41439 41427 MenhirLib.EngineTypes.state = _menhir_s; ··· 41458 41446 let _v : (string) = 41459 41447 # 3764 "parsing/parser.mly" 41460 41448 ( "as" ) 41461 41461 - # 41462 "parsing/parser.ml" 41449 41449 + # 41450 "parsing/parser.ml" 41462 41450 in 41463 41451 { 41464 41452 MenhirLib.EngineTypes.state = _menhir_s; ··· 41483 41471 let _v : (string) = 41484 41472 # 3765 "parsing/parser.mly" 41485 41473 ( "assert" ) 41486 41486 - # 41487 "parsing/parser.ml" 41474 41474 + # 41475 "parsing/parser.ml" 41487 41475 in 41488 41476 { 41489 41477 MenhirLib.EngineTypes.state = _menhir_s; ··· 41508 41496 let _v : (string) = 41509 41497 # 3766 "parsing/parser.mly" 41510 41498 ( "begin" ) 41511 41511 - # 41512 "parsing/parser.ml" 41499 41499 + # 41500 "parsing/parser.ml" 41512 41500 in 41513 41501 { 41514 41502 MenhirLib.EngineTypes.state = _menhir_s; ··· 41533 41521 let _v : (string) = 41534 41522 # 3767 "parsing/parser.mly" 41535 41523 ( "class" ) 41536 41536 - # 41537 "parsing/parser.ml" 41524 41524 + # 41525 "parsing/parser.ml" 41537 41525 in 41538 41526 { 41539 41527 MenhirLib.EngineTypes.state = _menhir_s; ··· 41558 41546 let _v : (string) = 41559 41547 # 3768 "parsing/parser.mly" 41560 41548 ( "constraint" ) 41561 41561 - # 41562 "parsing/parser.ml" 41549 41549 + # 41550 "parsing/parser.ml" 41562 41550 in 41563 41551 { 41564 41552 MenhirLib.EngineTypes.state = _menhir_s; ··· 41583 41571 let _v : (string) = 41584 41572 # 3769 "parsing/parser.mly" 41585 41573 ( "do" ) 41586 41586 - # 41587 "parsing/parser.ml" 41574 41574 + # 41575 "parsing/parser.ml" 41587 41575 in 41588 41576 { 41589 41577 MenhirLib.EngineTypes.state = _menhir_s; ··· 41608 41596 let _v : (string) = 41609 41597 # 3770 "parsing/parser.mly" 41610 41598 ( "done" ) 41611 41611 - # 41612 "parsing/parser.ml" 41599 41599 + # 41600 "parsing/parser.ml" 41612 41600 in 41613 41601 { 41614 41602 MenhirLib.EngineTypes.state = _menhir_s; ··· 41633 41621 let _v : (string) = 41634 41622 # 3771 "parsing/parser.mly" 41635 41623 ( "downto" ) 41636 41636 - # 41637 "parsing/parser.ml" 41624 41624 + # 41625 "parsing/parser.ml" 41637 41625 in 41638 41626 { 41639 41627 MenhirLib.EngineTypes.state = _menhir_s; ··· 41658 41646 let _v : (string) = 41659 41647 # 3772 "parsing/parser.mly" 41660 41648 ( "else" ) 41661 41661 - # 41662 "parsing/parser.ml" 41649 41649 + # 41650 "parsing/parser.ml" 41662 41650 in 41663 41651 { 41664 41652 MenhirLib.EngineTypes.state = _menhir_s; ··· 41683 41671 let _v : (string) = 41684 41672 # 3773 "parsing/parser.mly" 41685 41673 ( "end" ) 41686 41686 - # 41687 "parsing/parser.ml" 41674 41674 + # 41675 "parsing/parser.ml" 41687 41675 in 41688 41676 { 41689 41677 MenhirLib.EngineTypes.state = _menhir_s; ··· 41708 41696 let _v : (string) = 41709 41697 # 3774 "parsing/parser.mly" 41710 41698 ( "exception" ) 41711 41711 - # 41712 "parsing/parser.ml" 41699 41699 + # 41700 "parsing/parser.ml" 41712 41700 in 41713 41701 { 41714 41702 MenhirLib.EngineTypes.state = _menhir_s; ··· 41733 41721 let _v : (string) = 41734 41722 # 3775 "parsing/parser.mly" 41735 41723 ( "external" ) 41736 41736 - # 41737 "parsing/parser.ml" 41724 41724 + # 41725 "parsing/parser.ml" 41737 41725 in 41738 41726 { 41739 41727 MenhirLib.EngineTypes.state = _menhir_s; ··· 41758 41746 let _v : (string) = 41759 41747 # 3776 "parsing/parser.mly" 41760 41748 ( "false" ) 41761 41761 - # 41762 "parsing/parser.ml" 41749 41749 + # 41750 "parsing/parser.ml" 41762 41750 in 41763 41751 { 41764 41752 MenhirLib.EngineTypes.state = _menhir_s; ··· 41783 41771 let _v : (string) = 41784 41772 # 3777 "parsing/parser.mly" 41785 41773 ( "for" ) 41786 41786 - # 41787 "parsing/parser.ml" 41774 41774 + # 41775 "parsing/parser.ml" 41787 41775 in 41788 41776 { 41789 41777 MenhirLib.EngineTypes.state = _menhir_s; ··· 41808 41796 let _v : (string) = 41809 41797 # 3778 "parsing/parser.mly" 41810 41798 ( "fun" ) 41811 41811 - # 41812 "parsing/parser.ml" 41799 41799 + # 41800 "parsing/parser.ml" 41812 41800 in 41813 41801 { 41814 41802 MenhirLib.EngineTypes.state = _menhir_s; ··· 41833 41821 let _v : (string) = 41834 41822 # 3779 "parsing/parser.mly" 41835 41823 ( "function" ) 41836 41836 - # 41837 "parsing/parser.ml" 41824 41824 + # 41825 "parsing/parser.ml" 41837 41825 in 41838 41826 { 41839 41827 MenhirLib.EngineTypes.state = _menhir_s; ··· 41858 41846 let _v : (string) = 41859 41847 # 3780 "parsing/parser.mly" 41860 41848 ( "functor" ) 41861 41861 - # 41862 "parsing/parser.ml" 41849 41849 + # 41850 "parsing/parser.ml" 41862 41850 in 41863 41851 { 41864 41852 MenhirLib.EngineTypes.state = _menhir_s; ··· 41883 41871 let _v : (string) = 41884 41872 # 3781 "parsing/parser.mly" 41885 41873 ( "if" ) 41886 41886 - # 41887 "parsing/parser.ml" 41874 41874 + # 41875 "parsing/parser.ml" 41887 41875 in 41888 41876 { 41889 41877 MenhirLib.EngineTypes.state = _menhir_s; ··· 41908 41896 let _v : (string) = 41909 41897 # 3782 "parsing/parser.mly" 41910 41898 ( "in" ) 41911 41911 - # 41912 "parsing/parser.ml" 41899 41899 + # 41900 "parsing/parser.ml" 41912 41900 in 41913 41901 { 41914 41902 MenhirLib.EngineTypes.state = _menhir_s; ··· 41933 41921 let _v : (string) = 41934 41922 # 3783 "parsing/parser.mly" 41935 41923 ( "include" ) 41936 41936 - # 41937 "parsing/parser.ml" 41924 41924 + # 41925 "parsing/parser.ml" 41937 41925 in 41938 41926 { 41939 41927 MenhirLib.EngineTypes.state = _menhir_s; ··· 41958 41946 let _v : (string) = 41959 41947 # 3784 "parsing/parser.mly" 41960 41948 ( "inherit" ) 41961 41961 - # 41962 "parsing/parser.ml" 41949 41949 + # 41950 "parsing/parser.ml" 41962 41950 in 41963 41951 { 41964 41952 MenhirLib.EngineTypes.state = _menhir_s; ··· 41983 41971 let _v : (string) = 41984 41972 # 3785 "parsing/parser.mly" 41985 41973 ( "initializer" ) 41986 41986 - # 41987 "parsing/parser.ml" 41974 41974 + # 41975 "parsing/parser.ml" 41987 41975 in 41988 41976 { 41989 41977 MenhirLib.EngineTypes.state = _menhir_s; ··· 42008 41996 let _v : (string) = 42009 41997 # 3786 "parsing/parser.mly" 42010 41998 ( "lazy" ) 42011 42011 - # 42012 "parsing/parser.ml" 41999 41999 + # 42000 "parsing/parser.ml" 42012 42000 in 42013 42001 { 42014 42002 MenhirLib.EngineTypes.state = _menhir_s; ··· 42033 42021 let _v : (string) = 42034 42022 # 3787 "parsing/parser.mly" 42035 42023 ( "let" ) 42036 42036 - # 42037 "parsing/parser.ml" 42024 42024 + # 42025 "parsing/parser.ml" 42037 42025 in 42038 42026 { 42039 42027 MenhirLib.EngineTypes.state = _menhir_s; ··· 42058 42046 let _v : (string) = 42059 42047 # 3788 "parsing/parser.mly" 42060 42048 ( "match" ) 42061 42061 - # 42062 "parsing/parser.ml" 42049 42049 + # 42050 "parsing/parser.ml" 42062 42050 in 42063 42051 { 42064 42052 MenhirLib.EngineTypes.state = _menhir_s; ··· 42083 42071 let _v : (string) = 42084 42072 # 3789 "parsing/parser.mly" 42085 42073 ( "method" ) 42086 42086 - # 42087 "parsing/parser.ml" 42074 42074 + # 42075 "parsing/parser.ml" 42087 42075 in 42088 42076 { 42089 42077 MenhirLib.EngineTypes.state = _menhir_s; ··· 42108 42096 let _v : (string) = 42109 42097 # 3790 "parsing/parser.mly" 42110 42098 ( "module" ) 42111 42111 - # 42112 "parsing/parser.ml" 42099 42099 + # 42100 "parsing/parser.ml" 42112 42100 in 42113 42101 { 42114 42102 MenhirLib.EngineTypes.state = _menhir_s; ··· 42133 42121 let _v : (string) = 42134 42122 # 3791 "parsing/parser.mly" 42135 42123 ( "mutable" ) 42136 42136 - # 42137 "parsing/parser.ml" 42124 42124 + # 42125 "parsing/parser.ml" 42137 42125 in 42138 42126 { 42139 42127 MenhirLib.EngineTypes.state = _menhir_s; ··· 42158 42146 let _v : (string) = 42159 42147 # 3792 "parsing/parser.mly" 42160 42148 ( "new" ) 42161 42161 - # 42162 "parsing/parser.ml" 42149 42149 + # 42150 "parsing/parser.ml" 42162 42150 in 42163 42151 { 42164 42152 MenhirLib.EngineTypes.state = _menhir_s; ··· 42183 42171 let _v : (string) = 42184 42172 # 3793 "parsing/parser.mly" 42185 42173 ( "nonrec" ) 42186 42186 - # 42187 "parsing/parser.ml" 42174 42174 + # 42175 "parsing/parser.ml" 42187 42175 in 42188 42176 { 42189 42177 MenhirLib.EngineTypes.state = _menhir_s; ··· 42208 42196 let _v : (string) = 42209 42197 # 3794 "parsing/parser.mly" 42210 42198 ( "object" ) 42211 42211 - # 42212 "parsing/parser.ml" 42199 42199 + # 42200 "parsing/parser.ml" 42212 42200 in 42213 42201 { 42214 42202 MenhirLib.EngineTypes.state = _menhir_s; ··· 42233 42221 let _v : (string) = 42234 42222 # 3795 "parsing/parser.mly" 42235 42223 ( "of" ) 42236 42236 - # 42237 "parsing/parser.ml" 42224 42224 + # 42225 "parsing/parser.ml" 42237 42225 in 42238 42226 { 42239 42227 MenhirLib.EngineTypes.state = _menhir_s; ··· 42258 42246 let _v : (string) = 42259 42247 # 3796 "parsing/parser.mly" 42260 42248 ( "open" ) 42261 42261 - # 42262 "parsing/parser.ml" 42249 42249 + # 42250 "parsing/parser.ml" 42262 42250 in 42263 42251 { 42264 42252 MenhirLib.EngineTypes.state = _menhir_s; ··· 42283 42271 let _v : (string) = 42284 42272 # 3797 "parsing/parser.mly" 42285 42273 ( "or" ) 42286 42286 - # 42287 "parsing/parser.ml" 42274 42274 + # 42275 "parsing/parser.ml" 42287 42275 in 42288 42276 { 42289 42277 MenhirLib.EngineTypes.state = _menhir_s; ··· 42308 42296 let _v : (string) = 42309 42297 # 3798 "parsing/parser.mly" 42310 42298 ( "private" ) 42311 42311 - # 42312 "parsing/parser.ml" 42299 42299 + # 42300 "parsing/parser.ml" 42312 42300 in 42313 42301 { 42314 42302 MenhirLib.EngineTypes.state = _menhir_s; ··· 42333 42321 let _v : (string) = 42334 42322 # 3799 "parsing/parser.mly" 42335 42323 ( "rec" ) 42336 42336 - # 42337 "parsing/parser.ml" 42324 42324 + # 42325 "parsing/parser.ml" 42337 42325 in 42338 42326 { 42339 42327 MenhirLib.EngineTypes.state = _menhir_s; ··· 42358 42346 let _v : (string) = 42359 42347 # 3800 "parsing/parser.mly" 42360 42348 ( "sig" ) 42361 42361 - # 42362 "parsing/parser.ml" 42349 42349 + # 42350 "parsing/parser.ml" 42362 42350 in 42363 42351 { 42364 42352 MenhirLib.EngineTypes.state = _menhir_s; ··· 42383 42371 let _v : (string) = 42384 42372 # 3801 "parsing/parser.mly" 42385 42373 ( "struct" ) 42386 42386 - # 42387 "parsing/parser.ml" 42374 42374 + # 42375 "parsing/parser.ml" 42387 42375 in 42388 42376 { 42389 42377 MenhirLib.EngineTypes.state = _menhir_s; ··· 42408 42396 let _v : (string) = 42409 42397 # 3802 "parsing/parser.mly" 42410 42398 ( "then" ) 42411 42411 - # 42412 "parsing/parser.ml" 42399 42399 + # 42400 "parsing/parser.ml" 42412 42400 in 42413 42401 { 42414 42402 MenhirLib.EngineTypes.state = _menhir_s; ··· 42433 42421 let _v : (string) = 42434 42422 # 3803 "parsing/parser.mly" 42435 42423 ( "to" ) 42436 42436 - # 42437 "parsing/parser.ml" 42424 42424 + # 42425 "parsing/parser.ml" 42437 42425 in 42438 42426 { 42439 42427 MenhirLib.EngineTypes.state = _menhir_s; ··· 42458 42446 let _v : (string) = 42459 42447 # 3804 "parsing/parser.mly" 42460 42448 ( "true" ) 42461 42461 - # 42462 "parsing/parser.ml" 42449 42449 + # 42450 "parsing/parser.ml" 42462 42450 in 42463 42451 { 42464 42452 MenhirLib.EngineTypes.state = _menhir_s; ··· 42483 42471 let _v : (string) = 42484 42472 # 3805 "parsing/parser.mly" 42485 42473 ( "try" ) 42486 42486 - # 42487 "parsing/parser.ml" 42474 42474 + # 42475 "parsing/parser.ml" 42487 42475 in 42488 42476 { 42489 42477 MenhirLib.EngineTypes.state = _menhir_s; ··· 42508 42496 let _v : (string) = 42509 42497 # 3806 "parsing/parser.mly" 42510 42498 ( "type" ) 42511 42511 - # 42512 "parsing/parser.ml" 42499 42499 + # 42500 "parsing/parser.ml" 42512 42500 in 42513 42501 { 42514 42502 MenhirLib.EngineTypes.state = _menhir_s; ··· 42533 42521 let _v : (string) = 42534 42522 # 3807 "parsing/parser.mly" 42535 42523 ( "val" ) 42536 42536 - # 42537 "parsing/parser.ml" 42524 42524 + # 42525 "parsing/parser.ml" 42537 42525 in 42538 42526 { 42539 42527 MenhirLib.EngineTypes.state = _menhir_s; ··· 42558 42546 let _v : (string) = 42559 42547 # 3808 "parsing/parser.mly" 42560 42548 ( "virtual" ) 42561 42561 - # 42562 "parsing/parser.ml" 42549 42549 + # 42550 "parsing/parser.ml" 42562 42550 in 42563 42551 { 42564 42552 MenhirLib.EngineTypes.state = _menhir_s; ··· 42583 42571 let _v : (string) = 42584 42572 # 3809 "parsing/parser.mly" 42585 42573 ( "when" ) 42586 42586 - # 42587 "parsing/parser.ml" 42574 42574 + # 42575 "parsing/parser.ml" 42587 42575 in 42588 42576 { 42589 42577 MenhirLib.EngineTypes.state = _menhir_s; ··· 42608 42596 let _v : (string) = 42609 42597 # 3810 "parsing/parser.mly" 42610 42598 ( "while" ) 42611 42611 - # 42612 "parsing/parser.ml" 42599 42599 + # 42600 "parsing/parser.ml" 42612 42600 in 42613 42601 { 42614 42602 MenhirLib.EngineTypes.state = _menhir_s; ··· 42633 42621 let _v : (string) = 42634 42622 # 3811 "parsing/parser.mly" 42635 42623 ( "with" ) 42636 42636 - # 42637 "parsing/parser.ml" 42624 42624 + # 42625 "parsing/parser.ml" 42637 42625 in 42638 42626 { 42639 42627 MenhirLib.EngineTypes.state = _menhir_s; ··· 42658 42646 let _v : (Parsetree.type_exception * string Asttypes.loc option) = 42659 42647 # 3082 "parsing/parser.mly" 42660 42648 ( _1 ) 42661 42661 - # 42662 "parsing/parser.ml" 42649 42649 + # 42650 "parsing/parser.ml" 42662 42650 in 42663 42651 { 42664 42652 MenhirLib.EngineTypes.state = _menhir_s; ··· 42734 42722 42735 42723 # 3836 "parsing/parser.mly" 42736 42724 ( _1 ) 42737 42737 - # 42738 "parsing/parser.ml" 42725 42725 + # 42726 "parsing/parser.ml" 42738 42726 42739 42727 in 42740 42728 let _endpos_attrs_ = _endpos__1_inlined5_ in ··· 42743 42731 42744 42732 # 3840 "parsing/parser.mly" 42745 42733 ( _1 ) 42746 42746 - # 42747 "parsing/parser.ml" 42734 42734 + # 42735 "parsing/parser.ml" 42747 42735 42748 42736 in 42749 42737 let lid = ··· 42754 42742 42755 42743 # 883 "parsing/parser.mly" 42756 42744 ( mkrhs _1 _sloc ) 42757 42757 - # 42758 "parsing/parser.ml" 42745 42745 + # 42746 "parsing/parser.ml" 42758 42746 42759 42747 in 42760 42748 let id = ··· 42765 42753 42766 42754 # 883 "parsing/parser.mly" 42767 42755 ( mkrhs _1 _sloc ) 42768 42768 - # 42769 "parsing/parser.ml" 42756 42756 + # 42757 "parsing/parser.ml" 42769 42757 42770 42758 in 42771 42759 let attrs1 = ··· 42773 42761 42774 42762 # 3840 "parsing/parser.mly" 42775 42763 ( _1 ) 42776 42776 - # 42777 "parsing/parser.ml" 42764 42764 + # 42765 "parsing/parser.ml" 42777 42765 42778 42766 in 42779 42767 let _endpos = _endpos_attrs_ in ··· 42786 42774 Te.mk_exception ~attrs 42787 42775 (Te.rebind id lid ~attrs:(attrs1 @ attrs2) ~loc ~docs) 42788 42776 , ext ) 42789 42789 - # 42790 "parsing/parser.ml" 42777 42777 + # 42778 "parsing/parser.ml" 42790 42778 in 42791 42779 { 42792 42780 MenhirLib.EngineTypes.state = _menhir_s; ··· 42818 42806 let _v : (Parsetree.expression) = 42819 42807 # 2589 "parsing/parser.mly" 42820 42808 ( _2 ) 42821 42821 - # 42822 "parsing/parser.ml" 42809 42809 + # 42810 "parsing/parser.ml" 42822 42810 in 42823 42811 { 42824 42812 MenhirLib.EngineTypes.state = _menhir_s; ··· 42853 42841 42854 42842 # 2591 "parsing/parser.mly" 42855 42843 ( let (l, o, p) = _1 in ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2)) ) 42856 42856 - # 42857 "parsing/parser.ml" 42844 42844 + # 42845 "parsing/parser.ml" 42857 42845 in 42858 42846 { 42859 42847 MenhirLib.EngineTypes.state = _menhir_s; ··· 42906 42894 let _v : (Parsetree.expression) = let _3 = 42907 42895 # 2481 "parsing/parser.mly" 42908 42896 ( xs ) 42909 42909 - # 42910 "parsing/parser.ml" 42897 42897 + # 42898 "parsing/parser.ml" 42910 42898 in 42911 42899 let _endpos = _endpos__5_ in 42912 42900 let _symbolstartpos = _startpos__1_ in ··· 42914 42902 42915 42903 # 2593 "parsing/parser.mly" 42916 42904 ( mk_newtypes ~loc:_sloc _3 _5 ) 42917 42917 - # 42918 "parsing/parser.ml" 42905 42905 + # 42906 "parsing/parser.ml" 42918 42906 in 42919 42907 { 42920 42908 MenhirLib.EngineTypes.state = _menhir_s; ··· 42941 42929 let ys = 42942 42930 # 260 "<standard.mly>" 42943 42931 ( List.flatten xss ) 42944 42944 - # 42945 "parsing/parser.ml" 42932 42932 + # 42933 "parsing/parser.ml" 42945 42933 in 42946 42934 let xs = 42947 42935 let items = 42948 42936 # 953 "parsing/parser.mly" 42949 42937 ( [] ) 42950 42950 - # 42951 "parsing/parser.ml" 42938 42938 + # 42939 "parsing/parser.ml" 42951 42939 in 42952 42940 42953 42941 # 1372 "parsing/parser.mly" 42954 42942 ( items ) 42955 42955 - # 42956 "parsing/parser.ml" 42943 42943 + # 42944 "parsing/parser.ml" 42956 42944 42957 42945 in 42958 42946 42959 42947 # 267 "<standard.mly>" 42960 42948 ( xs @ ys ) 42961 42961 - # 42962 "parsing/parser.ml" 42949 42949 + # 42950 "parsing/parser.ml" 42962 42950 42963 42951 in 42964 42952 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in ··· 42967 42955 42968 42956 # 875 "parsing/parser.mly" 42969 42957 ( extra_str _startpos _endpos _1 ) 42970 42970 - # 42971 "parsing/parser.ml" 42958 42958 + # 42959 "parsing/parser.ml" 42971 42959 42972 42960 in 42973 42961 42974 42962 # 1365 "parsing/parser.mly" 42975 42963 ( _1 ) 42976 42976 - # 42977 "parsing/parser.ml" 42964 42964 + # 42965 "parsing/parser.ml" 42977 42965 in 42978 42966 { 42979 42967 MenhirLib.EngineTypes.state = _menhir_s; ··· 43014 43002 let ys = 43015 43003 # 260 "<standard.mly>" 43016 43004 ( List.flatten xss ) 43017 43017 - # 43018 "parsing/parser.ml" 43005 43005 + # 43006 "parsing/parser.ml" 43018 43006 in 43019 43007 let xs = 43020 43008 let items = ··· 43024 43012 let attrs = 43025 43013 # 3836 "parsing/parser.mly" 43026 43014 ( _1 ) 43027 43027 - # 43028 "parsing/parser.ml" 43015 43015 + # 43016 "parsing/parser.ml" 43028 43016 in 43029 43017 43030 43018 # 1379 "parsing/parser.mly" 43031 43019 ( mkstrexp e attrs ) 43032 43032 - # 43033 "parsing/parser.ml" 43020 43020 + # 43021 "parsing/parser.ml" 43033 43021 43034 43022 in 43035 43023 let _startpos__1_ = _startpos_e_ in ··· 43037 43025 43038 43026 # 887 "parsing/parser.mly" 43039 43027 ( text_str _startpos @ [_1] ) 43040 43040 - # 43041 "parsing/parser.ml" 43028 43028 + # 43029 "parsing/parser.ml" 43041 43029 43042 43030 in 43043 43031 let _startpos__1_ = _startpos_e_ in ··· 43047 43035 # 906 "parsing/parser.mly" 43048 43036 ( mark_rhs_docs _startpos _endpos; 43049 43037 _1 ) 43050 43050 - # 43051 "parsing/parser.ml" 43038 43038 + # 43039 "parsing/parser.ml" 43051 43039 43052 43040 in 43053 43041 43054 43042 # 955 "parsing/parser.mly" 43055 43043 ( x ) 43056 43056 - # 43057 "parsing/parser.ml" 43044 43044 + # 43045 "parsing/parser.ml" 43057 43045 43058 43046 in 43059 43047 43060 43048 # 1372 "parsing/parser.mly" 43061 43049 ( items ) 43062 43062 - # 43063 "parsing/parser.ml" 43050 43050 + # 43051 "parsing/parser.ml" 43063 43051 43064 43052 in 43065 43053 43066 43054 # 267 "<standard.mly>" 43067 43055 ( xs @ ys ) 43068 43068 - # 43069 "parsing/parser.ml" 43056 43056 + # 43057 "parsing/parser.ml" 43069 43057 43070 43058 in 43071 43059 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in ··· 43074 43062 43075 43063 # 875 "parsing/parser.mly" 43076 43064 ( extra_str _startpos _endpos _1 ) 43077 43077 - # 43078 "parsing/parser.ml" 43065 43065 + # 43066 "parsing/parser.ml" 43078 43066 43079 43067 in 43080 43068 43081 43069 # 1365 "parsing/parser.mly" 43082 43070 ( _1 ) 43083 43083 - # 43084 "parsing/parser.ml" 43071 43071 + # 43072 "parsing/parser.ml" 43084 43072 in 43085 43073 { 43086 43074 MenhirLib.EngineTypes.state = _menhir_s; ··· 43108 43096 43109 43097 # 1394 "parsing/parser.mly" 43110 43098 ( val_of_let_bindings ~loc:_sloc _1 ) 43111 43111 - # 43112 "parsing/parser.ml" 43099 43099 + # 43100 "parsing/parser.ml" 43112 43100 in 43113 43101 { 43114 43102 MenhirLib.EngineTypes.state = _menhir_s; ··· 43144 43132 43145 43133 # 3836 "parsing/parser.mly" 43146 43134 ( _1 ) 43147 43147 - # 43148 "parsing/parser.ml" 43135 43135 + # 43136 "parsing/parser.ml" 43148 43136 43149 43137 in 43150 43138 let _endpos__2_ = _endpos__1_inlined1_ in ··· 43155 43143 # 1397 "parsing/parser.mly" 43156 43144 ( let docs = symbol_docs _sloc in 43157 43145 Pstr_extension (_1, add_docs_attrs docs _2) ) 43158 43158 - # 43159 "parsing/parser.ml" 43146 43146 + # 43147 "parsing/parser.ml" 43159 43147 43160 43148 in 43161 43149 let _endpos__1_ = _endpos__1_inlined1_ in ··· 43165 43153 43166 43154 # 922 "parsing/parser.mly" 43167 43155 ( mkstr ~loc:_sloc _1 ) 43168 43168 - # 43169 "parsing/parser.ml" 43156 43156 + # 43157 "parsing/parser.ml" 43169 43157 43170 43158 in 43171 43159 43172 43160 # 1428 "parsing/parser.mly" 43173 43161 ( _1 ) 43174 43174 - # 43175 "parsing/parser.ml" 43162 43162 + # 43163 "parsing/parser.ml" 43175 43163 in 43176 43164 { 43177 43165 MenhirLib.EngineTypes.state = _menhir_s; ··· 43197 43185 let _1 = 43198 43186 # 1400 "parsing/parser.mly" 43199 43187 ( Pstr_attribute _1 ) 43200 43200 - # 43201 "parsing/parser.ml" 43188 43188 + # 43189 "parsing/parser.ml" 43201 43189 in 43202 43190 let _endpos = _endpos__1_ in 43203 43191 let _symbolstartpos = _startpos__1_ in ··· 43205 43193 43206 43194 # 922 "parsing/parser.mly" 43207 43195 ( mkstr ~loc:_sloc _1 ) 43208 43208 - # 43209 "parsing/parser.ml" 43196 43196 + # 43197 "parsing/parser.ml" 43209 43197 43210 43198 in 43211 43199 43212 43200 # 1428 "parsing/parser.mly" 43213 43201 ( _1 ) 43214 43214 - # 43215 "parsing/parser.ml" 43202 43202 + # 43203 "parsing/parser.ml" 43215 43203 in 43216 43204 { 43217 43205 MenhirLib.EngineTypes.state = _menhir_s; ··· 43237 43225 let _1 = 43238 43226 # 1404 "parsing/parser.mly" 43239 43227 ( pstr_primitive _1 ) 43240 43240 - # 43241 "parsing/parser.ml" 43228 43228 + # 43229 "parsing/parser.ml" 43241 43229 in 43242 43230 let _endpos = _endpos__1_ in 43243 43231 let _symbolstartpos = _startpos__1_ in ··· 43245 43233 43246 43234 # 939 "parsing/parser.mly" 43247 43235 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43248 43248 - # 43249 "parsing/parser.ml" 43236 43236 + # 43237 "parsing/parser.ml" 43249 43237 43250 43238 in 43251 43239 43252 43240 # 1428 "parsing/parser.mly" 43253 43241 ( _1 ) 43254 43254 - # 43255 "parsing/parser.ml" 43242 43242 + # 43243 "parsing/parser.ml" 43255 43243 in 43256 43244 { 43257 43245 MenhirLib.EngineTypes.state = _menhir_s; ··· 43277 43265 let _1 = 43278 43266 # 1406 "parsing/parser.mly" 43279 43267 ( pstr_primitive _1 ) 43280 43280 - # 43281 "parsing/parser.ml" 43268 43268 + # 43269 "parsing/parser.ml" 43281 43269 in 43282 43270 let _endpos = _endpos__1_ in 43283 43271 let _symbolstartpos = _startpos__1_ in ··· 43285 43273 43286 43274 # 939 "parsing/parser.mly" 43287 43275 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43288 43288 - # 43289 "parsing/parser.ml" 43276 43276 + # 43277 "parsing/parser.ml" 43289 43277 43290 43278 in 43291 43279 43292 43280 # 1428 "parsing/parser.mly" 43293 43281 ( _1 ) 43294 43294 - # 43295 "parsing/parser.ml" 43282 43282 + # 43283 "parsing/parser.ml" 43295 43283 in 43296 43284 { 43297 43285 MenhirLib.EngineTypes.state = _menhir_s; ··· 43328 43316 let _1 = 43329 43317 # 1114 "parsing/parser.mly" 43330 43318 ( let (x, b) = a in x, b :: bs ) 43331 43331 - # 43332 "parsing/parser.ml" 43319 43319 + # 43320 "parsing/parser.ml" 43332 43320 in 43333 43321 43334 43322 # 2926 "parsing/parser.mly" 43335 43323 ( _1 ) 43336 43336 - # 43337 "parsing/parser.ml" 43324 43324 + # 43325 "parsing/parser.ml" 43337 43325 43338 43326 in 43339 43327 43340 43328 # 2909 "parsing/parser.mly" 43341 43329 ( _1 ) 43342 43342 - # 43343 "parsing/parser.ml" 43330 43330 + # 43331 "parsing/parser.ml" 43343 43331 43344 43332 in 43345 43333 43346 43334 # 1408 "parsing/parser.mly" 43347 43335 ( pstr_type _1 ) 43348 43348 - # 43349 "parsing/parser.ml" 43336 43336 + # 43337 "parsing/parser.ml" 43349 43337 43350 43338 in 43351 43339 let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in ··· 43355 43343 43356 43344 # 939 "parsing/parser.mly" 43357 43345 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43358 43358 - # 43359 "parsing/parser.ml" 43346 43346 + # 43347 "parsing/parser.ml" 43359 43347 43360 43348 in 43361 43349 43362 43350 # 1428 "parsing/parser.mly" 43363 43351 ( _1 ) 43364 43364 - # 43365 "parsing/parser.ml" 43352 43352 + # 43353 "parsing/parser.ml" 43365 43353 in 43366 43354 { 43367 43355 MenhirLib.EngineTypes.state = _menhir_s; ··· 43448 43436 43449 43437 # 3836 "parsing/parser.mly" 43450 43438 ( _1 ) 43451 43451 - # 43452 "parsing/parser.ml" 43439 43439 + # 43440 "parsing/parser.ml" 43452 43440 43453 43441 in 43454 43442 let _endpos_attrs2_ = _endpos__1_inlined3_ in 43455 43443 let cs = 43456 43444 # 1106 "parsing/parser.mly" 43457 43445 ( List.rev xs ) 43458 43458 - # 43459 "parsing/parser.ml" 43446 43446 + # 43447 "parsing/parser.ml" 43459 43447 in 43460 43448 let tid = 43461 43449 let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in ··· 43465 43453 43466 43454 # 883 "parsing/parser.mly" 43467 43455 ( mkrhs _1 _sloc ) 43468 43468 - # 43469 "parsing/parser.ml" 43456 43456 + # 43457 "parsing/parser.ml" 43469 43457 43470 43458 in 43471 43459 let _4 = 43472 43460 # 3681 "parsing/parser.mly" 43473 43461 ( Recursive ) 43474 43474 - # 43475 "parsing/parser.ml" 43462 43462 + # 43463 "parsing/parser.ml" 43475 43463 in 43476 43464 let attrs1 = 43477 43465 let _1 = _1_inlined1 in 43478 43466 43479 43467 # 3840 "parsing/parser.mly" 43480 43468 ( _1 ) 43481 43481 - # 43482 "parsing/parser.ml" 43469 43469 + # 43470 "parsing/parser.ml" 43482 43470 43483 43471 in 43484 43472 let _endpos = _endpos_attrs2_ in ··· 43490 43478 let attrs = attrs1 @ attrs2 in 43491 43479 Te.mk tid cs ~params ~priv ~attrs ~docs, 43492 43480 ext ) 43493 43493 - # 43494 "parsing/parser.ml" 43481 43481 + # 43482 "parsing/parser.ml" 43494 43482 43495 43483 in 43496 43484 43497 43485 # 3163 "parsing/parser.mly" 43498 43486 ( _1 ) 43499 43499 - # 43500 "parsing/parser.ml" 43487 43487 + # 43488 "parsing/parser.ml" 43500 43488 43501 43489 in 43502 43490 43503 43491 # 1410 "parsing/parser.mly" 43504 43492 ( pstr_typext _1 ) 43505 43505 - # 43506 "parsing/parser.ml" 43493 43493 + # 43494 "parsing/parser.ml" 43506 43494 43507 43495 in 43508 43496 let _endpos__1_ = _endpos__1_inlined3_ in ··· 43512 43500 43513 43501 # 939 "parsing/parser.mly" 43514 43502 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43515 43515 - # 43516 "parsing/parser.ml" 43503 43503 + # 43504 "parsing/parser.ml" 43516 43504 43517 43505 in 43518 43506 43519 43507 # 1428 "parsing/parser.mly" 43520 43508 ( _1 ) 43521 43521 - # 43522 "parsing/parser.ml" 43509 43509 + # 43510 "parsing/parser.ml" 43522 43510 in 43523 43511 { 43524 43512 MenhirLib.EngineTypes.state = _menhir_s; ··· 43612 43600 43613 43601 # 3836 "parsing/parser.mly" 43614 43602 ( _1 ) 43615 43615 - # 43616 "parsing/parser.ml" 43603 43603 + # 43604 "parsing/parser.ml" 43616 43604 43617 43605 in 43618 43606 let _endpos_attrs2_ = _endpos__1_inlined4_ in 43619 43607 let cs = 43620 43608 # 1106 "parsing/parser.mly" 43621 43609 ( List.rev xs ) 43622 43622 - # 43623 "parsing/parser.ml" 43610 43610 + # 43611 "parsing/parser.ml" 43623 43611 in 43624 43612 let tid = 43625 43613 let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in ··· 43629 43617 43630 43618 # 883 "parsing/parser.mly" 43631 43619 ( mkrhs _1 _sloc ) 43632 43632 - # 43633 "parsing/parser.ml" 43620 43620 + # 43621 "parsing/parser.ml" 43633 43621 43634 43622 in 43635 43623 let _4 = ··· 43640 43628 43641 43629 # 3683 "parsing/parser.mly" 43642 43630 ( not_expecting _loc "nonrec flag" ) 43643 43643 - # 43644 "parsing/parser.ml" 43631 43631 + # 43632 "parsing/parser.ml" 43644 43632 43645 43633 in 43646 43634 let attrs1 = ··· 43648 43636 43649 43637 # 3840 "parsing/parser.mly" 43650 43638 ( _1 ) 43651 43651 - # 43652 "parsing/parser.ml" 43639 43639 + # 43640 "parsing/parser.ml" 43652 43640 43653 43641 in 43654 43642 let _endpos = _endpos_attrs2_ in ··· 43660 43648 let attrs = attrs1 @ attrs2 in 43661 43649 Te.mk tid cs ~params ~priv ~attrs ~docs, 43662 43650 ext ) 43663 43663 - # 43664 "parsing/parser.ml" 43651 43651 + # 43652 "parsing/parser.ml" 43664 43652 43665 43653 in 43666 43654 43667 43655 # 3163 "parsing/parser.mly" 43668 43656 ( _1 ) 43669 43669 - # 43670 "parsing/parser.ml" 43657 43657 + # 43658 "parsing/parser.ml" 43670 43658 43671 43659 in 43672 43660 43673 43661 # 1410 "parsing/parser.mly" 43674 43662 ( pstr_typext _1 ) 43675 43675 - # 43676 "parsing/parser.ml" 43663 43663 + # 43664 "parsing/parser.ml" 43676 43664 43677 43665 in 43678 43666 let _endpos__1_ = _endpos__1_inlined4_ in ··· 43682 43670 43683 43671 # 939 "parsing/parser.mly" 43684 43672 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43685 43685 - # 43686 "parsing/parser.ml" 43673 43673 + # 43674 "parsing/parser.ml" 43686 43674 43687 43675 in 43688 43676 43689 43677 # 1428 "parsing/parser.mly" 43690 43678 ( _1 ) 43691 43691 - # 43692 "parsing/parser.ml" 43679 43679 + # 43680 "parsing/parser.ml" 43692 43680 in 43693 43681 { 43694 43682 MenhirLib.EngineTypes.state = _menhir_s; ··· 43714 43702 let _1 = 43715 43703 # 1412 "parsing/parser.mly" 43716 43704 ( pstr_exception _1 ) 43717 43717 - # 43718 "parsing/parser.ml" 43705 43705 + # 43706 "parsing/parser.ml" 43718 43706 in 43719 43707 let _endpos = _endpos__1_ in 43720 43708 let _symbolstartpos = _startpos__1_ in ··· 43722 43710 43723 43711 # 939 "parsing/parser.mly" 43724 43712 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43725 43725 - # 43726 "parsing/parser.ml" 43713 43713 + # 43714 "parsing/parser.ml" 43726 43714 43727 43715 in 43728 43716 43729 43717 # 1428 "parsing/parser.mly" 43730 43718 ( _1 ) 43731 43731 - # 43732 "parsing/parser.ml" 43719 43719 + # 43720 "parsing/parser.ml" 43732 43720 in 43733 43721 { 43734 43722 MenhirLib.EngineTypes.state = _menhir_s; ··· 43793 43781 43794 43782 # 3836 "parsing/parser.mly" 43795 43783 ( _1 ) 43796 43796 - # 43797 "parsing/parser.ml" 43784 43784 + # 43785 "parsing/parser.ml" 43797 43785 43798 43786 in 43799 43787 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 43805 43793 43806 43794 # 883 "parsing/parser.mly" 43807 43795 ( mkrhs _1 _sloc ) 43808 43808 - # 43809 "parsing/parser.ml" 43796 43796 + # 43797 "parsing/parser.ml" 43809 43797 43810 43798 in 43811 43799 let attrs1 = ··· 43813 43801 43814 43802 # 3840 "parsing/parser.mly" 43815 43803 ( _1 ) 43816 43816 - # 43817 "parsing/parser.ml" 43804 43804 + # 43805 "parsing/parser.ml" 43817 43805 43818 43806 in 43819 43807 let _endpos = _endpos_attrs2_ in ··· 43826 43814 let attrs = attrs1 @ attrs2 in 43827 43815 let body = Mb.mk name body ~attrs ~loc ~docs in 43828 43816 Pstr_module body, ext ) 43829 43829 - # 43830 "parsing/parser.ml" 43817 43817 + # 43818 "parsing/parser.ml" 43830 43818 43831 43819 in 43832 43820 43833 43821 # 1414 "parsing/parser.mly" 43834 43822 ( _1 ) 43835 43835 - # 43836 "parsing/parser.ml" 43823 43823 + # 43824 "parsing/parser.ml" 43836 43824 43837 43825 in 43838 43826 let _endpos__1_ = _endpos__1_inlined3_ in ··· 43842 43830 43843 43831 # 939 "parsing/parser.mly" 43844 43832 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43845 43845 - # 43846 "parsing/parser.ml" 43833 43833 + # 43834 "parsing/parser.ml" 43846 43834 43847 43835 in 43848 43836 43849 43837 # 1428 "parsing/parser.mly" 43850 43838 ( _1 ) 43851 43851 - # 43852 "parsing/parser.ml" 43839 43839 + # 43840 "parsing/parser.ml" 43852 43840 in 43853 43841 { 43854 43842 MenhirLib.EngineTypes.state = _menhir_s; ··· 43929 43917 43930 43918 # 3836 "parsing/parser.mly" 43931 43919 ( _1 ) 43932 43932 - # 43933 "parsing/parser.ml" 43920 43920 + # 43921 "parsing/parser.ml" 43933 43921 43934 43922 in 43935 43923 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 43941 43929 43942 43930 # 883 "parsing/parser.mly" 43943 43931 ( mkrhs _1 _sloc ) 43944 43944 - # 43945 "parsing/parser.ml" 43932 43932 + # 43933 "parsing/parser.ml" 43945 43933 43946 43934 in 43947 43935 let attrs1 = ··· 43949 43937 43950 43938 # 3840 "parsing/parser.mly" 43951 43939 ( _1 ) 43952 43952 - # 43953 "parsing/parser.ml" 43940 43940 + # 43941 "parsing/parser.ml" 43953 43941 43954 43942 in 43955 43943 let _endpos = _endpos_attrs2_ in ··· 43964 43952 ext, 43965 43953 Mb.mk name body ~attrs ~loc ~docs 43966 43954 ) 43967 43967 - # 43968 "parsing/parser.ml" 43955 43955 + # 43956 "parsing/parser.ml" 43968 43956 43969 43957 in 43970 43958 43971 43959 # 1114 "parsing/parser.mly" 43972 43960 ( let (x, b) = a in x, b :: bs ) 43973 43973 - # 43974 "parsing/parser.ml" 43961 43961 + # 43962 "parsing/parser.ml" 43974 43962 43975 43963 in 43976 43964 43977 43965 # 1461 "parsing/parser.mly" 43978 43966 ( _1 ) 43979 43979 - # 43980 "parsing/parser.ml" 43967 43967 + # 43968 "parsing/parser.ml" 43980 43968 43981 43969 in 43982 43970 43983 43971 # 1416 "parsing/parser.mly" 43984 43972 ( pstr_recmodule _1 ) 43985 43985 - # 43986 "parsing/parser.ml" 43973 43973 + # 43974 "parsing/parser.ml" 43986 43974 43987 43975 in 43988 43976 let _endpos__1_ = _endpos_bs_ in ··· 43992 43980 43993 43981 # 939 "parsing/parser.mly" 43994 43982 ( wrap_mkstr_ext ~loc:_sloc _1 ) 43995 43995 - # 43996 "parsing/parser.ml" 43983 43983 + # 43984 "parsing/parser.ml" 43996 43984 43997 43985 in 43998 43986 43999 43987 # 1428 "parsing/parser.mly" 44000 43988 ( _1 ) 44001 44001 - # 44002 "parsing/parser.ml" 43989 43989 + # 43990 "parsing/parser.ml" 44002 43990 in 44003 43991 { 44004 43992 MenhirLib.EngineTypes.state = _menhir_s; ··· 44024 44012 let _1 = 44025 44013 # 1418 "parsing/parser.mly" 44026 44014 ( let (body, ext) = _1 in (Pstr_modtype body, ext) ) 44027 44027 - # 44028 "parsing/parser.ml" 44015 44015 + # 44016 "parsing/parser.ml" 44028 44016 in 44029 44017 let _endpos = _endpos__1_ in 44030 44018 let _symbolstartpos = _startpos__1_ in ··· 44032 44020 44033 44021 # 939 "parsing/parser.mly" 44034 44022 ( wrap_mkstr_ext ~loc:_sloc _1 ) 44035 44035 - # 44036 "parsing/parser.ml" 44023 44023 + # 44024 "parsing/parser.ml" 44036 44024 44037 44025 in 44038 44026 44039 44027 # 1428 "parsing/parser.mly" 44040 44028 ( _1 ) 44041 44041 - # 44042 "parsing/parser.ml" 44029 44029 + # 44030 "parsing/parser.ml" 44042 44030 in 44043 44031 { 44044 44032 MenhirLib.EngineTypes.state = _menhir_s; ··· 44064 44052 let _1 = 44065 44053 # 1420 "parsing/parser.mly" 44066 44054 ( let (body, ext) = _1 in (Pstr_open body, ext) ) 44067 44067 - # 44068 "parsing/parser.ml" 44055 44055 + # 44056 "parsing/parser.ml" 44068 44056 in 44069 44057 let _endpos = _endpos__1_ in 44070 44058 let _symbolstartpos = _startpos__1_ in ··· 44072 44060 44073 44061 # 939 "parsing/parser.mly" 44074 44062 ( wrap_mkstr_ext ~loc:_sloc _1 ) 44075 44075 - # 44076 "parsing/parser.ml" 44063 44063 + # 44064 "parsing/parser.ml" 44076 44064 44077 44065 in 44078 44066 44079 44067 # 1428 "parsing/parser.mly" 44080 44068 ( _1 ) 44081 44081 - # 44082 "parsing/parser.ml" 44069 44069 + # 44070 "parsing/parser.ml" 44082 44070 in 44083 44071 { 44084 44072 MenhirLib.EngineTypes.state = _menhir_s; ··· 44150 44138 let _1_inlined2 : ( 44151 44139 # 705 "parsing/parser.mly" 44152 44140 (string) 44153 44153 - # 44154 "parsing/parser.ml" 44141 44141 + # 44142 "parsing/parser.ml" 44154 44142 ) = Obj.magic _1_inlined2 in 44155 44143 let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in 44156 44144 let virt : (Asttypes.virtual_flag) = Obj.magic virt in ··· 44170 44158 44171 44159 # 3836 "parsing/parser.mly" 44172 44160 ( _1 ) 44173 44173 - # 44174 "parsing/parser.ml" 44161 44161 + # 44162 "parsing/parser.ml" 44174 44162 44175 44163 in 44176 44164 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 44182 44170 44183 44171 # 883 "parsing/parser.mly" 44184 44172 ( mkrhs _1 _sloc ) 44185 44185 - # 44186 "parsing/parser.ml" 44173 44173 + # 44174 "parsing/parser.ml" 44186 44174 44187 44175 in 44188 44176 let attrs1 = ··· 44190 44178 44191 44179 # 3840 "parsing/parser.mly" 44192 44180 ( _1 ) 44193 44193 - # 44194 "parsing/parser.ml" 44181 44181 + # 44182 "parsing/parser.ml" 44194 44182 44195 44183 in 44196 44184 let _endpos = _endpos_attrs2_ in ··· 44205 44193 ext, 44206 44194 Ci.mk id body ~virt ~params ~attrs ~loc ~docs 44207 44195 ) 44208 44208 - # 44209 "parsing/parser.ml" 44196 44196 + # 44197 "parsing/parser.ml" 44209 44197 44210 44198 in 44211 44199 44212 44200 # 1114 "parsing/parser.mly" 44213 44201 ( let (x, b) = a in x, b :: bs ) 44214 44214 - # 44215 "parsing/parser.ml" 44202 44202 + # 44203 "parsing/parser.ml" 44215 44203 44216 44204 in 44217 44205 44218 44206 # 1800 "parsing/parser.mly" 44219 44207 ( _1 ) 44220 44220 - # 44221 "parsing/parser.ml" 44208 44208 + # 44209 "parsing/parser.ml" 44221 44209 44222 44210 in 44223 44211 44224 44212 # 1422 "parsing/parser.mly" 44225 44213 ( let (ext, l) = _1 in (Pstr_class l, ext) ) 44226 44226 - # 44227 "parsing/parser.ml" 44214 44214 + # 44215 "parsing/parser.ml" 44227 44215 44228 44216 in 44229 44217 let _endpos__1_ = _endpos_bs_ in ··· 44233 44221 44234 44222 # 939 "parsing/parser.mly" 44235 44223 ( wrap_mkstr_ext ~loc:_sloc _1 ) 44236 44236 - # 44237 "parsing/parser.ml" 44224 44224 + # 44225 "parsing/parser.ml" 44237 44225 44238 44226 in 44239 44227 44240 44228 # 1428 "parsing/parser.mly" 44241 44229 ( _1 ) 44242 44242 - # 44243 "parsing/parser.ml" 44230 44230 + # 44231 "parsing/parser.ml" 44243 44231 in 44244 44232 { 44245 44233 MenhirLib.EngineTypes.state = _menhir_s; ··· 44265 44253 let _1 = 44266 44254 # 1424 "parsing/parser.mly" 44267 44255 ( let (ext, l) = _1 in (Pstr_class_type l, ext) ) 44268 44268 - # 44269 "parsing/parser.ml" 44256 44256 + # 44257 "parsing/parser.ml" 44269 44257 in 44270 44258 let _endpos = _endpos__1_ in 44271 44259 let _symbolstartpos = _startpos__1_ in ··· 44273 44261 44274 44262 # 939 "parsing/parser.mly" 44275 44263 ( wrap_mkstr_ext ~loc:_sloc _1 ) 44276 44276 - # 44277 "parsing/parser.ml" 44264 44264 + # 44265 "parsing/parser.ml" 44277 44265 44278 44266 in 44279 44267 44280 44268 # 1428 "parsing/parser.mly" 44281 44269 ( _1 ) 44282 44282 - # 44283 "parsing/parser.ml" 44270 44270 + # 44271 "parsing/parser.ml" 44283 44271 in 44284 44272 { 44285 44273 MenhirLib.EngineTypes.state = _menhir_s; ··· 44337 44325 44338 44326 # 3836 "parsing/parser.mly" 44339 44327 ( _1 ) 44340 44340 - # 44341 "parsing/parser.ml" 44328 44328 + # 44329 "parsing/parser.ml" 44341 44329 44342 44330 in 44343 44331 let _endpos_attrs2_ = _endpos__1_inlined2_ in ··· 44346 44334 44347 44335 # 3840 "parsing/parser.mly" 44348 44336 ( _1 ) 44349 44349 - # 44350 "parsing/parser.ml" 44337 44337 + # 44338 "parsing/parser.ml" 44350 44338 44351 44339 in 44352 44340 let _endpos = _endpos_attrs2_ in ··· 44360 44348 let docs = symbol_docs _sloc in 44361 44349 Incl.mk thing ~attrs ~loc ~docs, ext 44362 44350 ) 44363 44363 - # 44364 "parsing/parser.ml" 44351 44351 + # 44352 "parsing/parser.ml" 44364 44352 44365 44353 in 44366 44354 44367 44355 # 1426 "parsing/parser.mly" 44368 44356 ( pstr_include _1 ) 44369 44369 - # 44370 "parsing/parser.ml" 44357 44357 + # 44358 "parsing/parser.ml" 44370 44358 44371 44359 in 44372 44360 let _endpos__1_ = _endpos__1_inlined2_ in ··· 44376 44364 44377 44365 # 939 "parsing/parser.mly" 44378 44366 ( wrap_mkstr_ext ~loc:_sloc _1 ) 44379 44379 - # 44380 "parsing/parser.ml" 44367 44367 + # 44368 "parsing/parser.ml" 44380 44368 44381 44369 in 44382 44370 44383 44371 # 1428 "parsing/parser.mly" 44384 44372 ( _1 ) 44385 44385 - # 44386 "parsing/parser.ml" 44373 44373 + # 44374 "parsing/parser.ml" 44386 44374 in 44387 44375 { 44388 44376 MenhirLib.EngineTypes.state = _menhir_s; ··· 44407 44395 let _v : (string) = 44408 44396 # 3746 "parsing/parser.mly" 44409 44397 ( "-" ) 44410 44410 - # 44411 "parsing/parser.ml" 44398 44398 + # 44399 "parsing/parser.ml" 44411 44399 in 44412 44400 { 44413 44401 MenhirLib.EngineTypes.state = _menhir_s; ··· 44432 44420 let _v : (string) = 44433 44421 # 3747 "parsing/parser.mly" 44434 44422 ( "-." ) 44435 44435 - # 44436 "parsing/parser.ml" 44423 44423 + # 44424 "parsing/parser.ml" 44436 44424 in 44437 44425 { 44438 44426 MenhirLib.EngineTypes.state = _menhir_s; ··· 44487 44475 44488 44476 # 3840 "parsing/parser.mly" 44489 44477 ( _1 ) 44490 44490 - # 44491 "parsing/parser.ml" 44478 44478 + # 44479 "parsing/parser.ml" 44491 44479 44492 44480 in 44493 44481 let _endpos__5_ = _endpos__1_inlined1_ in ··· 44496 44484 let xs = 44497 44485 # 253 "<standard.mly>" 44498 44486 ( List.rev xs ) 44499 44499 - # 44500 "parsing/parser.ml" 44487 44487 + # 44488 "parsing/parser.ml" 44500 44488 in 44501 44489 44502 44490 # 1017 "parsing/parser.mly" 44503 44491 ( xs ) 44504 44504 - # 44505 "parsing/parser.ml" 44492 44492 + # 44493 "parsing/parser.ml" 44505 44493 44506 44494 in 44507 44495 44508 44496 # 3454 "parsing/parser.mly" 44509 44497 ( _1 ) 44510 44510 - # 44511 "parsing/parser.ml" 44498 44498 + # 44499 "parsing/parser.ml" 44511 44499 44512 44500 in 44513 44501 let _1 = ··· 44517 44505 44518 44506 # 883 "parsing/parser.mly" 44519 44507 ( mkrhs _1 _sloc ) 44520 44520 - # 44521 "parsing/parser.ml" 44508 44508 + # 44509 "parsing/parser.ml" 44521 44509 44522 44510 in 44523 44511 let _endpos = _endpos__5_ in ··· 44528 44516 ( let info = symbol_info _endpos in 44529 44517 let attrs = add_info_attrs info _5 in 44530 44518 Rf.tag ~loc:(make_loc _sloc) ~attrs _1 _3 _4 ) 44531 44531 - # 44532 "parsing/parser.ml" 44519 44519 + # 44520 "parsing/parser.ml" 44532 44520 in 44533 44521 { 44534 44522 MenhirLib.EngineTypes.state = _menhir_s; ··· 44562 44550 44563 44551 # 3840 "parsing/parser.mly" 44564 44552 ( _1 ) 44565 44565 - # 44566 "parsing/parser.ml" 44553 44553 + # 44554 "parsing/parser.ml" 44566 44554 44567 44555 in 44568 44556 let _endpos__2_ = _endpos__1_inlined1_ in ··· 44573 44561 44574 44562 # 883 "parsing/parser.mly" 44575 44563 ( mkrhs _1 _sloc ) 44576 44576 - # 44577 "parsing/parser.ml" 44564 44564 + # 44565 "parsing/parser.ml" 44577 44565 44578 44566 in 44579 44567 let _endpos = _endpos__2_ in ··· 44584 44572 ( let info = symbol_info _endpos in 44585 44573 let attrs = add_info_attrs info _2 in 44586 44574 Rf.tag ~loc:(make_loc _sloc) ~attrs _1 true [] ) 44587 44587 - # 44588 "parsing/parser.ml" 44575 44575 + # 44576 "parsing/parser.ml" 44588 44576 in 44589 44577 { 44590 44578 MenhirLib.EngineTypes.state = _menhir_s; ··· 44616 44604 let _v : (Parsetree.toplevel_phrase) = let arg = 44617 44605 # 124 "<standard.mly>" 44618 44606 ( None ) 44619 44619 - # 44620 "parsing/parser.ml" 44607 44607 + # 44608 "parsing/parser.ml" 44620 44608 in 44621 44609 let _endpos_arg_ = _endpos__1_inlined1_ in 44622 44610 let dir = ··· 44627 44615 44628 44616 # 883 "parsing/parser.mly" 44629 44617 ( mkrhs _1 _sloc ) 44630 44630 - # 44631 "parsing/parser.ml" 44618 44618 + # 44619 "parsing/parser.ml" 44631 44619 44632 44620 in 44633 44621 let _endpos = _endpos_arg_ in ··· 44636 44624 44637 44625 # 3644 "parsing/parser.mly" 44638 44626 ( mk_directive ~loc:_sloc dir arg ) 44639 44639 - # 44640 "parsing/parser.ml" 44627 44627 + # 44628 "parsing/parser.ml" 44640 44628 in 44641 44629 { 44642 44630 MenhirLib.EngineTypes.state = _menhir_s; ··· 44669 44657 let _1_inlined2 : ( 44670 44658 # 743 "parsing/parser.mly" 44671 44659 (string * Location.t * string option) 44672 44672 - # 44673 "parsing/parser.ml" 44660 44660 + # 44661 "parsing/parser.ml" 44673 44661 ) = Obj.magic _1_inlined2 in 44674 44662 let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in 44675 44663 let _1 : unit = Obj.magic _1 in ··· 44682 44670 let _1 = 44683 44671 # 3648 "parsing/parser.mly" 44684 44672 ( let (s, _, _) = _1 in Pdir_string s ) 44685 44685 - # 44686 "parsing/parser.ml" 44673 44673 + # 44674 "parsing/parser.ml" 44686 44674 in 44687 44675 let _endpos = _endpos__1_ in 44688 44676 let _symbolstartpos = _startpos__1_ in ··· 44690 44678 44691 44679 # 944 "parsing/parser.mly" 44692 44680 ( mk_directive_arg ~loc:_sloc _1 ) 44693 44693 - # 44694 "parsing/parser.ml" 44681 44681 + # 44682 "parsing/parser.ml" 44694 44682 44695 44683 in 44696 44684 44697 44685 # 126 "<standard.mly>" 44698 44686 ( Some x ) 44699 44699 - # 44700 "parsing/parser.ml" 44687 44687 + # 44688 "parsing/parser.ml" 44700 44688 44701 44689 in 44702 44690 let _endpos_arg_ = _endpos__1_inlined2_ in ··· 44708 44696 44709 44697 # 883 "parsing/parser.mly" 44710 44698 ( mkrhs _1 _sloc ) 44711 44711 - # 44712 "parsing/parser.ml" 44699 44699 + # 44700 "parsing/parser.ml" 44712 44700 44713 44701 in 44714 44702 let _endpos = _endpos_arg_ in ··· 44717 44705 44718 44706 # 3644 "parsing/parser.mly" 44719 44707 ( mk_directive ~loc:_sloc dir arg ) 44720 44720 - # 44721 "parsing/parser.ml" 44708 44708 + # 44709 "parsing/parser.ml" 44721 44709 in 44722 44710 { 44723 44711 MenhirLib.EngineTypes.state = _menhir_s; ··· 44750 44738 let _1_inlined2 : ( 44751 44739 # 691 "parsing/parser.mly" 44752 44740 (string * char option) 44753 44753 - # 44754 "parsing/parser.ml" 44741 44741 + # 44742 "parsing/parser.ml" 44754 44742 ) = Obj.magic _1_inlined2 in 44755 44743 let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in 44756 44744 let _1 : unit = Obj.magic _1 in ··· 44763 44751 let _1 = 44764 44752 # 3649 "parsing/parser.mly" 44765 44753 ( let (n, m) = _1 in Pdir_int (n ,m) ) 44766 44766 - # 44767 "parsing/parser.ml" 44754 44754 + # 44755 "parsing/parser.ml" 44767 44755 in 44768 44756 let _endpos = _endpos__1_ in 44769 44757 let _symbolstartpos = _startpos__1_ in ··· 44771 44759 44772 44760 # 944 "parsing/parser.mly" 44773 44761 ( mk_directive_arg ~loc:_sloc _1 ) 44774 44774 - # 44775 "parsing/parser.ml" 44762 44762 + # 44763 "parsing/parser.ml" 44775 44763 44776 44764 in 44777 44765 44778 44766 # 126 "<standard.mly>" 44779 44767 ( Some x ) 44780 44780 - # 44781 "parsing/parser.ml" 44768 44768 + # 44769 "parsing/parser.ml" 44781 44769 44782 44770 in 44783 44771 let _endpos_arg_ = _endpos__1_inlined2_ in ··· 44789 44777 44790 44778 # 883 "parsing/parser.mly" 44791 44779 ( mkrhs _1 _sloc ) 44792 44792 - # 44793 "parsing/parser.ml" 44780 44780 + # 44781 "parsing/parser.ml" 44793 44781 44794 44782 in 44795 44783 let _endpos = _endpos_arg_ in ··· 44798 44786 44799 44787 # 3644 "parsing/parser.mly" 44800 44788 ( mk_directive ~loc:_sloc dir arg ) 44801 44801 - # 44802 "parsing/parser.ml" 44789 44789 + # 44790 "parsing/parser.ml" 44802 44790 in 44803 44791 { 44804 44792 MenhirLib.EngineTypes.state = _menhir_s; ··· 44840 44828 let _1 = 44841 44829 # 3650 "parsing/parser.mly" 44842 44830 ( Pdir_ident _1 ) 44843 44843 - # 44844 "parsing/parser.ml" 44831 44831 + # 44832 "parsing/parser.ml" 44844 44832 in 44845 44833 let _endpos = _endpos__1_ in 44846 44834 let _symbolstartpos = _startpos__1_ in ··· 44848 44836 44849 44837 # 944 "parsing/parser.mly" 44850 44838 ( mk_directive_arg ~loc:_sloc _1 ) 44851 44851 - # 44852 "parsing/parser.ml" 44839 44839 + # 44840 "parsing/parser.ml" 44852 44840 44853 44841 in 44854 44842 44855 44843 # 126 "<standard.mly>" 44856 44844 ( Some x ) 44857 44857 - # 44858 "parsing/parser.ml" 44845 44845 + # 44846 "parsing/parser.ml" 44858 44846 44859 44847 in 44860 44848 let _endpos_arg_ = _endpos__1_inlined2_ in ··· 44866 44854 44867 44855 # 883 "parsing/parser.mly" 44868 44856 ( mkrhs _1 _sloc ) 44869 44869 - # 44870 "parsing/parser.ml" 44857 44857 + # 44858 "parsing/parser.ml" 44870 44858 44871 44859 in 44872 44860 let _endpos = _endpos_arg_ in ··· 44875 44863 44876 44864 # 3644 "parsing/parser.mly" 44877 44865 ( mk_directive ~loc:_sloc dir arg ) 44878 44878 - # 44879 "parsing/parser.ml" 44866 44866 + # 44867 "parsing/parser.ml" 44879 44867 in 44880 44868 { 44881 44869 MenhirLib.EngineTypes.state = _menhir_s; ··· 44917 44905 let _1 = 44918 44906 # 3651 "parsing/parser.mly" 44919 44907 ( Pdir_ident _1 ) 44920 44920 - # 44921 "parsing/parser.ml" 44908 44908 + # 44909 "parsing/parser.ml" 44921 44909 in 44922 44910 let _endpos = _endpos__1_ in 44923 44911 let _symbolstartpos = _startpos__1_ in ··· 44925 44913 44926 44914 # 944 "parsing/parser.mly" 44927 44915 ( mk_directive_arg ~loc:_sloc _1 ) 44928 44928 - # 44929 "parsing/parser.ml" 44916 44916 + # 44917 "parsing/parser.ml" 44929 44917 44930 44918 in 44931 44919 44932 44920 # 126 "<standard.mly>" 44933 44921 ( Some x ) 44934 44934 - # 44935 "parsing/parser.ml" 44922 44922 + # 44923 "parsing/parser.ml" 44935 44923 44936 44924 in 44937 44925 let _endpos_arg_ = _endpos__1_inlined2_ in ··· 44943 44931 44944 44932 # 883 "parsing/parser.mly" 44945 44933 ( mkrhs _1 _sloc ) 44946 44946 - # 44947 "parsing/parser.ml" 44934 44934 + # 44935 "parsing/parser.ml" 44947 44935 44948 44936 in 44949 44937 let _endpos = _endpos_arg_ in ··· 44952 44940 44953 44941 # 3644 "parsing/parser.mly" 44954 44942 ( mk_directive ~loc:_sloc dir arg ) 44955 44955 - # 44956 "parsing/parser.ml" 44943 44943 + # 44944 "parsing/parser.ml" 44956 44944 in 44957 44945 { 44958 44946 MenhirLib.EngineTypes.state = _menhir_s; ··· 44994 44982 let _1 = 44995 44983 # 3652 "parsing/parser.mly" 44996 44984 ( Pdir_bool false ) 44997 44997 - # 44998 "parsing/parser.ml" 44985 44985 + # 44986 "parsing/parser.ml" 44998 44986 in 44999 44987 let _endpos = _endpos__1_ in 45000 44988 let _symbolstartpos = _startpos__1_ in ··· 45002 44990 45003 44991 # 944 "parsing/parser.mly" 45004 44992 ( mk_directive_arg ~loc:_sloc _1 ) 45005 45005 - # 45006 "parsing/parser.ml" 44993 44993 + # 44994 "parsing/parser.ml" 45006 44994 45007 44995 in 45008 44996 45009 44997 # 126 "<standard.mly>" 45010 44998 ( Some x ) 45011 45011 - # 45012 "parsing/parser.ml" 44999 44999 + # 45000 "parsing/parser.ml" 45012 45000 45013 45001 in 45014 45002 let _endpos_arg_ = _endpos__1_inlined2_ in ··· 45020 45008 45021 45009 # 883 "parsing/parser.mly" 45022 45010 ( mkrhs _1 _sloc ) 45023 45023 - # 45024 "parsing/parser.ml" 45011 45011 + # 45012 "parsing/parser.ml" 45024 45012 45025 45013 in 45026 45014 let _endpos = _endpos_arg_ in ··· 45029 45017 45030 45018 # 3644 "parsing/parser.mly" 45031 45019 ( mk_directive ~loc:_sloc dir arg ) 45032 45032 - # 45033 "parsing/parser.ml" 45020 45020 + # 45021 "parsing/parser.ml" 45033 45021 in 45034 45022 { 45035 45023 MenhirLib.EngineTypes.state = _menhir_s; ··· 45071 45059 let _1 = 45072 45060 # 3653 "parsing/parser.mly" 45073 45061 ( Pdir_bool true ) 45074 45074 - # 45075 "parsing/parser.ml" 45062 45062 + # 45063 "parsing/parser.ml" 45075 45063 in 45076 45064 let _endpos = _endpos__1_ in 45077 45065 let _symbolstartpos = _startpos__1_ in ··· 45079 45067 45080 45068 # 944 "parsing/parser.mly" 45081 45069 ( mk_directive_arg ~loc:_sloc _1 ) 45082 45082 - # 45083 "parsing/parser.ml" 45070 45070 + # 45071 "parsing/parser.ml" 45083 45071 45084 45072 in 45085 45073 45086 45074 # 126 "<standard.mly>" 45087 45075 ( Some x ) 45088 45088 - # 45089 "parsing/parser.ml" 45076 45076 + # 45077 "parsing/parser.ml" 45089 45077 45090 45078 in 45091 45079 let _endpos_arg_ = _endpos__1_inlined2_ in ··· 45097 45085 45098 45086 # 883 "parsing/parser.mly" 45099 45087 ( mkrhs _1 _sloc ) 45100 45100 - # 45101 "parsing/parser.ml" 45088 45088 + # 45089 "parsing/parser.ml" 45101 45089 45102 45090 in 45103 45091 let _endpos = _endpos_arg_ in ··· 45106 45094 45107 45095 # 3644 "parsing/parser.mly" 45108 45096 ( mk_directive ~loc:_sloc dir arg ) 45109 45109 - # 45110 "parsing/parser.ml" 45097 45097 + # 45098 "parsing/parser.ml" 45110 45098 in 45111 45099 { 45112 45100 MenhirLib.EngineTypes.state = _menhir_s; ··· 45148 45136 let attrs = 45149 45137 # 3836 "parsing/parser.mly" 45150 45138 ( _1 ) 45151 45151 - # 45152 "parsing/parser.ml" 45139 45139 + # 45140 "parsing/parser.ml" 45152 45140 in 45153 45141 45154 45142 # 1379 "parsing/parser.mly" 45155 45143 ( mkstrexp e attrs ) 45156 45156 - # 45157 "parsing/parser.ml" 45144 45144 + # 45145 "parsing/parser.ml" 45157 45145 45158 45146 in 45159 45147 let _startpos__1_ = _startpos_e_ in ··· 45161 45149 45162 45150 # 887 "parsing/parser.mly" 45163 45151 ( text_str _startpos @ [_1] ) 45164 45164 - # 45165 "parsing/parser.ml" 45152 45152 + # 45153 "parsing/parser.ml" 45165 45153 45166 45154 in 45167 45155 let _startpos__1_ = _startpos_e_ in ··· 45170 45158 45171 45159 # 875 "parsing/parser.mly" 45172 45160 ( extra_str _startpos _endpos _1 ) 45173 45173 - # 45174 "parsing/parser.ml" 45161 45161 + # 45162 "parsing/parser.ml" 45174 45162 45175 45163 in 45176 45164 45177 45165 # 1154 "parsing/parser.mly" 45178 45166 ( Ptop_def _1 ) 45179 45179 - # 45180 "parsing/parser.ml" 45167 45167 + # 45168 "parsing/parser.ml" 45180 45168 in 45181 45169 { 45182 45170 MenhirLib.EngineTypes.state = _menhir_s; ··· 45209 45197 let _1 = 45210 45198 # 260 "<standard.mly>" 45211 45199 ( List.flatten xss ) 45212 45212 - # 45213 "parsing/parser.ml" 45200 45200 + # 45201 "parsing/parser.ml" 45213 45201 in 45214 45202 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in 45215 45203 let _endpos = _endpos__1_ in ··· 45217 45205 45218 45206 # 875 "parsing/parser.mly" 45219 45207 ( extra_str _startpos _endpos _1 ) 45220 45220 - # 45221 "parsing/parser.ml" 45208 45208 + # 45209 "parsing/parser.ml" 45221 45209 45222 45210 in 45223 45211 45224 45212 # 1158 "parsing/parser.mly" 45225 45213 ( Ptop_def _1 ) 45226 45226 - # 45227 "parsing/parser.ml" 45214 45214 + # 45215 "parsing/parser.ml" 45227 45215 in 45228 45216 { 45229 45217 MenhirLib.EngineTypes.state = _menhir_s; ··· 45255 45243 let _v : (Parsetree.toplevel_phrase) = 45256 45244 # 1162 "parsing/parser.mly" 45257 45245 ( _1 ) 45258 45258 - # 45259 "parsing/parser.ml" 45246 45246 + # 45247 "parsing/parser.ml" 45259 45247 in 45260 45248 { 45261 45249 MenhirLib.EngineTypes.state = _menhir_s; ··· 45280 45268 let _v : (Parsetree.toplevel_phrase) = 45281 45269 # 1165 "parsing/parser.mly" 45282 45270 ( raise End_of_file ) 45283 45283 - # 45284 "parsing/parser.ml" 45271 45271 + # 45272 "parsing/parser.ml" 45284 45272 in 45285 45273 { 45286 45274 MenhirLib.EngineTypes.state = _menhir_s; ··· 45305 45293 let _v : (Parsetree.core_type) = 45306 45294 # 3346 "parsing/parser.mly" 45307 45295 ( ty ) 45308 45308 - # 45309 "parsing/parser.ml" 45296 45296 + # 45297 "parsing/parser.ml" 45309 45297 in 45310 45298 { 45311 45299 MenhirLib.EngineTypes.state = _menhir_s; ··· 45333 45321 let xs = 45334 45322 # 253 "<standard.mly>" 45335 45323 ( List.rev xs ) 45336 45336 - # 45337 "parsing/parser.ml" 45324 45324 + # 45325 "parsing/parser.ml" 45337 45325 in 45338 45326 45339 45327 # 1045 "parsing/parser.mly" 45340 45328 ( xs ) 45341 45341 - # 45342 "parsing/parser.ml" 45329 45329 + # 45330 "parsing/parser.ml" 45342 45330 45343 45331 in 45344 45332 45345 45333 # 3349 "parsing/parser.mly" 45346 45334 ( Ptyp_tuple tys ) 45347 45347 - # 45348 "parsing/parser.ml" 45335 45335 + # 45336 "parsing/parser.ml" 45348 45336 45349 45337 in 45350 45338 let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in ··· 45354 45342 45355 45343 # 920 "parsing/parser.mly" 45356 45344 ( mktyp ~loc:_sloc _1 ) 45357 45357 - # 45358 "parsing/parser.ml" 45345 45345 + # 45346 "parsing/parser.ml" 45358 45346 45359 45347 in 45360 45348 45361 45349 # 3351 "parsing/parser.mly" 45362 45350 ( _1 ) 45363 45363 - # 45364 "parsing/parser.ml" 45351 45351 + # 45352 "parsing/parser.ml" 45364 45352 in 45365 45353 { 45366 45354 MenhirLib.EngineTypes.state = _menhir_s; ··· 45392 45380 let _v : (Parsetree.core_type option * Parsetree.core_type option) = 45393 45381 # 2667 "parsing/parser.mly" 45394 45382 ( (Some _2, None) ) 45395 45395 - # 45396 "parsing/parser.ml" 45383 45383 + # 45384 "parsing/parser.ml" 45396 45384 in 45397 45385 { 45398 45386 MenhirLib.EngineTypes.state = _menhir_s; ··· 45438 45426 let _v : (Parsetree.core_type option * Parsetree.core_type option) = 45439 45427 # 2668 "parsing/parser.mly" 45440 45428 ( (Some _2, Some _4) ) 45441 45441 - # 45442 "parsing/parser.ml" 45429 45429 + # 45430 "parsing/parser.ml" 45442 45430 in 45443 45431 { 45444 45432 MenhirLib.EngineTypes.state = _menhir_s; ··· 45470 45458 let _v : (Parsetree.core_type option * Parsetree.core_type option) = 45471 45459 # 2669 "parsing/parser.mly" 45472 45460 ( (None, Some _2) ) 45473 45473 - # 45474 "parsing/parser.ml" 45461 45461 + # 45462 "parsing/parser.ml" 45474 45462 in 45475 45463 { 45476 45464 MenhirLib.EngineTypes.state = _menhir_s; ··· 45502 45490 let _v : (Parsetree.core_type option * Parsetree.core_type option) = 45503 45491 # 2670 "parsing/parser.mly" 45504 45492 ( syntax_error() ) 45505 45505 - # 45506 "parsing/parser.ml" 45493 45493 + # 45494 "parsing/parser.ml" 45506 45494 in 45507 45495 { 45508 45496 MenhirLib.EngineTypes.state = _menhir_s; ··· 45534 45522 let _v : (Parsetree.core_type option * Parsetree.core_type option) = 45535 45523 # 2671 "parsing/parser.mly" 45536 45524 ( syntax_error() ) 45537 45537 - # 45538 "parsing/parser.ml" 45525 45525 + # 45526 "parsing/parser.ml" 45538 45526 in 45539 45527 { 45540 45528 MenhirLib.EngineTypes.state = _menhir_s; ··· 45552 45540 let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = 45553 45541 # 3000 "parsing/parser.mly" 45554 45542 ( (Ptype_abstract, Public, None) ) 45555 45555 - # 45556 "parsing/parser.ml" 45543 45543 + # 45544 "parsing/parser.ml" 45556 45544 in 45557 45545 { 45558 45546 MenhirLib.EngineTypes.state = _menhir_s; ··· 45584 45572 let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = 45585 45573 # 3002 "parsing/parser.mly" 45586 45574 ( _2 ) 45587 45587 - # 45588 "parsing/parser.ml" 45575 45575 + # 45576 "parsing/parser.ml" 45588 45576 in 45589 45577 { 45590 45578 MenhirLib.EngineTypes.state = _menhir_s; ··· 45609 45597 let _v : (Longident.t) = 45610 45598 # 3605 "parsing/parser.mly" 45611 45599 ( _1 ) 45612 45612 - # 45613 "parsing/parser.ml" 45600 45600 + # 45601 "parsing/parser.ml" 45613 45601 in 45614 45602 { 45615 45603 MenhirLib.EngineTypes.state = _menhir_s; ··· 45641 45629 let _v : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) = 45642 45630 # 3017 "parsing/parser.mly" 45643 45631 ( _2, _1 ) 45644 45644 - # 45645 "parsing/parser.ml" 45632 45632 + # 45633 "parsing/parser.ml" 45645 45633 in 45646 45634 { 45647 45635 MenhirLib.EngineTypes.state = _menhir_s; ··· 45659 45647 let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = 45660 45648 # 3010 "parsing/parser.mly" 45661 45649 ( [] ) 45662 45662 - # 45663 "parsing/parser.ml" 45650 45650 + # 45651 "parsing/parser.ml" 45663 45651 in 45664 45652 { 45665 45653 MenhirLib.EngineTypes.state = _menhir_s; ··· 45684 45672 let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = 45685 45673 # 3012 "parsing/parser.mly" 45686 45674 ( [p] ) 45687 45687 - # 45688 "parsing/parser.ml" 45675 45675 + # 45676 "parsing/parser.ml" 45688 45676 in 45689 45677 { 45690 45678 MenhirLib.EngineTypes.state = _menhir_s; ··· 45724 45712 let xs = 45725 45713 # 253 "<standard.mly>" 45726 45714 ( List.rev xs ) 45727 45727 - # 45728 "parsing/parser.ml" 45715 45715 + # 45716 "parsing/parser.ml" 45728 45716 in 45729 45717 45730 45718 # 1017 "parsing/parser.mly" 45731 45719 ( xs ) 45732 45732 - # 45733 "parsing/parser.ml" 45720 45720 + # 45721 "parsing/parser.ml" 45733 45721 45734 45722 in 45735 45723 45736 45724 # 3014 "parsing/parser.mly" 45737 45725 ( ps ) 45738 45738 - # 45739 "parsing/parser.ml" 45726 45726 + # 45727 "parsing/parser.ml" 45739 45727 in 45740 45728 { 45741 45729 MenhirLib.EngineTypes.state = _menhir_s; ··· 45768 45756 let _1 = 45769 45757 # 3022 "parsing/parser.mly" 45770 45758 ( Ptyp_var tyvar ) 45771 45771 - # 45772 "parsing/parser.ml" 45759 45759 + # 45760 "parsing/parser.ml" 45772 45760 in 45773 45761 let _endpos__1_ = _endpos_tyvar_ in 45774 45762 let _endpos = _endpos__1_ in ··· 45777 45765 45778 45766 # 920 "parsing/parser.mly" 45779 45767 ( mktyp ~loc:_sloc _1 ) 45780 45780 - # 45781 "parsing/parser.ml" 45768 45768 + # 45769 "parsing/parser.ml" 45781 45769 45782 45770 in 45783 45771 45784 45772 # 3025 "parsing/parser.mly" 45785 45773 ( _1 ) 45786 45786 - # 45787 "parsing/parser.ml" 45774 45774 + # 45775 "parsing/parser.ml" 45787 45775 in 45788 45776 { 45789 45777 MenhirLib.EngineTypes.state = _menhir_s; ··· 45809 45797 let _1 = 45810 45798 # 3024 "parsing/parser.mly" 45811 45799 ( Ptyp_any ) 45812 45812 - # 45813 "parsing/parser.ml" 45800 45800 + # 45801 "parsing/parser.ml" 45813 45801 in 45814 45802 let _endpos = _endpos__1_ in 45815 45803 let _symbolstartpos = _startpos__1_ in ··· 45817 45805 45818 45806 # 920 "parsing/parser.mly" 45819 45807 ( mktyp ~loc:_sloc _1 ) 45820 45820 - # 45821 "parsing/parser.ml" 45808 45808 + # 45809 "parsing/parser.ml" 45821 45809 45822 45810 in 45823 45811 45824 45812 # 3025 "parsing/parser.mly" 45825 45813 ( _1 ) 45826 45826 - # 45827 "parsing/parser.ml" 45814 45814 + # 45815 "parsing/parser.ml" 45827 45815 in 45828 45816 { 45829 45817 MenhirLib.EngineTypes.state = _menhir_s; ··· 45841 45829 let _v : (Asttypes.variance * Asttypes.injectivity) = 45842 45830 # 3029 "parsing/parser.mly" 45843 45831 ( NoVariance, NoInjectivity ) 45844 45844 - # 45845 "parsing/parser.ml" 45832 45832 + # 45833 "parsing/parser.ml" 45845 45833 in 45846 45834 { 45847 45835 MenhirLib.EngineTypes.state = _menhir_s; ··· 45866 45854 let _v : (Asttypes.variance * Asttypes.injectivity) = 45867 45855 # 3030 "parsing/parser.mly" 45868 45856 ( Covariant, NoInjectivity ) 45869 45869 - # 45870 "parsing/parser.ml" 45857 45857 + # 45858 "parsing/parser.ml" 45870 45858 in 45871 45859 { 45872 45860 MenhirLib.EngineTypes.state = _menhir_s; ··· 45891 45879 let _v : (Asttypes.variance * Asttypes.injectivity) = 45892 45880 # 3031 "parsing/parser.mly" 45893 45881 ( Contravariant, NoInjectivity ) 45894 45894 - # 45895 "parsing/parser.ml" 45882 45882 + # 45883 "parsing/parser.ml" 45895 45883 in 45896 45884 { 45897 45885 MenhirLib.EngineTypes.state = _menhir_s; ··· 45916 45904 let _v : (Asttypes.variance * Asttypes.injectivity) = 45917 45905 # 3032 "parsing/parser.mly" 45918 45906 ( NoVariance, Injective ) 45919 45919 - # 45920 "parsing/parser.ml" 45907 45907 + # 45908 "parsing/parser.ml" 45920 45908 in 45921 45909 { 45922 45910 MenhirLib.EngineTypes.state = _menhir_s; ··· 45948 45936 let _v : (Asttypes.variance * Asttypes.injectivity) = 45949 45937 # 3033 "parsing/parser.mly" 45950 45938 ( Covariant, Injective ) 45951 45951 - # 45952 "parsing/parser.ml" 45939 45939 + # 45940 "parsing/parser.ml" 45952 45940 in 45953 45941 { 45954 45942 MenhirLib.EngineTypes.state = _menhir_s; ··· 45980 45968 let _v : (Asttypes.variance * Asttypes.injectivity) = 45981 45969 # 3033 "parsing/parser.mly" 45982 45970 ( Covariant, Injective ) 45983 45983 - # 45984 "parsing/parser.ml" 45971 45971 + # 45972 "parsing/parser.ml" 45984 45972 in 45985 45973 { 45986 45974 MenhirLib.EngineTypes.state = _menhir_s; ··· 46012 46000 let _v : (Asttypes.variance * Asttypes.injectivity) = 46013 46001 # 3034 "parsing/parser.mly" 46014 46002 ( Contravariant, Injective ) 46015 46015 - # 46016 "parsing/parser.ml" 46003 46003 + # 46004 "parsing/parser.ml" 46016 46004 in 46017 46005 { 46018 46006 MenhirLib.EngineTypes.state = _menhir_s; ··· 46044 46032 let _v : (Asttypes.variance * Asttypes.injectivity) = 46045 46033 # 3034 "parsing/parser.mly" 46046 46034 ( Contravariant, Injective ) 46047 46047 - # 46048 "parsing/parser.ml" 46035 46035 + # 46036 "parsing/parser.ml" 46048 46036 in 46049 46037 { 46050 46038 MenhirLib.EngineTypes.state = _menhir_s; ··· 46065 46053 let _1 : ( 46066 46054 # 683 "parsing/parser.mly" 46067 46055 (string) 46068 46068 - # 46069 "parsing/parser.ml" 46056 46056 + # 46057 "parsing/parser.ml" 46069 46057 ) = Obj.magic _1 in 46070 46058 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 46071 46059 let _startpos = _startpos__1_ in ··· 46076 46064 ( if _1 = "+!" then Covariant, Injective else 46077 46065 if _1 = "-!" then Contravariant, Injective else 46078 46066 expecting _loc__1_ "type_variance" ) 46079 46079 - # 46080 "parsing/parser.ml" 46067 46067 + # 46068 "parsing/parser.ml" 46080 46068 in 46081 46069 { 46082 46070 MenhirLib.EngineTypes.state = _menhir_s; ··· 46097 46085 let _1 : ( 46098 46086 # 729 "parsing/parser.mly" 46099 46087 (string) 46100 46100 - # 46101 "parsing/parser.ml" 46088 46088 + # 46089 "parsing/parser.ml" 46101 46089 ) = Obj.magic _1 in 46102 46090 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 46103 46091 let _startpos = _startpos__1_ in ··· 46108 46096 ( if _1 = "!+" then Covariant, Injective else 46109 46097 if _1 = "!-" then Contravariant, Injective else 46110 46098 expecting _loc__1_ "type_variance" ) 46111 46111 - # 46112 "parsing/parser.ml" 46099 46099 + # 46100 "parsing/parser.ml" 46112 46100 in 46113 46101 { 46114 46102 MenhirLib.EngineTypes.state = _menhir_s; ··· 46142 46130 let ys = 46143 46131 # 260 "<standard.mly>" 46144 46132 ( List.flatten xss ) 46145 46145 - # 46146 "parsing/parser.ml" 46133 46133 + # 46134 "parsing/parser.ml" 46146 46134 in 46147 46135 let xs = 46148 46136 let _1 = 46149 46137 # 953 "parsing/parser.mly" 46150 46138 ( [] ) 46151 46151 - # 46152 "parsing/parser.ml" 46139 46139 + # 46140 "parsing/parser.ml" 46152 46140 in 46153 46141 46154 46142 # 1185 "parsing/parser.mly" 46155 46143 ( _1 ) 46156 46156 - # 46157 "parsing/parser.ml" 46144 46144 + # 46145 "parsing/parser.ml" 46157 46145 46158 46146 in 46159 46147 46160 46148 # 267 "<standard.mly>" 46161 46149 ( xs @ ys ) 46162 46162 - # 46163 "parsing/parser.ml" 46150 46150 + # 46151 "parsing/parser.ml" 46163 46151 46164 46152 in 46165 46153 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in ··· 46168 46156 46169 46157 # 879 "parsing/parser.mly" 46170 46158 ( extra_def _startpos _endpos _1 ) 46171 46171 - # 46172 "parsing/parser.ml" 46159 46159 + # 46160 "parsing/parser.ml" 46172 46160 46173 46161 in 46174 46162 46175 46163 # 1178 "parsing/parser.mly" 46176 46164 ( _1 ) 46177 46177 - # 46178 "parsing/parser.ml" 46165 46165 + # 46166 "parsing/parser.ml" 46178 46166 in 46179 46167 { 46180 46168 MenhirLib.EngineTypes.state = _menhir_s; ··· 46222 46210 let ys = 46223 46211 # 260 "<standard.mly>" 46224 46212 ( List.flatten xss ) 46225 46225 - # 46226 "parsing/parser.ml" 46213 46213 + # 46214 "parsing/parser.ml" 46226 46214 in 46227 46215 let xs = 46228 46216 let _1 = ··· 46232 46220 let attrs = 46233 46221 # 3836 "parsing/parser.mly" 46234 46222 ( _1 ) 46235 46235 - # 46236 "parsing/parser.ml" 46223 46223 + # 46224 "parsing/parser.ml" 46236 46224 in 46237 46225 46238 46226 # 1379 "parsing/parser.mly" 46239 46227 ( mkstrexp e attrs ) 46240 46240 - # 46241 "parsing/parser.ml" 46228 46228 + # 46229 "parsing/parser.ml" 46241 46229 46242 46230 in 46243 46231 46244 46232 # 897 "parsing/parser.mly" 46245 46233 ( Ptop_def [_1] ) 46246 46246 - # 46247 "parsing/parser.ml" 46234 46234 + # 46235 "parsing/parser.ml" 46247 46235 46248 46236 in 46249 46237 let _startpos__1_ = _startpos_e_ in ··· 46251 46239 46252 46240 # 895 "parsing/parser.mly" 46253 46241 ( text_def _startpos @ [_1] ) 46254 46254 - # 46255 "parsing/parser.ml" 46242 46242 + # 46243 "parsing/parser.ml" 46255 46243 46256 46244 in 46257 46245 46258 46246 # 955 "parsing/parser.mly" 46259 46247 ( x ) 46260 46260 - # 46261 "parsing/parser.ml" 46248 46248 + # 46249 "parsing/parser.ml" 46261 46249 46262 46250 in 46263 46251 46264 46252 # 1185 "parsing/parser.mly" 46265 46253 ( _1 ) 46266 46266 - # 46267 "parsing/parser.ml" 46254 46254 + # 46255 "parsing/parser.ml" 46267 46255 46268 46256 in 46269 46257 46270 46258 # 267 "<standard.mly>" 46271 46259 ( xs @ ys ) 46272 46272 - # 46273 "parsing/parser.ml" 46260 46260 + # 46261 "parsing/parser.ml" 46273 46261 46274 46262 in 46275 46263 let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in ··· 46278 46266 46279 46267 # 879 "parsing/parser.mly" 46280 46268 ( extra_def _startpos _endpos _1 ) 46281 46281 - # 46282 "parsing/parser.ml" 46269 46269 + # 46270 "parsing/parser.ml" 46282 46270 46283 46271 in 46284 46272 46285 46273 # 1178 "parsing/parser.mly" 46286 46274 ( _1 ) 46287 46287 - # 46288 "parsing/parser.ml" 46275 46275 + # 46276 "parsing/parser.ml" 46288 46276 in 46289 46277 { 46290 46278 MenhirLib.EngineTypes.state = _menhir_s; ··· 46323 46311 let _v : (Asttypes.label) = 46324 46312 # 3524 "parsing/parser.mly" 46325 46313 ( _2 ) 46326 46326 - # 46327 "parsing/parser.ml" 46314 46314 + # 46315 "parsing/parser.ml" 46327 46315 in 46328 46316 { 46329 46317 MenhirLib.EngineTypes.state = _menhir_s; ··· 46364 46352 46365 46353 # 3525 "parsing/parser.mly" 46366 46354 ( unclosed "(" _loc__1_ ")" _loc__3_ ) 46367 46367 - # 46368 "parsing/parser.ml" 46355 46355 + # 46356 "parsing/parser.ml" 46368 46356 in 46369 46357 { 46370 46358 MenhirLib.EngineTypes.state = _menhir_s; ··· 46397 46385 46398 46386 # 3526 "parsing/parser.mly" 46399 46387 ( expecting _loc__2_ "operator" ) 46400 46400 - # 46401 "parsing/parser.ml" 46388 46388 + # 46389 "parsing/parser.ml" 46401 46389 in 46402 46390 { 46403 46391 MenhirLib.EngineTypes.state = _menhir_s; ··· 46437 46425 46438 46426 # 3527 "parsing/parser.mly" 46439 46427 ( expecting _loc__3_ "module-expr" ) 46440 46440 - # 46441 "parsing/parser.ml" 46428 46428 + # 46429 "parsing/parser.ml" 46441 46429 in 46442 46430 { 46443 46431 MenhirLib.EngineTypes.state = _menhir_s; ··· 46458 46446 let _1 : ( 46459 46447 # 705 "parsing/parser.mly" 46460 46448 (string) 46461 46461 - # 46462 "parsing/parser.ml" 46449 46449 + # 46450 "parsing/parser.ml" 46462 46450 ) = Obj.magic _1 in 46463 46451 let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in 46464 46452 let _startpos = _startpos__1_ in ··· 46466 46454 let _v : (Asttypes.label) = 46467 46455 # 3530 "parsing/parser.mly" 46468 46456 ( _1 ) 46469 46469 - # 46470 "parsing/parser.ml" 46457 46457 + # 46458 "parsing/parser.ml" 46470 46458 in 46471 46459 { 46472 46460 MenhirLib.EngineTypes.state = _menhir_s; ··· 46491 46479 let _v : (Asttypes.label) = 46492 46480 # 3531 "parsing/parser.mly" 46493 46481 ( _1 ) 46494 46494 - # 46495 "parsing/parser.ml" 46482 46482 + # 46483 "parsing/parser.ml" 46495 46483 in 46496 46484 { 46497 46485 MenhirLib.EngineTypes.state = _menhir_s; ··· 46516 46504 let _v : (Longident.t) = 46517 46505 # 3599 "parsing/parser.mly" 46518 46506 ( _1 ) 46519 46519 - # 46520 "parsing/parser.ml" 46507 46507 + # 46508 "parsing/parser.ml" 46520 46508 in 46521 46509 { 46522 46510 MenhirLib.EngineTypes.state = _menhir_s; ··· 46563 46551 let _1_inlined1 : ( 46564 46552 # 705 "parsing/parser.mly" 46565 46553 (string) 46566 46566 - # 46567 "parsing/parser.ml" 46554 46554 + # 46555 "parsing/parser.ml" 46567 46555 ) = Obj.magic _1_inlined1 in 46568 46556 let mutable_ : (Asttypes.mutable_flag) = Obj.magic mutable_ in 46569 46557 let _1 : (Parsetree.attributes) = Obj.magic _1 in ··· 46577 46565 let _1 = 46578 46566 # 3498 "parsing/parser.mly" 46579 46567 ( _1 ) 46580 46580 - # 46581 "parsing/parser.ml" 46568 46568 + # 46569 "parsing/parser.ml" 46581 46569 in 46582 46570 let _endpos = _endpos__1_ in 46583 46571 let _symbolstartpos = _startpos__1_ in ··· 46585 46573 46586 46574 # 883 "parsing/parser.mly" 46587 46575 ( mkrhs _1 _sloc ) 46588 46588 - # 46589 "parsing/parser.ml" 46576 46576 + # 46577 "parsing/parser.ml" 46589 46577 46590 46578 in 46591 46579 let attrs = 46592 46580 # 3840 "parsing/parser.mly" 46593 46581 ( _1 ) 46594 46594 - # 46595 "parsing/parser.ml" 46582 46582 + # 46583 "parsing/parser.ml" 46595 46583 in 46596 46584 let _1 = 46597 46585 # 3739 "parsing/parser.mly" 46598 46586 ( Fresh ) 46599 46599 - # 46600 "parsing/parser.ml" 46587 46587 + # 46588 "parsing/parser.ml" 46600 46588 in 46601 46589 46602 46590 # 1951 "parsing/parser.mly" 46603 46591 ( (label, mutable_, Cfk_virtual ty), attrs ) 46604 46604 - # 46605 "parsing/parser.ml" 46592 46592 + # 46593 "parsing/parser.ml" 46605 46593 in 46606 46594 { 46607 46595 MenhirLib.EngineTypes.state = _menhir_s; ··· 46648 46636 let _1_inlined1 : ( 46649 46637 # 705 "parsing/parser.mly" 46650 46638 (string) 46651 46651 - # 46652 "parsing/parser.ml" 46639 46639 + # 46640 "parsing/parser.ml" 46652 46640 ) = Obj.magic _1_inlined1 in 46653 46641 let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in 46654 46642 let _1 : (Parsetree.attributes) = Obj.magic _1 in ··· 46662 46650 let _1 = 46663 46651 # 3498 "parsing/parser.mly" 46664 46652 ( _1 ) 46665 46665 - # 46666 "parsing/parser.ml" 46653 46653 + # 46654 "parsing/parser.ml" 46666 46654 in 46667 46655 let _endpos = _endpos__1_ in 46668 46656 let _symbolstartpos = _startpos__1_ in ··· 46670 46658 46671 46659 # 883 "parsing/parser.mly" 46672 46660 ( mkrhs _1 _sloc ) 46673 46673 - # 46674 "parsing/parser.ml" 46661 46661 + # 46662 "parsing/parser.ml" 46674 46662 46675 46663 in 46676 46664 let _2 = 46677 46665 # 3840 "parsing/parser.mly" 46678 46666 ( _1 ) 46679 46679 - # 46680 "parsing/parser.ml" 46667 46667 + # 46668 "parsing/parser.ml" 46680 46668 in 46681 46669 let _1 = 46682 46670 # 3742 "parsing/parser.mly" 46683 46671 ( Fresh ) 46684 46684 - # 46685 "parsing/parser.ml" 46672 46672 + # 46673 "parsing/parser.ml" 46685 46673 in 46686 46674 46687 46675 # 1953 "parsing/parser.mly" 46688 46676 ( (_4, _3, Cfk_concrete (_1, _6)), _2 ) 46689 46689 - # 46690 "parsing/parser.ml" 46677 46677 + # 46678 "parsing/parser.ml" 46690 46678 in 46691 46679 { 46692 46680 MenhirLib.EngineTypes.state = _menhir_s; ··· 46739 46727 let _1_inlined2 : ( 46740 46728 # 705 "parsing/parser.mly" 46741 46729 (string) 46742 46742 - # 46743 "parsing/parser.ml" 46730 46730 + # 46731 "parsing/parser.ml" 46743 46731 ) = Obj.magic _1_inlined2 in 46744 46732 let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in 46745 46733 let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in ··· 46754 46742 let _1 = 46755 46743 # 3498 "parsing/parser.mly" 46756 46744 ( _1 ) 46757 46757 - # 46758 "parsing/parser.ml" 46745 46745 + # 46746 "parsing/parser.ml" 46758 46746 in 46759 46747 let _endpos = _endpos__1_ in 46760 46748 let _symbolstartpos = _startpos__1_ in ··· 46762 46750 46763 46751 # 883 "parsing/parser.mly" 46764 46752 ( mkrhs _1 _sloc ) 46765 46765 - # 46766 "parsing/parser.ml" 46753 46753 + # 46754 "parsing/parser.ml" 46766 46754 46767 46755 in 46768 46756 let _2 = ··· 46770 46758 46771 46759 # 3840 "parsing/parser.mly" 46772 46760 ( _1 ) 46773 46773 - # 46774 "parsing/parser.ml" 46761 46761 + # 46762 "parsing/parser.ml" 46774 46762 46775 46763 in 46776 46764 let _1 = 46777 46765 # 3743 "parsing/parser.mly" 46778 46766 ( Override ) 46779 46779 - # 46780 "parsing/parser.ml" 46767 46767 + # 46768 "parsing/parser.ml" 46780 46768 in 46781 46769 46782 46770 # 1953 "parsing/parser.mly" 46783 46771 ( (_4, _3, Cfk_concrete (_1, _6)), _2 ) 46784 46784 - # 46785 "parsing/parser.ml" 46772 46772 + # 46773 "parsing/parser.ml" 46785 46773 in 46786 46774 { 46787 46775 MenhirLib.EngineTypes.state = _menhir_s; ··· 46835 46823 let _1_inlined1 : ( 46836 46824 # 705 "parsing/parser.mly" 46837 46825 (string) 46838 46838 - # 46839 "parsing/parser.ml" 46826 46826 + # 46827 "parsing/parser.ml" 46839 46827 ) = Obj.magic _1_inlined1 in 46840 46828 let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in 46841 46829 let _1 : (Parsetree.attributes) = Obj.magic _1 in ··· 46849 46837 let _1 = 46850 46838 # 3498 "parsing/parser.mly" 46851 46839 ( _1 ) 46852 46852 - # 46853 "parsing/parser.ml" 46840 46840 + # 46841 "parsing/parser.ml" 46853 46841 in 46854 46842 let _endpos = _endpos__1_ in 46855 46843 let _symbolstartpos = _startpos__1_ in ··· 46857 46845 46858 46846 # 883 "parsing/parser.mly" 46859 46847 ( mkrhs _1 _sloc ) 46860 46860 - # 46861 "parsing/parser.ml" 46848 46848 + # 46849 "parsing/parser.ml" 46861 46849 46862 46850 in 46863 46851 let _startpos__4_ = _startpos__1_inlined1_ in 46864 46852 let _2 = 46865 46853 # 3840 "parsing/parser.mly" 46866 46854 ( _1 ) 46867 46867 - # 46868 "parsing/parser.ml" 46855 46855 + # 46856 "parsing/parser.ml" 46868 46856 in 46869 46857 let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in 46870 46858 let _1 = 46871 46859 # 3742 "parsing/parser.mly" 46872 46860 ( Fresh ) 46873 46873 - # 46874 "parsing/parser.ml" 46861 46861 + # 46862 "parsing/parser.ml" 46874 46862 in 46875 46863 let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in 46876 46864 let _endpos = _endpos__7_ in ··· 46890 46878 ( let e = mkexp_constraint ~loc:_sloc _7 _5 in 46891 46879 (_4, _3, Cfk_concrete (_1, e)), _2 46892 46880 ) 46893 46893 - # 46894 "parsing/parser.ml" 46881 46881 + # 46882 "parsing/parser.ml" 46894 46882 in 46895 46883 { 46896 46884 MenhirLib.EngineTypes.state = _menhir_s; ··· 46950 46938 let _1_inlined2 : ( 46951 46939 # 705 "parsing/parser.mly" 46952 46940 (string) 46953 46953 - # 46954 "parsing/parser.ml" 46941 46941 + # 46942 "parsing/parser.ml" 46954 46942 ) = Obj.magic _1_inlined2 in 46955 46943 let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in 46956 46944 let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in ··· 46965 46953 let _1 = 46966 46954 # 3498 "parsing/parser.mly" 46967 46955 ( _1 ) 46968 46968 - # 46969 "parsing/parser.ml" 46956 46956 + # 46957 "parsing/parser.ml" 46969 46957 in 46970 46958 let _endpos = _endpos__1_ in 46971 46959 let _symbolstartpos = _startpos__1_ in ··· 46973 46961 46974 46962 # 883 "parsing/parser.mly" 46975 46963 ( mkrhs _1 _sloc ) 46976 46976 - # 46977 "parsing/parser.ml" 46964 46964 + # 46965 "parsing/parser.ml" 46977 46965 46978 46966 in 46979 46967 let _startpos__4_ = _startpos__1_inlined2_ in ··· 46982 46970 46983 46971 # 3840 "parsing/parser.mly" 46984 46972 ( _1 ) 46985 46985 - # 46986 "parsing/parser.ml" 46973 46973 + # 46974 "parsing/parser.ml" 46986 46974 46987 46975 in 46988 46976 let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in 46989 46977 let _1 = 46990 46978 # 3743 "parsing/parser.mly" 46991 46979 ( Override ) 46992 46992 - # 46993 "parsing/parser.ml" 46980 46980 + # 46981 "parsing/parser.ml" 46993 46981 in 46994 46982 let _endpos = _endpos__7_ in 46995 46983 let _symbolstartpos = if _startpos__1_ != _endpos__1_ then ··· 47008 46996 ( let e = mkexp_constraint ~loc:_sloc _7 _5 in 47009 46997 (_4, _3, Cfk_concrete (_1, e)), _2 47010 46998 ) 47011 47011 - # 47012 "parsing/parser.ml" 46999 46999 + # 47000 "parsing/parser.ml" 47012 47000 in 47013 47001 { 47014 47002 MenhirLib.EngineTypes.state = _menhir_s; ··· 47077 47065 47078 47066 # 3836 "parsing/parser.mly" 47079 47067 ( _1 ) 47080 47080 - # 47081 "parsing/parser.ml" 47068 47068 + # 47069 "parsing/parser.ml" 47081 47069 47082 47070 in 47083 47071 let _endpos_attrs2_ = _endpos__1_inlined3_ in ··· 47089 47077 47090 47078 # 883 "parsing/parser.mly" 47091 47079 ( mkrhs _1 _sloc ) 47092 47092 - # 47093 "parsing/parser.ml" 47080 47080 + # 47081 "parsing/parser.ml" 47093 47081 47094 47082 in 47095 47083 let attrs1 = ··· 47097 47085 47098 47086 # 3840 "parsing/parser.mly" 47099 47087 ( _1 ) 47100 47100 - # 47101 "parsing/parser.ml" 47088 47088 + # 47089 "parsing/parser.ml" 47101 47089 47102 47090 in 47103 47091 let _endpos = _endpos_attrs2_ in ··· 47110 47098 let docs = symbol_docs _sloc in 47111 47099 Val.mk id ty ~attrs ~loc ~docs, 47112 47100 ext ) 47113 47113 - # 47114 "parsing/parser.ml" 47101 47101 + # 47102 "parsing/parser.ml" 47114 47102 in 47115 47103 { 47116 47104 MenhirLib.EngineTypes.state = _menhir_s; ··· 47128 47116 let _v : (Asttypes.virtual_flag) = 47129 47117 # 3703 "parsing/parser.mly" 47130 47118 ( Concrete ) 47131 47131 - # 47132 "parsing/parser.ml" 47119 47119 + # 47120 "parsing/parser.ml" 47132 47120 in 47133 47121 { 47134 47122 MenhirLib.EngineTypes.state = _menhir_s; ··· 47153 47141 let _v : (Asttypes.virtual_flag) = 47154 47142 # 3704 "parsing/parser.mly" 47155 47143 ( Virtual ) 47156 47156 - # 47157 "parsing/parser.ml" 47144 47144 + # 47145 "parsing/parser.ml" 47157 47145 in 47158 47146 { 47159 47147 MenhirLib.EngineTypes.state = _menhir_s; ··· 47178 47166 let _v : (Asttypes.mutable_flag) = 47179 47167 # 3727 "parsing/parser.mly" 47180 47168 ( Immutable ) 47181 47181 - # 47182 "parsing/parser.ml" 47169 47169 + # 47170 "parsing/parser.ml" 47182 47170 in 47183 47171 { 47184 47172 MenhirLib.EngineTypes.state = _menhir_s; ··· 47210 47198 let _v : (Asttypes.mutable_flag) = 47211 47199 # 3728 "parsing/parser.mly" 47212 47200 ( Mutable ) 47213 47213 - # 47214 "parsing/parser.ml" 47201 47201 + # 47202 "parsing/parser.ml" 47214 47202 in 47215 47203 { 47216 47204 MenhirLib.EngineTypes.state = _menhir_s; ··· 47242 47230 let _v : (Asttypes.mutable_flag) = 47243 47231 # 3729 "parsing/parser.mly" 47244 47232 ( Mutable ) 47245 47245 - # 47246 "parsing/parser.ml" 47233 47233 + # 47234 "parsing/parser.ml" 47246 47234 in 47247 47235 { 47248 47236 MenhirLib.EngineTypes.state = _menhir_s; ··· 47267 47255 let _v : (Asttypes.private_flag) = 47268 47256 # 3734 "parsing/parser.mly" 47269 47257 ( Public ) 47270 47270 - # 47271 "parsing/parser.ml" 47258 47258 + # 47259 "parsing/parser.ml" 47271 47259 in 47272 47260 { 47273 47261 MenhirLib.EngineTypes.state = _menhir_s; ··· 47299 47287 let _v : (Asttypes.private_flag) = 47300 47288 # 3735 "parsing/parser.mly" 47301 47289 ( Private ) 47302 47302 - # 47303 "parsing/parser.ml" 47290 47290 + # 47291 "parsing/parser.ml" 47303 47291 in 47304 47292 { 47305 47293 MenhirLib.EngineTypes.state = _menhir_s; ··· 47331 47319 let _v : (Asttypes.private_flag) = 47332 47320 # 3736 "parsing/parser.mly" 47333 47321 ( Private ) 47334 47334 - # 47335 "parsing/parser.ml" 47322 47322 + # 47323 "parsing/parser.ml" 47335 47323 in 47336 47324 { 47337 47325 MenhirLib.EngineTypes.state = _menhir_s; ··· 47393 47381 let xs = 47394 47382 # 253 "<standard.mly>" 47395 47383 ( List.rev xs ) 47396 47396 - # 47397 "parsing/parser.ml" 47384 47384 + # 47385 "parsing/parser.ml" 47397 47385 in 47398 47386 47399 47387 # 967 "parsing/parser.mly" 47400 47388 ( xs ) 47401 47401 - # 47402 "parsing/parser.ml" 47389 47389 + # 47390 "parsing/parser.ml" 47402 47390 47403 47391 in 47404 47392 47405 47393 # 2971 "parsing/parser.mly" 47406 47394 ( _1 ) 47407 47407 - # 47408 "parsing/parser.ml" 47395 47395 + # 47396 "parsing/parser.ml" 47408 47396 47409 47397 in 47410 47398 let _endpos__6_ = _endpos_xs_ in ··· 47413 47401 47414 47402 # 3294 "parsing/parser.mly" 47415 47403 ( _1 ) 47416 47416 - # 47417 "parsing/parser.ml" 47404 47404 + # 47405 "parsing/parser.ml" 47417 47405 47418 47406 in 47419 47407 let _3 = ··· 47424 47412 47425 47413 # 883 "parsing/parser.mly" 47426 47414 ( mkrhs _1 _sloc ) 47427 47427 - # 47428 "parsing/parser.ml" 47415 47415 + # 47416 "parsing/parser.ml" 47428 47416 47429 47417 in 47430 47418 let _endpos = _endpos__6_ in ··· 47441 47429 ~manifest:_5 47442 47430 ~priv:_4 47443 47431 ~loc:(make_loc _sloc))) ) 47444 47444 - # 47445 "parsing/parser.ml" 47432 47432 + # 47433 "parsing/parser.ml" 47445 47433 in 47446 47434 { 47447 47435 MenhirLib.EngineTypes.state = _menhir_s; ··· 47496 47484 47497 47485 # 3294 "parsing/parser.mly" 47498 47486 ( _1 ) 47499 47499 - # 47500 "parsing/parser.ml" 47487 47487 + # 47488 "parsing/parser.ml" 47500 47488 47501 47489 in 47502 47490 let _endpos__5_ = _endpos__1_inlined2_ in ··· 47508 47496 47509 47497 # 883 "parsing/parser.mly" 47510 47498 ( mkrhs _1 _sloc ) 47511 47511 - # 47512 "parsing/parser.ml" 47499 47499 + # 47500 "parsing/parser.ml" 47512 47500 47513 47501 in 47514 47502 let _endpos = _endpos__5_ in ··· 47523 47511 ~params:_2 47524 47512 ~manifest:_5 47525 47513 ~loc:(make_loc _sloc))) ) 47526 47526 - # 47527 "parsing/parser.ml" 47514 47514 + # 47515 "parsing/parser.ml" 47527 47515 in 47528 47516 { 47529 47517 MenhirLib.EngineTypes.state = _menhir_s; ··· 47574 47562 47575 47563 # 883 "parsing/parser.mly" 47576 47564 ( mkrhs _1 _sloc ) 47577 47577 - # 47578 "parsing/parser.ml" 47565 47565 + # 47566 "parsing/parser.ml" 47578 47566 47579 47567 in 47580 47568 let _2 = ··· 47585 47573 47586 47574 # 883 "parsing/parser.mly" 47587 47575 ( mkrhs _1 _sloc ) 47588 47588 - # 47589 "parsing/parser.ml" 47576 47576 + # 47577 "parsing/parser.ml" 47589 47577 47590 47578 in 47591 47579 47592 47580 # 3234 "parsing/parser.mly" 47593 47581 ( Pwith_module (_2, _4) ) 47594 47594 - # 47595 "parsing/parser.ml" 47582 47582 + # 47583 "parsing/parser.ml" 47595 47583 in 47596 47584 { 47597 47585 MenhirLib.EngineTypes.state = _menhir_s; ··· 47642 47630 47643 47631 # 883 "parsing/parser.mly" 47644 47632 ( mkrhs _1 _sloc ) 47645 47645 - # 47646 "parsing/parser.ml" 47633 47633 + # 47634 "parsing/parser.ml" 47646 47634 47647 47635 in 47648 47636 let _2 = ··· 47653 47641 47654 47642 # 883 "parsing/parser.mly" 47655 47643 ( mkrhs _1 _sloc ) 47656 47656 - # 47657 "parsing/parser.ml" 47644 47644 + # 47645 "parsing/parser.ml" 47657 47645 47658 47646 in 47659 47647 47660 47648 # 3236 "parsing/parser.mly" 47661 47649 ( Pwith_modsubst (_2, _4) ) 47662 47662 - # 47663 "parsing/parser.ml" 47650 47650 + # 47651 "parsing/parser.ml" 47663 47651 in 47664 47652 { 47665 47653 MenhirLib.EngineTypes.state = _menhir_s; ··· 47717 47705 47718 47706 # 883 "parsing/parser.mly" 47719 47707 ( mkrhs _1 _sloc ) 47720 47720 - # 47721 "parsing/parser.ml" 47708 47708 + # 47709 "parsing/parser.ml" 47721 47709 47722 47710 in 47723 47711 47724 47712 # 3238 "parsing/parser.mly" 47725 47713 ( Pwith_modtype (l, rhs) ) 47726 47726 - # 47727 "parsing/parser.ml" 47714 47714 + # 47715 "parsing/parser.ml" 47727 47715 in 47728 47716 { 47729 47717 MenhirLib.EngineTypes.state = _menhir_s; ··· 47781 47769 47782 47770 # 883 "parsing/parser.mly" 47783 47771 ( mkrhs _1 _sloc ) 47784 47784 - # 47785 "parsing/parser.ml" 47772 47772 + # 47773 "parsing/parser.ml" 47785 47773 47786 47774 in 47787 47775 47788 47776 # 3240 "parsing/parser.mly" 47789 47777 ( Pwith_modtypesubst (l, rhs) ) 47790 47790 - # 47791 "parsing/parser.ml" 47778 47778 + # 47779 "parsing/parser.ml" 47791 47779 in 47792 47780 { 47793 47781 MenhirLib.EngineTypes.state = _menhir_s; ··· 47812 47800 let _v : (Asttypes.private_flag) = 47813 47801 # 3243 "parsing/parser.mly" 47814 47802 ( Public ) 47815 47815 - # 47816 "parsing/parser.ml" 47803 47803 + # 47804 "parsing/parser.ml" 47816 47804 in 47817 47805 { 47818 47806 MenhirLib.EngineTypes.state = _menhir_s; ··· 47844 47832 let _v : (Asttypes.private_flag) = 47845 47833 # 3244 "parsing/parser.mly" 47846 47834 ( Private ) 47847 47847 - # 47848 "parsing/parser.ml" 47835 47835 + # 47836 "parsing/parser.ml" 47848 47836 in 47849 47837 { 47850 47838 MenhirLib.EngineTypes.state = _menhir_s; ··· 47981 47969 # 3872 "parsing/parser.mly" 47982 47970 47983 47971 47984 47984 - # 47985 "parsing/parser.ml" 47972 47972 + # 47973 "parsing/parser.ml" 47985 47973 47986 47974 # 269 "<standard.mly>" 47987 47975 47988 47976 47989 47989 - # 47990 "parsing/parser.ml" 47977 47977 + # 47978 "parsing/parser.ml"

+19 -19

parsing/parser.mly

reviewed

··· 208 208 209 209 let mkexp_constraint ~loc e (t1, t2) = 210 210 match t1, t2 with 211 211 - | Some t, None -> ghexp ~loc (Pexp_constraint(e, t)) 212 212 - | _, Some t -> ghexp ~loc (Pexp_coerce(e, t1, t)) 211 211 + | Some t, None -> mkexp ~loc (Pexp_constraint(e, t)) 212 212 + | _, Some t -> mkexp ~loc (Pexp_coerce(e, t1, t)) 213 213 | None, None -> assert false 214 214 215 215 let mkexp_opt_constraint ~loc e = function ··· 218 218 219 219 let mkpat_opt_constraint ~loc p = function 220 220 | None -> p 221 221 - | Some typ -> ghpat ~loc (Ppat_constraint(p, typ)) 221 221 + | Some typ -> mkpat ~loc (Ppat_constraint(p, typ)) 222 222 223 223 let syntax_error () = 224 224 raise Syntaxerr.Escape_error ··· 389 389 let loc_lident (id : string Location.loc) : Longident.t Location.loc = 390 390 loc_map (fun x -> Lident x) id 391 391 392 392 - let exp_of_longident ~loc lid = 393 393 - let lid = make_ghost (loc_map (fun id -> Lident (Longident.last id)) lid) in 394 394 - ghexp ~loc (Pexp_ident lid) 392 392 + let exp_of_longident lid = 393 393 + let lid = loc_map (fun id -> Lident (Longident.last id)) lid in 394 394 + Exp.mk ~loc:lid.loc (Pexp_ident lid) 395 395 396 396 - let exp_of_label ~loc lbl = 397 397 - mkexp ~loc (Pexp_ident (loc_lident lbl)) 396 396 + let exp_of_label lbl = 397 397 + Exp.mk ~loc:lbl.loc (Pexp_ident (loc_lident lbl)) 398 398 399 399 let pat_of_label lbl = 400 400 Pat.mk ~loc:lbl.loc (Ppat_var (loc_last lbl)) ··· 2632 2632 | label = mkrhs(label_longident) 2633 2633 c = type_constraint? 2634 2634 eo = preceded(EQUAL, expr)? 2635 2635 - { let e = 2635 2635 + { let constraint_loc, label, e = 2636 2636 match eo with 2637 2637 | None -> 2638 2638 (* No pattern; this is a pun. Desugar it. *) 2639 2639 - exp_of_longident ~loc:$sloc label 2639 2639 + $sloc, make_ghost label, exp_of_longident label 2640 2640 | Some e -> 2641 2641 - e 2641 2641 + ($startpos(c), $endpos), label, e 2642 2642 in 2643 2643 - label, mkexp_opt_constraint ~loc:$sloc e c } 2643 2643 + label, mkexp_opt_constraint ~loc:constraint_loc e c } 2644 2644 ; 2645 2645 %inline object_expr_content: 2646 2646 xs = separated_or_terminated_nonempty_list(SEMI, object_expr_field) ··· 2649 2649 %inline object_expr_field: 2650 2650 label = mkrhs(label) 2651 2651 oe = preceded(EQUAL, expr)? 2652 2652 - { let e = 2652 2652 + { let label, e = 2653 2653 match oe with 2654 2654 | None -> 2655 2655 (* No expression; this is a pun. Desugar it. *) 2656 2656 - exp_of_label ~loc:$sloc label 2656 2656 + make_ghost label, exp_of_label label 2657 2657 | Some e -> 2658 2658 - e 2658 2658 + label, e 2659 2659 in 2660 2660 label, e } 2661 2661 ; ··· 2843 2843 label = mkrhs(label_longident) 2844 2844 octy = preceded(COLON, core_type)? 2845 2845 opat = preceded(EQUAL, pattern)? 2846 2846 - { let label, pat = 2846 2846 + { let constraint_loc, label, pat = 2847 2847 match opat with 2848 2848 | None -> 2849 2849 (* No pattern; this is a pun. Desugar it. 2850 2850 But that the pattern was there and the label reconstructed (which 2851 2851 piece of AST is marked as ghost is important for warning 2852 2852 emission). *) 2853 2853 - make_ghost label, pat_of_label label 2853 2853 + $sloc, make_ghost label, pat_of_label label 2854 2854 | Some pat -> 2855 2855 - label, pat 2855 2855 + ($startpos(octy), $endpos), label, pat 2856 2856 in 2857 2857 - label, mkpat_opt_constraint ~loc:$sloc pat octy 2857 2857 + label, mkpat_opt_constraint ~loc:constraint_loc pat octy 2858 2858 } 2859 2859 ; 2860 2860

+3 -1

parsing/pprintast.ml

reviewed

··· 95 95 let needs_spaces txt = 96 96 first_is '*' txt || last_is '*' txt 97 97 98 98 + let string_loc ppf x = fprintf ppf "%s" x.txt 99 99 + 98 100 (* add parentheses to binders when they are in fact infix or prefix operators *) 99 101 let protect_ident ppf txt = 100 102 let format : (_, _, _) format = ··· 446 448 pp f "%a@;%a" longident_loc li (simple_pattern ctxt) x 447 449 | Some (vl, x) -> 448 450 pp f "%a@ (type %a)@;%a" longident_loc li 449 449 - (list ~sep:"@ " tyvar_loc) vl 451 451 + (list ~sep:"@ " string_loc) vl 450 452 (simple_pattern ctxt) x 451 453 | None -> pp f "%a" longident_loc li) 452 454 | _ -> simple_pattern ctxt f x

+57 -12

testsuite/tests/parsetree/locations_test.compilers.reference

reviewed

··· 231 231 core_type (//toplevel//[4,29+8]..[4,29+11]) 232 232 Ptyp_constr "int" (//toplevel//[4,29+8]..[4,29+11]) 233 233 [] 234 234 - expression (//toplevel//[4,29+4]..[4,29+15]) ghost 234 234 + expression (//toplevel//[4,29+4]..[4,29+15]) 235 235 Pexp_constraint 236 236 expression (//toplevel//[4,29+14]..[4,29+15]) 237 237 Pexp_constant PConst_int (3,None) ··· 359 359 expression (//toplevel//[4,17+17]..[4,17+29]) 360 360 Pexp_record 361 361 [ 362 362 - "contents" (//toplevel//[4,17+19]..[4,17+27]) 363 363 - expression (//toplevel//[4,17+19]..[4,17+27]) ghost 364 364 - Pexp_ident "contents" (//toplevel//[4,17+19]..[4,17+27]) ghost 362 362 + "contents" (//toplevel//[4,17+19]..[4,17+27]) ghost 363 363 + expression (//toplevel//[4,17+19]..[4,17+27]) 364 364 + Pexp_ident "contents" (//toplevel//[4,17+19]..[4,17+27]) 365 365 ] 366 366 None 367 367 ] ··· 380 380 Pexp_record 381 381 [ 382 382 "contents" (//toplevel//[2,1+10]..[2,1+18]) 383 383 - expression (//toplevel//[2,1+10]..[2,1+28]) ghost 383 383 + expression (//toplevel//[2,1+19]..[2,1+28]) 384 384 Pexp_constraint 385 385 expression (//toplevel//[2,1+27]..[2,1+28]) 386 386 Pexp_constant PConst_int (3,None) ··· 410 410 expression (//toplevel//[2,1+17]..[2,1+35]) 411 411 Pexp_record 412 412 [ 413 413 - "contents" (//toplevel//[2,1+19]..[2,1+27]) 414 414 - expression (//toplevel//[2,1+19]..[2,1+33]) ghost 413 413 + "contents" (//toplevel//[2,1+19]..[2,1+27]) ghost 414 414 + expression (//toplevel//[2,1+19]..[2,1+33]) 415 415 Pexp_constraint 416 416 - expression (//toplevel//[2,1+19]..[2,1+33]) ghost 417 417 - Pexp_ident "contents" (//toplevel//[2,1+19]..[2,1+27]) ghost 416 416 + expression (//toplevel//[2,1+19]..[2,1+27]) 417 417 + Pexp_ident "contents" (//toplevel//[2,1+19]..[2,1+27]) 418 418 core_type (//toplevel//[2,1+30]..[2,1+33]) 419 419 Ptyp_constr "int" (//toplevel//[2,1+30]..[2,1+33]) 420 420 [] ··· 466 466 Ppat_record Closed 467 467 [ 468 468 "contents" (//toplevel//[2,1+19]..[2,1+27]) ghost 469 469 - pattern (//toplevel//[2,1+19]..[2,1+33]) ghost 469 469 + pattern (//toplevel//[2,1+19]..[2,1+33]) 470 470 Ppat_constraint 471 471 pattern (//toplevel//[2,1+19]..[2,1+27]) 472 472 Ppat_var "contents" (//toplevel//[2,1+19]..[2,1+27]) ··· 497 497 Ppat_record Closed 498 498 [ 499 499 "contents" (//toplevel//[2,1+19]..[2,1+27]) 500 500 - pattern (//toplevel//[2,1+19]..[2,1+37]) ghost 500 500 + pattern (//toplevel//[2,1+28]..[2,1+37]) 501 501 Ppat_constraint 502 502 pattern (//toplevel//[2,1+36]..[2,1+37]) 503 503 Ppat_var "i" (//toplevel//[2,1+36]..[2,1+37]) ··· 512 512 ] 513 513 514 514 val x : int ref -> int = <fun> 515 515 + Ptop_def 516 516 + [ 517 517 + structure_item (//toplevel//[2,1+0]..[3,9+50]) 518 518 + Pstr_value Nonrec 519 519 + [ 520 520 + <def> 521 521 + pattern (//toplevel//[2,1+4]..[2,1+5]) 522 522 + Ppat_any 523 523 + expression (//toplevel//[3,9+2]..[3,9+50]) 524 524 + Pexp_object 525 525 + class_structure 526 526 + pattern (//toplevel//[3,9+8]..[3,9+8]) ghost 527 527 + Ppat_any 528 528 + [ 529 529 + class_field (//toplevel//[3,9+9]..[3,9+21]) 530 530 + Pcf_val Immutable 531 531 + "foo" (//toplevel//[3,9+13]..[3,9+16]) 532 532 + Concrete Fresh 533 533 + expression (//toplevel//[3,9+19]..[3,9+21]) 534 534 + Pexp_constant PConst_int (12,None) 535 535 + class_field (//toplevel//[3,9+22]..[3,9+46]) 536 536 + Pcf_method Public 537 537 + "x" (//toplevel//[3,9+29]..[3,9+30]) 538 538 + Concrete Fresh 539 539 + expression (//toplevel//[3,9+31]..[3,9+46]) ghost 540 540 + Pexp_poly 541 541 + expression (//toplevel//[3,9+31]..[3,9+46]) ghost 542 542 + Pexp_fun 543 543 + Nolabel 544 544 + None 545 545 + pattern (//toplevel//[3,9+31]..[3,9+34]) 546 546 + Ppat_var "foo" (//toplevel//[3,9+31]..[3,9+34]) 547 547 + expression (//toplevel//[3,9+37]..[3,9+46]) 548 548 + Pexp_override 549 549 + [ 550 550 + <override> "foo" (//toplevel//[3,9+40]..[3,9+43]) ghost 551 551 + expression (//toplevel//[3,9+40]..[3,9+43]) 552 552 + Pexp_ident "foo" (//toplevel//[3,9+40]..[3,9+43]) 553 553 + ] 554 554 + None 555 555 + ] 556 556 + ] 557 557 + ] 558 558 + 559 559 + - : < x : int -> 'a > as 'a = <obj> 515 560 Ptop_def 516 561 [ 517 562 structure_item (//toplevel//[4,19+0]..[4,19+26]) ··· 1356 1401 [ 1357 1402 <arg> 1358 1403 Labelled "y" 1359 1359 - expression (//toplevel//[5,98+5]..[5,98+12]) ghost 1404 1404 + expression (//toplevel//[5,98+5]..[5,98+12]) 1360 1405 Pexp_constraint 1361 1406 expression (//toplevel//[5,98+6]..[5,98+7]) 1362 1407 Pexp_ident "y" (//toplevel//[5,98+6]..[5,98+7])

+4

testsuite/tests/parsetree/locations_test.ml

reviewed

··· 57 57 58 58 let x = function { contents : int = i } -> i;; 59 59 60 60 + let _ = 61 61 + object val foo = 12 method x foo = {< foo >} end 62 62 + ;; 63 63 + 60 64 (* Local open *) 61 65 62 66 let x = M.{ contents = 3 };;

+2

testsuite/tests/parsetree/source.ml

reviewed

··· 7441 7441 let g y = 7442 7442 let f ~y = y + 1 in 7443 7443 f ~(y:int) 7444 7444 + 7445 7445 + let goober a = match a with C (type a b) y -> y

+73

testsuite/tests/typing-objects/field_kind.ml

reviewed

··· 1 1 + (* TEST 2 2 + * expect 3 3 + *) 4 4 + 5 5 + type _ t = Int : int t;; 6 6 + [%%expect{| 7 7 + type _ t = Int : int t 8 8 + |}] 9 9 + 10 10 + let o = 11 11 + object (self) 12 12 + method private x = 3 13 13 + method m : type a. a t -> a = fun Int -> (self#x : int) 14 14 + end;; 15 15 + [%%expect{| 16 16 + val o : < m : 'a. 'a t -> 'a > = <obj> 17 17 + |}] 18 18 + 19 19 + let o' = 20 20 + object (self : 's) 21 21 + method private x = 3 22 22 + method m : type a. a t -> 's -> a = fun Int other -> (other#x : int) 23 23 + end;; 24 24 + 25 25 + let aargh = assert (o'#m Int o' = 3);; 26 26 + [%%expect{| 27 27 + Lines 2-5, characters 2-5: 28 28 + 2 | ..object (self : 's) 29 29 + 3 | method private x = 3 30 30 + 4 | method m : type a. a t -> 's -> a = fun Int other -> (other#x : int) 31 31 + 5 | end.. 32 32 + Warning 15 [implicit-public-methods]: the following private methods were made public implicitly: 33 33 + x. 34 34 + val o' : < m : 'a. 'a t -> 'b -> 'a; x : int > as 'b = <obj> 35 35 + val aargh : unit = () 36 36 + |}] 37 37 + 38 38 + let o2 = 39 39 + object (self : 's) 40 40 + method private x = 3 41 41 + method m : 's -> int = fun other -> (other#x : int) 42 42 + end;; 43 43 + [%%expect{| 44 44 + Lines 2-5, characters 2-5: 45 45 + 2 | ..object (self : 's) 46 46 + 3 | method private x = 3 47 47 + 4 | method m : 's -> int = fun other -> (other#x : int) 48 48 + 5 | end.. 49 49 + Warning 15 [implicit-public-methods]: the following private methods were made public implicitly: 50 50 + x. 51 51 + val o2 : < m : 'a -> int; x : int > as 'a = <obj> 52 52 + |}] 53 53 + 54 54 + let o3 = 55 55 + object (self : 's) 56 56 + method private x = 3 57 57 + method m : 's -> int = fun other -> 58 58 + let module M = struct let other = other end in (M.other#x : int) 59 59 + end;; 60 60 + 61 61 + let aargh = assert (o3#m o3 = 3);; 62 62 + [%%expect{| 63 63 + Lines 2-6, characters 2-5: 64 64 + 2 | ..object (self : 's) 65 65 + 3 | method private x = 3 66 66 + 4 | method m : 's -> int = fun other -> 67 67 + 5 | let module M = struct let other = other end in (M.other#x : int) 68 68 + 6 | end.. 69 69 + Warning 15 [implicit-public-methods]: the following private methods were made public implicitly: 70 70 + x. 71 71 + val o3 : < m : 'a -> int; x : int > as 'a = <obj> 72 72 + val aargh : unit = () 73 73 + |}]

+2

toplevel/toploop.ml

reviewed

··· 96 96 use_input ppf ~wrap_in_module:true name 97 97 let use_input ppf name = 98 98 use_input ppf ~wrap_in_module:false name 99 99 + let use_file ppf name = 100 100 + use_input ppf (File name) 99 101 100 102 let use_silently ppf name = 101 103 Misc.protect_refs

+1

toplevel/toploop.mli

reviewed

··· 95 95 val use_output : formatter -> string -> bool 96 96 val use_silently : formatter -> input -> bool 97 97 val mod_use_input : formatter -> input -> bool 98 98 + val use_file : formatter -> string -> bool 98 99 (* Read and execute commands from a file. 99 100 [use_input] prints the types and values of the results. 100 101 [use_silently] does not print them.

+3 -21

typing/btype.ml

reviewed

··· 494 494 495 495 val redirect_desc: copy_scope -> type_expr -> type_desc -> unit 496 496 497 497 - val dup_kind: copy_scope -> field_kind option ref -> unit 498 498 - 499 497 val with_scope: (copy_scope -> 'a) -> 'a 500 498 end = struct 501 499 type copy_scope = { 502 500 mutable saved_desc : (transient_expr * type_desc) list; 503 501 (* Save association of generic nodes with their description. *) 504 504 - 505 505 - mutable saved_kinds: field_kind option ref list; 506 506 - (* duplicated kind variables *) 507 507 - 508 508 - mutable new_kinds : field_kind option ref list; 509 509 - (* new kind variables *) 510 502 } 511 503 512 504 let redirect_desc copy_scope ty desc = ··· 514 506 copy_scope.saved_desc <- (ty, ty.desc) :: copy_scope.saved_desc; 515 507 Transient_expr.set_desc ty desc 516 508 517 517 - let dup_kind copy_scope r = 518 518 - assert (Option.is_none !r); 519 519 - if not (List.memq r copy_scope.new_kinds) then begin 520 520 - copy_scope.saved_kinds <- r :: copy_scope.saved_kinds; 521 521 - let r' = ref None in 522 522 - copy_scope.new_kinds <- r' :: copy_scope.new_kinds; 523 523 - r := Some (Fvar r') 524 524 - end 525 525 - 526 509 (* Restore type descriptions. *) 527 527 - let cleanup { saved_desc; saved_kinds; _ } = 528 528 - List.iter (fun (ty, desc) -> Transient_expr.set_desc ty desc) saved_desc; 529 529 - List.iter (fun r -> r := None) saved_kinds 510 510 + let cleanup { saved_desc; _ } = 511 511 + List.iter (fun (ty, desc) -> Transient_expr.set_desc ty desc) saved_desc 530 512 531 513 let with_scope f = 532 532 - let scope = { saved_desc = []; saved_kinds = []; new_kinds = [] } in 514 514 + let scope = { saved_desc = [] } in 533 515 let res = f scope in 534 516 cleanup scope; 535 517 res

-3

typing/btype.mli

reviewed

··· 185 185 val redirect_desc: copy_scope -> type_expr -> type_desc -> unit 186 186 (* Temporarily change a type description *) 187 187 188 188 - val dup_kind: copy_scope -> field_kind option ref -> unit 189 189 - (* Save a None field_kind, and make it point to a fresh Fvar *) 190 190 - 191 188 val with_scope: (copy_scope -> 'a) -> 'a 192 189 (* [with_scope f] calls [f] and restores saved type descriptions 193 190 before returning its result. *)

-8

typing/ctype.ml

reviewed

··· 1119 1119 (* Return a new copy *) 1120 1120 Tvariant (copy_row copy true row keep more') 1121 1121 end 1122 1122 - | Tfield (_p, k, _ty1, ty2) -> 1123 1123 - begin match field_kind_repr k with 1124 1124 - Fabsent -> Tlink (copy ty2) 1125 1125 - | Fpresent -> copy_type_desc copy desc 1126 1126 - | Fvar r -> 1127 1127 - For_copy.dup_kind scope r; 1128 1128 - copy_type_desc copy desc 1129 1129 - end 1130 1122 | Tobject (ty1, _) when partial <> None -> 1131 1123 Tobject (copy ty1, ref None) 1132 1124 | _ -> copy_type_desc ?keep_names copy desc