move over all expansion view rules to new eval-system lookup hooks; eliminate most of old hooks

src/eval/eval_ir.c

@@ -90,6 +90,11 @@ e_lookup_rule_map_insert(Arena *arena, E_LookupRuleMap *map, E_LookupRule *rule)
   E_LookupRuleNode *n = push_array(arena, E_LookupRuleNode, 1);
   SLLQueuePush(map->slots[slot_idx].first, map->slots[slot_idx].last, n);
   MemoryCopyStruct(&n->v, rule);
+  if(n->v.info == 0)       { n->v.info = E_LOOKUP_INFO_FUNCTION_NAME(default); }
+  if(n->v.access == 0)     { n->v.access = E_LOOKUP_ACCESS_FUNCTION_NAME(default); }
+  if(n->v.range == 0)      { n->v.range = E_LOOKUP_RANGE_FUNCTION_NAME(default); }
+  if(n->v.id_from_num == 0){ n->v.id_from_num = E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(default); }
+  if(n->v.num_from_id == 0){ n->v.num_from_id = E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(default); }
   n->v.name = push_str8_copy(arena, n->v.name);
 }
 
@@ -155,9 +160,18 @@ E_LOOKUP_INFO_FUNCTION_DEF(default)
   return lookup_info;
 }
 
-E_LOOKUP_FUNCTION_DEF(default)
+E_LOOKUP_ACCESS_FUNCTION_DEF(default)
 {
-  E_Lookup lookup = {{&e_irnode_nil}};
+  //
+  // TODO(rjf): need to define what it means to access a set expression
+  // whose type *does not* define its IR generation rules, BUT it does
+  // define specific child expressions. so e.g. `watches`, does not
+  // define `watches[0]`, because it has defined that `watches[0]`
+  // maps to another expression, which is whatever the first watch
+  // expression is (e.g. `basics`). so, in that case, we can just use
+  // the lookup-range rule, grab the Nth expression, and IR-ify *that*.
+  //
+  E_LookupAccess result = {{&e_irnode_nil}};
   switch(kind)
   {
     default:{}break;
@@ -180,7 +194,7 @@ E_LOOKUP_FUNCTION_DEF(default)
         check_type_key = e_type_unwrap(e_type_direct_from_key(e_type_unwrap(l_restype)));
         check_type_kind = e_type_kind_from_key(check_type_key);
       }
-      e_msg_list_concat_in_place(&lookup.irtree_and_type.msgs, &l.msgs);
+      e_msg_list_concat_in_place(&result.irtree_and_type.msgs, &l.msgs);
       
       // rjf: look up member
       B32 r_found = 0;
@@ -234,12 +248,12 @@ E_LOOKUP_FUNCTION_DEF(default)
       }
       else if(exprr->kind != E_ExprKind_LeafMember)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Expected member name.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Expected member name.");
         break;
       }
       else if(!r_found)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Could not find a member named `%S`.", exprr->string);
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Could not find a member named `%S`.", exprr->string);
         break;
       }
       else if(check_type_kind != E_TypeKind_Struct &&
@@ -247,7 +261,7 @@ E_LOOKUP_FUNCTION_DEF(default)
               check_type_kind != E_TypeKind_Union &&
               check_type_kind != E_TypeKind_Enum)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot perform member access on this type.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot perform member access on this type.");
         break;
       }
       
@@ -275,9 +289,9 @@ E_LOOKUP_FUNCTION_DEF(default)
         }
         
         // rjf: fill
-        lookup.irtree_and_type.root     = new_tree;
-        lookup.irtree_and_type.type_key = r_type;
-        lookup.irtree_and_type.mode     = mode;
+        result.irtree_and_type.root     = new_tree;
+        result.irtree_and_type.type_key = r_type;
+        result.irtree_and_type.mode     = mode;
       }
     }break;
     
@@ -302,8 +316,8 @@ E_LOOKUP_FUNCTION_DEF(default)
       direct_type = e_type_direct_from_key(direct_type);
       direct_type = e_type_unwrap(direct_type);
       U64 direct_type_size = e_type_byte_size_from_key(direct_type);
-      e_msg_list_concat_in_place(&lookup.irtree_and_type.msgs, &l.msgs);
-      e_msg_list_concat_in_place(&lookup.irtree_and_type.msgs, &r.msgs);
+      e_msg_list_concat_in_place(&result.irtree_and_type.msgs, &l.msgs);
+      e_msg_list_concat_in_place(&result.irtree_and_type.msgs, &r.msgs);
       
       // rjf: bad conditions? -> error if applicable, exit
       if(r.root->op == 0)
