5001 - drop the :(scenario) DSL

I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.

[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2

The implementation of the DSL was also highly hacky:

a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.

b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?

On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.

Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.

---

This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.

1 files changed, 356 insertions, 237 deletions

diff --git a/030container.cc b/030container.cc
index ca2d6743..e20af025 100644
--- a/030container.cc
+++ b/030container.cc
@@ -15,22 +15,34 @@ get(Type, point).elements.push_back(reagent("y:number"));
 //: Tests in this layer often explicitly set up memory before reading it as a
 //: container. Don't do this in general. I'm tagging such cases with /unsafe;
 //: they'll be exceptions to later checks.
-:(scenario copy_multiple_locations)
-def main [
-  1:num <- copy 34
-  2:num <- copy 35
-  3:point <- copy 1:point/unsafe
-]
-+mem: storing 34 in location 3
-+mem: storing 35 in location 4
+
+:(code)
+void test_copy_multiple_locations() {
+  run(
+      "def main [\n"
+      "  1:num <- copy 34\n"
+      "  2:num <- copy 35\n"
+      "  3:point <- copy 1:point/unsafe\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 34 in location 3\n"
+      "mem: storing 35 in location 4\n"
+  );
+}
 
 //: trying to copy to a differently-typed destination will fail
-:(scenario copy_checks_size)
-% Hide_errors = true;
-def main [
-  2:point <- copy 1:num
-]
-+error: main: can't copy '1:num' to '2:point'; types don't match
+void test_copy_checks_size() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  2:point <- copy 1:num\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: can't copy '1:num' to '2:point'; types don't match\n"
+  );
+}
 
 :(before "End Mu Types Initialization")
 // A more complex example container, containing another container as one of
@@ -42,55 +54,76 @@ get(Type, point_number).name = "point-number";
 get(Type, point_number).elements.push_back(reagent("xy:point"));
 get(Type, point_number).elements.push_back(reagent("z:number"));
 
-:(scenario copy_handles_nested_container_elements)
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  14:num <- copy 36
-  15:point-number <- copy 12:point-number/unsafe
-]
-+mem: storing 36 in location 17
+:(code)
+void test_copy_handles_nested_container_elements() {
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  14:num <- copy 36\n"
+      "  15:point-number <- copy 12:point-number/unsafe\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 36 in location 17\n"
+  );
+}
 
 //: products of recipes can include containers
-:(scenario return_container)
-def main [
-  3:point <- f 2
-]
-def f [
-  12:num <- next-ingredient
-  13:num <- copy 35
-  return 12:point/raw
-]
-+run: result 0 is [2, 35]
-+mem: storing 2 in location 3
-+mem: storing 35 in location 4
+void test_return_container() {
+  run(
+      "def main [\n"
+      "  3:point <- f 2\n"
+      "]\n"
+      "def f [\n"
+      "  12:num <- next-ingredient\n"
+      "  13:num <- copy 35\n"
+      "  return 12:point/raw\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "run: result 0 is [2, 35]\n"
+      "mem: storing 2 in location 3\n"
+      "mem: storing 35 in location 4\n"
+  );
+}
 
 //: Containers can be checked for equality with a single instruction just like
 //: numbers, no matter how large they are.
 
-:(scenario compare_multiple_locations)
-def main [
-  1:num <- copy 34  # first
-  2:num <- copy 35
-  3:num <- copy 36
-  4:num <- copy 34  # second
-  5:num <- copy 35
-  6:num <- copy 36
-  7:bool <- equal 1:point-number/raw, 4:point-number/unsafe
-]
-+mem: storing 1 in location 7
-
-:(scenario compare_multiple_locations_2)
-def main [
-  1:num <- copy 34  # first
-  2:num <- copy 35
-  3:num <- copy 36
-  4:num <- copy 34  # second
-  5:num <- copy 35
-  6:num <- copy 37  # different
-  7:bool <- equal 1:point-number/raw, 4:point-number/unsafe
-]
-+mem: storing 0 in location 7
+void test_compare_multiple_locations() {
+  run(
+      "def main [\n"
+      "  1:num <- copy 34\n"  // first
+      "  2:num <- copy 35\n"
+      "  3:num <- copy 36\n"
+      "  4:num <- copy 34\n"  // second
+      "  5:num <- copy 35\n"
+      "  6:num <- copy 36\n"
+      "  7:bool <- equal 1:point-number/raw, 4:point-number/unsafe\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 1 in location 7\n"
+  );
+}
+
+void test_compare_multiple_locations_2() {
+  run(
+      "def main [\n"
+      "  1:num <- copy 34\n"  // first
+      "  2:num <- copy 35\n"
+      "  3:num <- copy 36\n"
+      "  4:num <- copy 34\n"  // second
+      "  5:num <- copy 35\n"
+      "  6:num <- copy 37\n"  // different
+      "  7:bool <- equal 1:point-number/raw, 4:point-number/unsafe\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 0 in location 7\n"
+  );
+}
 
 :(before "End size_of(type) Special-cases")
 if (type->value == -1) return 1;  // error value, but we'll raise it elsewhere
