feat: generalized imports supporting pattern matching and selective field import

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

@@ -299,6 +299,7 @@
 
 <imp> ::= 
     'import' <id>? '='? <text>
+    'import' '{' <list(<pat_field>, ';')> '}' '=' <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,7 +858,7 @@ let link_declarations imports (cu, flavor) =
 
 
 let transform_import (i : S.import) : import_declaration =
-  let (id, f, ir) = i.it in
+  let (mid, f, ir) = i.it in
   let t = i.note in
   assert (t <> T.Pre);
   let rhs = match !ir with
@@ -869,7 +869,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 t) (dotE rhs id.it T.Any(*FIXME*))]
 
 let transform_unit_body (u : S.comp_unit_body) : Ir.comp_unit =
   match u.it with

src/mo_def/compUnit.ml

@@ -30,8 +30,17 @@ 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 e = { it = DotE (es, f.label); at = es.at; note = e.note.note_typ } in*)
+      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, 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,9 +97,11 @@ 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}  ->
+  let import_decs = List.map (fun { it = (mid, fp, ri); at; note}  ->
     { it = LetD (
-      { it = VarP id; at; note; },
+               { it = (match mid with
+                       | Surface id -> VarP id
+                       | Bulk id -> ObjP [{it = { id; pat = { it = VarP id; at; note }}; at; note = ()}]); at; note },
       { it = ImportE (fp, ri);
         at;
         note = { note_typ = note; note_eff = Type.Triv} });

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
 
 type comp_unit_body = (comp_unit_body', typ_note) Source.annotated_phrase
 and comp_unit_body' =

src/mo_frontend/parser.mly

@@ -874,6 +874,8 @@ 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 LCURLY fps=seplist(pat_field, semicolon) RCURLY EQ f=TEXT
+    { LetD(ObjP(fps) @! at $sloc, 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>());

test/run/ok/import-module-explicit.comp.ok

@@ -0,0 +1,5 @@
+Ill-typed intermediate code after Desugaring (use -v to see dumped IR):
+(unknown location): IR type error [M0000], subtype violation:
+  module {type List<T> = ?(T, List<T>); cons : <T>(T, List<T>) -> List<T>; nil : <T>() -> List<T>}
+  <T>(T, List<T>) -> List<T>
+

test/run/ok/import-module-explicit.comp.ret.ok

@@ -0,0 +1 @@
+Return code 1

test/run/ok/import-module-explicit.diff-ir.ok

@@ -0,0 +1,8 @@
+--- import-module-explicit.run
++++ import-module-explicit.run-ir
+@@ -0,0 +1,5 @@
++Ill-typed intermediate code after Desugaring (use -v to see dumped IR):
++(unknown location): IR type error [M0000], subtype violation:
++  module {type List<T> = ?(T, List<T>); cons : <T>(T, List<T>) -> List<T>; nil : <T>() -> List<T>}
++  <T>(T, List<T>) -> List<T>
++

test/run/ok/import-module-explicit.diff-low.ok

@@ -0,0 +1,8 @@
+--- import-module-explicit.run
++++ import-module-explicit.run-low
+@@ -0,0 +1,5 @@
++Ill-typed intermediate code after Desugaring (use -v to see dumped IR):
++(unknown location): IR type error [M0000], subtype violation:
++  module {type List<T> = ?(T, List<T>); cons : <T>(T, List<T>) -> List<T>; nil : <T>() -> List<T>}
++  <T>(T, List<T>) -> List<T>
++

test/run/ok/import-module-explicit.run-ir.ok

@@ -0,0 +1,5 @@
+Ill-typed intermediate code after Desugaring (use -v to see dumped IR):
+(unknown location): IR type error [M0000], subtype violation:
+  module {type List<T> = ?(T, List<T>); cons : <T>(T, List<T>) -> List<T>; nil : <T>() -> List<T>}
+  <T>(T, List<T>) -> List<T>
+

test/run/ok/import-module-explicit.run-ir.ret.ok

@@ -0,0 +1 @@
+Return code 1

test/run/ok/import-module-explicit.run-low.ok

@@ -0,0 +1,5 @@
+Ill-typed intermediate code after Desugaring (use -v to see dumped IR):
+(unknown location): IR type error [M0000], subtype violation:
+  module {type List<T> = ?(T, List<T>); cons : <T>(T, List<T>) -> List<T>; nil : <T>() -> List<T>}
+  <T>(T, List<T>) -> List<T>
+

test/run/ok/import-module-explicit.run-low.ret.ok

@@ -0,0 +1 @@
+Return code 1