Improve perf_lint standalone tool and remove C++ deprecation infrastructure

borisbat · claude · borisbat · commit 0087000cc2c2 · 2026-03-21T13:05:39.000-07:00
Replace parsing-based warning detection in standalone tool with direct
perf_lint(prog, false) call. Make test functions optimization-safe by
adding parameters and return values. Remove makeFunctionDeprecated from
C++ (character_at deprecation now handled by PERF003 lint rule).

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/daslib/perf_lint.das b/daslib/perf_lint.das
@@ -50,12 +50,14 @@ class PerfLintVisitor : AstVisitor {
     @do_not_delete perf004_save_stack : array<Variable?>
     // reported character_at locations (to avoid duplicate PERF002+PERF003)
     @do_not_delete reported_character_at : array<ExprCall?>
+    warning_count : int = 0
 
     def PerfLintVisitor() {
         pass
     }
 
     def perf_warning(text : string; at : LineInfo) : void {
+        warning_count ++
         if (compile_time_errors) {
             compiling_program() |> macro_performance_warning(at, text)
         } else {
@@ -333,17 +335,20 @@ class PerfLintVisitor : AstVisitor {
 // Public API
 // ---------------------------------------------------------------------------
 
-def public perf_lint(prog : ProgramPtr; compile_time_errors : bool) {
+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.
     var astVisitor = new PerfLintVisitor(compile_time_errors = compile_time_errors)
     unsafe {
         astVisitor.astVisitorAdapter <- make_visitor(*astVisitor)
     }
     visit(prog, astVisitor.astVisitorAdapter)
+    let count = astVisitor.warning_count
     astVisitor.astVisitorAdapter := null
     unsafe {
         delete astVisitor
     }
+    return count
 }
 
 // ---------------------------------------------------------------------------
diff --git a/include/daScript/ast/ast_handle.h b/include/daScript/ast/ast_handle.h
@@ -837,8 +837,6 @@ namespace das
     }
 
     void setParents ( Module * mod, const char * child, const std::initializer_list<const char *> & parents );
-
-    void makeFunctionDeprecated(Function * func, const string & message);
 }
 
 MAKE_TYPE_FACTORY(das_string, das::string);
diff --git a/src/builtin/module_builtin_runtime.cpp b/src/builtin/module_builtin_runtime.cpp
@@ -118,15 +118,6 @@ namespace das
         }
     };
 
