AST-73 Allow the produce exchange to be compiled

.gitignore

@@ -2,8 +2,6 @@
 .dvm
 /result*
 
-nix/dev-in-nix
-
 **/*~
 **/_build
 **/_output

README.md

@@ -13,21 +13,6 @@ To install the `asc` binary into your nix environment, use
 $ nix-env -i -f . -A native
 ```
 
-## Setup of `dev`
-
-Until we join the monorepo, we need a checkout the `dev` repository in
-`nix/dev`; see the `Jenkinsfile` the precise revision to use.
-
-For a fresh checkout, run
-```
-git clone --recursive git@github.com:dfinity-lab/dev nix/dev
-git -C nix/dev checkout 2bc6…see…Jenkinsfile…fecd
-git -C nix/dev submodule update --init --recursive
-```
-
-To update, just run the last two commands again.
-
-
 ## Development using Nix
 
 This is the command that should always pass on master is the following, which builds everything:
@@ -65,27 +50,21 @@ installing all required tools without nix is out of scope).
    ```
    opam install num vlq yojson bisect_ppx bisect_ppx-ocamlbuild menhir
    ```
- * Install the `wasm` package. We use a newer version than is on opam, and a
+ * Install the `wasm` Ocaml package. We use a newer version than is on opam, and a
    fork that supports the multi-value extension. See `nix/ocaml-wasm.nix` for
    the precise repository and version. You can use `nix` to fetch the correct
    source for you, and run the manual installation inside:
    ```
    cd $(nix-build -Q -A wasm.src)/interpreter
    make install
    ```
- * Install the `wasm` tool, using
+ * Install various command line tools used by, in particuar, the test suite:
    ```
    nix-env -i -f . -A wasm
