Post-Christmas kitchen sink PR

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "vendor/wasm-spec"]
 	path = vendor/wasm-spec
-	url = https://github.com/WebAssembly/spec/
+	url = https://github.com/WebAssembly/multi-value/

Jenkinsfile

@@ -5,7 +5,7 @@ pipeline {
             steps {
                 sh 'git submodule update --init --recursive'
                 sh 'git clone --recursive git@github.com:dfinity-lab/dev nix/dev'
-                sh 'git -C nix/dev checkout f2bbb3d91ef87a037044ed3822a222a0654cd835'
+                sh 'git -C nix/dev checkout 268a453421fc345bf170435a264c03826b14999f'
                 sh 'git -C nix/dev submodule update --init --recursive'
             }
         }

default.nix

@@ -65,6 +65,7 @@ rec {
       "src/.*.mli"
       "src/.*.mly"
       "src/.*.mll"
+      "src/.*.mlpack"
       "src/_tags"
       "test/"
       "test/node-test.js"
@@ -101,6 +102,7 @@ rec {
     buildInputs =
       [ native
         ocaml_wasm
+        nixpkgs.wabt
         nixpkgs.bash
         nixpkgs.perl
       ] ++
@@ -149,7 +151,7 @@ rec {
 
     buildInputs =
       [ native-coverage
-        ocaml_wasm
+        nixpkgs.wabt
         nixpkgs.bash
         nixpkgs.perl
         ocaml_bisect_ppx

nix/ocaml-wasm.nix

@@ -18,9 +18,9 @@ stdenv.mkDerivation rec {
   #src = ../vendor/wasm-spec;
   src = fetchFromGitHub {
     owner = "WebAssembly";
-    repo = "spec";
-    rev = "639bb02f851d9468bdae533457d40731156ef12a";
-    sha256 = "0vqkz428bkwpm0jdy717sfxvp9mh0ai9n849f3wq0vbiw0k6vzmk";
+    repo = "multi-value";
+    rev = "fa755dfe0c8ab3ec93636a092fc3dfbe8c8a232c";
+    sha256 = "0867nd4k2lypal7g2a7816wi5zs4kp4w2dv9dxan9vvn3wi19b5i";
   };
 
   buildInputs = [ ocaml findlib ocamlbuild ];

shell.nix

@@ -17,7 +17,7 @@ let default = import ./default.nix { inherit nixpkgs test-dvm; }; in
 nixpkgs.mkShell {
   buildInputs =
     default.native.buildInputs ++
-    default.native_test.buildInputs ++
+    builtins.filter (i: i != default.native) default.native_test.buildInputs ++
     [ nixpkgs.ncurses ];
 }
 

src/_tags

@@ -1 +1 @@
-<*>: coverage
+<**/*>: coverage

src/arrange.ml

@@ -7,9 +7,9 @@ let ($$) head inner = Node (head, inner)
 let rec exp e = match e.it with
   | VarE i              -> "VarE"    $$ [id i]
   | LitE l              -> "LitE"    $$ [lit !l]
-  | UnE (uo, e)         -> "UnE"     $$ [unop uo; exp e]
-  | BinE (e1, bo, e2)   -> "BinE"    $$ [exp e1; binop bo; exp e2]
-  | RelE (e1, ro, e2)   -> "RelE"    $$ [exp e1; relop ro; exp e2]
+  | UnE (ot, uo, e)     -> "UnE"     $$ [operator_type !ot; unop uo; exp e]
+  | BinE (ot, e1, bo, e2) -> "BinE"    $$ [operator_type !ot; exp e1; binop bo; exp e2]
+  | RelE (ot, e1, ro, e2) -> "RelE"    $$ [operator_type !ot; exp e1; relop ro; exp e2]
   | TupE es             -> "TupE"    $$ List.map exp es
   | ProjE (e, i)        -> "ProjE"   $$ [exp e; Atom (string_of_int i)]
   | ObjE (s, i, efs)    -> "ObjE"    $$ [obj_sort s; id i] @ List.map exp_field efs
@@ -136,7 +136,9 @@ and exp_field (ef : exp_field)
   = (string_of_name ef.it.name.it) $$ [id ef.it.id; exp ef.it.exp; mut ef.it.mut; priv ef.it.priv]
 
 and inst t = typ t.it
-
+
+and operator_type t = Atom (Type.string_of_typ t)
+
 and typ t = match t.it with
   | VarT (s, ts)        -> "VarT" $$ [id s] @ List.map typ ts
   | PrimT p             -> "PrimT" $$ [Atom p]

src/arrange_ir.ml

@@ -7,13 +7,14 @@ let ($$) head inner = Node (head, inner)
 let rec exp e = match e.it with
   | VarE i              -> "VarE"    $$ [id i]
   | LitE l              -> "LitE"    $$ [Arrange.lit l]
-  | UnE (uo, e)         -> "UnE"     $$ [Arrange.unop uo; exp e]
-  | BinE (e1, bo, e2)   -> "BinE"    $$ [exp e1; Arrange.binop bo; exp e2]
-  | RelE (e1, ro, e2)   -> "RelE"    $$ [exp e1; Arrange.relop ro; exp e2]
+  | UnE (t, uo, e)      -> "UnE"     $$ [typ t; Arrange.unop uo; exp e]
+  | BinE (t, e1, bo, e2)-> "BinE"    $$ [typ t; exp e1; Arrange.binop bo; exp e2]
+  | RelE (t, e1, ro, e2)-> "RelE"    $$ [typ t; exp e1; Arrange.relop ro; exp e2]
   | TupE es             -> "TupE"    $$ List.map exp es
   | ProjE (e, i)        -> "ProjE"   $$ [exp e; Atom (string_of_int i)]
   | ActorE (i, efs)     -> "ActorE"  $$ [id i] @ List.map exp_field efs
   | DotE (e, n)         -> "DotE"    $$ [exp e; name n]
+  | ActorDotE (e, n)    -> "ActorDotE" $$ [exp e; name n]
   | AssignE (e1, e2)    -> "AssignE" $$ [exp e1; exp e2]
   | ArrayE (m, es)      -> "ArrayE"  $$ [Arrange.mut m] @ List.map exp es
   | IdxE (e1, e2)       -> "IdxE"    $$ [exp e1; exp e2]
@@ -50,7 +51,7 @@ and pat p = match p.it with
 
 and case c = "case" $$ [pat c.it.pat; exp c.it.exp]
 
-and prim p = Atom (Type.string_of_prim p)
+and typ t = Atom (Type.string_of_typ t)
 
 and exp_field (ef : exp_field)
   = (Syntax.string_of_name ef.it.name.it) $$ [id ef.it.id; exp ef.it.exp; Arrange.mut ef.it.mut; Arrange.priv ef.it.priv]

src/async.ml

@@ -200,6 +200,12 @@ let rec t_typ (t:T.typ) =
 and t_bind {var; bound} =
   {var; bound = t_typ bound}
 
+and t_operator_type ot =
+  (* We recreate the reference here. That is ok, because it
+     we run after type inference. Once we move async past desugaring,
+     it will be a pure value anyways. *)
+  ref (t_typ !ot)
+
 and t_field {name; typ} =
   {name; typ = t_typ typ}
 let rec t_exp (exp:Syntax.exp) =
@@ -214,12 +220,12 @@ and t_exp' (exp:Syntax.exp) =
   | PrimE _
   | LitE _ -> exp'
   | VarE id -> exp'
-  | UnE (op, exp1) ->
-    UnE (op, t_exp exp1)
-  | BinE (exp1, op, exp2) ->
-    BinE (t_exp exp1, op, t_exp exp2)
-  | RelE (exp1, op, exp2) ->
-    RelE (t_exp exp1, op, t_exp exp2)
+  | UnE (ot, op, exp1) ->
+    UnE (t_operator_type ot, op, t_exp exp1)
+  | BinE (ot, exp1, op, exp2) ->
+    BinE (t_operator_type ot, t_exp exp1, op, t_exp exp2)
+  | RelE (ot, exp1, op, exp2) ->
+    RelE (t_operator_type ot, t_exp exp1, op, t_exp exp2)
   | TupE exps ->
     TupE (List.map t_exp exps)
   | OptE exp1 ->

src/awaitopt.ml

@@ -67,12 +67,12 @@ and t_exp' context exp' =
   | PrimE _
   | VarE _
   | LitE _ -> exp'
-  | UnE (op, exp1) ->
-    UnE (op, t_exp context exp1)
-  | BinE (exp1, op, exp2) ->
-    BinE (t_exp context exp1, op, t_exp context exp2)
-  | RelE (exp1, op, exp2) ->
-    RelE (t_exp context exp1, op, t_exp context exp2)
+  | UnE (ot, op, exp1) ->
+    UnE (ot, op, t_exp context exp1)
+  | BinE (ot, exp1, op, exp2) ->
+    BinE (ot, t_exp context exp1, op, t_exp context exp2)
+  | RelE (ot, exp1, op, exp2) ->
+    RelE (ot, t_exp context exp1, op, t_exp context exp2)
   | TupE exps ->
     TupE (List.map (t_exp context) exps)
   | OptE exp1 ->
@@ -393,12 +393,12 @@ and c_exp' context exp k =
   | VarE _
   | LitE _ ->
     assert false
-  | UnE (op, exp1) ->
-    unary context k (fun v1 -> e (UnE(op, v1))) exp1
-  | BinE (exp1, op, exp2) ->
-    binary context k (fun v1 v2 -> e (BinE (v1, op, v2))) exp1 exp2
-  | RelE (exp1, op, exp2) ->
-    binary context k (fun v1 v2 -> e (RelE (v1, op, v2))) exp1 exp2
+  | UnE (ot, op, exp1) ->
+    unary context k (fun v1 -> e (UnE (ot, op, v1))) exp1
+  | BinE (ot, exp1, op, exp2) ->
+    binary context k (fun v1 v2 -> e (BinE (ot, v1, op, v2))) exp1 exp2
+  | RelE (ot, exp1, op, exp2) ->
+    binary context k (fun v1 v2 -> e (RelE (ot, v1, op, v2))) exp1 exp2
   | TupE exps ->
     nary context k (fun vs -> e (TupE vs)) exps
   | OptE exp1 ->