2441 - never miss any specializations

I was failing to specialize calls containing literals. And then I had to
deal with whether literals should map to numbers or characters. (Answer:
both.)

One of the issues that still remains: shape-shifting recipes can't be
called with literals for addresses, even if it's 0.

8 files changed, 76 insertions, 37 deletions

diff --git a/010vm.cc b/010vm.cc
index 92721d32..0b2888f0 100644
--- a/010vm.cc
+++ b/010vm.cc
@@ -484,6 +484,16 @@ bool deeply_equal(const string_tree* a, const string_tree* b) {
       && deeply_equal(a->right, b->right);
 }
 
+bool deeply_equal_types(const string_tree* a, const string_tree* b) {
+  if (!a) return !b;
+  if (!b) return !a;
+  if (a->value == "character" && b->value == "number") return true;
+  if (a->value == "number" && b->value == "character") return true;
+  return a->value == b->value
+      && deeply_equal_types(a->left, b->left)
+      && deeply_equal_types(a->right, b->right);
+}
+
 void dump_memory() {
   for (map<long long int, double>::iterator p = Memory.begin(); p != Memory.end(); ++p) {
     cout << p->first << ": " << no_scientific(p->second) << '\n';
diff --git a/021check_instruction.cc b/021check_instruction.cc
index 1d831369..fc1f0a1f 100644
--- a/021check_instruction.cc
+++ b/021check_instruction.cc
@@ -81,11 +81,18 @@ bool types_match(reagent lhs, reagent rhs) {
   if (is_raw(rhs)) return true;
   // allow writing 0 to any address
   if (rhs.name == "0" && is_mu_address(lhs)) return true;
-  if (is_literal(rhs)) return !is_mu_array(lhs) && !is_mu_address(lhs) && size_of(rhs) == size_of(lhs);
+  if (is_literal(rhs)) return valid_type_for_literal(lhs) && size_of(rhs) == size_of(lhs);
   if (!lhs.type) return !rhs.type;
   return types_match(lhs.type, rhs.type);
 }
 
+bool valid_type_for_literal(const reagent& r) {
+  if (is_mu_array(r)) return false;
+  if (is_mu_address(r)) return false;
+  // End valid_type_for_literal Special-cases
+  return true;
+}
+
 // two types match if the second begins like the first
 // (trees perform the same check recursively on each subtree)
 bool types_match(type_tree* lhs, type_tree* rhs) {
@@ -95,6 +102,8 @@ bool types_match(type_tree* lhs, type_tree* rhs) {
     if (lhs->value == get(Type_ordinal, "address")) return false;
     return size_of(rhs) == size_of(lhs);
   }
+  if (lhs->value == get(Type_ordinal, "character") && rhs->value == get(Type_ordinal, "number")) return true;
+  if (lhs->value == get(Type_ordinal, "number") && rhs->value == get(Type_ordinal, "character")) return true;
   if (lhs->value != rhs->value) return false;
   return types_match(lhs->left, rhs->left) && types_match(lhs->right, rhs->right);
 }
diff --git a/041jump_target.cc b/041jump_target.cc
index 0155ae89..00e9fc39 100644
--- a/041jump_target.cc
+++ b/041jump_target.cc
@@ -64,7 +64,7 @@ void replace_offset(reagent& x, /*const*/ map<string, long long int>& offset, co
     x.set_value(0);  // no jump by default
     return;
   }
-  assert(!x.initialized);
+  if (x.initialized) return;
   if (is_integer(x.name)) return;  // non-labels will be handled like other number operands
   if (!is_jump_target(x.name)) {
     raise_error << maybe(get(Recipe, r).name) << "can't jump to label " << x.name << '\n' << end();
diff --git a/059shape_shifting_recipe.cc b/059shape_shifting_recipe.cc
index bc63d616..feffd410 100644
--- a/059shape_shifting_recipe.cc
+++ b/059shape_shifting_recipe.cc
@@ -34,6 +34,11 @@ if (Current_routine->calls.front().running_step_index == 0
   raise_error << "ran into unspecialized shape-shifting recipe " << current_recipe_name() << '\n' << end();
 }
 
+//: Make sure we don't match up literals with type ingredients without
+//: specialization.
+:(before "End valid_type_for_literal Special-cases")
+if (contains_type_ingredient_name(r)) return false;
+
 //: We'll be creating recipes without loading them from anywhere by
 //: *specializing* existing recipes, so make sure we don't clear any of those
 //: when we start running tests.
@@ -202,14 +207,16 @@ void save_or_deduce_type_name(reagent& x, map<string, string_tree*>& type_name)
 }
 
 void compute_type_ingredient_mappings(const recipe& exemplar, const instruction& inst, map<string, const string_tree*>& mappings, const recipe& caller_recipe, bool* error) {
-  for (long long int i = 0; i < SIZE(exemplar.ingredients); ++i) {
+  long long int limit = min(SIZE(inst.ingredients), SIZE(exemplar.ingredients));
+  for (long long int i = 0; i < limit; ++i) {
     const reagent& exemplar_reagent = exemplar.ingredients.at(i);
     reagent ingredient = inst.ingredients.at(i);
     assert(ingredient.properties.at(0).second);
     canonize_type(ingredient);
     accumulate_type_ingredients(exemplar_reagent, ingredient, mappings, exemplar, inst, caller_recipe, error);
   }
-  for (long long int i = 0; i < SIZE(exemplar.products); ++i) {
+  limit = min(SIZE(inst.products), SIZE(exemplar.products));
+  for (long long int i = 0; i < limit; ++i) {
     const reagent& exemplar_reagent = exemplar.products.at(i);
     reagent product = inst.products.at(i);
     assert(product.properties.at(0).second);
@@ -218,6 +225,10 @@ void compute_type_ingredient_mappings(const recipe& exemplar, const instruction&
   }
 }
 
+inline long long int min(long long int a, long long int b) {
+  return (a < b) ? a : b;
+}
+
 void accumulate_type_ingredients(const reagent& exemplar_reagent, reagent& refinement, map<string, const string_tree*>& mappings, const recipe& exemplar, const instruction& call_instruction, const recipe& caller_recipe, bool* error) {
   assert(refinement.properties.at(0).second);
   accumulate_type_ingredients(exemplar_reagent.properties.at(0).second, refinement.properties.at(0).second, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error);
@@ -237,10 +248,13 @@ void accumulate_type_ingredients(const string_tree* exemplar_type, const string_
     }
     if (!contains_key(mappings, exemplar_type->value)) {
       trace(9993, "transform") << "adding mapping from " << exemplar_type->value << " to " << debug_string(refinement_type) << end();
-      put(mappings, exemplar_type->value, new string_tree(*refinement_type));
+      if (refinement_type->value == "literal")
+        put(mappings, exemplar_type->value, new string_tree("number"));
+      else
+        put(mappings, exemplar_type->value, new string_tree(*refinement_type));
     }
     else {
-      if (!deeply_equal(get(mappings, exemplar_type->value), refinement_type)) {
+      if (!deeply_equal_types(get(mappings, exemplar_type->value), refinement_type)) {
         raise_error << maybe(caller_recipe.name) << "no call found for '" << call_instruction.to_string() << "'\n" << end();
         *error = true;
         return;
@@ -467,3 +481,29 @@ recipe bar x:_elem -> y:_elem [
   y <- add x, 1
 ]
 +mem: storing 4 in location 1
+
+:(scenario specialize_with_literal)
+recipe main [
+  local-scope
+  # permit literal to map to number
+  1:number/raw <- foo 3
+]
+recipe foo x:_elem -> y:_elem [
+  local-scope
+  load-ingredients
+  y <- add x, 1
+]
++mem: storing 4 in location 1
+
+:(scenario specialize_with_literal_2)
+recipe main [
+  local-scope
+  # permit literal to map to character
+  1:character/raw <- foo 3
+]
+recipe foo x:_elem -> y:_elem [
+  local-scope
+  load-ingredients
+  y <- add x, 1
+]
++mem: storing 4 in location 1
diff --git a/073list.mu b/073list.mu
index a1076792..7d8c2297 100644
--- a/073list.mu
+++ b/073list.mu
@@ -32,18 +32,10 @@ recipe rest in:address:list:_elem -> result:address:list:_elem [
   result <- get *in, next:offset
 ]
 
-recipe force-specialization-list-number [
-  1:address:list:number <- push 2:number, 1:address:list:number
-  2:number <- first 1:address:list:number
-  1:address:list:number <- rest 1:address:list:number
-]
-
-# todo: automatically specialize code in scenarios
 scenario list-handling [
   run [
     1:address:list:number <- copy 0
-    2:number <- copy 3
-    1:address:list:number <- push 2:number, 1:address:list:number
+    1:address:list:number <- push 3, 1:address:list:number
     1:address:list:number <- push 4, 1:address:list:number
     1:address:list:number <- push 5, 1:address:list:number
     2:number <- first 1:address:list:number
diff --git a/075duplex_list.mu b/075duplex_list.mu
index 765a6a17..168c0b88 100644
--- a/075duplex_list.mu
+++ b/075duplex_list.mu
@@ -356,10 +356,8 @@ scenario removing-from-singleton-list [
   ]
 ]
 
-# l:address:duplex-list <- remove-duplex-between start:address:duplex-list, end:address:duplex-list
-# Remove values between 'start' and 'end' (both exclusive). Returns some valid
-# pointer into the rest of the list.
-# Also clear pointers back out from start/end for hygiene.
+# remove values between 'start' and 'end' (both exclusive)
+# also clear pointers back out from start/end for hygiene
 recipe remove-duplex-between start:address:duplex-list:_elem, end:address:duplex-list:_elem -> start:address:duplex-list:_elem [
   local-scope
   load-ingredients
@@ -383,7 +381,7 @@ recipe remove-duplex-between start:address:duplex-list:_elem, end:address:duplex
 
 scenario remove-range [
   # construct a duplex list with six elements [13, 14, 15, 16, 17, 18]
-  1:address:duplex-list:character <- copy 0  # 1 points to singleton list
+  1:address:duplex-list:character <- copy 0
   1:address:duplex-list:character <- push-duplex 18, 1:address:duplex-list:character
   1:address:duplex-list:character <- push-duplex 17, 1:address:duplex-list:character
   1:address:duplex-list:character <- push-duplex 16, 1:address:duplex-list:character
@@ -395,7 +393,8 @@ scenario remove-range [
     # first pointer: to the third element
     2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character
     2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character
-    2:address:duplex-list:character <- remove-duplex-between 2:address:duplex-list:character, 0
+    3:address:duplex-list:character <- copy 0
+    2:address:duplex-list:character <- remove-duplex-between 2:address:duplex-list:character, 3:address:duplex-list:character/null
     # now check the list
     4:character <- get *1:address:duplex-list:character, value:offset
     5:address:duplex-list:character <- next-duplex 1:address:duplex-list:character
@@ -414,7 +413,7 @@ scenario remove-range [
 
 scenario remove-range-to-end [
   # construct a duplex list with six elements [13, 14, 15, 16, 17, 18]
-  1:address:duplex-list:character <- copy 0  # 1 points to singleton list
+  1:address:duplex-list:character <- copy 0
   1:address:duplex-list:character <- push-duplex 18, 1:address:duplex-list:character
   1:address:duplex-list:character <- push-duplex 17, 1:address:duplex-list:character
   1:address:duplex-list:character <- push-duplex 16, 1:address:duplex-list:character
@@ -540,16 +539,3 @@ recipe dump-duplex-from x:address:duplex-list:_elem [
   }
   $print 10/newline, [---], 10/newline
 ]
-
-recipe force-specialization-duplex-list-character [
-  1:address:duplex-list:character <- push-duplex 2:character, 1:address:duplex-list:character
-  2:character <- first-duplex 1:address:duplex-list:character
-  1:address:duplex-list:character <- next-duplex 1:address:duplex-list:character
-  1:address:duplex-list:character <- prev-duplex 1:address:duplex-list:character
-  1:address:duplex-list:character <- insert-duplex 2:character, 1:address:duplex-list:character
-  1:address:duplex-list:character <- remove-duplex 1:address:duplex-list:character
-  1:address:duplex-list:character <- remove-duplex-between 1:address:duplex-list:character, 1:address:duplex-list:character
-  1:address:duplex-list:character <- insert-duplex-range 1:address:duplex-list:character, 1:address:duplex-list:character
-  1:address:duplex-list:character <- append-duplex 1:address:duplex-list:character, 1:address:duplex-list:character
-  1:address:duplex-list:character <- last-duplex 1:address:duplex-list:character
-]
diff --git a/edit/001-editor.mu b/edit/001-editor.mu
index 4b8da7a8..97953274 100644
--- a/edit/001-editor.mu
+++ b/edit/001-editor.mu
@@ -64,7 +64,8 @@ recipe new-editor s:address:array:character, screen:address:screen, left:number,
   x <- get-address *result, cursor-column:offset
   *x <- copy left
   init:address:address:duplex-list:character <- get-address *result, data:offset
-  *init <- push-duplex 167/§, 0/tail
+  *init <- copy 0
+  *init <- push-duplex 167/§, *init
   top-of-screen:address:address:duplex-list:character <- get-address *result, top-of-screen:offset
   *top-of-screen <- copy *init
   y:address:address:duplex-list:character <- get-address *result, before-cursor:offset
diff --git a/edit/005-sandbox.mu b/edit/005-sandbox.mu
index 358d148c..53e42701 100644
--- a/edit/005-sandbox.mu
+++ b/edit/005-sandbox.mu
@@ -151,7 +151,8 @@ recipe run-sandboxes env:address:programming-environment-data, screen:address:sc
     *dest <- copy new-sandbox
     # clear sandbox editor
     init:address:address:duplex-list:character <- get-address *current-sandbox, data:offset
-    *init <- push-duplex 167/§, 0/tail
+    *init <- copy 0
+    *init <- push-duplex 167/§, *init
     top-of-screen:address:address:duplex-list:character <- get-address *current-sandbox, top-of-screen:offset
     *top-of-screen <- copy *init
   }