@@ -114,26 +147,37 @@ if (t.kind == CONTAINER) {
   return result;
 }
 
-:(scenario stash_container)
-def main [
-  1:num <- copy 34  # first
-  2:num <- copy 35
-  3:num <- copy 36
-  stash [foo:], 1:point-number/raw
-]
-+app: foo: 34 35 36
+:(code)
+void test_stash_container() {
+  run(
+      "def main [\n"
+      "  1:num <- copy 34\n"  // first
+      "  2:num <- copy 35\n"
+      "  3:num <- copy 36\n"
+      "  stash [foo:], 1:point-number/raw\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "app: foo: 34 35 36\n"
+  );
+}
 
 //:: To access elements of a container, use 'get'
 //: 'get' takes a 'base' container and an 'offset' into it and returns the
 //: appropriate element of the container value.
 
-:(scenario get)
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  15:num <- get 12:point/raw, 1:offset  # unsafe
-]
-+mem: storing 35 in location 15
+void test_get() {
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  15:num <- get 12:point/raw, 1:offset\n"  // unsafe
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 35 in location 15\n"
+  );
+}
 
 :(before "End Primitive Recipe Declarations")
 GET,
@@ -223,66 +267,94 @@ const reagent element_type(const type_tree* type, int offset_value) {
   return element;
 }
 
-:(scenario get_handles_nested_container_elements)
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  14:num <- copy 36
-  15:num <- get 12:point-number/raw, 1:offset  # unsafe
-]
-+mem: storing 36 in location 15
-
-:(scenario get_out_of_bounds)
-% Hide_errors = true;
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  14:num <- copy 36
-  get 12:point-number/raw, 2:offset  # point-number occupies 3 locations but has only 2 fields; out of bounds
-]
-+error: main: invalid offset '2' for 'point-number'
-
-:(scenario get_out_of_bounds_2)
-% Hide_errors = true;
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  14:num <- copy 36
-  get 12:point-number/raw, -1:offset
-]
-+error: main: invalid offset '-1' for 'point-number'
-
-:(scenario get_product_type_mismatch)
-% Hide_errors = true;
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  14:num <- copy 36
-  15:&:num <- get 12:point-number/raw, 1:offset
-]
-+error: main: 'get 12:point-number/raw, 1:offset' should write to number but '15' has type (address number)
+void test_get_handles_nested_container_elements() {
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  14:num <- copy 36\n"
+      "  15:num <- get 12:point-number/raw, 1:offset\n"  // unsafe
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 36 in location 15\n"
+  );
+}
+
+void test_get_out_of_bounds() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  14:num <- copy 36\n"
+      "  get 12:point-number/raw, 2:offset\n"  // point-number occupies 3 locations but has only 2 fields; out of bounds
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: invalid offset '2' for 'point-number'\n"
+  );
+}
+
+void test_get_out_of_bounds_2() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  14:num <- copy 36\n"
+      "  get 12:point-number/raw, -1:offset\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: invalid offset '-1' for 'point-number'\n"
+  );
+}
+
+void test_get_product_type_mismatch() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  14:num <- copy 36\n"
+      "  15:&:num <- get 12:point-number/raw, 1:offset\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: 'get 12:point-number/raw, 1:offset' should write to number but '15' has type (address number)\n"
+  );
+}
 
 //: we might want to call 'get' without saving the results, say in a sandbox
 
