lint: repo-level .lint_config (TOML) with STYLE005 off by default

Reviewers asked for TOML over a custom line-based syntax. So:

- New module daslib/toml.das — full TOML 1.0 parser that reads into the
  same JsonValue? tree shape produced by daslib/json. Existing json_boost
  accessors (v ?? def, from_JV, etc.) work on TOML inputs unchanged.
- .lint_config is now TOML. A single [rules] table; each entry is a
  bool (true = on, false = off).
- STYLE005 is off by default. Bad TOML / missing file / no [rules] /
  non-bool entries → no-op, defaults stand.
- Same dispatch as before: the three [lint_macro] paths,
  utils/lint/main.das (skipped under --enable whitelist mode), and the
  MCP lint subtool all consult the file via daslib/lint_config.

TOML 1.0 surface: comments, basic/literal/multi-line strings with
escapes, decimal/hex/octal/binary integers with _ separators, floats
with exponent and inf/nan, booleans, datetimes (preserved as raw
RFC-3339 strings since JSON has no date type), inline + multi-line
arrays, inline tables, [section] / [a.b] dotted headers, [[a]] arrays
of tables, dotted keys. Fail-fast error via `error` out-param.

Drive-by daslang AOT C++ emitter fix (daslib/aot_cpp.das):
to_cpp_double's daslang-side override only handled finite doubles —
'{val:.17e}' formats non-finite values as the bare tokens `inf`/`nan`,
which either don't exist in C++ (inf) or resolve to <cmath>'s
double nan(const char*) overload (nan). Both bake into AOT-emitted
code and break every C++ build. Mirrored the C++-side to_cpp_double
behavior (runtime_string.cpp:526): emit ((double)INFINITY) /
((double)(-INFINITY)) / ((double)NAN) for non-finite, DBL_MIN/DBL_MAX
boundaries for the extremes. Uses self-comparison + magnitude tests
to avoid requiring math (which cascade-broke this file's match-based
type helpers under lint-mode no_infer_time_folding).

Drive-by aot_cpp.das lint cleanups surfaced once this PR's lint
covered the file (it had never been included in any prior PR's
changed-files set):
- Add explicit fallthrough returns after match blocks so lint-mode
  exhaustiveness check passes without infer-time folding (das_to_cppString,
  das_to_cppCTypeString, isConstRedundantForCpp).
- PERF020: drop redundant int(...) / string(...) casts on already-typed
  values (tupleSize / variantSize / variantAlign / info.name).
- STYLE016: consolidate isConstRedundantForCpp's run of same-result
  match arms into one OR-chain.
- STYLE010 false positives on match's `if (_)` wildcard suppressed via
  // nolint:STYLE010 (the macro expands `_` to `if (true)`; rule is right
  about the source shape, wrong about the macro generator).
- TOML fixture for STYLE005: per-module opt-in
  'options _enable_default_off_rules = true' in
  utils/lint/tests/style005_braced_terminator.das so the rule fires
  for that fixture's 5 expected sites despite the new default-off.

Tests: tests/daslib/test_toml.das (42 cases — every value type,
section / dotted / AoT shapes, parse-failure paths). Existing
tests/lint/test_lint_config.das rewritten for the TOML shape (16
cases). All 60 pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: borisbat

daslib/aot_cpp.das

@@ -86,8 +86,9 @@ def das_to_cppString(t : Type) {
         if (Type.tLambda) { return "Lambda"; }
         if (Type.tTuple) { return "Tuple"; }
         if (Type.tVariant) { return "Variant"; }
-        if (_) { panic("Missed type {t}"); return ""; }
     }
+    panic("Missed type {t}")
+    return ""
 }
 
 def das_to_cppCTypeString(t : Type) {
@@ -141,8 +142,9 @@ def das_to_cppCTypeString(t : Type) {
         if (Type.tTuple) { return "tTuple"; }
         if (Type.tVariant) { return "tVariant"; }
         if (Type.tHandle) { return "tHandle"; }
-        if (_) { panic("Missed type {t}"); return ""; }
     }
+    panic("Missed type {t}")
+    return ""
 }
 
 
