experiment: approximate stable as shared types in view queries

src/mo_frontend/typing.ml

@@ -4196,9 +4196,9 @@ and infer_viewer env scope mut id viewer =
     then () (* avoid any clash with local or reserved `__motokoXXX` members by omitting viewer *)
     else
       let viewer_field args ret =
-        (* approximate non-shared returns to Any, if necessary *)
+        (* approximate any stable to shared returns, if necessary *)
         let shared_ret =
-          List.map (fun ty -> if T.shared ty then ty else T.Any) ret in
+          List.map (fun ty -> if T.shared ty then ty else T.shared_of_stable ty) ret in
         T.{ lab; typ = Func (Shared Query, Promises, [scope_bind], args, shared_ret); src = empty_src } in
       let infer_dot_view =
         Diag.with_message_store (recover_opt (fun msgs ->
@@ -4214,7 +4214,7 @@ and infer_viewer env scope mut id viewer =
           let viewer_typ = infer_exp env exp in
           match T.normalize viewer_typ with
            | T.Func(T.Local, T.Returns, [], ts1, ts2)
-             when List.for_all T.shared ts1 && List.for_all T.shared ts2 ->
+             when List.for_all T.shared ts1 && List.for_all T.stable ts2 ->
               { viewer_body = DotViewV exp;
                 viewer_field = viewer_field ts1 ts2 }
            | _ ->

src/mo_types/type.ml

@@ -1016,6 +1016,58 @@ let is_local_async_func typ =
 let shared t = serializable false t
 let stable t = serializable true t
 
+let shared_of_stable t =
+  assert (stable t);
+  let seen = ref ConEnv.empty in
+  let rec go t =
+    begin
+      match t with
+      | Var _ | Pre -> t
+      | Prim Error -> assert false
+      | Prim Region -> Any
+      | Any | Non | Prim _ -> t
+      | Async _ -> assert false
+      | Weak t -> Any
+      | Mut t -> Any
+      | Con (c, ts) ->
+        (match ConEnv.find_opt c !seen with
+         | Some c' -> Con (c', List.map go ts)
+         | None ->
+            match Cons.kind c with
+            | Abs _ -> Any
+            | Def(tbs, u) ->
+              (* copy constructor with approximated body *)
+              (* just weaken bounds to Any  *)
+              let tbs' = List.map (fun tb -> {tb with bound = Any}) tbs in
+              let c' = Cons.fresh (Cons.name c) (Abs(tbs', Pre)) in
+              seen := ConEnv.add c c' !seen;
+              let u' = go u in
+              set_kind c' (Def(tbs', u'));
+              Con (c', List.map go ts))
+      | Array (Mut t) -> Any
+      | Array t -> Array (go t)
+      | Opt t -> Opt (go t)
+      | Tup ts -> Tup (List.map go ts)
+      | Obj (s, fs, ts) ->
+        (match s with
+         | Actor -> t
+         | Module | Mixin ->
+             assert false (* TODO(1452) make modules sharable *)
+         | Object | Memory ->
+             Obj(s,
+                 (* drop mutable fields, approx others *)
+                 List.filter_map (fun f ->
+                     if is_mut f.typ then
+                       None else
+                       Some { f with typ = go f.typ }) fs, ts))
+      | Variant fs -> Variant (List.map (fun f -> {f with typ = go f.typ}) fs)
+      | Func (s, c, tbs, ts1, ts2) ->
+        assert (is_shared_sort s);
+        t
+      | Named (n, t) -> Named (n, go t)
+    end
+  in go t
+
 (* Forward declare
    TODO: haul string_of_typ before the lub/glb business, if possible *)
 let str = ref (fun _ -> failwith "")

src/mo_types/type.mli

@@ -235,6 +235,8 @@ val is_local_async_func : typ -> bool
 
 val stable : typ -> bool
 
+val shared_of_stable : typ -> typ
+
 val inhabited : typ -> bool
 val singleton : typ -> bool
 

test/run-drun/data-view-nested.mo

@@ -1,6 +1,7 @@
 //MOC-FLAG --generate-view-queries --package core $MOTOKO_CORE
 import Map "mo:core/Map";
 import Set "mo:core/Set";
+import Nat "mo:core/Nat";
 import Text "mo:core/Text";
 import Principal "mo:core/Principal";
 import Debug "mo:core/Debug";
@@ -11,8 +12,20 @@ import Views "data-view-sample/views";
 /*
 produces .did
 
+type Set = record {}; // approximated
 service : {
-  __customers: () -> (reserved) query; // approximated
+  __customers: (ko: opt text, count: opt nat) ->
+   (vec
+     record {
+       text;
+       record {
+         city: text;
+         companyName: text;
+         contactName: text;
+         contactTitle: text;
+         countries: Set;
+       };
+     }) query;
   go: () -> ();
 }
 */
@@ -47,16 +60,19 @@ persistent actor Self {
   customers.add("CHOPS", {companyName = "Chop-suey Chinese"; contactName = "Yang Wang"; contactTitle = "Owner"; city = "Bern"; countries = Set.singleton "Switzerland"});
   customers.add("COMMI", {companyName = "Comercio Mineiro"; contactName = "Pedro Afonso"; contactTitle = "Sales Associate"; city = "Sao Paulo"; countries = Set.singleton "Brazil"});
 
-  func debugShow(_ : Any) { Debug.print("any") };
-
   public func go() : async () {
     let views = actor (debug_show (Principal.fromActor(Self))) :
       actor {
-        __customers: query () ->
-	  async Any
+        __customers: query (ko: ?Text, count: ?Nat) ->
+	  async [(Text,
+	         { city: Text;
+                   companyName: Text;
+                   contactName: Text;
+                   contactTitle: Text;
+                   countries: {} })]
      };
-
-     debugShow(await views.__customers());
+     Debug.print(debug_show (await views.__customers(null, null))); // show all customers from first key
+     Debug.print(debug_show (await views.__customers(?"BOTTM", ?4))); // show at most 4 customers from key ""
    }
 
 }

test/run-drun/data-view.mo

@@ -20,23 +20,22 @@ persistent actor Self {
   */
 
   // here, [array_of_non_shared.view] produces a non-shared result type,
-  // approximated to Any entries
+  // approximated to shared {b:{#B}; c : Any} entries
   let array_of_non_shared : [var { var a : {#A}; b : {#B}; c : [var {#C}]}] =
      [ var {var a = #A; b = #B; c = [var #C]} ];
 
   /* generates
-  public query func __array_of_non_shared() :
-    async Any // <- approximation
-  {
-     array_of_non_shared : Any;
+  public query func __array_of_non_shared(start:Nat, count: Nat) : async [
+    {b:{#B}; c : Any} // <- approximation
+  ] {
+     array_of_non_shared.view()(start, count);
   };
   */
 
   // here, [non_shared_array.view] produces a non-shared (mutable) type,
-  // approximate to Any
+  // approximate to [Any]
   let non_shared_array : [[var Nat]] = [];
 
-
   // shared values we can just display, sans viewer
   type Tree = { #leaf; #node : (Tree, Nat, Tree) };
   var some_variant = #node (#leaf, 0, #leaf);
@@ -67,36 +66,37 @@ persistent actor Self {
   /* generates nothing as would clash with reserved __motoko_ members" */
 
 
+
   public func go() : async () {
     let views = actor (debug_show (Prim.principalOfActor(Self))) :
       actor {
         /* generated .views */
         __array : shared query (Nat, Nat) -> async [(Nat, Text)];
-        __array_of_non_shared : shared query () -> async Any; // approximation
+        __array_of_non_shared : shared query (Nat, Nat) -> async [
+	   {b:{#B}; c : Any} ];
 	/* generated simple */
         __some_variant: shared query () -> async Tree;
 	__some_record : shared query () -> async {a:Nat; b: Text; c : Bool};
 	/* user-defined */
 	__override : shared query () -> async Text;
 	/* unable to generate because of (potential) name clash, no viewer or non-shared type*/
-        __non_shared_array : shared query() -> async Any; // approximation
-        __some_mutable_record : shared query() -> async Any; // approximation
+        __non_shared_array : shared query() -> async [Any];
+        __some_mutable_record : shared query() -> async {b : Nat; c : Any}; // drop a, approximate type of c
 	__some_list : shared query () -> async List<Nat>;
-	__some_non_shared_list : shared query () -> async Any; // approximation
+	__some_non_shared_list : shared query () -> async List<{b:Text}>;
         __motoko_xxx : shared query () -> async None;
 
     };
-    func printAny(_ : Any) { Prim.debugPrint("any") };
     Prim.debugPrint(debug_show (await views.__array(0,0)));
     Prim.debugPrint(debug_show (await views.__some_variant()));
     Prim.debugPrint(debug_show (await views.__some_record()));
     Prim.debugPrint(debug_show (await views.__override())); // calls user-defined method
-    Prim.debugPrint(debug_show (await views.__some_list()));
     // debug_show doesn't support Any values, so avoid those below
-    printAny(await views.__array_of_non_shared());
-    printAny(await views.__non_shared_array());
-    printAny(await views.__some_mutable_record());
-    printAny(await views.__some_non_shared_list());
+    Prim.debugPrint(debug_show (await views.__array_of_non_shared(0,0)).size());
+    Prim.debugPrint(debug_show (await views.__non_shared_array()).size());
+    Prim.debugPrint(debug_show (await views.__some_mutable_record()).b);
+    Prim.debugPrint(debug_show (await views.__some_list()));
+    Prim.debugPrint(debug_show (await views.__some_non_shared_list()));
     try {
       await views.__motoko_xxx(); //fails with method not available
       assert false;

test/run-drun/ok/data-view-nested.tc.ok

@@ -0,0 +1 @@
+moc: multiple execution modes specified

test/run-drun/ok/data-view-nested.tc.ret.ok

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

test/run-drun/ok/data-view.drun-run.ok

@@ -4,11 +4,11 @@ debug.print: []
 debug.print: #node(#leaf, 0, #leaf)
 debug.print: {a = 1; b = "hello"; c = true}
 debug.print: "user defined __override"
+debug.print: 0
+debug.print: 0
+debug.print: 0
 debug.print: ?(1, ?(2, null))
-debug.print: any
-debug.print: any
-debug.print: any
-debug.print: any
+debug.print: ?({b = "1"}, ?({b = "2"}, null))
 debug.print: IC0536: Error from Canister rwlgt-iiaaa-aaaaa-aaaaa-cai: Canister has no update method '__motoko_xxx'..
 Check that the method being called is exported by the target canister. See documentation: https://internetcomputer.org/docs/current/references/execution-errors#method-not-found
 ingress Completed: Reply: 0x4449444c0000

test/run-drun/ok/data-view.tc.ok

@@ -1,5 +1,5 @@
-data-view.mo:42.7-42.19: warning [M0244], variable some_variant is never reassigned, consider using `let`
-data-view.mo:63.7-63.15: warning [M0194], unused identifier: `override`
+data-view.mo:41.7-41.19: warning [M0244], variable some_variant is never reassigned, consider using `let`
+data-view.mo:62.7-62.15: warning [M0194], unused identifier: `override`
 help: if this is intentional, prefix it with an underscore: `_override`
-data-view.mo:66.7-66.17: warning [M0194], unused identifier: `motoko_xxx`
+data-view.mo:65.7-65.17: warning [M0194], unused identifier: `motoko_xxx`
 help: if this is intentional, prefix it with an underscore: `_motoko_xxx`