-:(scenario get_without_product)
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  get 12:point/raw, 1:offset  # unsafe
-]
-# just don't die
+void test_get_without_product() {
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  get 12:point/raw, 1:offset\n"  // unsafe
+      "]\n"
+  );
+  // just don't die
+}
 
 //:: To write to elements of containers, use 'put'.
 
-:(scenario put)
-def main [
-  12:num <- copy 34
-  13:num <- copy 35
-  $clear-trace
-  12:point <- put 12:point, 1:offset, 36
-]
-+mem: storing 36 in location 13
--mem: storing 34 in location 12
+void test_put() {
+  run(
+      "def main [\n"
+      "  12:num <- copy 34\n"
+      "  13:num <- copy 35\n"
+      "  $clear-trace\n"
+      "  12:point <- put 12:point, 1:offset, 36\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 36 in location 13"
+  );
+  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 34 in location 12");
+}
 
 :(before "End Primitive Recipe Declarations")
 PUT,
@@ -367,67 +439,85 @@ case PUT: {
   break;
 }
 
-:(scenario put_product_error)
-% Hide_errors = true;
-def main [
-  local-scope
-  load-ingredients
-  1:point <- merge 34, 35
-  3:point <- put 1:point, x:offset, 36
-]
-+error: main: product of 'put' must be first ingredient '1:point', but got '3:point'
+:(code)
+void test_put_product_error() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  1:point <- merge 34, 35\n"
+      "  3:point <- put 1:point, x:offset, 36\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: product of 'put' must be first ingredient '1:point', but got '3:point'\n"
+  );
+}
 
 //:: Allow containers to be defined in Mu code.
 
-:(scenarios load)
-:(scenario container)
-container foo [
-  x:num
-  y:num
-]
-+parse: --- defining container foo
-+parse: element: {x: "number"}
-+parse: element: {y: "number"}
-
-:(scenario container_use_before_definition)
-container foo [
-  x:num
-  y:bar
-]
-container bar [
-  x:num
-  y:num
-]
-+parse: --- defining container foo
-+parse: type number: 1000
-+parse:   element: {x: "number"}
-# todo: brittle
-# type bar is unknown at this point, but we assign it a number
-+parse:   element: {y: "bar"}
-# later type bar geon
-+parse: --- defining container bar
-+parse: type number: 1001
-+parse:   element: {x: "number"}
-+parse:   element: {y: "number"}
+void test_container() {
+  load(
+      "container foo [\n"
+      "  x:num\n"
+      "  y:num\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "parse: --- defining container foo\n"
+      "parse: element: {x: \"number\"}\n"
+      "parse: element: {y: \"number\"}\n"
+  );
+}
+
+void test_container_use_before_definition() {
+  load(
+      "container foo [\n"
+      "  x:num\n"
+      "  y:bar\n"
+      "]\n"
+      "container bar [\n"
+      "  x:num\n"
+      "  y:num\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "parse: --- defining container foo\n"
+      "parse: type number: 1000\n"
+      "parse:   element: {x: \"number\"}\n"
+      // todo: brittle
+      // type bar is unknown at this point, but we assign it a number
+      "parse:   element: {y: \"bar\"}\n"
+      // later type bar gets a definition
+      "parse: --- defining container bar\n"
+      "parse: type number: 1001\n"
+      "parse:   element: {x: \"number\"}\n"
+      "parse:   element: {y: \"number\"}\n"
+  );
+}
 
 //: if a container is defined again, the new fields add to the original definition