@@ -151,27 +153,15 @@ def isConstRedundantForCpp(typeDecl : TypeDeclPtr) {
     if (!empty(typeDecl.dim)) return false;
     if (typeDecl.isVectorType) return true;
     match (typeDecl.baseType) {
-        if (Type.tBool) { return true; }
-        if (Type.tInt8) { return true; }
-        if (Type.tUInt8) { return true; }
-        if (Type.tInt16) { return true; }
-        if (Type.tUInt16) { return true; }
-        if (Type.tInt64) { return true; }
-        if (Type.tUInt64) { return true; }
-        if (Type.tInt) { return true; }
-        if (Type.tUInt) { return true; }
-        if (Type.tFloat) { return true; }
-        if (Type.tDouble) { return true; }
-        if (Type.tEnumeration) { return true; }
-        if (Type.tEnumeration8) { return true; }
-        if (Type.tEnumeration16) { return true; }
-        if (Type.tEnumeration64) { return true; }
-        if (Type.tBitfield) { return true; }
-        if (Type.tBitfield8) { return true; }
-        if (Type.tBitfield16) { return true; }
-        if (Type.tBitfield64) { return true; }  // nolint:STYLE017 (match arm chain)
-        if (_) { return false; }
+        if (Type.tBool || Type.tInt8 || Type.tUInt8 || Type.tInt16 || Type.tUInt16 ||
+            Type.tInt64 || Type.tUInt64 || Type.tInt || Type.tUInt ||
+            Type.tFloat || Type.tDouble ||
+            Type.tEnumeration || Type.tEnumeration8 || Type.tEnumeration16 || Type.tEnumeration64 ||
+            Type.tBitfield || Type.tBitfield8 || Type.tBitfield16 || Type.tBitfield64) {
+            return true
+        }
     }
+    return false
 }
 
 