@@ -312,22 +326,22 @@ E_LOOKUP_FUNCTION_DEF(default)
       }
       else if(l_restype_kind != E_TypeKind_Ptr && l_restype_kind != E_TypeKind_Array)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot index into this type.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot index into this type.");
         break;
       }
       else if(!e_type_kind_is_integer(r_restype_kind))
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index with this type.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index with this type.");
         break;
       }
       else if(l_restype_kind == E_TypeKind_Ptr && direct_type_size == 0)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into pointers of zero-sized types.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into pointers of zero-sized types.");
         break;
       }
       else if(l_restype_kind == E_TypeKind_Array && direct_type_size == 0)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into arrays of zero-sized types.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into arrays of zero-sized types.");
         break;
       }
       
@@ -381,12 +395,64 @@ E_LOOKUP_FUNCTION_DEF(default)
       }
       
       // rjf: fill
-      lookup.irtree_and_type.root     = new_tree;
-      lookup.irtree_and_type.type_key = direct_type;
-      lookup.irtree_and_type.mode     = l.mode;
+      result.irtree_and_type.root     = new_tree;
+      result.irtree_and_type.type_key = direct_type;
+      result.irtree_and_type.mode     = l.mode;
     }break;
   }
-  return lookup;
+  return result;
+}
+
+E_LOOKUP_RANGE_FUNCTION_DEF(default)
+{
+  E_LookupRange result = {0};
+  Temp scratch = scratch_begin(&arena, 1);
+  {
+    E_IRTreeAndType lhs_irtree = e_irtree_and_type_from_expr(scratch.arena, lhs);
+    E_TypeKey lhs_type_key = lhs_irtree.type_key;
+    E_TypeKind lhs_type_kind = e_type_kind_from_key(lhs_type_key);
+    if(lhs_type_kind == E_TypeKind_Struct ||
+       lhs_type_kind == E_TypeKind_Union ||
+       lhs_type_kind == E_TypeKind_Class ||
+       lhs_type_kind == E_TypeKind_Enum)
+    {
+      E_Type *lhs_type = e_type_from_key(scratch.arena, lhs_type_key);
+      Rng1U64 legal_idx_range = r1u64(0, lhs_type->count);
+      Rng1U64 read_range = intersect_1u64(legal_idx_range, idx_range);
+      U64 read_range_count = dim_1u64(read_range);
+      result.exprs_count = read_range_count;
+      result.exprs = push_array(arena, E_Expr *, result.exprs_count);
+      for(U64 idx = 0; idx < result.exprs_count; idx += 1)
+      {
+        U64 member_idx = idx + read_range.min;
+        String8 member_name = (lhs_type->members   ? lhs_type->members[member_idx].name :
+                               lhs_type->enum_vals ? lhs_type->enum_vals[member_idx].name : str8_lit(""));
+        result.exprs[idx] = e_expr_ref_member_access(arena, lhs, member_name);
+      }
+    }
+    else if(lhs_type_kind == E_TypeKind_Set)
+    {
+      result.exprs_count = dim_1u64(idx_range);
+      result.exprs = push_array(arena, E_Expr *, result.exprs_count);
+      result.exprs_strings = push_array(arena, String8, result.exprs_count);
+      for(U64 idx = 0; idx < result.exprs_count; idx += 1)
+      {
+        result.exprs[idx] = e_expr_ref_array_index(arena, lhs, idx_range.min + idx);
+      }
+    }
+  }
+  scratch_end(scratch);
+  return result;
+}
+
+E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(default)
+{
+  return num;
+}
+
+E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(default)
+{
+  return id;
 }
 
 ////////////////////////////////
@@ -716,9 +782,9 @@ e_irtree_and_type_from_expr__space(Arena *arena, E_Space *current_space, E_Expr
       }
       E_Expr *rhs = lhs->next;
       E_LookupRule *lookup_rule = e_lookup_rule_from_string(lookup_rule_name);
-      E_LookupInfo lookup_info = lookup_rule->lookup_info(arena, lhs);
-      E_Lookup lookup = lookup_rule->lookup(arena, expr->kind, lhs, rhs, lookup_info.user_data);
-      result = lookup.irtree_and_type;
+      E_LookupInfo lookup_info = lookup_rule->info(arena, lhs, str8_zero());
+      E_LookupAccess lookup_access = lookup_rule->access(arena, expr->kind, lhs, rhs, lookup_info.user_data);
+      result = lookup_access.irtree_and_type;
       scratch_end(scratch);
     }break;
     

src/eval/eval_ir.h

@@ -66,31 +66,60 @@ struct E_LookupInfo
   U64 idxed_expr_count;
 };
 
-typedef struct E_Lookup E_Lookup;
-struct E_Lookup
+typedef struct E_LookupAccess E_LookupAccess;
+struct E_LookupAccess
 {
   E_IRTreeAndType irtree_and_type;
 };
 
