Compiler: make string literals const

* modify type of string literals to const arrays of char
* update tests

Author: chqrlie

analyser/module_analyser_expr.c2

@@ -306,6 +306,16 @@ fn QualType Analyser.analyseConditionalOperator(Analyser* ma, Expr** e_ptr) {
 }
 
 fn bool Analyser.checkAssignment(Analyser* ma, Expr* assignee, QualType tleft, const char* msg, SrcLoc loc) {
+    if (!assignee.isLValue()) {
+        ma.errorRange(assignee.getLoc(), assignee.getRange(), "lvalue required as %s", msg);
+        return false;
+    }
+
+    if (tleft.isArray()) {
+        ma.error(loc, "array type '%s' is not assignable", tleft.diagName());
+        return false;
+    }
+
     if (tleft.isConst()) {
         //assignee.dump();
         if (assignee.isIdentifier()) {
@@ -342,16 +352,6 @@ fn bool Analyser.checkAssignment(Analyser* ma, Expr* assignee, QualType tleft, c
         return false;
     }
 
-    if (!assignee.isLValue()) {
-        ma.errorRange(assignee.getLoc(), assignee.getRange(), "lvalue required as %s", msg);
-        return false;
-    }
-
-    if (tleft.isArray()) {
-        ma.error(loc, "array type '%s' is not assignable", tleft.diagName());
-        return false;
-    }
-
     return true;
 }
 

ast/string_type_pool.c2

@@ -70,7 +70,11 @@ fn QualType StringTypePool.get(StringTypePool* p, u32 len) {
     // Note: re-use char[x] existing types
     for (u32 i=0; i<p.count; i++) {
         StringTypeSlot* s = &p.slots[i];
-        if (s.len == len) return QualType.create(s.type_);
+        if (s.len == len) {
+            QualType qt = QualType.create(s.type_);
+            qt.setConst();
+            return qt;
+        }
     }
     if (p.count == p.capacity) p.resize(p.capacity * 2);
 
@@ -81,6 +85,7 @@ fn QualType StringTypePool.get(StringTypePool* p, u32 len) {
     p.count++;
     QualType qt = QualType.create(t);
     t.setCanonicalType(qt);
+    qt.setConst();
     return qt;
 }
 

test/c_generator/constants/string_escape_chars.c2t

@@ -5,23 +5,23 @@
 // @file{file1}
 module test;
 
-char* a = " ";
-char* b = "a\rb";
-char* c = "a\tb";
-char* d = "a\nb";
-char* e = "a\0b";
-char* f = "a'b";
-char* g = "a\"b";
-char* h = "a\\b";
+const char* a = " ";
+const char* b = "a\rb";
+const char* c = "a\tb";
+const char* d = "a\nb";
+const char* e = "a\0b";
+const char* f = "a'b";
+const char* g = "a\"b";
+const char* h = "a\\b";
 
 // @expect{atleast, cgen/build.c}
 
-static char* test_a = " ";
-static char* test_b = "a\rb";
-static char* test_c = "a\tb";
-static char* test_d = "a\nb";
-static char* test_e = "a\0b";
-static char* test_f = "a'b";
-static char* test_g = "a\"b";
-static char* test_h = "a\\b";
+static const char* test_a = " ";
+static const char* test_b = "a\rb";
+static const char* test_c = "a\tb";
+static const char* test_d = "a\nb";
+static const char* test_e = "a\0b";
+static const char* test_f = "a'b";
+static const char* test_g = "a\"b";
+static const char* test_h = "a\\b";
 

test/c_generator/constants/string_literals.c2t

@@ -8,14 +8,14 @@ module test1;
 // const with inits
 public const char[] AAA = "aaa";
 public const char[4] BBB = "bbb";
-public const char* ccc = "ccc";
+//public const char* ccc = "ccc";
 
 // non-const with inits
 public char[] ddd = "ddd";
 public char[4] eee = "eee";
-public char* fff = "fff";
+public const char* fff = "fff";
 
-// 'const' without init
+// 'const' without init (actually non-const)
 public const char* ggg;
 
 // non-const without init
@@ -32,10 +32,9 @@ static const char test1_AAA[4] = "aaa";
 
 static const char test1_BBB[4] = "bbb";
 
-static const char* test1_ccc = "ccc";
 static char test1_ddd[4] = "ddd";
 static char test1_eee[4] = "eee";
-static char* test1_fff = "fff";
+static const char* test1_fff = "fff";
 static const char* test1_ggg = NULL;
 static char test1_hhh[3] = { };
 static char* test1_iii = NULL;

test/expr/assign_to_non_assignable.c2

@@ -6,7 +6,7 @@ fn void test1() {
 }
 
 fn void test2() {
-    "foo" = "bar";  // @error{array type 'char[4]' is not assignable}
+    "foo" = "bar";  // @error{array type 'const char[4]' is not assignable}
 }
 
 fn void test3() {

test/stmt/for_const.c2

@@ -2,6 +2,6 @@ module test;
 
 public fn i32 main() {
     for (const char *p = "abc"; *p; p++) {}
-    for (volatile char *p = "abc"; *p; p++) {}
+    for (const volatile char *p = "abc"; *p; p++) {}
     return 0;
 }

test/types/string_init.c2

@@ -1,7 +1,7 @@
 // @warnings{no-unused}
 module test;
 
-char* a = "AAA";
-u8* b = "BBB";
-i8* c = "CCC"; // @error{invalid type conversion from 'char[4]' to 'i8*'}
-
+const char* a = "AAA";
+const u8* b = "BBB";
+const i8* c = "CCC"; // @error{invalid type conversion from 'const char[4]' to 'const i8*'}
+char* d = "CCC"; // @error{pointer conversion discards const qualifier}

test/types/struct_array_init_ok.c2

@@ -2,7 +2,7 @@
 module test;
 
 type S struct {
-    u8* cp;
+    const u8* cp;
     i32 a;
 }
 

test/types/symbol_single/init_global_invalid_type.c2

@@ -2,6 +2,6 @@
 module test;
 
 fn void test1() {
-    i32 a = "test";     // @error{invalid type conversion from 'char[5]' to 'i32'}
+    i32 a = "test";     // @error{invalid type conversion from 'const char[5]' to 'i32'}
 }
 

test/vars/array_large.c2

@@ -1,7 +1,7 @@
 // @warnings{no-unused}
 module test;
 
-char*[] a = {
+const char*[] a = {
     "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
     "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
     "20", "21", "22", "23", "24", "25", "26", "27", "28", "29",