-
Notifications
You must be signed in to change notification settings - Fork 86
/
Copy pathparsetree.mli
1340 lines (1188 loc) · 49.7 KB
/
parsetree.mli
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
(**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
(** Abstract syntax tree produced by parsing
{b Warning:} this module is unstable and part of
{{!Compiler_libs}compiler-libs}.
*)
open Asttypes
type constant =
| Pconst_integer of string * char option
(** Integer constants such as [3] [3l] [3L] [3n].
Suffixes [[g-z][G-Z]] are accepted by the parser.
Suffixes except ['l'], ['L'] and ['n'] are rejected by the typechecker
*)
| Pconst_unboxed_integer of string * char
(** Integer constants such as [#3] [#3l] [#3L] [#3n].
A suffix [[g-z][G-Z]] is required by the parser.
Suffixes except ['l'], ['L'] and ['n'] are rejected by the typechecker
*)
| Pconst_char of char (** Character such as ['c']. *)
| Pconst_string of string * Location.t * string option
(** Constant string such as ["constant"] or
[{delim|other constant|delim}].
The location span the content of the string, without the delimiters.
*)
| Pconst_float of string * char option
(** Float constant such as [3.4], [2e5] or [1.4e-4].
Suffixes [g-z][G-Z] are accepted by the parser.
Suffixes except ['s'] are rejected by the typechecker.
*)
| Pconst_unboxed_float of string * char option
(** Float constant such as [#3.4], [#2e5] or [#1.4e-4].
Suffixes [g-z][G-Z] are accepted by the parser.
Suffixes except ['s'] are rejected by the typechecker.
*)
type location_stack = Location.t list
type modality = | Modality of string [@@unboxed]
type modalities = modality loc list
type mode = | Mode of string [@@unboxed]
type modes = mode loc list
type include_kind = Structure | Functor
(** {1 Extension points} *)
type attribute = {
attr_name : string loc;
attr_payload : payload;
attr_loc : Location.t;
}
(** Attributes such as [[\@id ARG]] and [[\@\@id ARG]].
Metadata containers passed around within the AST.
The compiler ignores unknown attributes.
*)
and extension = string loc * payload
(** Extension points such as [[%id ARG] and [%%id ARG]].
Sub-language placeholder -- rejected by the typechecker.
*)
and attributes = attribute list
and payload =
| PStr of structure
| PSig of signature (** [: SIG] in an attribute or an extension point *)
| PTyp of core_type (** [: T] in an attribute or an extension point *)
| PPat of pattern * expression option
(** [? P] or [? P when E], in an attribute or an extension point *)
(** {1 Core language} *)
(** {2 Type expressions} *)
and core_type =
{
ptyp_desc: core_type_desc;
ptyp_loc: Location.t;
ptyp_loc_stack: location_stack;
ptyp_attributes: attributes; (** [... [\@id1] [\@id2]] *)
}
and core_type_desc =
| Ptyp_any of jkind_annotation option (** [_] or [_ : k] *)
| Ptyp_var of string * jkind_annotation option
(** A type variable such as ['a] or ['a : k] *)
| Ptyp_arrow of arg_label * core_type * core_type * modes * modes
(** [Ptyp_arrow(lbl, T1, T2, M1, M2)] represents:
- [T1 @ M1 -> T2 @ M2] when [lbl] is
{{!arg_label.Nolabel}[Nolabel]},
- [~l:(T1 @ M1) -> (T2 @ M2)] when [lbl] is
{{!arg_label.Labelled}[Labelled]},
- [?l:(T1 @ M1) -> (T2 @ M2)] when [lbl] is
{{!arg_label.Optional}[Optional]}.
*)
| Ptyp_tuple of (string option * core_type) list
(** [Ptyp_tuple(tl)] represents a product type:
- [T1 * ... * Tn] when [tl] is [(None,T1);...;(None,Tn)]
- [L1:T1 * ... * Ln:Tn] when [tl] is [(Some L1,T1);...;(Some Ln,Tn)]
- A mix, e.g. [L1:T1 * T2] when [tl] is [(Some L1,T1);(None,T2)]
Invariant: [n >= 2].
*)
| Ptyp_unboxed_tuple of (string option * core_type) list
(** Unboxed tuple types: [Ptyp_unboxed_tuple([(Some l1,P1);...;(Some l2,Pn)]]
represents a product type [#(l1:T1 * ... * l2:Tn)], and the labels
are optional.
Invariant: [n >= 2].
*)
| Ptyp_constr of Longident.t loc * core_type list
(** [Ptyp_constr(lident, l)] represents:
- [tconstr] when [l=[]],
- [T tconstr] when [l=[T]],
- [(T1, ..., Tn) tconstr] when [l=[T1 ; ... ; Tn]].
*)
| Ptyp_object of object_field list * closed_flag
(** [Ptyp_object([ l1:T1; ...; ln:Tn ], flag)] represents:
- [< l1:T1; ...; ln:Tn >] when [flag] is
{{!Asttypes.closed_flag.Closed}[Closed]},
- [< l1:T1; ...; ln:Tn; .. >] when [flag] is
{{!Asttypes.closed_flag.Open}[Open]}.
*)
| Ptyp_class of Longident.t loc * core_type list
(** [Ptyp_class(tconstr, l)] represents:
- [#tconstr] when [l=[]],
- [T #tconstr] when [l=[T]],
- [(T1, ..., Tn) #tconstr] when [l=[T1 ; ... ; Tn]].
*)
| Ptyp_alias of core_type * string loc option * jkind_annotation option
(** [T as 'a] or [T as ('a : k)] or [T as (_ : k)].
Invariant: the name or jkind annotation is non-None.
*)
| Ptyp_variant of row_field list * closed_flag * label list option
(** [Ptyp_variant([`A;`B], flag, labels)] represents:
- [[ `A|`B ]]
when [flag] is {{!Asttypes.closed_flag.Closed}[Closed]},
and [labels] is [None],
- [[> `A|`B ]]
when [flag] is {{!Asttypes.closed_flag.Open}[Open]},
and [labels] is [None],
- [[< `A|`B ]]
when [flag] is {{!Asttypes.closed_flag.Closed}[Closed]},
and [labels] is [Some []],
- [[< `A|`B > `X `Y ]]
when [flag] is {{!Asttypes.closed_flag.Closed}[Closed]},
and [labels] is [Some ["X";"Y"]].
*)
| Ptyp_poly of (string loc * jkind_annotation option) list * core_type
(** ['a1 ... 'an. T]
[('a1 : k1) ... ('an : kn). T]
Can only appear in the following context:
- As the {!core_type} of a
{{!pattern_desc.Ppat_constraint}[Ppat_constraint]} node corresponding
to a constraint on a let-binding:
{[let x : 'a1 ... 'an. T = e ...]}
- Under {{!class_field_kind.Cfk_virtual}[Cfk_virtual]} for methods
(not values).
- As the {!core_type} of a
{{!class_type_field_desc.Pctf_method}[Pctf_method]} node.
- As the {!core_type} of a {{!expression_desc.Pexp_poly}[Pexp_poly]}
node.
- As the {{!label_declaration.pld_type}[pld_type]} field of a
{!label_declaration}.
- As a {!core_type} of a {{!core_type_desc.Ptyp_object}[Ptyp_object]}
node.
- As the {{!value_description.pval_type}[pval_type]} field of a
{!value_description}.
*)
| Ptyp_package of package_type (** [(module S)]. *)
| Ptyp_open of Longident.t loc * core_type (** [M.(T)] *)
| Ptyp_extension of extension (** [[%id]]. *)
and arg_label = Asttypes.arg_label =
Nolabel
| Labelled of string
| Optional of string
and package_type = Longident.t loc * (Longident.t loc * core_type) list
(** As {!package_type} typed values:
- [(S, [])] represents [(module S)],
- [(S, [(t1, T1) ; ... ; (tn, Tn)])]
represents [(module S with type t1 = T1 and ... and tn = Tn)].
*)
and row_field = {
prf_desc : row_field_desc;
prf_loc : Location.t;
prf_attributes : attributes;
}
and row_field_desc =
| Rtag of label loc * bool * core_type list
(** [Rtag(`A, b, l)] represents:
- [`A] when [b] is [true] and [l] is [[]],
- [`A of T] when [b] is [false] and [l] is [[T]],
- [`A of T1 & .. & Tn] when [b] is [false] and [l] is [[T1;...Tn]],
- [`A of & T1 & .. & Tn] when [b] is [true] and [l] is [[T1;...Tn]].
- The [bool] field is true if the tag contains a
constant (empty) constructor.
- [&] occurs when several types are used for the same constructor
(see 4.2 in the manual)
*)
| Rinherit of core_type (** [[ | t ]] *)
and object_field = {
pof_desc : object_field_desc;
pof_loc : Location.t;
pof_attributes : attributes;
}
and object_field_desc =
| Otag of label loc * core_type
| Oinherit of core_type
(** {2 Patterns} *)
and pattern =
{
ppat_desc: pattern_desc;
ppat_loc: Location.t;
ppat_loc_stack: location_stack;
ppat_attributes: attributes; (** [... [\@id1] [\@id2]] *)
}
and pattern_desc =
| Ppat_any (** The pattern [_]. *)
| Ppat_var of string loc (** A variable pattern such as [x] *)
| Ppat_alias of pattern * string loc
(** An alias pattern such as [P as 'a] *)
| Ppat_constant of constant
(** Patterns such as [1], ['a'], ["true"], [1.0], [1l], [1L], [1n] *)
| Ppat_interval of constant * constant
(** Patterns such as ['a'..'z'].
Other forms of interval are recognized by the parser
but rejected by the type-checker. *)
| Ppat_tuple of (string option * pattern) list * Asttypes.closed_flag
(** [Ppat_tuple(pl, Closed)] represents
- [(P1, ..., Pn)] when [pl] is [(None, P1);...;(None, Pn)]
- [(~L1:P1, ..., ~Ln:Pn)] when [pl] is
[(Some L1, P1);...;(Some Ln, Pn)]
- A mix, e.g. [(~L1:P1, P2)] when [pl] is [(Some L1, P1);(None, P2)]
- If pattern is open, then it also ends in a [..]
Invariant:
- If Closed, [n >= 2].
- If Open, [n >= 1].
*)
| Ppat_unboxed_tuple of (string option * pattern) list * Asttypes.closed_flag
(** Unboxed tuple patterns: [#(l1:P1, ..., ln:Pn)] is [([(Some
l1,P1);...;(Some l2,Pn)], Closed)], and the labels are optional. An
[Open] pattern ends in [..].
Invariant:
- If Closed, [n >= 2]
- If Open, [n >= 1]
*)
| Ppat_construct of
Longident.t loc
* ((string loc * jkind_annotation option) list * pattern) option
(** [Ppat_construct(C, args)] represents:
- [C] when [args] is [None],
- [C P] when [args] is [Some ([], P)]
- [C (P1, ..., Pn)] when [args] is
[Some ([], Ppat_tuple [P1; ...; Pn])]
- [C (type a b) P] when [args] is [Some ([a, None; b, None], P)]
- [C (type (a : k) b) P]
when [args] is [Some ([a, Some k; b, None], P)]
*)
| Ppat_variant of label * pattern option
(** [Ppat_variant(`A, pat)] represents:
- [`A] when [pat] is [None],
- [`A P] when [pat] is [Some P]
*)
| Ppat_record of (Longident.t loc * pattern) list * closed_flag
(** [Ppat_record([(l1, P1) ; ... ; (ln, Pn)], flag)] represents:
- [{ l1=P1; ...; ln=Pn }]
when [flag] is {{!Asttypes.closed_flag.Closed}[Closed]}
- [{ l1=P1; ...; ln=Pn; _}]
when [flag] is {{!Asttypes.closed_flag.Open}[Open]}
Invariant: [n > 0]
*)
| Ppat_record_unboxed_product of (Longident.t loc * pattern) list * closed_flag
(** [Ppat_record_unboxed_product([(l1, P1) ; ... ; (ln, Pn)], flag)] represents:
- [#{ l1=P1; ...; ln=Pn }]
when [flag] is {{!Asttypes.closed_flag.Closed}[Closed]}
- [#{ l1=P1; ...; ln=Pn; _}]
when [flag] is {{!Asttypes.closed_flag.Open}[Open]}
Invariant: [n > 0]
*)
| Ppat_array of mutable_flag * pattern list
(** Pattern [[| P1; ...; Pn |]] or [[: P1; ...; Pn :]] *)
| Ppat_or of pattern * pattern (** Pattern [P1 | P2] *)
| Ppat_constraint of pattern * core_type option * modes
(** [Ppat_constraint(tyopt, modes)] represents:
- [(P : ty @@ modes)] when [tyopt] is [Some ty]
- [(P @ modes)] when [tyopt] is [None]
*)
| Ppat_type of Longident.t loc (** Pattern [#tconst] *)
| Ppat_lazy of pattern (** Pattern [lazy P] *)
| Ppat_unpack of string option loc
(** [Ppat_unpack(s)] represents:
- [(module P)] when [s] is [Some "P"]
- [(module _)] when [s] is [None]
Note: [(module P : S)] is represented as
[Ppat_constraint(Ppat_unpack(Some "P"), Ptyp_package S)]
*)
| Ppat_exception of pattern (** Pattern [exception P] *)
| Ppat_extension of extension (** Pattern [[%id]] *)
| Ppat_open of Longident.t loc * pattern (** Pattern [M.(P)] *)
(** {2 Value expressions} *)
and expression =
{
pexp_desc: expression_desc;
pexp_loc: Location.t;
pexp_loc_stack: location_stack;
pexp_attributes: attributes; (** [... [\@id1] [\@id2]] *)
}
and expression_desc =
| Pexp_ident of Longident.t loc
(** Identifiers such as [x] and [M.x]
*)
| Pexp_constant of constant
(** Expressions constant such as [1], ['a'], ["true"], [1.0], [1l],
[1L], [1n] *)
| Pexp_let of rec_flag * value_binding list * expression
(** [Pexp_let(flag, [(P1,E1) ; ... ; (Pn,En)], E)] represents:
- [let P1 = E1 and ... and Pn = EN in E]
when [flag] is {{!Asttypes.rec_flag.Nonrecursive}[Nonrecursive]},
- [let rec P1 = E1 and ... and Pn = EN in E]
when [flag] is {{!Asttypes.rec_flag.Recursive}[Recursive]}.
*)
| Pexp_function of
function_param list * function_constraint * function_body
(** [Pexp_function ([P1; ...; Pn], C, body)] represents any construct
involving [fun] or [function], including:
- [fun P1 ... Pn -> E]
when [body = Pfunction_body E]
- [fun P1 ... Pn -> function p1 -> e1 | ... | pm -> em]
when [body = Pfunction_cases [ p1 -> e1; ...; pm -> em ]]
[C] represents a type constraint or coercion placed immediately before the
arrow, e.g. [fun P1 ... Pn : ty -> ...] when [C = Some (Pconstraint ty)].
A function must have parameters. [Pexp_function (params, _, body)] must
have non-empty [params] or a [Pfunction_cases _] body.
*)
| Pexp_apply of expression * (arg_label * expression) list
(** [Pexp_apply(E0, [(l1, E1) ; ... ; (ln, En)])]
represents [E0 ~l1:E1 ... ~ln:En]
[li] can be
{{!arg_label.Nolabel}[Nolabel]} (non labeled argument),
{{!arg_label.Labelled}[Labelled]} (labelled arguments) or
{{!arg_label.Optional}[Optional]} (optional argument).
Invariant: [n > 0]
*)
| Pexp_match of expression * case list
(** [match E0 with P1 -> E1 | ... | Pn -> En] *)
| Pexp_try of expression * case list
(** [try E0 with P1 -> E1 | ... | Pn -> En] *)
| Pexp_tuple of (string option * expression) list
(** [Pexp_tuple(el)] represents
- [(E1, ..., En)]
when [el] is [(None, E1);...;(None, En)]
- [(~L1:E1, ..., ~Ln:En)]
when [el] is [(Some L1, E1);...;(Some Ln, En)]
- A mix, e.g.:
[(~L1:E1, E2)] when [el] is [(Some L1, E1); (None, E2)]
Invariant: [n >= 2]
*)
| Pexp_unboxed_tuple of (string option * expression) list
(** Unboxed tuple expressions: [Pexp_unboxed_tuple([(Some l1,P1);...;(Some
l2,Pn)])] represents [#(l1:E1, ..., ln:En)], and the labels are
optional.
Invariant: [n >= 2]
*)
| Pexp_construct of Longident.t loc * expression option
(** [Pexp_construct(C, exp)] represents:
- [C] when [exp] is [None],
- [C E] when [exp] is [Some E],
- [C (E1, ..., En)] when [exp] is [Some (Pexp_tuple[E1;...;En])]
*)
| Pexp_variant of label * expression option
(** [Pexp_variant(`A, exp)] represents
- [`A] when [exp] is [None]
- [`A E] when [exp] is [Some E]
*)
| Pexp_record of (Longident.t loc * expression) list * expression option
(** [Pexp_record([(l1,P1) ; ... ; (ln,Pn)], exp0)] represents
- [{ l1=P1; ...; ln=Pn }] when [exp0] is [None]
- [{ E0 with l1=P1; ...; ln=Pn }] when [exp0] is [Some E0]
Invariant: [n > 0]
*)
| Pexp_record_unboxed_product of (Longident.t loc * expression) list * expression option
(** [Pexp_record_unboxed_product([(l1,P1) ; ... ; (ln,Pn)], exp0)] represents
- [#{ l1=P1; ...; ln=Pn }] when [exp0] is [None]
- [#{ E0 with l1=P1; ...; ln=Pn }] when [exp0] is [Some E0]
Invariant: [n > 0]
*)
| Pexp_field of expression * Longident.t loc (** [E.l] *)
| Pexp_unboxed_field of expression * Longident.t loc (** [E.#l] *)
| Pexp_setfield of expression * Longident.t loc * expression
(** [E1.l <- E2] *)
| Pexp_array of mutable_flag * expression list
(** [[| E1; ...; En |]] or [[: E1; ...; En :]] *)
| Pexp_ifthenelse of expression * expression * expression option
(** [if E1 then E2 else E3] *)
| Pexp_sequence of expression * expression (** [E1; E2] *)
| Pexp_while of expression * expression (** [while E1 do E2 done] *)
| Pexp_for of pattern * expression * expression * direction_flag * expression
(** [Pexp_for(i, E1, E2, direction, E3)] represents:
- [for i = E1 to E2 do E3 done]
when [direction] is {{!Asttypes.direction_flag.Upto}[Upto]}
- [for i = E1 downto E2 do E3 done]
when [direction] is {{!Asttypes.direction_flag.Downto}[Downto]}
*)
| Pexp_constraint of expression * core_type option * modes (** [(E : T @@ modes)] *)
| Pexp_coerce of expression * core_type option * core_type
(** [Pexp_coerce(E, from, T)] represents
- [(E :> T)] when [from] is [None],
- [(E : T0 :> T)] when [from] is [Some T0].
*)
| Pexp_send of expression * label loc (** [E # m] *)
| Pexp_new of Longident.t loc (** [new M.c] *)
| Pexp_setinstvar of label loc * expression (** [x <- 2] *)
| Pexp_override of (label loc * expression) list
(** [{< x1 = E1; ...; xn = En >}] *)
| Pexp_letmodule of string option loc * module_expr * expression
(** [let module M = ME in E] *)
| Pexp_letexception of extension_constructor * expression
(** [let exception C in E] *)
| Pexp_assert of expression
(** [assert E].
Note: [assert false] is treated in a special way by the
type-checker. *)
| Pexp_lazy of expression (** [lazy E] *)
| Pexp_poly of expression * core_type option
(** Used for method bodies.
Can only be used as the expression under
{{!class_field_kind.Cfk_concrete}[Cfk_concrete]} for methods (not
values). *)
| Pexp_object of class_structure (** [object ... end] *)
| Pexp_newtype of string loc * jkind_annotation option * expression
(** [fun (type t) -> E] or [fun (type t : k) -> E] *)
| Pexp_pack of module_expr
(** [(module ME)].
[(module ME : S)] is represented as
[Pexp_constraint(Pexp_pack ME, Ptyp_package S)] *)
| Pexp_open of open_declaration * expression
(** - [M.(E)]
- [let open M in E]
- [let open! M in E] *)
| Pexp_letop of letop
(** - [let* P = E0 in E1]
- [let* P0 = E00 and* P1 = E01 in E1] *)
| Pexp_extension of extension (** [[%id]] *)
| Pexp_unreachable (** [.] *)
| Pexp_stack of expression (** stack_ exp *)
| Pexp_comprehension of comprehension_expression
(** [[? BODY ...CLAUSES... ?]], where:
- [?] is either [""] (list), [:] (immutable array), or [|] (array).
- [BODY] is an expression.
- [CLAUSES] is a series of [comprehension_clause].
*)
| Pexp_overwrite of expression * expression (** overwrite_ exp with exp *)
| Pexp_hole (** _ *)
and case =
{
pc_lhs: pattern;
pc_guard: expression option;
pc_rhs: expression;
}
(** Values of type {!case} represents [(P -> E)] or [(P when E0 -> E)] *)
and letop =
{
let_ : binding_op;
ands : binding_op list;
body : expression;
}
and binding_op =
{
pbop_op : string loc;
pbop_pat : pattern;
pbop_exp : expression;
pbop_loc : Location.t;
}
and function_param_desc =
| Pparam_val of arg_label * expression option * pattern
(** [Pparam_val (lbl, exp0, P)] represents the parameter:
- [P]
when [lbl] is {{!Asttypes.arg_label.Nolabel}[Nolabel]}
and [exp0] is [None]
- [~l:P]
when [lbl] is {{!Asttypes.arg_label.Labelled}[Labelled l]}
and [exp0] is [None]
- [?l:P]
when [lbl] is {{!Asttypes.arg_label.Optional}[Optional l]}
and [exp0] is [None]
- [?l:(P = E0)]
when [lbl] is {{!Asttypes.arg_label.Optional}[Optional l]}
and [exp0] is [Some E0]
Note: If [E0] is provided, only
{{!Asttypes.arg_label.Optional}[Optional]} is allowed.
*)
| Pparam_newtype of string loc * jkind_annotation option
(** [Pparam_newtype x] represents the parameter [(type x)].
[x] carries the location of the identifier, whereas the [pparam_loc]
on the enclosing [function_param] node is the location of the [(type x)]
as a whole.
Multiple parameters [(type a b c)] are represented as multiple
[Pparam_newtype] nodes, let's say:
{[ [ { pparam_kind = Pparam_newtype a; pparam_loc = loc1 };
{ pparam_kind = Pparam_newtype b; pparam_loc = loc2 };
{ pparam_kind = Pparam_newtype c; pparam_loc = loc3 };
]
]}
Here, the first loc [loc1] is the location of [(type a b c)], and the
subsequent locs [loc2] and [loc3] are the same as [loc1], except marked as
ghost locations. The locations on [a], [b], [c], correspond to the
variables [a], [b], and [c] in the source code.
*)
and function_param =
{ pparam_loc : Location.t;
pparam_desc : function_param_desc;
}
and function_body =
| Pfunction_body of expression
| Pfunction_cases of case list * Location.t * attributes
(** In [Pfunction_cases (_, loc, attrs)], the location extends from the
start of the [function] keyword to the end of the last case. The compiler
will only use typechecking-related attributes from [attrs], e.g. enabling
or disabling a warning.
*)
(** See the comment on {{!expression_desc.Pexp_function}[Pexp_function]}. *)
and type_constraint =
| Pconstraint of core_type
| Pcoerce of core_type option * core_type
(** See the comment on {{!expression_desc.Pexp_function}[Pexp_function]}. *)
and function_constraint =
{ mode_annotations : modes;
(** The mode annotation placed on a function let-binding, e.g.
[let local_ f x : int -> int = ...].
The [local_] syntax is parsed into two nodes: the field here, and [pvb_modes].
This field only affects the interpretation of [ret_type_constraint], while the
latter is translated in [typecore] to [Pexp_constraint] to contrain the mode of the
function.
(* CR zqian: This field is not failthful representation of the user syntax, and
complicates [pprintast]. It should be removed and their functionality should be
moved to [pvb_modes]. *)
*)
ret_mode_annotations : modes;
(** The mode annotation placed on a function's body, e.g.
[let f x : int -> int @@ local = ...].
This field constrains the mode of function's body.
*)
ret_type_constraint : type_constraint option;
(** The type constraint placed on a function's body. *)
}
(** See the comment on {{!expression_desc.Pexp_function}[Pexp_function]}. *)
and comprehension_iterator =
| Pcomp_range of
{ start : expression;
stop : expression;
direction : direction_flag
}
(** "= START to STOP" (direction = Upto)
"= START downto STOP" (direction = Downto) *)
| Pcomp_in of expression (** "in EXPR" *)
(** [@...] PAT (in/=) ... *)
and comprehension_clause_binding =
{ pcomp_cb_pattern : pattern;
pcomp_cb_iterator : comprehension_iterator;
pcomp_cb_attributes : attributes
}
and comprehension_clause =
| Pcomp_for of comprehension_clause_binding list
(** "for PAT (in/=) ... and PAT (in/=) ... and ..."; must be nonempty *)
| Pcomp_when of expression (** "when EXPR" *)
and comprehension =
{ pcomp_body : expression;
(** The body/generator of the comprehension *)
pcomp_clauses : comprehension_clause list;
(** The clauses of the comprehension; must be nonempty *)
}
and comprehension_expression =
| Pcomp_list_comprehension of comprehension (** [[BODY ...CLAUSES...]] *)
| Pcomp_array_comprehension of mutable_flag * comprehension
(** [[|BODY ...CLAUSES...|]] (flag = Mutable)
[[:BODY ...CLAUSES...:]] (flag = Immutable)
(only allowed with [-extension immutable_arrays])
*)
(** {2 Value descriptions} *)
and value_description =
{
pval_name: string loc;
pval_type: core_type;
pval_modalities : modalities;
pval_prim: string list;
pval_attributes: attributes; (** [... [\@\@id1] [\@\@id2]] *)
pval_loc: Location.t;
}
(** Values of type {!value_description} represents:
- [val x: T],
when {{!value_description.pval_prim}[pval_prim]} is [[]]
- [external x: T = "s1" ... "sn"]
when {{!value_description.pval_prim}[pval_prim]} is [["s1";..."sn"]]
*)
(** {2 Type declarations} *)
and type_declaration =
{
ptype_name: string loc;
ptype_params: (core_type * (variance * injectivity)) list;
(** [('a1,...'an) t] *)
ptype_cstrs: (core_type * core_type * Location.t) list;
(** [... constraint T1=T1' ... constraint Tn=Tn'] *)
ptype_kind: type_kind;
ptype_private: private_flag; (** for [= private ...] *)
ptype_manifest: core_type option; (** represents [= T] *)
ptype_attributes: attributes; (** [... [\@\@id1] [\@\@id2]] *)
ptype_jkind_annotation: jkind_annotation option; (** for [: jkind] *)
ptype_loc: Location.t;
}
(**
Here are type declarations and their representation,
for various {{!type_declaration.ptype_kind}[ptype_kind]}
and {{!type_declaration.ptype_manifest}[ptype_manifest]} values:
- [type t] when [type_kind] is {{!type_kind.Ptype_abstract}[Ptype_abstract]},
and [manifest] is [None],
- [type t = T0]
when [type_kind] is {{!type_kind.Ptype_abstract}[Ptype_abstract]},
and [manifest] is [Some T0],
- [type t = C of T | ...]
when [type_kind] is {{!type_kind.Ptype_variant}[Ptype_variant]},
and [manifest] is [None],
- [type t = T0 = C of T | ...]
when [type_kind] is {{!type_kind.Ptype_variant}[Ptype_variant]},
and [manifest] is [Some T0],
- [type t = {l: T; ...}]
when [type_kind] is {{!type_kind.Ptype_record}[Ptype_record]},
and [manifest] is [None],
- [type t = T0 = {l : T; ...}]
when [type_kind] is {{!type_kind.Ptype_record}[Ptype_record]},
and [manifest] is [Some T0],
- [type t = ..]
when [type_kind] is {{!type_kind.Ptype_open}[Ptype_open]},
and [manifest] is [None].
*)
and type_kind =
| Ptype_abstract
| Ptype_variant of constructor_declaration list
| Ptype_record of label_declaration list (** Invariant: non-empty list *)
| Ptype_record_unboxed_product of label_declaration list (** Invariant: non-empty list *)
| Ptype_open
and label_declaration =
{
pld_name: string loc;
pld_mutable: mutable_flag;
pld_modalities: modalities;
pld_type: core_type;
pld_loc: Location.t;
pld_attributes: attributes; (** [l : T [\@id1] [\@id2]] *)
}
(**
- [{ ...; l: T; ... }]
when {{!label_declaration.pld_mutable}[pld_mutable]}
is {{!Asttypes.mutable_flag.Immutable}[Immutable]},
- [{ ...; mutable l: T; ... }]
when {{!label_declaration.pld_mutable}[pld_mutable]}
is {{!Asttypes.mutable_flag.Mutable}[Mutable]}.
Note: [T] can be a {{!core_type_desc.Ptyp_poly}[Ptyp_poly]}.
*)
and constructor_declaration =
{
pcd_name: string loc;
pcd_vars: (string loc * jkind_annotation option) list;
(** jkind annotations are [C : ('a : kind1) ('a2 : kind2). ...] *)
pcd_args: constructor_arguments;
pcd_res: core_type option;
pcd_loc: Location.t;
pcd_attributes: attributes; (** [C of ... [\@id1] [\@id2]] *)
}
and constructor_argument =
{
pca_modalities: modalities;
pca_type: core_type;
pca_loc: Location.t;
}
and constructor_arguments =
| Pcstr_tuple of constructor_argument list
| Pcstr_record of label_declaration list
(** Values of type {!constructor_declaration}
represents the constructor arguments of:
- [C of T1 * ... * Tn] when [res = None],
and [args = Pcstr_tuple [T1; ... ; Tn]],
- [C: T0] when [res = Some T0],
and [args = Pcstr_tuple []],
- [C: T1 * ... * Tn -> T0] when [res = Some T0],
and [args = Pcstr_tuple [T1; ... ; Tn]],
- [C of {...}] when [res = None],
and [args = Pcstr_record [...]],
- [C: {...} -> T0] when [res = Some T0],
and [args = Pcstr_record [...]].
*)
and type_extension =
{
ptyext_path: Longident.t loc;
ptyext_params: (core_type * (variance * injectivity)) list;
ptyext_constructors: extension_constructor list;
ptyext_private: private_flag;
ptyext_loc: Location.t;
ptyext_attributes: attributes; (** ... [\@\@id1] [\@\@id2] *)
}
(**
Definition of new extensions constructors for the extensive sum type [t]
([type t += ...]).
*)
and extension_constructor =
{
pext_name: string loc;
pext_kind: extension_constructor_kind;
pext_loc: Location.t;
pext_attributes: attributes; (** [C of ... [\@id1] [\@id2]] *)
}
and type_exception =
{
ptyexn_constructor : extension_constructor;
ptyexn_loc : Location.t;
ptyexn_attributes : attributes; (** [... [\@\@id1] [\@\@id2]] *)
}
(** Definition of a new exception ([exception E]). *)
and extension_constructor_kind =
| Pext_decl of (string loc * jkind_annotation option) list
* constructor_arguments * core_type option
(** [Pext_decl(existentials, c_args, t_opt)]
describes a new extension constructor. It can be:
- [C of T1 * ... * Tn] when:
{ul {- [existentials] is [[]],}
{- [c_args] is [[T1; ...; Tn]],}
{- [t_opt] is [None]}.}
- [C: T0] when
{ul {- [existentials] is [[]],}
{- [c_args] is [[]],}
{- [t_opt] is [Some T0].}}
- [C: T1 * ... * Tn -> T0] when
{ul {- [existentials] is [[]],}
{- [c_args] is [[T1; ...; Tn]],}
{- [t_opt] is [Some T0].}}
- [C: ('a : k)... . T1 * ... * Tn -> T0] when
{ul {- [existentials] is [[('a : k);...]],}
{- [c_args] is [[T1; ... ; Tn]],}
{- [t_opt] is [Some T0].}}
*)
| Pext_rebind of Longident.t loc
(** [Pext_rebind(D)] re-export the constructor [D] with the new name [C] *)
(** {1 Class language} *)
(** {2 Type expressions for the class language} *)
and class_type =
{
pcty_desc: class_type_desc;
pcty_loc: Location.t;
pcty_attributes: attributes; (** [... [\@id1] [\@id2]] *)
}
and class_type_desc =
| Pcty_constr of Longident.t loc * core_type list
(** - [c]
- [['a1, ..., 'an] c] *)
| Pcty_signature of class_signature (** [object ... end] *)
| Pcty_arrow of arg_label * core_type * class_type
(** [Pcty_arrow(lbl, T, CT)] represents:
- [T -> CT]
when [lbl] is {{!arg_label.Nolabel}[Nolabel]},
- [~l:T -> CT]
when [lbl] is {{!arg_label.Labelled}[Labelled l]},
- [?l:T -> CT]
when [lbl] is {{!arg_label.Optional}[Optional l]}.
*)
| Pcty_extension of extension (** [%id] *)
| Pcty_open of open_description * class_type (** [let open M in CT] *)
and class_signature =
{
pcsig_self: core_type;
pcsig_fields: class_type_field list;
}
(** Values of type [class_signature] represents:
- [object('selfpat) ... end]
- [object ... end] when {{!class_signature.pcsig_self}[pcsig_self]}
is {{!core_type_desc.Ptyp_any}[Ptyp_any]}
*)
and class_type_field =
{
pctf_desc: class_type_field_desc;
pctf_loc: Location.t;
pctf_attributes: attributes; (** [... [\@\@id1] [\@\@id2]] *)
}
and class_type_field_desc =
| Pctf_inherit of class_type (** [inherit CT] *)
| Pctf_val of (label loc * mutable_flag * virtual_flag * core_type)
(** [val x: T] *)
| Pctf_method of (label loc * private_flag * virtual_flag * core_type)
(** [method x: T]
Note: [T] can be a {{!core_type_desc.Ptyp_poly}[Ptyp_poly]}.
*)
| Pctf_constraint of (core_type * core_type) (** [constraint T1 = T2] *)
| Pctf_attribute of attribute (** [[\@\@\@id]] *)
| Pctf_extension of extension (** [[%%id]] *)
and 'a class_infos =
{
pci_virt: virtual_flag;
pci_params: (core_type * (variance * injectivity)) list;
pci_name: string loc;
pci_expr: 'a;
pci_loc: Location.t;
pci_attributes: attributes; (** [... [\@\@id1] [\@\@id2]] *)
}
(** Values of type [class_expr class_infos] represents:
- [class c = ...]
- [class ['a1,...,'an] c = ...]
- [class virtual c = ...]
They are also used for "class type" declaration.
*)
and class_description = class_type class_infos
and class_type_declaration = class_type class_infos
(** {2 Value expressions for the class language} *)
and class_expr =
{
pcl_desc: class_expr_desc;
pcl_loc: Location.t;
pcl_attributes: attributes; (** [... [\@id1] [\@id2]] *)
}
and class_expr_desc =
| Pcl_constr of Longident.t loc * core_type list
(** [c] and [['a1, ..., 'an] c] *)
| Pcl_structure of class_structure (** [object ... end] *)
| Pcl_fun of arg_label * expression option * pattern * class_expr
(** [Pcl_fun(lbl, exp0, P, CE)] represents:
- [fun P -> CE]
when [lbl] is {{!arg_label.Nolabel}[Nolabel]}
and [exp0] is [None],
- [fun ~l:P -> CE]
when [lbl] is {{!arg_label.Labelled}[Labelled l]}
and [exp0] is [None],
- [fun ?l:P -> CE]
when [lbl] is {{!arg_label.Optional}[Optional l]}
and [exp0] is [None],
- [fun ?l:(P = E0) -> CE]
when [lbl] is {{!arg_label.Optional}[Optional l]}
and [exp0] is [Some E0].
*)
| Pcl_apply of class_expr * (arg_label * expression) list
(** [Pcl_apply(CE, [(l1,E1) ; ... ; (ln,En)])]
represents [CE ~l1:E1 ... ~ln:En].
[li] can be empty (non labeled argument) or start with [?]
(optional argument).
Invariant: [n > 0]
*)
| Pcl_let of rec_flag * value_binding list * class_expr
(** [Pcl_let(rec, [(P1, E1); ... ; (Pn, En)], CE)] represents:
- [let P1 = E1 and ... and Pn = EN in CE]
when [rec] is {{!Asttypes.rec_flag.Nonrecursive}[Nonrecursive]},
- [let rec P1 = E1 and ... and Pn = EN in CE]
when [rec] is {{!Asttypes.rec_flag.Recursive}[Recursive]}.
*)
| Pcl_constraint of class_expr * class_type (** [(CE : CT)] *)
| Pcl_extension of extension (** [[%id]] *)
| Pcl_open of open_description * class_expr (** [let open M in CE] *)
and class_structure =
{
pcstr_self: pattern;
pcstr_fields: class_field list;
}
(** Values of type {!class_structure} represents:
- [object(selfpat) ... end]
- [object ... end] when {{!class_structure.pcstr_self}[pcstr_self]}
is {{!pattern_desc.Ppat_any}[Ppat_any]}
*)
and class_field =
{
pcf_desc: class_field_desc;
pcf_loc: Location.t;
pcf_attributes: attributes; (** [... [\@\@id1] [\@\@id2]] *)
}
and class_field_desc =
| Pcf_inherit of override_flag * class_expr * string loc option
(** [Pcf_inherit(flag, CE, s)] represents:
- [inherit CE]
when [flag] is {{!Asttypes.override_flag.Fresh}[Fresh]}
and [s] is [None],
- [inherit CE as x]
when [flag] is {{!Asttypes.override_flag.Fresh}[Fresh]}
and [s] is [Some x],
- [inherit! CE]
when [flag] is {{!Asttypes.override_flag.Override}[Override]}
and [s] is [None],
- [inherit! CE as x]
when [flag] is {{!Asttypes.override_flag.Override}[Override]}
and [s] is [Some x]
*)
| Pcf_val of (label loc * mutable_flag * class_field_kind)
(** [Pcf_val(x,flag, kind)] represents:
- [val x = E]
when [flag] is {{!Asttypes.mutable_flag.Immutable}[Immutable]}
and [kind] is {{!class_field_kind.Cfk_concrete}[Cfk_concrete(Fresh, E)]}