Fully rename array to list

1 files changed, 14 insertions, 14 deletions

diff --git a/types.c b/types.c
index f09d3170..4ab11280 100644
--- a/types.c
+++ b/types.c
@@ -34,9 +34,9 @@ CORD type_to_cord(type_t *t) {
         case BigIntType: return "Int";
         case IntType: return CORD_asprintf("Int%d", Match(t, IntType)->bits);
         case NumType: return Match(t, NumType)->bits == TYPE_NBITS32 ? "Num32" : "Num";
-        case ArrayType: {
-            auto array = Match(t, ArrayType);
-            return CORD_asprintf("List(%r)", type_to_cord(array->item_type));
+        case ListType: {
+            auto list = Match(t, ListType);
+            return CORD_asprintf("List(%r)", type_to_cord(list->item_type));
         }
         case TableType: {
             auto table = Match(t, TableType);
@@ -258,7 +258,7 @@ PUREFUNC precision_cmp_e compare_precision(type_t *a, type_t *b)
 PUREFUNC bool has_heap_memory(type_t *t)
 {
     switch (t->tag) {
-    case ArrayType: return true;
+    case ListType: return true;
     case TableType: return true;
     case SetType: return true;
     case PointerType: return true;
@@ -421,9 +421,9 @@ PUREFUNC bool can_promote(type_t *actual, type_t *needed)
                 && can_promote(actual_ret, needed_ret)));
     }
 
-    // Set -> Array promotion
-    if (needed->tag == ArrayType && actual->tag == SetType
-        && type_eq(Match(needed, ArrayType)->item_type, Match(actual, SetType)->item_type))
+    // Set -> List promotion
+    if (needed->tag == ListType && actual->tag == SetType
+        && type_eq(Match(needed, ListType)->item_type, Match(actual, SetType)->item_type))
         return true;
 
     return false;
@@ -518,7 +518,7 @@ PUREFUNC size_t type_size(type_t *t)
     }
     case NumType: return Match(t, NumType)->bits == TYPE_NBITS64 ? sizeof(double) : sizeof(float);
     case TextType: return sizeof(Text_t);
-    case ArrayType: return sizeof(Array_t);
+    case ListType: return sizeof(List_t);
     case SetType: return sizeof(Table_t);
     case TableType: return sizeof(Table_t);
     case FunctionType: return sizeof(void*);
@@ -607,7 +607,7 @@ PUREFUNC size_t type_align(type_t *t)
     case NumType: return Match(t, NumType)->bits == TYPE_NBITS64 ? __alignof__(double) : __alignof__(float);
     case TextType: return __alignof__(Text_t);
     case SetType: return __alignof__(Table_t);
-    case ArrayType: return __alignof__(Array_t);
+    case ListType: return __alignof__(List_t);
     case TableType: return __alignof__(Table_t);
     case FunctionType: return __alignof__(void*);
     case ClosureType: return __alignof__(struct {void *fn, *userdata;});
@@ -687,21 +687,21 @@ type_t *get_field_type(type_t *t, const char *field_name)
         if (streq(field_name, "length"))
             return INT_TYPE;
         else if (streq(field_name, "items"))
-            return Type(ArrayType, .item_type=Match(t, SetType)->item_type);
+            return Type(ListType, .item_type=Match(t, SetType)->item_type);
         return NULL;
     }
     case TableType: {
         if (streq(field_name, "length"))
             return INT_TYPE;
         else if (streq(field_name, "keys"))
-            return Type(ArrayType, Match(t, TableType)->key_type);
+            return Type(ListType, Match(t, TableType)->key_type);
         else if (streq(field_name, "values"))
-            return Type(ArrayType, Match(t, TableType)->value_type);
+            return Type(ListType, Match(t, TableType)->value_type);
         else if (streq(field_name, "fallback"))
             return Type(OptionalType, .type=t);
         return NULL;
     }
-    case ArrayType: {
+    case ListType: {
         if (streq(field_name, "length")) return INT_TYPE;
         return NULL;
     }
@@ -719,7 +719,7 @@ PUREFUNC type_t *get_iterated_type(type_t *t)
     type_t *iter_value_t = value_type(t);
     switch (iter_value_t->tag) {
     case BigIntType: case IntType: return iter_value_t; break;
-    case ArrayType: return Match(iter_value_t, ArrayType)->item_type; break;
+    case ListType: return Match(iter_value_t, ListType)->item_type; break;
     case SetType: return Match(iter_value_t, SetType)->item_type; break;
     case TableType: return NULL;
     case FunctionType: case ClosureType: {