Compiler: add warning control over max_identifier_length

* pass warning flags to parser and tokenizer
* let specific projects allow longer identifiers with
  `$warnings no-max-identifier-length`

Author: chqrlie

common/build_target.c2

@@ -197,6 +197,7 @@ public fn void Target.disableWarnings(Target* t) {
     t.warnings.no_unused_enum_constant = true;
     t.warnings.no_unreachable_code = true;
     t.warnings.no_unknown_attribute = true;
+    t.warnings.no_max_identifier_length = true;
 }
 
 public fn void Target.enableWarnings(Target* t) {
@@ -212,6 +213,7 @@ public fn void Target.enableWarnings(Target* t) {
     t.warnings.no_unused_enum_constant = false;
     t.warnings.no_unreachable_code = false;
     t.warnings.no_unknown_attribute = false;
+    t.warnings.no_max_identifier_length = false;
 }
 
 public fn const warning_flags.Flags* Target.getWarnings(const Target* t) {

common/warning_flags.c2

@@ -28,6 +28,7 @@ public type Flags struct {
     bool no_unused_enum_constant;
     bool no_unreachable_code;
     bool no_unknown_attribute;
+    bool no_max_identifier_length;
     bool are_errors;
 }
 

compiler/c2recipe_parser.c2

@@ -583,6 +583,9 @@ fn void Parser.parseWarnings(Parser* p) {
         case "unknown-attribute":
             warnings.no_unknown_attribute = disable;
             break;
+        case "max-identifier-length":
+            warnings.no_max_identifier_length = disable;
+            break;
         case "promote-to-error":
             warnings.are_errors = !disable;
             break;

compiler/compiler.c2

@@ -40,6 +40,7 @@ import string_pool;
 import string_utils;
 import target_info;
 import utils;
+import warning_flags;
 
 import c_errno local;
 import ctype;
@@ -115,6 +116,7 @@ type Compiler struct {
     build_file.Info* build_info; // no ownership, can be nil
     build_target.Target* target; // no ownership
     const Options* opts;         // no ownership
+    const warning_flags.Flags* warnings;  // no ownership
     target_info.Info targetInfo;
     PluginHandler* pluginHandler; // no ownership
 
@@ -180,8 +182,9 @@ fn void Compiler.build(Compiler* c,
     c.target = target;
     c.opts = opts;
     c.pluginHandler = pluginHandler;
+    c.warnings = target.getWarnings();
 
-    diags.setWarningAsError(target.getWarnings().are_errors);
+    diags.setWarningAsError(c.warnings.are_errors);
     c.diags.clear();
 
     c.context = ast_context.create(16*1024);
@@ -272,7 +275,8 @@ fn void Compiler.build(Compiler* c,
                                 c.astPool,
                                 c.builder,
                                 &c.kwinfo,
-                                target.getFeatures());
+                                target.getFeatures(),
+                                c.warnings);
 
     ast.initialize(c.context, c.astPool, c.targetInfo.intWidth / 8, color.useColor());
 
@@ -281,7 +285,7 @@ fn void Compiler.build(Compiler* c,
                                         c.astPool,
                                         c.builder,
                                         &c.allmodules,
-                                        c.target.getWarnings());
+                                        c.warnings);
 
     if (opts.show_libs) {
         c.showAllLibs();

parser/c2_parser.c2

@@ -34,6 +34,7 @@ import token local;
 #if DumpTokens
 import utils;
 #endif
+import warning_flags;
 
 import stdarg local;
 import stdlib local;
@@ -58,8 +59,9 @@ public type Parser struct @(opaque) {
     diagnostics.Diags* diags;
     string_pool.Pool* pool;
     Builder* builder;
-    const string_list.List* features;
     const keywords.Info* kwinfo;
+    const string_list.List* features;
+    const warning_flags.Flags* warnings;
     bool is_interface;
     u32 va_list_idx;
     u32 varargs_idx;
@@ -79,15 +81,17 @@ public fn Parser* create(SourceMgr* sm,
                            string_pool.Pool* pool,
                            ast_builder.Builder* builder,
                            const keywords.Info* kwinfo,
-                           const string_list.List* features)
+                           const string_list.List* features,
+                           const warning_flags.Flags* warnings)
 {
     Parser* p = calloc(1, sizeof(Parser));
     p.sm = sm;
     p.diags = diags;
     p.pool = pool;
     p.builder = builder;
-    p.features = features;
     p.kwinfo = kwinfo;
+    p.features = features;
+    p.warnings = warnings;
     p.va_list_idx = pool.addStr("va_list", true);
     p.varargs_idx = pool.addStr("varargs", true);
     p.stdarg_idx = pool.addStr("stdarg", true);
@@ -123,6 +127,7 @@ public fn void Parser.parse(Parser* p, i32 file_id, bool is_interface, bool is_g
                      p.sm.get_offset(p.file_id),
                      p.kwinfo,
                      p.features,
+                     p.warnings,
                      nil,
                      nil,
                      nil,
@@ -145,6 +150,7 @@ public fn void Parser.parse(Parser* p, i32 file_id, bool is_interface, bool is_g
                          p.sm.get_offset(p.file_id),
                          p.kwinfo,
                          p.features,
+                         p.warnings,
                          Parser.on_tokenizer_error,
                          p,
                          false);
@@ -386,6 +392,7 @@ fn bool findName(const u32* names, u32 count, u32 name) {
 // returns the number of attributes parsed and stored in Builder
 fn u32 Parser.parseOptionalAttributes(Parser* p) {
     if (p.tok.kind != Kind.At) return 0;
+
     p.consumeToken();
 
     p.expectAndConsume(Kind.LParen);

parser/c2_tokenizer.c2

@@ -24,6 +24,7 @@ import string_list;
 import string_pool;
 import token local;
 import utf8;
+import warning_flags;
 
 import string;
 import stdlib;
@@ -266,6 +267,8 @@ public type Tokenizer struct {
 
     string_pool.Pool* pool; // no ownership
     string_buffer.Buf* buf; // no ownership, used for strings and character constants
+    const warning_flags.Flags* warnings;
+
     ErrorFn on_error;
     void* on_error_arg;
 
@@ -278,7 +281,7 @@ public type Tokenizer struct {
 
     char[256] error_msg;
 }
-static_assert(408, sizeof(Tokenizer));
+static_assert(416, sizeof(Tokenizer));
 
 public fn void Tokenizer.init(Tokenizer* t,
                               string_pool.Pool* pool,
@@ -287,6 +290,7 @@ public fn void Tokenizer.init(Tokenizer* t,
                               SrcLoc loc_start,
                               const keywords.Info* kwinfo,
                               const string_list.List* features,
+                              const warning_flags.Flags* warnings,
                               ErrorFn on_error,
                               void* on_error_arg,
                               bool raw_mode)
@@ -300,6 +304,7 @@ public fn void Tokenizer.init(Tokenizer* t,
     t.line_start = input;
     t.pool = pool;
     t.buf = buf;
+    t.warnings = warnings;
     t.on_error = on_error;
     t.on_error_arg = on_error_arg;
 
@@ -685,6 +690,15 @@ fn void Tokenizer.error(Tokenizer* t, Token* result, const char* format @(printf
     if (t.on_error) t.on_error(t.on_error_arg, FatalError, result.loc, t.error_msg);
 }
 
+fn void Tokenizer.warning(Tokenizer* t, SrcLoc loc, const char* format @(printf_format), ...) {
+    va_list args;
+    va_start(args, format);
+    vsnprintf(t.error_msg, sizeof(t.error_msg), format, args);
+    va_end(args);
+
+    if (t.on_error) t.on_error(t.on_error_arg, Warning, loc, t.error_msg);
+}
+
 // generate an error but keep parsing
 fn void Tokenizer.num_error(Tokenizer* t, Token* result, const char* p, const char* format @(printf_format), ...) {
     va_list args;
@@ -720,9 +734,8 @@ fn void Tokenizer.lex_identifier(Tokenizer* t, Token* result) {
     while (Identifier_char[(u8)(*end)]) end++;
 
     usize len = (usize)(end - start);
-    if (len > constants.MaxIdentifierLen && !t.raw_mode) {
-        t.error(result, "identifier too long (max %d chars)", constants.MaxIdentifierLen);
-        return;
+    if (len > constants.MaxIdentifierLen && !t.raw_mode && t.warnings && !t.warnings.no_max_identifier_length) {
+        t.warning(result.loc, "identifier too long (max %d chars)", constants.MaxIdentifierLen);
     }
     t.cur += len;
     result.name_idx = t.pool.add(start, len, true);

recipe.txt

@@ -405,6 +405,7 @@ executable c2cat
     common/file/reader.c2
     common/string_list.c2
     common/utf8.c2
+    common/warning_flags.c2
 
     parser/c2_tokenizer.c2
     parser/keywords.c2

test/naming/max_identifier_type.c2

@@ -5,7 +5,7 @@ type T123456789012345678901234567890 struct {
     i32 x;
 }
 
-type thirty_two_is_too_long_for_an_id struct {  // @error{identifier too long (max 31 chars)}
+type Thirty_two_is_too_long_for_an_id struct {  // @warning{identifier too long (max 31 chars)}
     i32 x;
 }
 

test/naming/max_identifier_var.c2

@@ -3,6 +3,6 @@ module test;
 
 fn void test1() {
     i32 thirty_one_is_fine_for_a_name__;
-    i32 thirty_two_is_too_long_for_an_id;   // @error{identifier too long (max 31 chars)}
+    i32 thirty_two_is_too_long_for_an_id;   // @warning{identifier too long (max 31 chars)}
 }
 

test/naming/no_max_identifier_type.c2

@@ -0,0 +1,12 @@
+// @warnings{no-unused}
+// @warnings{no-max-identifier-length}
+module test;
+
+type T123456789012345678901234567890 struct {
+    i32 x;
+}
+
+type Very_long_type_names_are_ok_if_requested_for_specific_targets struct {
+    i32 x;
+}
+