lint: fix LINT002 false positive on a devirtualized block holder

Invoke devirtualization splices the block literal in place and consumes the
holder local's only read. The patch slot runs before lint, and optimize -
which reaps the now-dead `let` - runs after it, so lint saw a variable with
no access flag left and reported it unused:

    def apply_via_call(x : int) : int
      let add_two = $(v : int) : int { return v + 2 }
      return apply_block(add_two, x)    // LINT002: unused variable add_two

At lint time add_two carries only access_init, while a function-pointer local
in the same position carries access_get|access_init|access_pass. That
asymmetry makes the gap look specific to block-typed variables, but it is not
- @@fn simply never devirtualizes. `options disable_auto_inline` compiles the
same file clean, which is what pins this on the splice rather than on passing
a variable as an argument.

The devirtualizer now marks the holder marked_used, the same "a transform ate
the reads" contract the unused-argument checks in ast_lint.cpp already honor,
and daslib/lint.das honors that flag for locals as it already did for
arguments. Optimize still reaps the dead `let`, so there is no codegen cost.

Found in dagor, where the reported variables could not be renamed away
without breaking the build.

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

Author: 2 people

daslib/lint.das

@@ -303,7 +303,8 @@ class LintVisitor : AstVisitor {
     }
 
     def validate_var(v : VariablePtr; can_make_const : bool) {
-        if (v.flags.generated) return
+        // marked_used: a transform consumed the reads (devirtualized block holder), or author intent
+        if (v.flags.generated || v.flags.marked_used) return
         let name = string(v.name)
         // skip system vars (`__name`) and compiler-generated names (backtick-mangled, e.g. tuple destructuring)
         if (name |> starts_with("__") || find(name, "`") >= 0) return

src/ast/ast_inline.cpp

@@ -1976,6 +1976,13 @@ namespace das {
                                     continue;
                                 }
                                 literal = bit->second.literal;
+                                // the splice consumes this read, and it is usually the holder's
+                                // ONLY one - lint runs after the patch slot but before optimize
+                                // reaps the now-dead `let`, so it would see a variable the user
+                                // demonstrably uses with no access flag left and report LINT002.
+                                // marked_used says "a transform ate the reads", same contract the
+                                // unused-argument checks already honor
+                                v->variable->marked_used = true;
                             }
                         }
                     }

tests/lint/test_lint002_block_var_used.das

@@ -0,0 +1,34 @@
+options gen2
+
+require dastest/testing_boost
+require daslib/lint
+
+// LINT002 false positive: invoke devirtualization splices the block literal in place and eats
+// the holder's only read. Lint runs after the patch slot but before optimize reaps the dead
+// `let`, so it saw a variable with no access flag and reported error[50503]. The devirtualizer
+// now marks such holders marked_used. A function-pointer local never devirtualizes, so it was
+// always clean - that asymmetry is what made this look block-typed-specific.
+
+def apply_via_invoke(x : int) : int {
+    let add_one = $(v : int) : int { return v + 1 }
+    return invoke(add_one, invoke(add_one, x))
+}
+
+def apply_block(blk : block<(v : int) : int>; x : int) : int {
+    return invoke(blk, x)
+}
+
+def apply_via_call(x : int) : int {
+    let add_two = $(v : int) : int { return v + 2 }
+    return apply_block(add_two, x)
+}
+
+[test]
+def test_block_var_read_by_invoke(t : T?) {
+    t |> equal(apply_via_invoke(1), 3)
+}
+
+[test]
+def test_block_var_passed_to_function(t : T?) {
+    t |> equal(apply_via_call(1), 3)
+}