-   ```
- * Install the `dvm` tool, using
-   ```
+   nix-env -i -f . -A filecheck
+   nix-env -i -f . -A wabt
    nix-env -i -f . -A dvm
    ```
-   or simply
-   ```
-   ./update-dvm.sh
-   ```
-   which also updates the `dev` checkout.
 
 
 ## Create a coverage report

ci-pr.nix

@@ -0,0 +1 @@
+import ./ci.nix

ci.nix

@@ -1,4 +1 @@
-# We need to set test-dvm to false because hydra has
-# no access to the `dev` repo. This can go away once we join
-# the monorepo.
-import ./default.nix { test-dvm = false; }
+import ./default.nix { }

default.nix

@@ -5,11 +5,14 @@
 
 let stdenv = nixpkgs.stdenv; in
 
-let sourceByRegex = src: regexes: builtins.filterSource (path: type:
+let sourceByRegex = src: regexes: builtins.path
+  { name = "actorscript";
+    path = src;
+    filter = path: type:
       let relPath = nixpkgs.lib.removePrefix (toString src + "/") (toString path); in
       let match = builtins.match (nixpkgs.lib.strings.concatStringsSep "|" regexes); in
-      ( type == "directory"  &&  match (relPath + "/") != null
-      || match relPath != null)) src; in
+      ( type == "directory"  &&  match (relPath + "/") != null || match relPath != null);
+  }; in
 
 let ocaml_wasm = (import ./nix/ocaml-wasm.nix) {
   inherit (nixpkgs) stdenv fetchFromGitHub ocaml;
@@ -30,12 +33,12 @@ let real-dvm =
   then
     if test-dvm
     then
-      if !builtins.pathExists ./nix/dev/default.nix
-      then
-        throw "\"test-dvm = true\" requires a checkout of dev in ./nix.\nSee Jenkinsfile for the required revision. "
-      else
-        # Pass devel = true until the dev test suite runs on MacOS again
-        ((import ./nix/dev) { devel = true; }).dvm
+      let dev = builtins.fetchGit {
+        url = "ssh://git@github.com/dfinity-lab/dev";
+        ref = "master";
+        rev = "55724569782676b1e08fdce265b7daddaeaec860";
+      }; in
+      (import dev {}).dvm
     else null
   else dvm; in
 
@@ -92,9 +95,10 @@ rec {
       "test/"
       "test/.*Makefile.*"
       "test/quick.mk"
-      "test/(run.*|fail)/"
-      "test/(run.*|fail)/.*.as"
-      "test/(run.*|fail)/ok/.*"
+      "test/(fail|run|run-dfinity)/"
+      "test/(fail|run|run-dfinity)/.*.as"
+      "test/(fail|run|run-dfinity)/ok/"
+      "test/(fail|run|run-dfinity)/ok/.*.ok"
       "test/.*.sh"
       "samples/"
       "samples/.*"
@@ -111,6 +115,7 @@ rec {
         nixpkgs.wabt
         nixpkgs.bash
         nixpkgs.perl
+        filecheck
       ] ++
       (if test-dvm then [ real-dvm ] else []);
 
@@ -119,12 +124,13 @@ rec {
       asc --version
       make -C stdlib ASC=asc all
       make -C samples ASC=asc all
-      make -C test/run VERBOSE=1 ASC=asc all
-      make -C test/fail VERBOSE=1 ASC=asc all
     '' +
-      (if test-dvm then ''
-      make -C test/run-dfinity VERBOSE=1 ASC=asc all
-      '' else "");
+      (if test-dvm
+      then ''
+      make -C test ASC=asc parallel
+      '' else ''
+      make -C test ASC=asc quick
+      '');
 
     installPhase = ''
       mkdir -p $out
@@ -149,9 +155,10 @@ rec {
       "test/"
       "test/.*Makefile.*"
       "test/quick.mk"
-      "test/(run.*|fail)/"
-      "test/(run.*|fail)/.*.as"
-      "test/(run.*|fail)/ok/.*"
+      "test/(fail|run|run-dfinity)/"
+      "test/(fail|run|run-dfinity)/.*.as"
+      "test/(fail|run|run-dfinity)/ok/"
+      "test/(fail|run|run-dfinity)/ok/.*.ok"
       "test/.*.sh"
       "samples/"
       "samples/.*"
@@ -208,6 +215,9 @@ rec {
 
   wasm = ocaml_wasm;
   dvm = real-dvm;
+  filecheck = nixpkgs.linkFarm "FileCheck"
+    [ { name = "bin/FileCheck"; path = "${nixpkgs.llvm}/bin/FileCheck";} ];
+  wabt = nixpkgs.wabt;
 
   all-systems-go = nixpkgs.releaseTools.aggregate {
     name = "all-systems-go";

design/TmpWireFormat.md

@@ -0,0 +1,102 @@
+Temporary Wire Format
+=====================
+
+This document describes the serializaion format currently used by the
+ActorScript runtime, i.e. a mapping from ActorScript types to DFINITY types (=
+WebAssembly types + `databuf`, `elmembuf`, `funcref` and `actorref`), and a
+mapping between the corresponding values.
+
+This is a scaffolding tool to prototype applications until we have decided upon
+the actual IDL of the system, which will change all that is described here.
+
+It also does not support all features that we want to support eventually. In
+particular, it does not support subtyping.
+
+Some types have a *specialized argument format* when used directly as a
+function arguments, rather than nested inside a data structure. Other types use
+the _general argument format (without references)_ or the _general argument
+format (with references)_.
+
+Each argument of a function is serialized separately. If the function is
+defined with a list of arguments, these all become arguments of the WebAssembly
+function. See the [ActorScript guide](https://hydra.oregon.dfinity.build//job/dfinity-ci-build/actorscript.pr-252/users-guide/latest/download/1/guide/#function-types) for the precise rules for function arities.
+
+
+Specialized argument format: `Word32`
+-------------------------------------
+
+A message entry point with an argument of type `Word32` is directly represented
+as a `I32`.
+
+Specialized argument format: `Text`
+-------------------------------------
+
+A message entry point with an argument of type `Text` is represented as a `databuf` that contains the UTF8-encoded string.
+
+Note that there is no terminating `\0`, and the length is implicit as the
+length of the `databuf`.
+
+
+General argument format (without references)
+--------------------------------------------
+
+Arguments with a type that does not mention any reference types (no actors, no
+shared functions), are represented as a `databuf`. This `databuf` is generated
+by an in-order traversal of the data type.  All numbers are fixed-width and in
+little endian format.
+
+ * A `Nat`, `Int` or `Word64` is represented by 8 bytes.
+ * A `Word32` is represented by 4 bytes.
+ * A `Word16` is represented by 2 bytes.
+ * A `Word8` is represented by 1 byte.
+ * A `Bool` is represented by 1 byte that is `0` for `false` and `1` for `true`.
+ * A `Text` is represented by 4 bytes indicating the length of the following
+   payload, followed by the payload as a utf8-encoded string (no trailing `\0`).
+ * An `Array` is represented by 4 bytes indicating the number of entries,
+   followed by the concatenation of the representation of these entries.
+ * An `Tuple` is represented the concatenation of the representation of its
+   entries. (No need for a length field, as it is statically determined.)
+ * An `Object` is represented the concatenation of the representation of its
+   fields, sorted by field name. (The field names are not serialized, as they
+   are statically known.)
+ * An `Option` is represented by a single byte `0` if it is `null`, or
+   otherwise by a single byte `1` followed by the representation of the value
+ * An empty tuple, the type `Null` and the type `Shared` are represented by
+   zero bytes.
+
+
+*Example:* The ActorScript value
+```
+(null, ?4, "!") : (?Text, ?Int, Text)
+```
+is represented as
+```
+00 01 04 00 00 00 00 00 00 00 01 21
+```
+
+General argument format (with references)
+-----------------------------------------
+
+Argument with a type that mentions reference types (actors or shared functions)
+are represented as an `elembuf`:
+
+ * the first entry is a `databuf` contains the data according to the format
+   above.
+ * all further entries are the references contained in the data.
+
+The above format is thus extended with the following case:
+
+ * A reference (`actor`, `shared func`) is represented as a 32 bit number (4
+   bytes). Thus number is an index into the surrounding `elembuf`.
+
+   NB: The index is never never `0`, as the first entry in the `elembuf` is the
+   `databuf` with the actual data.
+
+*Example:* The ActorScript value
+```
+(null, ?console) : (?actor {}, ?actor {log : Text -> () })
+```
+is represented as
+```
+elembuf [databuf [00 01 01 00 00 00], console]
+```