forked from coq/coq
-
Notifications
You must be signed in to change notification settings - Fork 0
/
declaremods.ml
1667 lines (1370 loc) · 59.3 KB
/
declaremods.ml
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
(************************************************************************)
(* * The Coq Proof Assistant / The Coq Development Team *)
(* v * Copyright INRIA, CNRS and contributors *)
(* <O___,, * (see version control and CREDITS file for authors & dates) *)
(* \VV/ **************************************************************)
(* // * This file is distributed under the terms of the *)
(* * GNU Lesser General Public License Version 2.1 *)
(* * (see LICENSE file for the text of the license) *)
(************************************************************************)
open Pp
open CErrors
open Util
open Names
open Declarations
open Entries
open Libnames
open Libobject
open Mod_subst
(** {6 Inlining levels} *)
(** Rigid / flexible module signature *)
type 'a module_signature =
| Enforce of 'a (** ... : T *)
| Check of 'a list (** ... <: T1 <: T2, possibly empty *)
(** Which module inline annotations should we honor,
either None or the ones whose level is less or equal
to the given integer *)
type inline =
| NoInline
| DefaultInline
| InlineAt of int
let default_inline () = Some (Flags.get_inline_level ())
let inl2intopt = function
| NoInline -> None
| InlineAt i -> Some i
| DefaultInline -> default_inline ()
(** These functions register the visibility of the module and iterates
through its components. They are called by plenty of module functions *)
let consistency_checks exists dir =
if exists then
let _ =
try Nametab.locate_module (qualid_of_dirpath dir)
with Not_found ->
user_err
(DirPath.print dir ++ str " should already exist!")
in
()
else
if Nametab.exists_module dir then
user_err
(DirPath.print dir ++ str " already exists.")
let rec get_module_path = function
| MEident mp -> mp
| MEwith (me,_) -> get_module_path me
| MEapply (me,_) -> get_module_path me
let type_of_mod mp env = function
| true -> (Environ.lookup_module mp env).mod_type
| false -> (Environ.lookup_modtype mp env).mod_type
(** {6 Name management}
Auxiliary functions to transform full_path and kernel_name given
by Lib into ModPath.t and DirPath.t needed for modules
*)
let mp_of_kn kn =
let mp,l = KerName.repr kn in
MPdot (mp,l)
let dir_of_sp sp =
let dir,id = repr_path sp in
add_dirpath_suffix dir id
(** The [ModActions] abstraction represent operations on modules
that are specific to a given stage. Two instances are defined below,
for Synterp and Interp. *)
module type ModActions = sig
type typexpr
type env
val stage : Summary.Stage.t
val substobjs_table_name : string
val modobjs_table_name : string
val enter_module : ModPath.t -> DirPath.t -> int -> unit
val enter_modtype : ModPath.t -> full_path -> int -> unit
val open_module : open_filter -> ModPath.t -> DirPath.t -> int -> unit
module Lib : Lib.StagedLibS
(** Create the substitution corresponding to some functor applications *)
val compute_subst : is_mod:bool -> env -> MBId.t list -> ModPath.t -> ModPath.t list -> Entries.inline -> MBId.t list * substitution
end
module SynterpActions : ModActions with
type env = unit with
type typexpr = Constrexpr.universe_decl_expr option * Constrexpr.constr_expr =
struct
type typexpr = Constrexpr.universe_decl_expr option * Constrexpr.constr_expr
type env = unit
let stage = Summary.Stage.Synterp
let substobjs_table_name = "MODULE-SYNTAX-SUBSTOBJS"
let modobjs_table_name = "MODULE-SYNTAX-OBJS"
let enter_module obj_mp obj_dir i =
consistency_checks false obj_dir;
Nametab.push_module (Until i) obj_dir obj_mp
let enter_modtype mp sp i =
if Nametab.exists_modtype sp then
anomaly (pr_path sp ++ str " already exists.");
Nametab.push_modtype (Nametab.Until i) sp mp
let open_module f obj_mp obj_dir i =
consistency_checks true obj_dir;
if in_filter ~cat:None f then Nametab.push_module (Nametab.Exactly i) obj_dir obj_mp
module Lib = Lib.Synterp
let rec compute_subst () mbids mp_l inl =
match mbids,mp_l with
| _,[] -> mbids,empty_subst
| [],r -> user_err Pp.(str "Application of a functor with too few arguments.")
| mbid::mbids,mp::mp_l ->
let mbid_left,subst = compute_subst () mbids mp_l inl in
mbid_left,join (map_mbid mbid mp empty_delta_resolver) subst
let compute_subst ~is_mod () mbids mp1 mp_l inl =
compute_subst () mbids mp_l inl
end
module InterpActions : ModActions
with type env = Environ.env
with type typexpr = Constr.t * UVars.AbstractContext.t option =
struct
type typexpr = Constr.t * UVars.AbstractContext.t option
type env = Environ.env
let stage = Summary.Stage.Interp
let substobjs_table_name = "MODULE-SUBSTOBJS"
let modobjs_table_name = "MODULE-OBJS"
(** {6 Current module type information}
This information is stored by each [start_modtype] for use
in a later [end_modtype]. *)
let enter_module obj_mp obj_dir i = ()
let enter_modtype mp sp i = ()
let open_module f obj_mp obj_dir i = ()
module Lib = Lib.Interp
let rec compute_subst env mbids sign mp_l inl =
match mbids,mp_l with
| _,[] -> mbids,empty_subst
| [],r -> user_err Pp.(str "Application of a functor with too few arguments.")
| mbid::mbids,mp::mp_l ->
let farg_id, farg_b, fbody_b = Modops.destr_functor sign in
let mb = Environ.lookup_module mp env in
let mbid_left,subst = compute_subst env mbids fbody_b mp_l inl in
let resolver =
if Modops.is_functor mb.mod_type then empty_delta_resolver
else
Modops.inline_delta_resolver env inl mp farg_id farg_b mb.mod_delta
in
mbid_left,join (map_mbid mbid mp resolver) subst
let compute_subst ~is_mod env mbids mp1 mp_l inl =
let typ = type_of_mod mp1 env is_mod in
compute_subst env mbids typ mp_l inl
end
type module_objects =
{ module_prefix : Nametab.object_prefix;
module_substituted_objects : Libobject.t list;
module_keep_objects : Libobject.t list;
}
(** The [StagedModS] abstraction describes module operations at a given stage. *)
module type StagedModS = sig
type typexpr
type env
val get_module_sobjs : bool -> env -> Entries.inline -> typexpr module_alg_expr -> substitutive_objects
val do_module : (int -> Nametab.object_prefix -> Libobject.t list -> unit) -> int -> DirPath.t -> ModPath.t -> substitutive_objects -> Libobject.t list -> unit
val load_objects : int -> Nametab.object_prefix -> Libobject.t list -> unit
val open_object : open_filter -> int -> Nametab.object_prefix * Libobject.t -> unit
val collect_modules : (open_filter * ModPath.t) list -> open_filter MPmap.t * (open_filter * (Nametab.object_prefix * Libobject.t)) list -> open_filter MPmap.t * (open_filter * (Nametab.object_prefix * Libobject.t)) list
val add_leaf : Libobject.t -> unit
val add_leaves : Libobject.t list -> unit
val expand_aobjs : Libobject.algebraic_objects -> Libobject.t list
val get_applications : typexpr module_alg_expr -> ModPath.t * ModPath.t list
val debug_print_modtab : unit -> Pp.t
module ModObjs : sig val all : unit -> module_objects MPmap.t end
end
(** Some utilities about substitutive objects :
substitution, expansion *)
let sobjs_no_functor (mbids,_) = List.is_empty mbids
let subst_filtered sub (f,mp as x) =
let mp' = subst_mp sub mp in
if mp == mp' then x
else f, mp'
let rec subst_aobjs sub = function
| Objs o as objs ->
let o' = subst_objects sub o in
if o == o' then objs else Objs o'
| Ref (mp, sub0) as r ->
let sub0' = join sub0 sub in
if sub0' == sub0 then r else Ref (mp, sub0')
and subst_sobjs sub (mbids,aobjs as sobjs) =
let aobjs' = subst_aobjs sub aobjs in
if aobjs' == aobjs then sobjs else (mbids, aobjs')
and subst_objects subst seg =
let subst_one node =
match node with
| AtomicObject obj ->
let obj' = Libobject.subst_object (subst,obj) in
if obj' == obj then node else AtomicObject obj'
| ModuleObject (id, sobjs) ->
let sobjs' = subst_sobjs subst sobjs in
if sobjs' == sobjs then node else ModuleObject (id, sobjs')
| ModuleTypeObject (id, sobjs) ->
let sobjs' = subst_sobjs subst sobjs in
if sobjs' == sobjs then node else ModuleTypeObject (id, sobjs')
| IncludeObject aobjs ->
let aobjs' = subst_aobjs subst aobjs in
if aobjs' == aobjs then node else IncludeObject aobjs'
| ExportObject { mpl } ->
let mpl' = List.Smart.map (subst_filtered subst) mpl in
if mpl'==mpl then node else ExportObject { mpl = mpl' }
| KeepObject _ -> assert false
in
List.Smart.map subst_one seg
(** The [StagedMod] abstraction factors out the code dealing with modules
that is common to all stages. *)
module StagedMod(Actions : ModActions) = struct
type typexpr = Actions.typexpr
type env = Actions.env
(** ModSubstObjs : a cache of module substitutive objects
This table is common to modules and module types.
- For a Module M:=N, the objects of N will be reloaded
with M after substitution.
- For a Module M:SIG:=..., the module M gets its objects from SIG
Invariants:
- A alias (i.e. a module path inside a Ref constructor) should
never lead to another alias, but rather to a concrete Objs
constructor.
We will plug later a handler dealing with missing entries in the
cache. Such missing entries may come from inner parts of module
types, which aren't registered by the standard libobject machinery.
*)
module ModSubstObjs :
sig
val set : ModPath.t -> substitutive_objects -> unit
val get : ModPath.t -> substitutive_objects
val set_missing_handler : (ModPath.t -> substitutive_objects) -> unit
end =
struct
let table =
Summary.ref ~stage:Actions.stage (MPmap.empty : substitutive_objects MPmap.t)
~name:Actions.substobjs_table_name
let missing_handler = ref (fun mp -> assert false)
let set_missing_handler f = (missing_handler := f)
let set mp objs = (table := MPmap.add mp objs !table)
let get mp =
try MPmap.find mp !table with Not_found -> !missing_handler mp
end
let expand_aobjs = function
| Objs o -> o
| Ref (mp, sub) ->
match ModSubstObjs.get mp with
| (_,Objs o) -> subst_objects sub o
| _ -> assert false (* Invariant : any alias points to concrete objs *)
let expand_sobjs (_,aobjs) = expand_aobjs aobjs
(** {6 ModObjs : a cache of module objects}
For each module, we also store a cache of
"prefix", "substituted objects", "keep objects".
This is used for instance to implement the "Import" command.
substituted objects :
roughly the objects above after the substitution - we need to
keep them to call open_object when the module is opened (imported)
keep objects :
The list of non-substitutive objects - as above, for each of
them we will call open_object when the module is opened
(Some) Invariants:
* If the module is a functor, it won't appear in this cache.
* Module objects in substitutive_objects part have empty substituted
objects.
* Modules which where created with Module M:=mexpr or with
Module M:SIG. ... End M. have the keep list empty.
*)
module ModObjs :
sig
val set : ModPath.t -> module_objects -> unit
val get : ModPath.t -> module_objects (* may raise Not_found *)
val all : unit -> module_objects MPmap.t
end =
struct
let table =
Summary.ref ~stage:Actions.stage (MPmap.empty : module_objects MPmap.t)
~name:Actions.modobjs_table_name
let set mp objs = (table := MPmap.add mp objs !table)
let get mp = MPmap.find mp !table
let all () = !table
end
(** {6 Declaration of module substitutive objects} *)
(** Iterate some function [iter_objects] on all components of a module *)
let do_module iter_objects i obj_dir obj_mp sobjs kobjs =
let prefix = Nametab.{ obj_dir ; obj_mp; } in
Actions.enter_module obj_mp obj_dir i;
ModSubstObjs.set obj_mp sobjs;
(* If we're not a functor, let's iter on the internal components *)
if sobjs_no_functor sobjs then begin
let objs = expand_sobjs sobjs in
let module_objects =
{ module_prefix = prefix;
module_substituted_objects = objs;
module_keep_objects = kobjs;
}
in
ModObjs.set obj_mp module_objects;
iter_objects (i+1) prefix objs;
iter_objects (i+1) prefix kobjs
end
let do_module' iter_objects i ((sp,kn),sobjs) =
do_module iter_objects i (dir_of_sp sp) (mp_of_kn kn) sobjs []
(** Nota: Interactive modules and module types cannot be recached!
This used to be checked here via a flag along the substobjs. *)
(** {6 Declaration of module type substitutive objects} *)
(** Nota: Interactive modules and module types cannot be recached!
This used to be checked more properly here. *)
let load_modtype i sp mp sobjs =
Actions.enter_modtype mp sp i;
ModSubstObjs.set mp sobjs
(** {6 Declaration of substitutive objects for Include} *)
let rec load_object i (prefix, obj) =
match obj with
| AtomicObject o -> Libobject.load_object i (prefix, o)
| ModuleObject (id,sobjs) ->
let name = Lib.make_oname prefix id in
do_module' load_objects i (name, sobjs)
| ModuleTypeObject (id,sobjs) ->
let name = Lib.make_oname prefix id in
let (sp,kn) = name in
load_modtype i sp (mp_of_kn kn) sobjs
| IncludeObject aobjs ->
load_include i (prefix, aobjs)
| ExportObject _ -> ()
| KeepObject (id,objs) ->
let name = Lib.make_oname prefix id in
load_keep i (name, objs)
and load_objects i prefix objs =
List.iter (fun obj -> load_object i (prefix, obj)) objs
and load_include i (prefix, aobjs) =
let o = expand_aobjs aobjs in
load_objects i prefix o
and load_keep i ((sp,kn),kobjs) =
(* Invariant : seg isn't empty *)
let obj_dir = dir_of_sp sp and obj_mp = mp_of_kn kn in
let prefix = Nametab.{ obj_dir ; obj_mp; } in
let modobjs =
try ModObjs.get obj_mp
with Not_found -> assert false (* a substobjs should already be loaded *)
in
assert Nametab.(eq_op modobjs.module_prefix prefix);
assert (List.is_empty modobjs.module_keep_objects);
ModObjs.set obj_mp { modobjs with module_keep_objects = kobjs };
load_objects i prefix kobjs
(** {6 Implementation of Import and Export commands} *)
let mark_object f obj (exports,acc) =
(exports, (f,obj)::acc)
let rec collect_modules mpl acc =
List.fold_left (fun acc fmp -> collect_module fmp acc) acc (List.rev mpl)
and collect_module (f,mp) acc =
try
(* May raise Not_found for unknown module and for functors *)
let modobjs = ModObjs.get mp in
let prefix = modobjs.module_prefix in
let acc = collect_objects f 1 prefix modobjs.module_keep_objects acc in
collect_objects f 1 prefix modobjs.module_substituted_objects acc
with Not_found when Actions.stage = Summary.Stage.Synterp ->
acc
and collect_object f i prefix obj acc =
match obj with
| ExportObject { mpl } -> collect_exports f i mpl acc
| AtomicObject _ | IncludeObject _ | KeepObject _
| ModuleObject _ | ModuleTypeObject _ -> mark_object f (prefix,obj) acc
and collect_objects f i prefix objs acc =
List.fold_left (fun acc obj -> collect_object f i prefix obj acc)
acc
(List.rev objs)
and collect_export f (f',mp) (exports,objs as acc) =
match filter_and f f' with
| None -> acc
| Some f ->
let exports' = MPmap.update mp (function
| None -> Some f
| Some f0 -> Some (filter_or f f0))
exports
in
(* If the map doesn't change there is nothing new to export.
It's possible that [filter_and] or [filter_or] mangled precise
filters such that we repeat uselessly, but the important
[Unfiltered] case is handled correctly.
*)
if exports == exports' then acc
else
collect_module (f,mp) (exports', objs)
and collect_exports f i mpl acc =
if Int.equal i 1 then
List.fold_left (fun acc fmp -> collect_export f fmp acc) acc (List.rev mpl)
else acc
let open_modtype i ((sp,kn),_) =
let mp = mp_of_kn kn in
let mp' =
try Nametab.locate_modtype (qualid_of_path sp)
with Not_found ->
anomaly (pr_path sp ++ str " should already exist!");
in
assert (ModPath.equal mp mp');
Nametab.push_modtype (Nametab.Exactly i) sp mp
let rec open_object f i (prefix, obj) =
match obj with
| AtomicObject o -> Libobject.open_object f i (prefix, o)
| ModuleObject (id,sobjs) ->
let name = Lib.make_oname prefix id in
let dir = dir_of_sp (fst name) in
let mp = mp_of_kn (snd name) in
open_module f i dir mp sobjs
| ModuleTypeObject (id,sobjs) ->
let name = Lib.make_oname prefix id in
open_modtype i (name, sobjs)
| IncludeObject aobjs ->
open_include f i (prefix, aobjs)
| ExportObject { mpl } -> open_export f i mpl
| KeepObject (id,objs) ->
let name = Lib.make_oname prefix id in
open_keep f i (name, objs)
and open_module f i obj_dir obj_mp sobjs =
Actions.open_module f obj_mp obj_dir i;
(* If we're not a functor, let's iter on the internal components *)
if sobjs_no_functor sobjs then begin
let modobjs = ModObjs.get obj_mp in
open_objects f (i+1) modobjs.module_prefix modobjs.module_substituted_objects
end
and open_objects f i prefix objs =
List.iter (fun obj -> open_object f i (prefix, obj)) objs
and open_include f i (prefix, aobjs) =
let o = expand_aobjs aobjs in
open_objects f i prefix o
and open_export f i mpl =
let _,objs = collect_exports f i mpl (MPmap.empty, []) in
List.iter (fun (f,o) -> open_object f 1 o) objs
and open_keep f i ((sp,kn),kobjs) =
let obj_dir = dir_of_sp sp and obj_mp = mp_of_kn kn in
let prefix = Nametab.{ obj_dir; obj_mp; } in
open_objects f i prefix kobjs
let cache_include (prefix, aobjs) =
let o = expand_aobjs aobjs in
load_objects 1 prefix o;
open_objects unfiltered 1 prefix o
and cache_keep ((sp,kn),kobjs) =
anomaly (Pp.str "This module should not be cached!")
let cache_object (prefix, obj) =
match obj with
| AtomicObject o -> Libobject.cache_object (prefix, o)
| ModuleObject (id,sobjs) ->
let name = Lib.make_oname prefix id in
do_module' load_objects 1 (name, sobjs)
| ModuleTypeObject (id,sobjs) ->
let name = Lib.make_oname prefix id in
let (sp,kn) = name in
load_modtype 0 sp (mp_of_kn kn) sobjs
| IncludeObject aobjs ->
cache_include (prefix, aobjs)
| ExportObject { mpl } -> anomaly Pp.(str "Export should not be cached")
| KeepObject (id,objs) ->
let name = Lib.make_oname prefix id in
cache_keep (name, objs)
(* Adding operations with containers *)
let add_leaf obj =
cache_object (Lib.prefix (),obj);
match Actions.stage with
| Summary.Stage.Synterp -> Lib.Synterp.add_leaf_entry obj
| Summary.Stage.Interp -> Lib.Interp.add_leaf_entry obj
let add_leaves objs =
let add_obj obj =
begin match Actions.stage with
| Summary.Stage.Synterp -> Lib.Synterp.add_leaf_entry obj
| Summary.Stage.Interp -> Lib.Interp.add_leaf_entry obj
end;
load_object 1 (Lib.prefix (),obj)
in
List.iter add_obj objs
(** {6 Handler for missing entries in ModSubstObjs} *)
(** Since the inner of Module Types are not added by default to
the ModSubstObjs table, we compensate this by explicit traversal
of Module Types inner objects when needed. Quite a hack... *)
let mp_id mp id = MPdot (mp, Label.of_id id)
let rec register_mod_objs mp obj = match obj with
| ModuleObject (id,sobjs) -> ModSubstObjs.set (mp_id mp id) sobjs
| ModuleTypeObject (id,sobjs) -> ModSubstObjs.set (mp_id mp id) sobjs
| IncludeObject aobjs ->
List.iter (register_mod_objs mp) (expand_aobjs aobjs)
| _ -> ()
let handle_missing_substobjs mp = match mp with
| MPdot (mp',l) ->
let objs = expand_sobjs (ModSubstObjs.get mp') in
List.iter (register_mod_objs mp') objs;
ModSubstObjs.get mp
| _ ->
assert false (* Only inner parts of module types should be missing *)
let () = ModSubstObjs.set_missing_handler handle_missing_substobjs
(** {6 From module expression to substitutive objects} *)
(** Turn a chain of [MSEapply] into the head ModPath.t and the
list of ModPath.t parameters (deepest param coming first).
The left part of a [MSEapply] must be either [MSEident] or
another [MSEapply]. *)
let get_applications mexpr =
let rec get params = function
| MEident mp -> mp, params
| MEapply (fexpr, mp) -> get (mp::params) fexpr
| MEwith _ -> user_err Pp.(str "Non-atomic functor application.")
in get [] mexpr
(** Create the objects of a "with Module" structure. *)
let rec replace_module_object idl mp0 objs0 mp1 objs1 =
match idl, objs0 with
| _,[] -> []
| id::idl,(ModuleObject (id', sobjs))::tail when Id.equal id id' ->
begin
let mp_id = MPdot(mp0, Label.of_id id) in
let objs = match idl with
| [] -> subst_objects (map_mp mp1 mp_id empty_delta_resolver) objs1
| _ ->
let objs_id = expand_sobjs sobjs in
replace_module_object idl mp_id objs_id mp1 objs1
in
(ModuleObject (id, ([], Objs objs)))::tail
end
| idl,lobj::tail -> lobj::replace_module_object idl mp0 tail mp1 objs1
(** Substitutive objects of a module expression (or module type) *)
let rec get_module_sobjs is_mod env inl = function
| MEident mp ->
begin match ModSubstObjs.get mp with
| (mbids,Objs _) when not (ModPath.is_bound mp) ->
(mbids,Ref (mp, empty_subst)) (* we create an alias *)
| sobjs -> sobjs
end
| MEwith (mty, WithDef _) -> get_module_sobjs is_mod env inl mty
| MEwith (mty, WithMod (idl,mp1)) ->
assert (not is_mod);
let sobjs0 = get_module_sobjs is_mod env inl mty in
if not (sobjs_no_functor sobjs0) then
user_err Pp.(str "Illegal use of a functor.");
(* For now, we expand everything, to be safe *)
let mp0 = get_module_path mty in
let objs0 = expand_sobjs sobjs0 in
let objs1 = expand_sobjs (ModSubstObjs.get mp1) in
([], Objs (replace_module_object idl mp0 objs0 mp1 objs1))
| MEapply _ as me ->
let mp1, mp_l = get_applications me in
let mbids, aobjs = get_module_sobjs is_mod env inl (MEident mp1) in
let mbids_left,subst = Actions.compute_subst ~is_mod env mbids mp1 mp_l inl in
(mbids_left, subst_aobjs subst aobjs)
let debug_print_modtab () =
let pr_seg = function
| [] -> str "[]"
| l -> str "[." ++ int (List.length l) ++ str ".]"
in
let pr_modinfo mp modobjs s =
let objs = modobjs.module_substituted_objects @ modobjs.module_keep_objects in
s ++ str (ModPath.to_string mp) ++ spc () ++ pr_seg objs
in
let modules = MPmap.fold pr_modinfo (ModObjs.all ()) (mt ()) in
hov 0 modules
end
module SynterpVisitor : StagedModS
with type env = SynterpActions.env
with type typexpr = Constrexpr.universe_decl_expr option * Constrexpr.constr_expr
= StagedMod(SynterpActions)
module InterpVisitor : StagedModS
with type env = InterpActions.env
with type typexpr = Constr.t * UVars.AbstractContext.t option
= StagedMod(InterpActions)
(** {6 Modules : start, end, declare} *)
type current_module_syntax_info = {
cur_mp : ModPath.t;
cur_typ : ((Constrexpr.universe_decl_expr option * Constrexpr.constr_expr) module_alg_expr * int option) option;
cur_mbids : MBId.t list;
}
let default_module_syntax_info mp = { cur_mp = mp; cur_typ = None; cur_mbids = [] }
let openmod_syntax_info =
Summary.ref None ~stage:Summary.Stage.Synterp ~name:"MODULE-SYNTAX-INFO"
(** {6 Current module information}
This information is stored by each [start_module] for use
in a later [end_module]. *)
type current_module_info = {
cur_typ : (module_struct_entry * int option) option; (** type via ":" *)
cur_typs : module_type_body list (** types via "<:" *)
}
let default_module_info = { cur_typ = None; cur_typs = [] }
let openmod_info = Summary.ref default_module_info ~name:"MODULE-INFO"
let start_library dir =
let mp = Global.start_library dir in
openmod_info := default_module_info;
openmod_syntax_info := Some (default_module_syntax_info mp);
Lib.start_compilation dir mp
let set_openmod_syntax_info info = match !openmod_syntax_info with
| None -> anomaly Pp.(str "bad init of openmod_syntax_info")
| Some _ -> openmod_syntax_info := Some info
let openmod_syntax_info () = match !openmod_syntax_info with
| None -> anomaly Pp.(str "missing init of openmod_syntax_info")
| Some v -> v
module RawModOps = struct
module Synterp = struct
let build_subtypes mtys =
List.map
(fun (m,ann) ->
let inl = inl2intopt ann in
let mte, base, kind = Modintern.intern_module_ast Modintern.ModType m in
(mte, base, kind, inl))
mtys
let intern_arg (idl,(typ,ann)) =
let inl = inl2intopt ann in
let lib_dir = Lib.library_dp() in
let (mty, base, kind) = Modintern.intern_module_ast Modintern.ModType typ in
let sobjs = SynterpVisitor.get_module_sobjs false () inl mty in
let mp0 = get_module_path mty in
let map {CAst.v=id} =
let dir = DirPath.make [id] in
let mbid = MBId.make lib_dir id in
let mp = MPbound mbid in
(* We can use an empty delta resolver because we load only syntax objects *)
let sobjs = subst_sobjs (map_mp mp0 mp empty_delta_resolver) sobjs in
SynterpVisitor.do_module SynterpVisitor.load_objects 1 dir mp sobjs [];
mbid
in
List.map map idl, (mty, base, kind, inl)
let intern_args params =
List.map intern_arg params
let start_module_core id args res =
(* Loads the parsing objects in arguments *)
let args = intern_args args in
let mbids = List.flatten @@ List.map (fun (mbidl,_) -> mbidl) args in
let res_entry_o, sign = match res with
| Enforce (res,ann) ->
let inl = inl2intopt ann in
let (mte, base, kind) = Modintern.intern_module_ast Modintern.ModType res in
Some (mte, inl), Enforce (mte, base, kind, inl)
| Check resl -> None, Check (build_subtypes resl)
in
let mp = ModPath.MPdot((openmod_syntax_info ()).cur_mp, Label.of_id id) in
mp, res_entry_o, mbids, sign, args
let start_module export id args res =
let () = if Option.has_some export && not (CList.is_empty args)
then user_err Pp.(str "Cannot import functors.")
in
let fs = Summary.Synterp.freeze_summaries () in
let mp, res_entry_o, mbids, sign, args = start_module_core id args res in
set_openmod_syntax_info { cur_mp = mp; cur_typ = res_entry_o; cur_mbids = mbids };
let prefix = Lib.Synterp.start_module export id mp fs in
Nametab.(push_dir (Until 1) (prefix.obj_dir) (GlobDirRef.DirOpenModule prefix.obj_mp));
mp, args, sign
let end_module_core id (m_info : current_module_syntax_info) objects fs =
let {Lib.Synterp.substobjs = substitute; keepobjs = keep; anticipateobjs = special; } = objects in
(* For sealed modules, we use the substitutive objects of their signatures *)
let sobjs0, keep, special = match m_info.cur_typ with
| None -> ([], Objs substitute), keep, special
| Some (mty, inline) ->
SynterpVisitor.get_module_sobjs false () inline mty, [], special
in
Summary.Synterp.unfreeze_summaries fs;
let sobjs = let (ms,objs) = sobjs0 in (m_info.cur_mbids@ms,objs) in
(* We substitute objects if the module is sealed by a signature *)
let sobjs =
match m_info.cur_typ with
| None -> sobjs
| Some (mty, _) ->
subst_sobjs (map_mp (get_module_path mty) m_info.cur_mp empty_delta_resolver) sobjs
in
let node = ModuleObject (id,sobjs) in
(* We add the keep objects, if any, and if this isn't a functor *)
let objects = match keep, m_info.cur_mbids with
| [], _ | _, _ :: _ -> special@[node]
| _ -> special@[node;KeepObject (id,keep)]
in
(* Name consistency check : start_ vs. end_module *)
(*
Printf.eprintf "newoname=%s, oldoname=%s\n" (string_of_path (fst newoname)) (string_of_path (fst oldoname));
assert (DirPath.equal (Lib.prefix()).Nametab.obj_dir olddp);
assert (ModPath.equal oldprefix.Nametab.obj_mp mp);
*)
(* Printf.eprintf "newoname=%s, oldoname=%s\n" (string_of_path (fst newoname)) (string_of_path (fst oldoname)); *)
(* Printf.eprintf "newoname=%s, cur_mp=%s\n" (ModPath.debug_to_string (mp_of_kn (snd newoname))) (ModPath.debug_to_string m_info.cur_mp); *)
m_info.cur_mp, objects
let end_module () =
let oldprefix,fs,objects = Lib.Synterp.end_module () in
let m_info = openmod_syntax_info () in
let olddp, id = split_dirpath oldprefix.Nametab.obj_dir in
let mp,objects = end_module_core id m_info objects fs in
let () = SynterpVisitor.add_leaves objects in
(* Name consistency check : kernel vs. library *)
(* CDebug.debug_synterp (fun () -> Pp.(str"prefix=" ++ DirPath.print ((Lib.prefix()).Nametab.obj_dir) ++ str", olddp=" ++ DirPath.print olddp)); *)
assert (DirPath.equal (Lib.prefix()).Nametab.obj_dir olddp);
mp
let get_functor_sobjs is_mod inl (mbids,mexpr) =
let (mbids0, aobjs) = SynterpVisitor.get_module_sobjs is_mod () inl mexpr in
(mbids @ mbids0, aobjs)
let declare_module id args res mexpr_o =
let fs = Summary.Synterp.freeze_summaries () in
(* We simulate the beginning of an interactive module,
then we adds the module parameters to the global env. *)
let mp = ModPath.MPdot((openmod_syntax_info ()).cur_mp, Label.of_id id) in
let args = intern_args args in
let mbids = List.flatten @@ List.map fst args in
let mty_entry_o = match res with
| Enforce (mty,ann) ->
let inl = inl2intopt ann in
let (mte, base, kind) = Modintern.intern_module_ast Modintern.ModType mty in
Enforce (mte, base, kind, inl)
| Check mtys ->
Check (build_subtypes mtys)
in
let mexpr_entry_o = match mexpr_o with
| None -> None
| Some (mexpr,ann) ->
let (mte, base, kind) = Modintern.intern_module_ast Modintern.Module mexpr in
Some (mte, base, kind, inl2intopt ann)
in
let sobjs, mp0 = match mexpr_entry_o, mty_entry_o with
| None, Check _ -> assert false (* No body, no type ... *)
| _, Enforce (typ,_,_,inl_res) -> get_functor_sobjs false inl_res (mbids,typ), get_module_path typ
| Some (body, _, _, inl_expr), Check _ ->
get_functor_sobjs true inl_expr (mbids,body), get_module_path body
in
(* Undo the simulated interactive building of the module
and declare the module as a whole *)
Summary.Synterp.unfreeze_summaries fs;
(* We can use an empty delta resolver on syntax objects *)
let sobjs = subst_sobjs (map_mp mp0 mp empty_delta_resolver) sobjs in
ignore (SynterpVisitor.add_leaf (ModuleObject (id,sobjs)));
mp, args, mexpr_entry_o, mty_entry_o
end
module Interp = struct
(** {6 Auxiliary functions concerning subtyping checks} *)
let check_sub mtb sub_mtb_l =
let fold sub_mtb (cst, env) =
let state = ((Environ.universes env, cst), Reductionops.inferred_universes) in
let graph, cst = Subtyping.check_subtypes state env mtb sub_mtb in
(cst, Environ.set_universes graph env)
in
let cst, _ = List.fold_right fold sub_mtb_l (Univ.Constraints.empty, Global.env ()) in
Global.add_constraints cst
(** This function checks if the type calculated for the module [mp] is
a "<:"-like subtype of all signatures in [sub_mtb_l]. Uses only
the global environment. *)
let check_subtypes mp sub_mtb_l =
let mb =
try Global.lookup_module mp with Not_found -> assert false
in
let mtb = Modops.module_type_of_module mb in
check_sub mtb sub_mtb_l
(** Same for module type [mp] *)
let check_subtypes_mt mp sub_mtb_l =
let mtb =
try Global.lookup_modtype mp with Not_found -> assert false
in
check_sub mtb sub_mtb_l
let current_modresolver () =
fst @@ Safe_typing.delta_of_senv @@ Global.safe_env ()
let current_struct () =
let struc = Safe_typing.structure_body_of_safe_env @@ Global.safe_env () in
NoFunctor (List.rev struc)
(** Prepare the module type list for check of subtypes *)
let build_subtypes env mp args mtys =
let (ctx, ans) = List.fold_left_map
(fun ctx (mte,base,kind,inl) ->
let mte, ctx' = Modintern.interp_module_ast env Modintern.ModType base mte in
let env = Environ.push_context_set ~strict:true ctx' env in
let ctx = Univ.ContextSet.union ctx ctx' in
let state = ((Environ.universes env, Univ.Constraints.empty), Reductionops.inferred_universes) in
let mtb, (_, cst) = Mod_typing.translate_modtype state env mp inl (args,mte) in
let ctx = Univ.ContextSet.add_constraints cst ctx in
ctx, mtb)
Univ.ContextSet.empty mtys
in
(ans, ctx)
(** Process a declaration of functor parameter(s) (Id1 .. Idn : Typ)
i.e. possibly multiple names with the same module type.
Global environment is updated on the fly.
Objects in these parameters are also loaded.
Output is accumulated on top of [acc] (in reverse order). *)
let intern_arg (acc, cst) (mbidl,(mty, base, kind, inl)) =
let env = Global.env() in
let (mty, cst') = Modintern.interp_module_ast env kind base mty in
let () = Global.push_context_set ~strict:true cst' in
let () =
let state = ((Global.universes (), Univ.Constraints.empty), Reductionops.inferred_universes) in
let _, (_, cst) = Mod_typing.translate_modtype state (Global.env ()) base inl ([], mty) in
Global.add_constraints cst
in
let env = Global.env () in
let sobjs = InterpVisitor.get_module_sobjs false env inl mty in
let mp0 = get_module_path mty in
let fold acc mbid =
let id = MBId.to_id mbid in
let dir = DirPath.make [id] in
let mp = MPbound mbid in
let resolver = Global.add_module_parameter mbid mty inl in
let sobjs = subst_sobjs (map_mp mp0 mp resolver) sobjs in
InterpVisitor.do_module InterpVisitor.load_objects 1 dir mp sobjs [];
(mbid,mty,inl)::acc
in
let acc = List.fold_left fold acc mbidl in
(acc, Univ.ContextSet.union cst cst')
(** Process a list of declarations of functor parameters
(Id11 .. Id1n : Typ1)..(Idk1 .. Idkm : Typk)
Global environment is updated on the fly.
The calls to [interp_modast] should be interleaved with these
env updates, otherwise some "with Definition" could be rejected.
Returns a list of mbids and entries (in reversed order).
This used to be a [List.concat (List.map ...)], but this should
be more efficient and independent of [List.map] eval order.
*)
let intern_args params =
let args, ctx = List.fold_left intern_arg ([], Univ.ContextSet.empty) params in
List.rev args, ctx
let start_module_core id args res =
let mp = Global.start_module id in
let params, ctx = intern_args args in
let () = Global.push_context_set ~strict:true ctx in
let env = Global.env () in
let res_entry_o, subtyps, ctx' = match res with
| Enforce (mte, base, kind, inl) ->
let (mte, ctx) = Modintern.interp_module_ast env kind base mte in
let env = Environ.push_context_set ~strict:true ctx env in
(* We check immediately that mte is well-formed *)
let state = ((Environ.universes env, Univ.Constraints.empty), Reductionops.inferred_universes) in
let _, (_, cst) = Mod_typing.translate_modtype state env mp inl ([], mte) in
let ctx = Univ.ContextSet.add_constraints cst ctx in
Some (mte, inl), [], ctx
| Check resl ->
let typs, ctx = build_subtypes env mp params resl in
None, typs, ctx
in
let () = Global.push_context_set ~strict:true ctx' in
mp, res_entry_o, subtyps, params, Univ.ContextSet.union ctx ctx'