1 files changed, 32 insertions, 32 deletions

diff --git a/059shape_shifting_recipe.cc b/059shape_shifting_recipe.cc
index dd874bb7..e8c3fcdf 100644
--- a/059shape_shifting_recipe.cc
+++ b/059shape_shifting_recipe.cc
@@ -121,14 +121,14 @@ bool all_concrete_header_reagents_strictly_match(const instruction& inst, const
     return false;
   }
   for (long long int i = 0; i < SIZE(variant.ingredients); ++i) {
-    if (!concrete_types_strictly_match(variant.ingredients.at(i), inst.ingredients.at(i))) {
+    if (!concrete_type_names_strictly_match(variant.ingredients.at(i), inst.ingredients.at(i))) {
       trace(9993, "transform") << "concrete-type match failed: ingredient " << i << end();
       return false;
     }
   }
   for (long long int i = 0; i < SIZE(inst.products); ++i) {
     if (is_dummy(inst.products.at(i))) continue;
-    if (!concrete_types_strictly_match(variant.products.at(i), inst.products.at(i))) {
+    if (!concrete_type_names_strictly_match(variant.products.at(i), inst.products.at(i))) {
       trace(9993, "transform") << "strict match failed: product " << i << end();
       return false;
     }
@@ -142,7 +142,7 @@ recipe_ordinal best_shape_shifting_variant(const instruction& inst, vector<recip
   // primary score
   long long int max_score = -1;
   for (long long int i = 0; i < SIZE(candidates); ++i) {
-    long long int score = number_of_concrete_types(candidates.at(i));
+    long long int score = number_of_concrete_type_names(candidates.at(i));
     assert(score > -1);
     if (score > max_score) max_score = score;
   }
@@ -150,7 +150,7 @@ recipe_ordinal best_shape_shifting_variant(const instruction& inst, vector<recip
   long long int min_score2 = 999;
   long long int best_index = 0;
   for (long long int i = 0; i < SIZE(candidates); ++i) {
-    long long int score1 = number_of_concrete_types(candidates.at(i));
+    long long int score1 = number_of_concrete_type_names(candidates.at(i));
     assert(score1 <= max_score);
     if (score1 != max_score) continue;
     const recipe& candidate = get(Recipe, candidates.at(i));
@@ -178,63 +178,63 @@ bool any_type_ingredient_in_header(recipe_ordinal variant) {
   return false;
 }
 
-bool concrete_types_strictly_match(reagent to, reagent from) {
+bool concrete_type_names_strictly_match(reagent to, reagent from) {
   canonize_type(to);
   canonize_type(from);
-  return concrete_types_strictly_match(to.properties.at(0).second, from.properties.at(0).second, from);
+  return concrete_type_names_strictly_match(to.type, from.type, from);
 }
 
-long long int number_of_concrete_types(recipe_ordinal r) {
+long long int number_of_concrete_type_names(recipe_ordinal r) {
   const recipe& caller = get(Recipe, r);
   long long int result = 0;
   for (long long int i = 0; i < SIZE(caller.ingredients); ++i)
-    result += number_of_concrete_types(caller.ingredients.at(i));
+    result += number_of_concrete_type_names(caller.ingredients.at(i));
   for (long long int i = 0; i < SIZE(caller.products); ++i)
-    result += number_of_concrete_types(caller.products.at(i));
+    result += number_of_concrete_type_names(caller.products.at(i));
   return result;
 }
 
-long long int number_of_concrete_types(const reagent& r) {
-  return number_of_concrete_types(r.properties.at(0).second);
+long long int number_of_concrete_type_names(const reagent& r) {
+  return number_of_concrete_type_names(r.type);
 }
 
-long long int number_of_concrete_types(const string_tree* type) {
+long long int number_of_concrete_type_names(const type_tree* type) {
   if (!type) return 0;
   long long int result = 0;
-  if (!type->value.empty() && !is_type_ingredient_name(type->value))
+  if (!type->name.empty() && !is_type_ingredient_name(type->name))
     result++;
-  result += number_of_concrete_types(type->left);
-  result += number_of_concrete_types(type->right);
+  result += number_of_concrete_type_names(type->left);
+  result += number_of_concrete_type_names(type->right);
   return result;
 }
 
-bool concrete_types_strictly_match(const string_tree* to, const string_tree* from, const reagent& rhs_reagent) {
+bool concrete_type_names_strictly_match(const type_tree* to, const type_tree* from, const reagent& rhs_reagent) {
   if (!to) return !from;
   if (!from) return !to;
-  if (is_type_ingredient_name(to->value)) return true;  // type ingredient matches anything
-  if (to->value == "literal" && from->value == "literal")
+  if (is_type_ingredient_name(to->name)) return true;  // type ingredient matches anything
+  if (to->name == "literal" && from->name == "literal")
     return true;
-  if (to->value == "literal"
-      && Literal_type_names.find(from->value) != Literal_type_names.end())
+  if (to->name == "literal"
+      && Literal_type_names.find(from->name) != Literal_type_names.end())
     return true;
-  if (from->value == "literal"
-      && Literal_type_names.find(to->value) != Literal_type_names.end())
+  if (from->name == "literal"
+      && Literal_type_names.find(to->name) != Literal_type_names.end())
     return true;
-  if (from->value == "literal" && to->value == "address")
+  if (from->name == "literal" && to->name == "address")
     return rhs_reagent.name == "0";
-//?   cerr << to->value << " vs " << from->value << '\n';
-  return to->value == from->value
-      && concrete_types_strictly_match(to->left, from->left, rhs_reagent)
-      && concrete_types_strictly_match(to->right, from->right, rhs_reagent);
+//?   cerr << to->name << " vs " << from->name << '\n';
+  return to->name == from->name
+      && concrete_type_names_strictly_match(to->left, from->left, rhs_reagent)
+      && concrete_type_names_strictly_match(to->right, from->right, rhs_reagent);
 }
 
 bool contains_type_ingredient_name(const reagent& x) {
-  return contains_type_ingredient_name(x.properties.at(0).second);
+  return contains_type_ingredient_name(x.type);
 }
 
-bool contains_type_ingredient_name(const string_tree* type) {
+bool contains_type_ingredient_name(const type_tree* type) {
   if (!type) return false;
-  if (is_type_ingredient_name(type->value)) return true;
+  if (is_type_ingredient_name(type->name)) return true;
   return contains_type_ingredient_name(type->left) || contains_type_ingredient_name(type->right);
 }
 
@@ -301,7 +301,7 @@ void save_or_deduce_type_name(reagent& x, map<string, string_tree*>& type_name,
     return;
   }
   if (contains_key(type_name, x.name)) return;
-  if (x.properties.at(0).second->value == "offset" || x.properties.at(0).second->value == "variant") return;  // special-case for container-access instructions
+  if (x.type->name == "offset" || x.type->name == "variant") return;  // special-case for container-access instructions
   put(type_name, x.name, x.properties.at(0).second);
   trace(9993, "transform") << "type of " << x.name << " is " << to_string(x.properties.at(0).second) << end();
 }
@@ -390,7 +390,7 @@ void replace_type_ingredients(recipe& new_recipe, const map<string, const string
     for (long long int j = 0; j < SIZE(inst.products); ++j)
       replace_type_ingredients(inst.products.at(j), mappings, new_recipe);
     // special-case for new: replace type ingredient in first ingredient *value*
-    if (inst.name == "new" && inst.ingredients.at(0).properties.at(0).second->value != "literal-string") {
+    if (inst.name == "new" && inst.ingredients.at(0).type->name != "literal-string") {
       string_tree* type_name = parse_string_tree(inst.ingredients.at(0).name);
       replace_type_ingredients(type_name, mappings);
       inst.ingredients.at(0).name = inspect(type_name);