2406

One new issue: the traces for all tests are perturbed by the .mu files we
choose to load.

8 files changed, 49 insertions, 80 deletions

diff --git a/010vm.cc b/010vm.cc
index 6b7d58ff..6512158c 100644
--- a/010vm.cc
+++ b/010vm.cc
@@ -145,13 +145,9 @@ void setup_types() {
   // End Mu Types Initialization
 }
 void teardown_types() {
-  // todo: why can't I just Type.clear()?
   for (map<type_ordinal, type_info>::iterator p = Type.begin(); p != Type.end(); ++p) {
-    if (!p->second.name.empty()) {
-      for (long long int i = 0; i < SIZE(p->second.elements); ++i) {
-        delete p->second.elements.at(i);
-      }
-    }
+    for (long long int i = 0; i < SIZE(p->second.elements); ++i)
+      delete p->second.elements.at(i);
   }
   Type_ordinal.clear();
 }
@@ -313,9 +309,8 @@ string_tree::string_tree(const string_tree& old) {  // :value(old.value) {
 reagent& reagent::operator=(const reagent& old) {
   original_string = old.original_string;
   properties.clear();
-  for (long long int i = 0; i < SIZE(old.properties); ++i) {
+  for (long long int i = 0; i < SIZE(old.properties); ++i)
     properties.push_back(pair<string, string_tree*>(old.properties.at(i).first, old.properties.at(i).second ? new string_tree(*old.properties.at(i).second) : NULL));
-  }
   name = old.name;
   value = old.value;
   initialized = old.initialized;
@@ -324,9 +319,8 @@ reagent& reagent::operator=(const reagent& old) {
 }
 
 reagent::~reagent() {
-  for (long long int i = 0; i < SIZE(properties); ++i) {
+  for (long long int i = 0; i < SIZE(properties); ++i)
     if (properties.at(i).second) delete properties.at(i).second;
-  }
   delete type;
 }
 type_tree::~type_tree() {
@@ -365,9 +359,7 @@ string debug_string(const reagent& x) {
 }
 
 string debug_string(const string_tree* property) {
-  if (!property) {
-    return "<>";
-  }
+  if (!property) return "<>";
   ostringstream out;
   if (!property->left && !property->right)
     // abbreviate a single-node tree to just its contents
@@ -393,9 +385,7 @@ void dump_property_tree(const string_tree* property, ostream& out) {
 
 string debug_string(const type_tree* type) {
   // abbreviate a single-node tree to just its contents
-  if (!type) {
-    return "NULLNULLNULL";  // should never happen
-  }
+  if (!type) return "NULLNULLNULL";  // should never happen
   ostringstream out;
   if (!type->left && !type->right)
     dump_type_name(type->value, out);
@@ -502,9 +492,8 @@ void dump_memory() {
 string recipe::to_string() const {
   ostringstream out;
   out << "recipe " << name << " [\n";
-  for (long long int i = 0; i < SIZE(steps); ++i) {
+  for (long long int i = 0; i < SIZE(steps); ++i)
     out << "  " << steps.at(i).to_string() << '\n';
-  }
   out << "]\n";
   return out.str();
 }
diff --git a/020run.cc b/020run.cc
index fad6a5b0..a1f0ad01 100644
--- a/020run.cc
+++ b/020run.cc
@@ -267,6 +267,10 @@ vector<double> read_memory(reagent x) {
 }
 
 void write_memory(reagent x, vector<double> data) {
+  if (!x.type) {
+    raise_error << "can't write to " << x.to_string() << "; no type\n" << end();
+    return;
+  }
   if (is_dummy(x)) return;
   if (is_literal(x)) return;
   long long int base = x.value;
diff --git a/030container.cc b/030container.cc
index 94310855..3684a5ce 100644
--- a/030container.cc
+++ b/030container.cc
@@ -481,9 +481,7 @@ while(p != Type_ordinal.end()) {
   // increment iterator
   ++p;
   // now delete current item if necessary
-  if (t >= 1000) {
-    Type_ordinal.erase(name);
-  }
+  if (t >= 1000) Type_ordinal.erase(name);
 }
 //: lastly, ensure scenarios are consistent by always starting them at the
 //: same type number.
@@ -580,9 +578,8 @@ void check_container_field_types() {
   for (map<type_ordinal, type_info>::iterator p = Type.begin(); p != Type.end(); ++p) {
     const type_info& info = p->second;
     // Check Container Field Types(info)
-    for (long long int i = 0; i < SIZE(info.elements); ++i) {
+    for (long long int i = 0; i < SIZE(info.elements); ++i)
       check_invalid_types(info.elements.at(i), maybe(info.name), info.element_names.at(i));
-    }
   }
 }
 
@@ -602,7 +599,6 @@ void check_invalid_types(const recipe_ordinal r) {
 
 void check_invalid_types(type_tree* type, const string& block, const string& name) {
   if (!type) return;  // will throw a more precise error elsewhere
-//?   cerr << "checking ";  dump_types(type, cerr);  cerr << '\n';
   // End Container Type Checks
   if (type->value == 0) {
     assert(!type->left && !type->right);
diff --git a/036call_reply.cc b/036call_reply.cc
index 2bc6485c..68bc533c 100644
--- a/036call_reply.cc
+++ b/036call_reply.cc
@@ -42,14 +42,12 @@ case REPLY: {
   for (long long int i = 0; i < SIZE(caller_instruction.products); ++i) {
     if (has_property(caller_instruction.products.at(i), "skiptypecheck")) continue;  // todo: drop this once we have generic containers
     if (!types_match(caller_instruction.products.at(i), reply_inst.ingredients.at(i))) {
-      raise_error << maybe(callee) << "reply ingredient " << reply_inst.ingredients.at(i).to_string() << " can't be saved in " << caller_instruction.products.at(i).to_string() << '\n' << end();
+      raise_error << maybe(callee) << "reply ingredient " << reply_inst.ingredients.at(i).original_string << " can't be saved in " << caller_instruction.products.at(i).original_string << '\n' << end();
       reagent lhs = reply_inst.ingredients.at(i);
       canonize_type(lhs);
       reagent rhs = caller_instruction.products.at(i);
       canonize_type(rhs);
-      raise_error << debug_string(lhs.type) << " ==== vs === " << debug_string(rhs.type) << '\n' << end();
-      DUMP("");
-      exit(0);
+      raise_error << debug_string(lhs.type) << " vs " << debug_string(rhs.type) << '\n' << end();
       goto finish_reply;
     }
   }
@@ -91,19 +89,18 @@ recipe f [
 +mem: storing 2 in location 3
 +mem: storing 35 in location 4
 
-:(code)
-//? :(scenario reply_type_mismatch)
-//? % Hide_errors = true;
-//? recipe main [
-//?   3:number <- f 2
-//? ]
-//? recipe f [
-//?   12:number <- next-ingredient
-//?   13:number <- copy 35
-//?   14:point <- copy 12:point/raw
-//?   reply 14:point
-//? ]
-//? +error: f: reply ingredient 14:point can't be saved in 3:number
+:(scenario reply_type_mismatch)
+% Hide_errors = true;
+recipe main [
+  3:number <- f 2
+]
+recipe f [
+  12:number <- next-ingredient
+  13:number <- copy 35
+  14:point <- copy 12:point/raw
+  reply 14:point
+]
++error: f: reply ingredient 14:point can't be saved in 3:number
 
 //: In mu we'd like to assume that any instruction doesn't modify its
 //: ingredients unless they're also products. The /same-as-ingredient inside
diff --git a/043new.cc b/043new.cc
index c442f58a..dd0fac14 100644
--- a/043new.cc
+++ b/043new.cc
@@ -98,12 +98,11 @@ case ALLOCATE: {
   products.resize(1);
   products.at(0).push_back(result);
   // initialize allocated space
-  for (long long int address = result; address < result+size; ++address) {
+  for (long long int address = result; address < result+size; ++address)
     put(Memory, address, 0);
-  }
-  if (SIZE(current_instruction().ingredients) > 1) {
-    put(Memory, result, ingredients.at(1).at(0));  // array length
-  }
+  // initialize array length
+  if (SIZE(current_instruction().ingredients) > 1)
+    put(Memory, result, ingredients.at(1).at(0));
   // bump
   Current_routine->alloc += size;
   // no support for reclaiming memory
diff --git a/056recipe_header.cc b/056recipe_header.cc
index a6ffa629..66e5217b 100644
--- a/056recipe_header.cc
+++ b/056recipe_header.cc
@@ -113,13 +113,11 @@ void check_header_products(const recipe_ordinal r) {
   for (long long int i = 0; i < SIZE(rr.steps); ++i) {
     const instruction& inst = rr.steps.at(i);
     if (inst.name != "reply") continue;
-    if (SIZE(rr.products) != SIZE(inst.ingredients)) {
+    if (SIZE(rr.products) != SIZE(inst.ingredients))
       raise_error << maybe(rr.name) << "tried to reply the wrong number of products in '" << inst.to_string() << "'\n" << end();
-    }
     for (long long int i = 0; i < SIZE(rr.products); ++i) {
-      if (!types_match(rr.products.at(i), inst.ingredients.at(i))) {
+      if (!types_match(rr.products.at(i), inst.ingredients.at(i)))
         raise_error << maybe(rr.name) << "replied with the wrong type at '" << inst.to_string() << "'\n" << end();
-      }
     }
   }
 }
diff --git a/057static_dispatch.cc b/057static_dispatch.cc
index e294b16d..2047db7a 100644
--- a/057static_dispatch.cc
+++ b/057static_dispatch.cc
@@ -83,9 +83,8 @@ string next_unused_recipe_name(const string& recipe_name) {
   for (long long int i = 2; ; ++i) {
     ostringstream out;
     out << recipe_name << '_' << i;
-    if (Recipe_ordinal.find(out.str()) == Recipe_ordinal.end()) {
+    if (Recipe_ordinal.find(out.str()) == Recipe_ordinal.end())
       return out.str();
-    }
   }
 }
 
@@ -105,8 +104,7 @@ recipe test a:number, b:number -> z:number [
 +mem: storing 2 in location 7
 
 //: after insert_fragments (tangle) and before computing operation ids
-//: after filling in all missing types (because we'll be specializing generics
-//: here in a later layer)
+//: after filling in all missing types (because we'll be specializing generics here in a later layer)
 :(after "Transform.push_back(deduce_types_from_header)")
 Transform.push_back(resolve_ambiguous_calls);  // idempotent
 
diff --git a/059generic_recipe.cc b/059generic_recipe.cc
index 2c91c669..6f6ca5c8 100644
--- a/059generic_recipe.cc
+++ b/059generic_recipe.cc
@@ -151,21 +151,17 @@ recipe_ordinal new_variant(recipe_ordinal exemplar, const instruction& inst) {
 void compute_type_names(recipe& variant) {
   trace(9993, "transform") << "compute type names: " << variant.name << end();
   map<string, string_tree*> type_names;
-  for (long long int i = 0; i < SIZE(variant.ingredients); ++i) {
+  for (long long int i = 0; i < SIZE(variant.ingredients); ++i)
     save_or_deduce_type_name(variant.ingredients.at(i), type_names);
-  }
-  for (long long int i = 0; i < SIZE(variant.products); ++i) {
+  for (long long int i = 0; i < SIZE(variant.products); ++i)
     save_or_deduce_type_name(variant.products.at(i), type_names);
-  }
   for (long long int i = 0; i < SIZE(variant.steps); ++i) {
     instruction& inst = variant.steps.at(i);
     trace(9993, "transform") << "  instruction: " << inst.to_string() << end();
-    for (long long int in = 0; in < SIZE(inst.ingredients); ++in) {
+    for (long long int in = 0; in < SIZE(inst.ingredients); ++in)
       save_or_deduce_type_name(inst.ingredients.at(in), type_names);
-    }
-    for (long long int out = 0; out < SIZE(inst.products); ++out) {
+    for (long long int out = 0; out < SIZE(inst.products); ++out)
       save_or_deduce_type_name(inst.products.at(out), type_names);
-    }
   }
 }
 
@@ -238,23 +234,19 @@ void replace_type_ingredients(recipe& new_recipe, const map<string, const string
   // update its header
   if (mappings.empty()) return;
   trace(9993, "transform") << "replacing in recipe header ingredients" << end();
-  for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i) {
+  for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i)
     replace_type_ingredients(new_recipe.ingredients.at(i), mappings);
-  }
   trace(9993, "transform") << "replacing in recipe header products" << end();
-  for (long long int i = 0; i < SIZE(new_recipe.products); ++i) {
+  for (long long int i = 0; i < SIZE(new_recipe.products); ++i)
     replace_type_ingredients(new_recipe.products.at(i), mappings);
-  }
   // update its body
   for (long long int i = 0; i < SIZE(new_recipe.steps); ++i) {
     instruction& inst = new_recipe.steps.at(i);
     trace(9993, "transform") << "replacing in instruction '" << inst.to_string() << "'" << end();
-    for (long long int j = 0; j < SIZE(inst.ingredients); ++j) {
+    for (long long int j = 0; j < SIZE(inst.ingredients); ++j)
       replace_type_ingredients(inst.ingredients.at(j), mappings);
-    }
-    for (long long int j = 0; j < SIZE(inst.products); ++j) {
+    for (long long int j = 0; j < SIZE(inst.products); ++j)
       replace_type_ingredients(inst.products.at(j), mappings);
-    }
     // special-case for new: replace type ingredient in first ingredient *value*
     if (inst.name == "new" && inst.ingredients.at(0).name.at(0) != '[') {
       string_tree* type_name = parse_string_tree(inst.ingredients.at(0).name);
@@ -291,30 +283,26 @@ void replace_type_ingredients(string_tree* type, const map<string, const string_
 }
 
 void ensure_all_concrete_types(const recipe& new_recipe) {
-  for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i) {
+  for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i)
     ensure_all_concrete_types(new_recipe.ingredients.at(i).type);
-  }
-  for (long long int i = 0; i < SIZE(new_recipe.products); ++i) {
+  for (long long int i = 0; i < SIZE(new_recipe.products); ++i)
     ensure_all_concrete_types(new_recipe.products.at(i).type);
-  }
   for (long long int i = 0; i < SIZE(new_recipe.steps); ++i) {
     const instruction& inst = new_recipe.steps.at(i);
-    for (long long int j = 0; j < SIZE(inst.ingredients); ++j) {
+    for (long long int j = 0; j < SIZE(inst.ingredients); ++j)
       ensure_all_concrete_types(inst.ingredients.at(j).type);
-    }
-    for (long long int j = 0; j < SIZE(inst.products); ++j) {
+    for (long long int j = 0; j < SIZE(inst.products); ++j)
       ensure_all_concrete_types(inst.products.at(j).type);
-    }
   }
 }
 
 void ensure_all_concrete_types(const type_tree* x) {
   if (!x) {
-    raise << "AAA null type\n" << end();
+    raise << "null type\n" << end();
     return;
   }
   if (x->value == -1) {
-    raise << "AAA unknown type\n" << end();
+    raise << "unknown type\n" << end();
     return;
   }
 }