-#define E_LOOKUP_INFO_FUNCTION_SIG(name) E_LookupInfo name(Arena *arena, E_Expr *lhs)
+typedef struct E_LookupRange E_LookupRange;
+struct E_LookupRange
+{
+  U64 exprs_count;
+  E_Expr **exprs;
+  String8 *exprs_strings;
+};
+
+#define E_LOOKUP_INFO_FUNCTION_SIG(name) E_LookupInfo name(Arena *arena, E_Expr *lhs, String8 filter)
 #define E_LOOKUP_INFO_FUNCTION_NAME(name) e_lookup_info_##name
 #define E_LOOKUP_INFO_FUNCTION_DEF(name) internal E_LOOKUP_INFO_FUNCTION_SIG(E_LOOKUP_INFO_FUNCTION_NAME(name))
 typedef E_LOOKUP_INFO_FUNCTION_SIG(E_LookupInfoFunctionType);
 
-#define E_LOOKUP_FUNCTION_SIG(name) E_Lookup name(Arena *arena, E_ExprKind kind, E_Expr *lhs, E_Expr *rhs, void *user_data)
-#define E_LOOKUP_FUNCTION_NAME(name) e_lookup_##name
-#define E_LOOKUP_FUNCTION_DEF(name) internal E_LOOKUP_FUNCTION_SIG(E_LOOKUP_FUNCTION_NAME(name))
-typedef E_LOOKUP_FUNCTION_SIG(E_LookupFunctionType);
+#define E_LOOKUP_ACCESS_FUNCTION_SIG(name) E_LookupAccess name(Arena *arena, E_ExprKind kind, E_Expr *lhs, E_Expr *rhs, void *user_data)
+#define E_LOOKUP_ACCESS_FUNCTION_NAME(name) e_lookup_access_##name
+#define E_LOOKUP_ACCESS_FUNCTION_DEF(name) internal E_LOOKUP_ACCESS_FUNCTION_SIG(E_LOOKUP_ACCESS_FUNCTION_NAME(name))
+typedef E_LOOKUP_ACCESS_FUNCTION_SIG(E_LookupAccessFunctionType);
+
+#define E_LOOKUP_RANGE_FUNCTION_SIG(name) E_LookupRange name(Arena *arena, E_Expr *lhs, Rng1U64 idx_range, void *user_data)
+#define E_LOOKUP_RANGE_FUNCTION_NAME(name) e_lookup_range_##name
+#define E_LOOKUP_RANGE_FUNCTION_DEF(name) internal E_LOOKUP_RANGE_FUNCTION_SIG(E_LOOKUP_RANGE_FUNCTION_NAME(name))
+typedef E_LOOKUP_RANGE_FUNCTION_SIG(E_LookupRangeFunctionType);
+
+#define E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(name) U64 name(U64 num, void *user_data)
+#define E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(name) e_lookup_id_from_num_##name
+#define E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(name) internal E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(name))
+typedef E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(E_LookupIDFromNumFunctionType);
+
+#define E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(name) U64 name(U64 id, void *user_data)
+#define E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(name) e_lookup_num_from_id_##name
+#define E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(name) internal E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(name))
+typedef E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(E_LookupNumFromIDFunctionType);
 
 E_LOOKUP_INFO_FUNCTION_DEF(default);
-E_LOOKUP_FUNCTION_DEF(default);
+E_LOOKUP_ACCESS_FUNCTION_DEF(default);
+E_LOOKUP_RANGE_FUNCTION_DEF(default);
+E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(default);
+E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(default);
 
 typedef struct E_LookupRule E_LookupRule;
 struct E_LookupRule
 {
   String8 name;
-  E_LookupInfoFunctionType *lookup_info;
-  E_LookupFunctionType *lookup;
+  E_LookupInfoFunctionType *info;
+  E_LookupAccessFunctionType *access;
+  E_LookupRangeFunctionType *range;
+  E_LookupIDFromNumFunctionType *id_from_num;
+  E_LookupNumFromIDFunctionType *num_from_id;
 };
 
 typedef struct E_LookupRuleNode E_LookupRuleNode;
@@ -131,7 +160,10 @@ local_persist read_only E_LookupRule e_lookup_rule__default =
 {
   str8_lit_comp("default"),
   E_LOOKUP_INFO_FUNCTION_NAME(default),
-  E_LOOKUP_FUNCTION_NAME(default),
+  E_LOOKUP_ACCESS_FUNCTION_NAME(default),
+  E_LOOKUP_RANGE_FUNCTION_NAME(default),
+  E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(default),
+  E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(default),
 };
 global read_only E_IRNode e_irnode_nil = {&e_irnode_nil, &e_irnode_nil, &e_irnode_nil};
 thread_static E_IRCtx *e_ir_ctx = 0;
