feat: generalized imports supporting pattern matching and selective field import

doc/modules/language-guide/examples/grammar.txt

@@ -298,7 +298,7 @@
     <obj_body>
 
 <imp> ::= 
-    'import' <id>? '='? <text>
+    'import' <pat_nullary> '='? <text>
 
 <prog> ::= 
     <list(<imp>, ';')> <list(<dec>, ';')> 

src/docs/extract.ml

@@ -55,7 +55,7 @@ let un_prog prog =
   let imports =
     List.map
       (fun i ->
-        let alias, path, _ = i.it in
+        let Syntax.Surface alias, path, _ = i.it in
         (alias.it, path))
       imports
   in

src/lowering/desugar.ml

@@ -858,8 +858,10 @@ let link_declarations imports (cu, flavor) =
 
 
 let transform_import (i : S.import) : import_declaration =
-  let (id, f, ir) = i.it in
-  let t = i.note in
+  let (mid, f, ir) = i.it in
+  let t = match mid with
+    | Surface _ -> i.note
+    | Bulk (_, mod_note) -> mod_note.note_typ in
   assert (t <> T.Pre);
   let rhs = match !ir with
     | S.Unresolved -> raise (Invalid_argument ("Unresolved import " ^ f))
@@ -869,7 +871,9 @@ let transform_import (i : S.import) : import_declaration =
       varE (var (id_of_full_path "@prim") t)
     | S.IDLPath (fp, canister_id) ->
       primE (I.ActorOfIdBlob t) [blobE canister_id]
-  in [ letD (var id.it t) rhs ]
+  in [ match mid with
+       | Surface id -> letD (var id.it t) rhs
+       | Bulk (id, _) -> letD (var id.it i.note) (dotE rhs id.it i.note)]
 
 let transform_unit_body (u : S.comp_unit_body) : Ir.comp_unit =
   match u.it with

src/mo_def/compUnit.ml

@@ -30,8 +30,16 @@ let comp_unit_of_prog as_lib (prog : prog) : comp_unit =
     match ds with
     (* imports *)
     | {it = LetD ({it = VarP n; _}, ({it = ImportE (url, ri); _} as e)); _} :: ds' ->
-      let i : import = { it = (n, url, ri); note = e.note.note_typ; at = e.at } in
+      let i : import = { it = (Surface n, url, ri); note = e.note.note_typ; at = e.at } in
       go (imports @ [i]) ds'
+    | {it = LetD ({it = ObjP []; _}, _); _} :: ds' ->
+      go imports ds'
+    | ({it = LetD (({it = ObjP (f :: fs); _} as letd), ({it = ImportE (url, ri); _} as es)); _} as imp) :: ds' ->
+      let m, tfs = Type.as_obj es.note.note_typ in
+      assert (m = Type.Module);
+      let field_id = f.it.id in
+      let i : import = { it = (Bulk (field_id, es.note), url, ri); note = Type.lookup_val_field field_id.it tfs; at = es.at } in
+      go (imports @ [i]) ({imp with it = LetD ({letd with it = ObjP fs}, es)} :: ds')
 
     (* terminal expressions *)
     | [{it = ExpD ({it = ObjBlockE ({it = Type.Module; _}, fields); _} as e); _}] when as_lib ->
@@ -88,14 +96,24 @@ let obj_decs obj_sort at note id_opt fields =
 let decs_of_lib (cu : comp_unit) =
   let open Source in
   let { imports; body = cub; _ } = cu.it in
-  let import_decs = List.map (fun { it = (id, fp, ri); at; note}  ->
-    { it = LetD (
-      { it = VarP id; at; note; },
-      { it = ImportE (fp, ri);
-        at;
-        note = { note_typ = note; note_eff = Type.Triv} });
-      at;
-      note = { note_typ = note; note_eff = Type.Triv } }) imports
+  let import_decs =
+    List.map (fun { it = (mid, fp, ri); at; note} ->
+        match mid with
+        | Surface id ->
+          { it = LetD ({ it = VarP id; at; note; },
+                       { it = ImportE (fp, ri);
+                         at;
+                         note = { note_typ = note; note_eff = Type.Triv} });
+            at;
+            note = { note_typ = note; note_eff = Type.Triv } }
+        | Bulk (id, mod_note) ->
+          { it = LetD ({ it = ObjP [{it = { id; pat = { it = VarP id; at; note }}; at; note = ()}]; at; note; },
+                       { it = ImportE (fp, ri);
+                         at;
+                         note = mod_note });
+            at;
+            note = { note_typ = note; note_eff = Type.Triv } }
+      ) imports
   in
   import_decs,
   match cub.it with

src/mo_def/syntax.ml

@@ -227,7 +227,8 @@ and stab_sig' = (dec list * typ_field list)      (* type declarations & stable a
 (* Compilation units *)
 
 type import = (import', Type.typ) Source.annotated_phrase
-and import' = id * string * resolved_import ref
+and import' = access * string * resolved_import ref
+and access = Surface of id | Bulk of id * typ_note
 
 type comp_unit_body = (comp_unit_body', typ_note) Source.annotated_phrase
 and comp_unit_body' =

src/mo_frontend/parser.mly

@@ -871,9 +871,8 @@ class_body :
 (* Programs *)
 
 imp :
-  | IMPORT xf=id_opt EQ? f=TEXT
-    { let _, x = xf "import" $sloc in
-      let_or_exp true x (ImportE (f, ref Unresolved)) (at $sloc) }
+  | IMPORT p=pat_nullary EQ? f=TEXT
+    { LetD(p, ImportE(f, ref Unresolved) @? at $sloc)  @? at $sloc }
 
 start : (* dummy non-terminal to satisfy ErrorReporting.ml, that requires a non-empty parse stack *)
   | (* empty *) { () }

test/run/import-module-explicit.mo

@@ -0,0 +1,5 @@
+import { cons; nil } = "lib/ListM";
+
+//type stack = List<Int>;
+let s = cons(1, nil());
+let u = cons<Int>(2, nil<Int>());