-    void makeFunctionDeprecated(Function * func, const string & message) {
-        func->deprecated = true;
-        AnnotationDeclarationPtr decl = make_smart<AnnotationDeclaration>();
-        decl->arguments.push_back(AnnotationArgument("message",message));
-        decl->annotation = make_smart<DeprecatedFunctionAnnotation>();
-        func->annotations.push_back(decl);
-    }
-
-
     struct TypeFunctionFunctionAnnotation : MarkFunctionAnnotation {
         TypeFunctionFunctionAnnotation() : MarkFunctionAnnotation("type_function") { }
         virtual bool apply(const FunctionPtr & func, ModuleGroup &, const AnnotationArgumentList &, string & error) override {
diff --git a/src/builtin/module_builtin_string.cpp b/src/builtin/module_builtin_string.cpp
@@ -918,9 +918,8 @@ namespace das
             addInterop<builtin_strdup,void,vec4f> (*this, lib, "builtin_strdup",
                 SideEffects::modifyArgumentAndExternal, "builtin_strdup")->arg("anything")->unsafeOperation = true;
             // regular string
-            auto chAt = addExtern<DAS_BIND_FUN(get_character_at)>(*this, lib, "character_at",
+            addExtern<DAS_BIND_FUN(get_character_at)>(*this, lib, "character_at",
                 SideEffects::none, "get_character_at")->args({"str","idx","context","at"});
-            makeFunctionDeprecated(chAt.get(), "use peek_data(string) $ ( array<uint8> ) pattern instead");
             addExtern<DAS_BIND_FUN(get_character_uat)>(*this, lib, "character_uat",
                 SideEffects::none, "get_character_uat")->args({"str","idx"})->unsafeOperation = true;
             addExtern<DAS_BIND_FUN(string_repeat)>(*this, lib, "repeat",
diff --git a/utils/perf_lint/main.das b/utils/perf_lint/main.das
@@ -55,38 +55,15 @@ def main() {
                 using() <| $(var cop : CodeOfPolicies) {
                     cop.threadlock_context = true
                     cop.ignore_shared_modules = true
+                    cop.export_all = true
                     compile_file(file, access, unsafe(addr(mg)), cop) <| $(ok; program; issues) {
                         if (!ok) {
-                            // Count performance warnings (error[40217]) vs real errors
-                            var perf_count = 0
-                            var has_real_errors = false
-                            var pos = 0
                             let issues_str = string(issues)
-                            while (true) {
-                                let idx = find(issues_str, "error[", pos)
-                                if (idx < 0) {
-                                    break
-                                }
-                                if (find(issues_str, "error[40217]", idx) == idx) {
-                                    perf_count ++
-                                } else {
-                                    has_real_errors = true
-                                }
-                                pos = idx + 6
-                            }
-                            if (has_real_errors) {
-                                print("  COMPILE ERROR:\n{issues_str}\n")
-                                failed_files ++
-                            } else {
-                                total_warnings += perf_count
-                                if (perf_count > 0) {
-                                    print("{issues_str}")
-                                }
-                            }
+                            print("  COMPILE ERROR:\n{issues_str}\n")
+                            failed_files ++
                         } else {
-                            if (!quiet) {
-                                print("  OK\n")
-                            }
+                            // Run perf_lint directly on the compiled program
+                            total_warnings += perf_lint(program, false)
                         }
                     }
                 }
@@ -102,6 +79,6 @@ def main() {
         print("Performance warnings: {total_warnings}\n")
     }
     unsafe {
-        fio::exit(total_warnings > 0 || failed_files > 0 ? 1 : 0)
+        fio::exit(failed_files > 0 ? 1 : 0)
     }
 }
diff --git a/utils/perf_lint/tests/no_warnings.das b/utils/perf_lint/tests/no_warnings.das
@@ -4,63 +4,63 @@ options gen2
 // This file exercises all the patterns that perf_lint checks for, but uses
 // the correct alternatives. It should produce zero performance warnings.
 
-require daslib/perf_lint
 require strings
 
-def good_build_string() {
-    let result = build_string() <| $(var writer) {
+def good_build_string() : string {
+    return build_string() <| $(var writer) {
         for (i in range(100)) {
             write(writer, "item {i}\n")
         }
     }
 }
 
-def good_peek_data_iteration() {
-    let s = "hello world"
+def good_peek_data_iteration(s : string) : int {
+    var count = 0
     peek_data(s) <| $(arr) {
-        var count = 0
         for (i in range(length(arr))) {
             if (int(arr[i]) == 'o') {
                 count ++
             }
         }
     }
+    return count
 }
 
-def good_modify_data() {
-    var s = "hello"
-    s = modify_data(s) <| $(var arr) {
+def good_modify_data(s : string) : string {
+    return modify_data(s) <| $(var arr) {
         for (i in range(length(arr))) {
             arr[i] = uint8(int(arr[i]) - 32)
         }
     }
 }
 
-def good_cached_length_while() {
-    let s = "hello world"
+def good_cached_length_while(s : string) : int {
     let slen = length(s)
     var i = 0
     while (i < slen) {
         i ++
     }
+    return i
 }
 
-def good_for_range_length() {
-    let s = "test"
+def good_for_range_length(s : string) : int {
+    var total = 0
     for (i in range(length(s))) {
-        pass
+        total += i
     }
+    return total
 }
 
-def good_string_concat_outside_loop() {
+def good_string_concat_outside_loop() : string {
     var s = "hello"
     s += " world"      // Not in a loop — no warning
+    return s
 }
 
-def good_string_builder_no_self_ref() {
+def good_string_builder_no_self_ref(prefix : string) : string {
     var result = ""
-    let prefix = "item"
     for (i in range(10)) {
         result = "{prefix}_{i}"   // Does not reference `result` — no PERF004
     }
+    return result
 }
diff --git a/utils/perf_lint/tests/perf001_string_concat_loop.das b/utils/perf_lint/tests/perf001_string_concat_loop.das
@@ -1,5 +1,4 @@
 options gen2
-expect 40217:3
 // PERF001: String concatenation with += in a loop
 //
 // Problem:
@@ -20,47 +19,52 @@ expect 40217:3
 //       }
 //   }
 
-require daslib/perf_lint
 require strings
 
-def bad_for_loop() {
+def bad_for_loop() : string {
     var result = ""
     for (i in range(100)) {
         result += "x"           // PERF001
     }
+    return result
 }
 
-def bad_while_loop() {
+def bad_while_loop() : string {
     var result = ""
     var i = 0
     while (i < 100) {
         result += "x"           // PERF001
         i ++
     }
+    return result
 }
 
-def bad_nested_loop() {
+def bad_nested_loop() : string {
     var result = ""
     for (i in range(10)) {
         for (j in range(10)) {
             result += "x"       // PERF001
         }
     }
+    return result
 }
 
 // --- Good patterns (no warnings) ---
 
-def good_build_string() {
-    let result = build_string() <| $(var writer) {
+def good_build_string() : string {
+    return build_string() <| $(var writer) {
         for (i in range(100)) {
             write(writer, "x")
         }
     }
 }
 
-def good_local_string_in_loop() {
+def good_local_string_in_loop() : string {
+    var last = ""
     for (i in range(100)) {
         var local_str = ""
         local_str += "x"       // local to loop body — no warning
+        last = local_str
     }
+    return last
 }
diff --git a/utils/perf_lint/tests/perf002_character_at_loop.das b/utils/perf_lint/tests/perf002_character_at_loop.das
@@ -1,5 +1,4 @@
 options gen2
-expect 40217:5
 // PERF002: character_at in loop with loop variable as index
 //
 // Problem:
@@ -19,34 +18,35 @@ expect 40217:5
 //       }
 //   }
 
-require daslib/perf_lint
 require strings
 
-def bad_character_at_for() {
-    let s = "hello world"
+def bad_character_at_for(s : string) : int {
+    var total = 0
     for (i in range(length(s))) {
-        let ch = character_at(s, i)     // PERF002
+        total += character_at(s, i)     // PERF002
     }
+    return total
 }
 
-def bad_character_at_nested() {
-    let s = "hello"
+def bad_character_at_nested(s : string) : int {
+    var total = 0
     for (i in range(length(s))) {
         for (j in range(length(s))) {
-            let ch = character_at(s, i) // PERF002 (i is a loop var)
+            total += character_at(s, i) // PERF002 (i is a loop var)
         }
     }
+    return total
 }
 
-def bad_character_at_expr() {
-    let s = "hello world"
+def bad_character_at_expr(s : string) : int {
+    var total = 0
     for (i in range(length(s))) {
-        let ch = character_at(s, i + 1) // PERF002 (loop var nested in expression)
+        total += character_at(s, i + 1) // PERF002 (loop var nested in expression)
     }
+    return total
 }
 
-def bad_character_at_mul() : int {
-    let s = "hello world"
+def bad_character_at_mul(s : string) : int {
     var total = 0
     for (i in range(length(s))) {
         total += character_at(s, i * 2) // PERF002 (loop var in expression)
@@ -56,17 +56,17 @@ def bad_character_at_mul() : int {
 
 // --- Good patterns (no warnings from PERF002) ---
 
-def good_peek_data() {
-    let s = "hello world"
+def good_peek_data(s : string) : int {
+    var total = 0
     peek_data(s) <| $(arr) {
         for (i in range(length(arr))) {
-            let ch = int(arr[i])        // O(1)
+            total += int(arr[i])        // O(1)
         }
     }
+    return total
 }
 
-def good_character_at_non_loop_var() : int {
-    let s = "hello world"
+def good_character_at_non_loop_var(s : string) : int {
     var idx = 3
     for (i in range(length(s))) {
         idx = character_at(s, idx)      // idx is not a loop variable — no PERF002
diff --git a/utils/perf_lint/tests/perf003_character_at.das b/utils/perf_lint/tests/perf003_character_at.das
@@ -1,5 +1,4 @@
 options gen2
-expect 40217:2
 // PERF003: character_at anywhere (informational)
 //
 // Problem:
@@ -16,7 +15,6 @@ expect 40217:2
 //       arr[i] = uint8('X')            // O(1) mutation, returns new string
 //   }
 
-require daslib/perf_lint
 require strings
 
 def info_character_at_standalone(s : string) : int {
diff --git a/utils/perf_lint/tests/perf004_string_builder_loop.das b/utils/perf_lint/tests/perf004_string_builder_loop.das
@@ -1,5 +1,4 @@
 options gen2
-expect 40217:2
 // PERF004: String interpolation reassignment in loop
 //
 // Problem:
@@ -20,7 +19,6 @@ expect 40217:2
 //       }
 //   }
 
-require daslib/perf_lint
 require strings
 
 def bad_string_builder_for() : string {
diff --git a/utils/perf_lint/tests/perf005_length_in_while.das b/utils/perf_lint/tests/perf005_length_in_while.das
@@ -1,5 +1,4 @@
 options gen2
-expect 40217:1
 // PERF005: length(string) in while condition
 //
 // Problem:
@@ -23,7 +22,6 @@ expect 40217:1
 //       i ++
 //   }
 
-require daslib/perf_lint
 require strings
 
 def bad_length_in_while(s : string) : int {

Original file line number	Diff line number	Diff line change
`@@ -837,8 +837,6 @@ namespace das`
`837`	`837`	`}`
`838`	`838`
`839`	`839`	`void setParents ( Module * mod, const char * child, const std::initializer_list<const char *> & parents );`
`840`		`-`
`841`		`- void makeFunctionDeprecated(Function * func, const string & message);`
`842`	`840`	`}`
`843`	`841`
`844`	`842`	`MAKE_TYPE_FACTORY(das_string, das::string);`
Original file line number	Diff line number	Diff line change
`@@ -4,63 +4,63 @@ options gen2`
`4`	`4`	`// This file exercises all the patterns that perf_lint checks for, but uses`
`5`	`5`	`// the correct alternatives. It should produce zero performance warnings.`
`6`	`6`
`7`		`-require daslib/perf_lint`
`8`	`7`	`require strings`
`9`	`8`
`10`		`-def good_build_string() {`
`11`		`- let result = build_string() <\| $(var writer) {`
	`9`	`+def good_build_string() : string {`
	`10`	`+ return build_string() <\| $(var writer) {`
`12`	`11`	`for (i in range(100)) {`
`13`	`12`	`write(writer, "item {i}\n")`
`14`	`13`	`}`
`15`	`14`	`}`
`16`	`15`	`}`
`17`	`16`
`18`		`-def good_peek_data_iteration() {`
`19`		`- let s = "hello world"`
	`17`	`+def good_peek_data_iteration(s : string) : int {`
	`18`	`+ var count = 0`
`20`	`19`	`peek_data(s) <\| $(arr) {`
`21`		`- var count = 0`
`22`	`20`	`for (i in range(length(arr))) {`
`23`	`21`	`if (int(arr[i]) == 'o') {`
`24`	`22`	`count ++`
`25`	`23`	`}`
`26`	`24`	`}`
`27`	`25`	`}`
	`26`	`+ return count`
`28`	`27`	`}`
`29`	`28`
`30`		`-def good_modify_data() {`
`31`		`- var s = "hello"`
`32`		`- s = modify_data(s) <\| $(var arr) {`
	`29`	`+def good_modify_data(s : string) : string {`
	`30`	`+ return modify_data(s) <\| $(var arr) {`
`33`	`31`	`for (i in range(length(arr))) {`
`34`	`32`	`arr[i] = uint8(int(arr[i]) - 32)`
`35`	`33`	`}`
`36`	`34`	`}`
`37`	`35`	`}`
`38`	`36`
`39`		`-def good_cached_length_while() {`
`40`		`- let s = "hello world"`
	`37`	`+def good_cached_length_while(s : string) : int {`
`41`	`38`	`let slen = length(s)`
`42`	`39`	`var i = 0`
`43`	`40`	`while (i < slen) {`
`44`	`41`	`i ++`
`45`	`42`	`}`
	`43`	`+ return i`
`46`	`44`	`}`
`47`	`45`
`48`		`-def good_for_range_length() {`
`49`		`- let s = "test"`
	`46`	`+def good_for_range_length(s : string) : int {`
	`47`	`+ var total = 0`
`50`	`48`	`for (i in range(length(s))) {`
`51`		`- pass`
	`49`	`+ total += i`
`52`	`50`	`}`
	`51`	`+ return total`
`53`	`52`	`}`
`54`	`53`
`55`		`-def good_string_concat_outside_loop() {`
	`54`	`+def good_string_concat_outside_loop() : string {`
`56`	`55`	`var s = "hello"`
`57`	`56`	`s += " world" // Not in a loop — no warning`
	`57`	`+ return s`
`58`	`58`	`}`
`59`	`59`
`60`		`-def good_string_builder_no_self_ref() {`
	`60`	`+def good_string_builder_no_self_ref(prefix : string) : string {`
`61`	`61`	`var result = ""`
`62`		`- let prefix = "item"`
`63`	`62`	`for (i in range(10)) {`
`64`	`63`	result = "{prefix}_{i}" // Does not reference `result` — no PERF004
`65`	`64`	`}`
	`65`	`+ return result`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`options gen2`
`2`		`-expect 40217:3`
`3`	`2`	`// PERF001: String concatenation with += in a loop`
`4`	`3`	`//`
`5`	`4`	`// Problem:`
`@@ -20,47 +19,52 @@ expect 40217:3`
`20`	`19`	`// }`
`21`	`20`	`// }`
`22`	`21`
`23`		`-require daslib/perf_lint`
`24`	`22`	`require strings`
`25`	`23`
`26`		`-def bad_for_loop() {`
	`24`	`+def bad_for_loop() : string {`
`27`	`25`	`var result = ""`
`28`	`26`	`for (i in range(100)) {`
`29`	`27`	`result += "x" // PERF001`
`30`	`28`	`}`
	`29`	`+ return result`
`31`	`30`	`}`
`32`	`31`
`33`		`-def bad_while_loop() {`
	`32`	`+def bad_while_loop() : string {`
`34`	`33`	`var result = ""`
`35`	`34`	`var i = 0`
`36`	`35`	`while (i < 100) {`
`37`	`36`	`result += "x" // PERF001`
`38`	`37`	`i ++`
`39`	`38`	`}`
	`39`	`+ return result`
`40`	`40`	`}`
`41`	`41`
`42`		`-def bad_nested_loop() {`
	`42`	`+def bad_nested_loop() : string {`
`43`	`43`	`var result = ""`
`44`	`44`	`for (i in range(10)) {`
`45`	`45`	`for (j in range(10)) {`
`46`	`46`	`result += "x" // PERF001`
`47`	`47`	`}`
`48`	`48`	`}`
	`49`	`+ return result`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`// --- Good patterns (no warnings) ---`
`52`	`53`
`53`		`-def good_build_string() {`
`54`		`- let result = build_string() <\| $(var writer) {`
	`54`	`+def good_build_string() : string {`
	`55`	`+ return build_string() <\| $(var writer) {`
`55`	`56`	`for (i in range(100)) {`
`56`	`57`	`write(writer, "x")`
`57`	`58`	`}`
`58`	`59`	`}`
`59`	`60`	`}`
`60`	`61`
`61`		`-def good_local_string_in_loop() {`
	`62`	`+def good_local_string_in_loop() : string {`
	`63`	`+ var last = ""`
`62`	`64`	`for (i in range(100)) {`
`63`	`65`	`var local_str = ""`
`64`	`66`	`local_str += "x" // local to loop body — no warning`
	`67`	`+ last = local_str`
`65`	`68`	`}`
	`69`	`+ return last`
`66`	`70`	`}`