-:(scenarios run)
-:(scenario container_extend)
-container foo [
-  x:num
-]
-# add to previous definition
-container foo [
-  y:num
-]
-def main [
-  1:num <- copy 34
-  2:num <- copy 35
-  3:num <- get 1:foo, 0:offset
-  4:num <- get 1:foo, 1:offset
-]
-+mem: storing 34 in location 3
-+mem: storing 35 in location 4
+void test_container_extend() {
+  run(
+      "container foo [\n"
+      "  x:num\n"
+      "]\n"
+      "container foo [\n"  // add to previous definition
+      "  y:num\n"
+      "]\n"
+      "def main [\n"
+      "  1:num <- copy 34\n"
+      "  2:num <- copy 35\n"
+      "  3:num <- get 1:foo, 0:offset\n"
+      "  4:num <- get 1:foo, 1:offset\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 34 in location 3\n"
+      "mem: storing 35 in location 4\n"
+  );
+}
 
 :(before "End Command Handlers")
 else if (command == "container") {
@@ -521,25 +611,35 @@ void skip_bracket(istream& in, string message) {
     raise << message << '\n' << end();
 }
 
-:(scenario multi_word_line_in_container_declaration)
-% Hide_errors = true;
-container foo [
-  x:num y:num
-]
-+error: container 'foo' contains multiple elements on a single line. Containers and exclusive containers must only contain elements, one to a line, no code.
+void test_multi_word_line_in_container_declaration() {
+  Hide_errors = true;
+  run(
+      "container foo [\n"
+      "  x:num y:num\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: container 'foo' contains multiple elements on a single line. Containers and exclusive containers must only contain elements, one to a line, no code.\n"
+  );
+}
 
 //: support type abbreviations in container definitions
 
-:(scenario type_abbreviations_in_containers)
-type foo = number
-container bar [
-  x:foo
-]
-def main [
-  1:num <- copy 34
-  2:foo <- get 1:bar/unsafe, 0:offset
-]
-+mem: storing 34 in location 2
+void test_type_abbreviations_in_containers() {
+  run(
+      "type foo = number\n"
+      "container bar [\n"
+      "  x:foo\n"
+      "]\n"
+      "def main [\n"
+      "  1:num <- copy 34\n"
+      "  2:foo <- get 1:bar/unsafe, 0:offset\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 34 in location 2\n"
+  );
+}
 
 :(after "Transform.push_back(expand_type_abbreviations)")
 Transform.push_back(expand_type_abbreviations_in_containers);  // idempotent
@@ -579,22 +679,29 @@ void test_error_on_transform_all_between_container_definition_and_extension() {
 //:: Allow container definitions anywhere in the codebase, but complain if you
 //:: can't find a definition at the end.
 
-:(scenario run_complains_on_unknown_types)
-% Hide_errors = true;
-def main [
-  # integer is not a type
-  1:integer <- copy 0
-]
-+error: main: unknown type integer in '1:integer <- copy 0'
-
-:(scenario run_allows_type_definition_after_use)
-def main [
-  1:bar <- copy 0/unsafe
-]
-container bar [
-  x:num
-]
-$error: 0
+void test_run_complains_on_unknown_types() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  1:integer <- copy 0\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: unknown type integer in '1:integer <- copy 0'\n"
+  );
+}
+
+void test_run_allows_type_definition_after_use() {
+  run(
+      "def main [\n"
+      "  1:bar <- copy 0/unsafe\n"
+      "]\n"
+      "container bar [\n"
+      "  x:num\n"
+      "]\n"
+  );
+  CHECK_TRACE_COUNT("error", 0);
+}
 
 :(before "End Type Modifying Transforms")
 Transform.push_back(check_or_set_invalid_types);  // idempotent
@@ -636,29 +743,41 @@ void check_or_set_invalid_types(type_tree* type, const string& location_for_erro
   }
 }
 
-:(scenario container_unknown_field)
-% Hide_errors = true;
-container foo [
-  x:num
-  y:bar
-]
-+error: foo: unknown type in y
-
-:(scenario read_container_with_bracket_in_comment)
-container foo [
-  x:num
-  # ']' in comment
-  y:num
-]
-+parse: --- defining container foo
-+parse: element: {x: "number"}
-+parse: element: {y: "number"}
-
-:(scenario container_with_compound_field_type)
-container foo [
-  {x: (address array (address array character))}
-]
-$error: 0
+void test_container_unknown_field() {
+  Hide_errors = true;
+  run(
+      "container foo [\n"
+      "  x:num\n"
+      "  y:bar\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: unknown type in y\n"
+  );
+}
+
+void test_read_container_with_bracket_in_comment() {
+  run(
+      "container foo [\n"
+      "  x:num\n"
+      "  # ']' in comment\n"
+      "  y:num\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "parse: --- defining container foo\n"
+      "parse: element: {x: \"number\"}\n"
+      "parse: element: {y: \"number\"}\n"
+  );
+}
+void test_container_with_compound_field_type() {
+  run(
+      "container foo [\n"
+      "  {x: (address array (address array character))}\n"
+      "]\n"
+  );
+  CHECK_TRACE_COUNT("error", 0);
+}
 
 :(before "End transform_all")
 check_container_field_types();