@@ -153,11 +185,9 @@ internal void e_select_ir_ctx(E_IRCtx *ctx);
 
 internal E_LookupRuleMap e_lookup_rule_map_make(Arena *arena, U64 slots_count);
 internal void e_lookup_rule_map_insert(Arena *arena, E_LookupRuleMap *map, E_LookupRule *rule);
-#define e_lookup_rule_map_insert_new(arena, map, name_, lookup_info_, lookup_) e_lookup_rule_map_insert((arena), (map), &(E_LookupRule){.name = (name_), .lookup_info = (lookup_info_), .lookup = (lookup_)})
+#define e_lookup_rule_map_insert_new(arena, map, name_, ...) e_lookup_rule_map_insert((arena), (map), &(E_LookupRule){.name = (name_), __VA_ARGS__})
 
 internal E_LookupRule *e_lookup_rule_from_string(String8 string);
-E_LOOKUP_INFO_FUNCTION_DEF(default);
-E_LOOKUP_FUNCTION_DEF(default);
 
 ////////////////////////////////
 //~ rjf: IR-ization Functions

src/eval/eval_types.c

@@ -1864,6 +1864,43 @@ e_type_key_list_copy(Arena *arena, E_TypeKeyList *src)
   return dst;
 }
 
+internal E_String2TypeKeyMap
+e_string2typekey_map_make(Arena *arena, U64 slots_count)
+{
+  E_String2TypeKeyMap map = {0};
+  map.slots_count = slots_count;
+  map.slots = push_array(arena, E_String2TypeKeySlot, map.slots_count);
+  return map;
+}
+
+internal void
+e_string2typekey_map_insert(Arena *arena, E_String2TypeKeyMap *map, String8 string, E_TypeKey key)
+{
+  E_String2TypeKeyNode *n = push_array(arena, E_String2TypeKeyNode, 1);
+  U64 hash = e_hash_from_string(5381, string);
+  U64 slot_idx = hash%map->slots_count;
+  SLLQueuePush(map->slots[slot_idx].first, map->slots[slot_idx].last, n);
+  n->string = push_str8_copy(arena, string);
+  n->key = key;
+}
+
+internal E_TypeKey
+e_string2typekey_map_lookup(E_String2TypeKeyMap *map, String8 string)
+{
+  E_TypeKey key = zero_struct;
+  U64 hash = e_hash_from_string(5381, string);
+  U64 slot_idx = hash%map->slots_count;
+  for(E_String2TypeKeyNode *n = map->slots[slot_idx].first; n != 0; n = n->next)
+  {
+    if(str8_match(n->string, string, 0))
+    {
+      key = n->key;
+      break;
+    }
+  }
+  return key;
+}
+
 ////////////////////////////////
 //~ rjf: Cache Lookups
 

src/eval/eval_types.h

@@ -137,6 +137,31 @@ struct E_Type
   E_EnumVal *enum_vals;
 };
 
+////////////////////////////////
+//~ rjf: String -> Type Key Map Data Structure
+
+typedef struct E_String2TypeKeyNode E_String2TypeKeyNode;
+struct E_String2TypeKeyNode
+{
+  E_String2TypeKeyNode *next;
+  String8 string;
+  E_TypeKey key;
+};
+
+typedef struct E_String2TypeKeySlot E_String2TypeKeySlot;
+struct E_String2TypeKeySlot
+{
+  E_String2TypeKeyNode *first;
+  E_String2TypeKeyNode *last;
+};
+
+typedef struct E_String2TypeKeyMap E_String2TypeKeyMap;
+struct E_String2TypeKeyMap
+{
+  U64 slots_count;
+  E_String2TypeKeySlot *slots;
+};
+
 ////////////////////////////////
 //~ rjf: Evaluation Context
 
@@ -323,6 +348,9 @@ internal String8 e_type_string_from_key(Arena *arena, E_TypeKey key);
 //- rjf: type key data structures
 internal void e_type_key_list_push(Arena *arena, E_TypeKeyList *list, E_TypeKey key);
 internal E_TypeKeyList e_type_key_list_copy(Arena *arena, E_TypeKeyList *src);
+internal E_String2TypeKeyMap e_string2typekey_map_make(Arena *arena, U64 slots_count);
+internal void e_string2typekey_map_insert(Arena *arena, E_String2TypeKeyMap *map, String8 string, E_TypeKey key);
+internal E_TypeKey e_string2typekey_map_lookup(E_String2TypeKeyMap *map, String8 string);
 
 ////////////////////////////////
 //~ rjf: Cache Lookups