@@ -255,7 +245,7 @@ def aotSuffixNameEx(funcName : string; suffix : string) {
                     if ('.') { t_ch = "Dot"; }
                     if ('`') { t_ch = "Tick"; }
                     if (',') { t_ch = "Comma"; }
-                    if (_) {
+                    if (_) {   // nolint:STYLE010 — match macro expands wildcard to `if (true)`
                         let repr = build_string() $(ss) {
                             ss |> write_char(hex_char(ch >> 4))
                             ss |> write_char(hex_char(ch));
@@ -345,7 +335,7 @@ def describeCppTypeEx(typeDecl : TypeDeclPtr;
             if (cfg.cross_platform) {
                 write(writer, "AutoTuple<{types}>")
             } else {
-                write(writer, "TTuple<{int(typeDecl.tupleSize)},{types}>")
+                write(writer, "TTuple<{typeDecl.tupleSize},{types}>")
             }
         } elif (baseType == Type.tVariant) {
             let types = (each(typeDecl.argTypes)
@@ -355,7 +345,7 @@ def describeCppTypeEx(typeDecl : TypeDeclPtr;
             if (cfg.cross_platform) {
                 write(writer, "AutoVariant<{types}>");
             } else {
-                write(writer, "TVariant<{int(typeDecl.variantSize)},{int(typeDecl.variantAlign)},{types}>")
+                write(writer, "TVariant<{typeDecl.variantSize},{typeDecl.variantAlign},{types}>")
             }
         } elif (baseType == Type.tStructure) {
             if (typeDecl.structType != null) {
@@ -814,7 +804,7 @@ class public AotDebugInfoHelper {
             writeDim(writer, fld, suffix);
             writeArgTypes(writer, fld, suffix);
             writeArgNames(writer, fld, suffix);
-            write(*writer, "VarInfo {funcInfoName(info)}_field_{fi} =  \{ {describeCppVarFuncInfo(string(info.name), fld,suffix)} \};\n");
+            write(*writer, "VarInfo {funcInfoName(info)}_field_{fi} =  \{ {describeCppVarFuncInfo(info.name, fld,suffix)} \};\n");
         }
 
         let fields = (each(range(info.count))
@@ -1885,7 +1875,7 @@ class public CppAot : AstVisitor {
                     if ("&") { op = "&&"; }
                     if ("|") { op = "||"; }
                     if ("^" || "^^") { op = "!="; }
-                    if (_) { op = that_op; }
+                    if (_) { op = that_op; }  // nolint:STYLE010 — match macro expands wildcard to `if (true)`
                 }
                 write(*ss, " {op} ");
             } else {
@@ -2382,8 +2372,24 @@ class public CppAot : AstVisitor {
         return c;
     }
 
-    def to_cpp_double(val : double) {
-        return "{val:.17e}";
+    def to_cpp_double(val : double) : string {
+        // Mirror the C++-side to_cpp_double (runtime_string.cpp:526): emit
+        // portable C++ tokens for non-finite and boundary doubles. Without
+        // this, daslang's '{val:.17e}' formatter prints bare 'inf' / 'nan',
+        // which either don't exist in C++ (inf) or resolve to '<cmath>'s
+        // 'double nan(const char*)' overload (nan) — both bake into the
+        // AOT-emitted code and break the C++ build. Bit-pattern tests
+        // (val != val for NaN, magnitude vs DBL_MAX for ±inf) avoid pulling
+        // in `require math`, which interferes with this file's `match`-based
+        // type-table helpers (control-flow inference cascade).
+        if (val == DBL_MIN) return "DBL_MIN"
+        if (val == -DBL_MIN) return "(-DBL_MIN)"
+        if (val == DBL_MAX) return "DBL_MAX"
+        if (val == -DBL_MAX) return "(-DBL_MAX)"
+        if (val != val) return "((double)NAN)"        // nolint:LINT007 — canonical IEEE-754 NaN test
+        if (val > DBL_MAX) return "((double)INFINITY)"
+        if (val < -DBL_MAX) return "((double)(-INFINITY))"
+        return "{val:.17e}"
     }
 
     def writeOutDouble(val : double) {
@@ -2644,7 +2650,7 @@ class public CppAot : AstVisitor {
                 if (1) { write(*ss, "y"); }
                 if (2) { write(*ss, "z"); }
                 if (3) { write(*ss, "w"); }
-                if (_) { write(*ss, "?"); }
+                if (_) { write(*ss, "?"); }  // nolint:STYLE010 — match macro expands wildcard to `if (true)`
             }
         }
         write(*ss, "*/");

daslib/lint.das

@@ -15,12 +15,16 @@ module lint shared private
 require daslib/strings_boost
 require daslib/ast_boost
 require daslib/strings_boost
+require daslib/lint_config
 
 [lint_macro]
 class LintEverything : AstPassMacro {
     //! Pass macro that enables lint checking for modules.
     def override apply(prog : ProgramPtr; mod : Module?) : bool {
-        paranoid(prog, true)
+        var disabled : table<string>
+        seed_default_disabled(disabled)
+        load_lint_config(disabled)
+        paranoid(prog, true, disabled)
         return true
     }
 }
@@ -438,7 +442,16 @@ class LintVisitor : AstVisitor {
 
 def public paranoid(prog : ProgramPtr; compile_time_errors : bool) {
     //! Runs the paranoid lint visitor on the program to check for common coding issues.
+    let empty_set : table<string>
+    paranoid(prog, compile_time_errors, empty_set)
+}
+
+def public paranoid(prog : ProgramPtr; compile_time_errors : bool; disabled_codes : table<string>) {
+    //! Filter-aware compile-time variant. ``disabled_codes`` suppresses
+    //! the listed rule IDs (e.g. "LINT003") alongside the usual
+    //! ``// nolint:CODE`` directives.
     var astVisitor = new LintVisitor(compile_time_errors = compile_time_errors)
+    astVisitor.disabled_codes := disabled_codes
     make_visitor(*astVisitor) $(adapter) {
         astVisitor.astVisitorAdapter = adapter
         visit(prog, astVisitor.astVisitorAdapter)

daslib/lint_config.das

@@ -0,0 +1,77 @@
+options gen2
+options indenting = 4
+options no_unused_function_arguments = false
+
+module lint_config shared private
+
+//! Repo-level lint enable/disable config.
+//!
+//! Loads ``{get_das_root()}/.lint_config`` (a TOML file) and folds its
+//! ``[rules]`` table into a ``disabled_codes`` set consumed by the three
+//! ``[lint_macro]`` pass-macros (``daslib/lint``, ``daslib/perf_lint``,
+//! ``daslib/style_lint``), by the standalone runner ``utils/lint/main.das``,
+//! and by the MCP ``lint`` subtool.
+//!
+//! Format (TOML 1.0). One ``[rules]`` table; each entry sets a rule to
+//! ``true`` (on) or ``false`` (off):
+//!
+//!   [rules]
+//!   STYLE005 = true     # re-enable a default-off rule
+//!   PERF007  = false    # disable a default-on rule
+//!
+//! Anything that is not a boolean entry under ``[rules]`` is ignored.
+//! If the file is missing, unreadable, or fails to parse the call is a
+//! no-op — built-in defaults stand.
+
+require fio
+require daslib/json
+require daslib/toml
+
+//! Loads ``{get_das_root()}/.lint_config`` into ``disabled_codes``.
+//! No-op when the file is missing or unreadable.
+def public load_lint_config(var disabled_codes : table<string>) : void {
+    load_lint_config_from_path("{get_das_root()}/.lint_config", disabled_codes)
+}
+
+//! Parser entry point. Reads ``path`` (TOML) and folds the ``[rules]``
+//! table into ``disabled_codes``. Public so tests can exercise the parser
+//! hermetically without writing into the repo root.
+def public load_lint_config_from_path(path : string; var disabled_codes : table<string>) : void {
+    let body = fread(path)
+    if (empty(body)) return
+    var error : string
+    var root : JsonValue? = read_toml(body, error)
+    // bad TOML or no [rules] table → defaults stand
+    if (root == null || !(root.value is _object)) return
+    var root_obj & = unsafe(root.value as _object)   // nolint:LINT003 — table [] requires mutable binding
+    if (!key_exists(root_obj, "rules")) return
+    var rules_obj : JsonValue? = root_obj["rules"]
+    if (rules_obj == null || !(rules_obj.value is _object)) return
+    var rules & = unsafe(rules_obj.value as _object)   // nolint:LINT003 — iteration requires mutable view
+    for (code, val_jv in keys(rules), values(rules)) {
+        if (val_jv == null || !(val_jv.value is _bool)) continue
+        let enabled = val_jv.value as _bool
+        if (enabled) {
+            // CODE = true → on → remove from default-disabled
+            if (key_exists(disabled_codes, code)) {
+                disabled_codes |> erase(code)
+            }
+        } else {
+            // CODE = false → off → add to disabled
+            if (!key_exists(disabled_codes, code)) {
+                disabled_codes |> insert(code)
+            }
+        }
+    }
+}
+
+//! Seeds ``disabled_codes`` with the canonical default-off rule set
+//! (currently just STYLE005). Call before ``load_lint_config`` so that
+//! a ``STYLE005 = true`` directive in ``.lint_config`` can re-enable it.
+//! Single source of truth used by the three ``[lint_macro]`` paths,
+//! ``utils/lint/main.das``, and the MCP ``lint`` subtool.
+def public seed_default_disabled(var disabled_codes : table<string>) : void {
+    if (!key_exists(disabled_codes, "STYLE005")) {
+        disabled_codes |> insert("STYLE005")
+    }
+}

daslib/perf_lint.das

@@ -39,6 +39,7 @@ module perf_lint shared private
 
 require daslib/ast_boost
 require strings
+require daslib/lint_config
 
 // ---------------------------------------------------------------------------
 // Visitor
@@ -1869,7 +1870,16 @@ class PerfLintVisitor : AstVisitor {
 def public perf_lint(prog : ProgramPtr; compile_time_errors : bool) : int {
     //! Runs the performance lint visitor on the compiled program.
     //! Returns the number of warnings found.
+    let empty_set : table<string>
+    return perf_lint(prog, compile_time_errors, empty_set)
+}
+
+def public perf_lint(prog : ProgramPtr; compile_time_errors : bool; disabled_codes : table<string>) : int {
+    //! Filter-aware compile-time variant. ``disabled_codes`` suppresses
+    //! the listed rule IDs (e.g. "PERF007") alongside the usual
+    //! ``// nolint:CODE`` directives.
     var astVisitor = new PerfLintVisitor(compile_time_errors = compile_time_errors)
+    astVisitor.disabled_codes := disabled_codes
     make_visitor(*astVisitor) $(astVisitorAdapter) {
         visit(prog, astVisitorAdapter)
     }
@@ -1908,7 +1918,10 @@ def public perf_lint_collect(prog : ProgramPtr; var warnings : array<string>;
 [lint_macro]
 class PerfLintMacro : AstPassMacro {
     def override apply(prog : ProgramPtr; mod : Module?) : bool {
-        perf_lint(prog, true)
+        var disabled : table<string>
+        seed_default_disabled(disabled)
+        load_lint_config(disabled)
+        perf_lint(prog, true, disabled)
         return true
     }
 }

daslib/style_lint.das

@@ -39,6 +39,7 @@ module style_lint shared private
 
 require daslib/ast_boost
 require daslib/is_local
+require daslib/lint_config
 require strings
 
 // ---------------------------------------------------------------------------
@@ -378,7 +379,7 @@ class StyleLintVisitor : AstVisitor {
         if (col + 1u >= llen) return
         var is_arrow = false
         peek_data(lineTxt) $(data) {
-            is_arrow = int(data[col]) == int('-') && int(data[col + 1u]) == int('>')
+            is_arrow = int(data[col]) == '-' && int(data[col + 1u]) == '>'
         }
         if (!is_arrow) return
         let prefix = strip_right(slice(lineTxt, 0, col |> int))
@@ -389,7 +390,7 @@ class StyleLintVisitor : AstVisitor {
             var prev_ok = false
             peek_data(prefix) $(pd) {
                 let ch = int(pd[plen - 5])
-                prev_ok = !(is_alpha(ch) || is_number(ch) || ch == int('_'))
+                prev_ok = !(is_alpha(ch) || is_number(ch) || ch == '_')
             }
             if (!prev_ok) return
         }
@@ -1741,7 +1742,16 @@ def public style_lint(prog : ProgramPtr; compile_time_errors : bool; comment_hyg
     //! Runs the style lint visitor on the compiled program.
     //! Returns the number of warnings found.
     //! Pass ``comment_hygiene = true`` to enable STYLE014/STYLE015 checks.
+    let empty_set : table<string>
+    return style_lint(prog, compile_time_errors, empty_set, [comment_hygiene = comment_hygiene])
+}
+
+def public style_lint(prog : ProgramPtr; compile_time_errors : bool; disabled_codes : table<string>; comment_hygiene : bool = false) : int {
+    //! Filter-aware compile-time variant. ``disabled_codes`` suppresses
+    //! the listed rule IDs (e.g. "STYLE005") alongside the usual
+    //! ``// nolint:CODE`` directives.
     var astVisitor = new StyleLintVisitor(compile_time_errors = compile_time_errors, comment_hygiene = comment_hygiene)
+    astVisitor.disabled_codes := disabled_codes
     make_visitor(*astVisitor) $(astVisitorAdapter) {
         visit_with_generics(prog, astVisitorAdapter)
     }
@@ -1797,7 +1807,19 @@ def public style_lint_collect(prog : ProgramPtr; var warnings : array<string>;
 class StyleLintMacro : AstPassMacro {
     def override apply(prog : ProgramPtr; mod : Module?) : bool {
         let hygiene = prog._options |> find_arg("_comment_hygiene") ?as tBool ?? false
-        style_lint(prog, true, [comment_hygiene = hygiene])
+        // Module-local opt-in: 'options _enable_default_off_rules = true' skips
+        // the default-disabled seed (currently STYLE005) so the rules-off-by-
+        // default fire for this module unless .lint_config disables them again.
+        // The `.lint_config` load still runs afterward, so repo-level config can
+        // override on top. Used by rule-specific test fixtures whose `expect`
+        // assertions depend on default-off rules firing.
+        let force_default_off = prog._options |> find_arg("_enable_default_off_rules") ?as tBool ?? false
+        var disabled : table<string>
+        if (!force_default_off) {
+            seed_default_disabled(disabled)
+        }
+        load_lint_config(disabled)
+        style_lint(prog, true, disabled, [comment_hygiene = hygiene])
         return true
     }
 }