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.{ it = VarP 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 (p, f, ir) = i.it in
   let t = i.note in
   assert (t <> T.Pre);
   let rhs = match !ir with
@@ -869,7 +869,7 @@ 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 [ letP (pat p) rhs ]
 
 let transform_unit_body (u : S.comp_unit_body) : Ir.comp_unit =
   match u.it with

src/mo_def/compUnit.ml

@@ -23,15 +23,16 @@ let comp_unit_of_prog as_lib (prog : prog) : comp_unit =
   let open Source in
   let f = prog.note in
 
-  let finish imports u = { it = { imports; body = u }; note = f; at = no_region } in
+  let finish imports u =
+    { it = { imports = List.rev imports; body = u }; note = f; at = no_region } in
   let prog_typ_note = { empty_typ_note with note_typ = Type.unit } in
 
   let rec go imports ds : 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
-      go (imports @ [i]) ds'
+    | {it = LetD (p, ({it = ImportE (url, ri); _} as e)); _} :: ds' ->
+      let i : import = { it = (p, url, ri); note = e.note.note_typ; at = e.at } in
+      go (i :: imports) ds'
 
     (* terminal expressions *)
     | [{it = ExpD ({it = ObjBlockE ({it = Type.Module; _}, fields); _} as e); _}] when as_lib ->
@@ -88,14 +89,15 @@ 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 = (pat, fp, ri); at; note} ->
+        { it = LetD (pat,
+                     { it = ImportE (fp, ri);
+                       at;
+                       note = { note_typ = note; note_eff = Type.Triv} });
+          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,7 @@ 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' = pat * string * resolved_import ref
 
 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>());