feiyunwill
diff --git a/‎daslib/lint.das‎
Lines changed: 49 additions & 0 deletions b/‎daslib/lint.das‎
Lines changed: 49 additions & 0 deletions
diff --git a/‎utils/lint/tests/lint017_long_counterpart_cast.das‎
Lines changed: 55 additions & 0 deletions b/‎utils/lint/tests/lint017_long_counterpart_cast.das‎
Lines changed: 55 additions & 0 deletions
diff --git a/‎utils/lint/tests/lint018_mem_size_narrowing.das‎
Lines changed: 38 additions & 0 deletions b/‎utils/lint/tests/lint018_mem_size_narrowing.das‎
Lines changed: 38 additions & 0 deletions
@@ -388,8 +388,57 @@ class LintVisitor : AstVisitor {
         validate_argument(arg, "LINT013", "block argument")
     }
 
+    // --- LINT017: int64/uint64 cast of a call that has a long_ counterpart ---
+
+    def lint017_long_twin(fname : string; icall : ExprCall?) : string {
+        // Receiver-gated, so a same-named user overload or the fixed-array `length` generic in daslib/builtin.das (which has no long_ twin) stays silent.
+        let nargs = length(icall.arguments)
+        if (nargs == 0 || icall.arguments[0]._type == null) return ""
+        let bt = icall.arguments[0]._type.baseType
+        if (fname == "length" && (bt == Type.tArray || bt == Type.tTable || bt == Type.tString)) return "long_length"
+        if (fname == "capacity" && (bt == Type.tArray || bt == Type.tTable)) return "long_capacity"
+        if (fname == "count" && (bt == Type.tArray || bt == Type.tIterator)) return "long_count"
+        if (fname == "find_index" && bt == Type.tArray && nargs == 2) return "long_find_index"
+        if ((fname == "fread" || fname == "fwrite") && nargs == 2) return "long_{fname}"
+        return ""
+    }
+
+    def check_lint017_long_cast(expr : ExprCall?) : void {
+        if (noLint || genericDepth > 0
+            || (expr.name != "int64" && expr.name != "uint64")
+            || length(expr.arguments) != 1) return
+        let inner = expr.arguments[0]
+        if (!(inner is ExprCall)) return
+        let icall = inner as ExprCall
+        let iname = string(icall.func != null && icall.func.fromGeneric != null
+            ? icall.func.fromGeneric.name
+            : icall.name)
+        let twin = lint017_long_twin(iname, icall)
+        if (empty(twin)) return
+        lint_error("LINT017: {expr.name}({iname}(...)) computes a 32-bit result and widens it, so it still wraps past 2^31; call {twin}(...) instead", expr.at)
+    }
+
+    // --- LINT018: narrowing the size argument of memcpy / memcmp ---
+
+    def check_lint018_mem_size_narrowing(expr : ExprCall?) : void {
+        if (noLint || genericDepth > 0
+            || (expr.name != "memcpy" && expr.name != "memcmp")
+            || length(expr.arguments) != 3) return
+        let size = expr.arguments[2]
+        if (!(size is ExprCall)) return
+        let scall = size as ExprCall
+        if (scall.name != "int" || length(scall.arguments) != 1) return
+        let src = scall.arguments[0]._type
+        if (src == null) return
+        let bt = src.baseType
+        if (bt != Type.tInt64 && bt != Type.tUInt64 && bt != Type.tUInt) return
+        lint_error("LINT018: int(...) truncates the {expr.name} size above 2^31; {expr.name} has uint/int64/uint64 overloads, so drop the cast", expr.at)
+    }
+
     def override preVisitExprCall(expr : ExprCall?) : void {
         check_string_push_clone(expr)
+        check_lint017_long_cast(expr)
+        check_lint018_mem_size_narrowing(expr)
     }
 
     // `assume name = <block>` keeps a template block at the alias-definition site; every use of
 
@@ -0,0 +1,55 @@
+options gen2
+options auto_inline_functions = false   // lint fixtures assert SOURCE shapes; splices rewrite them
+// LINT017: int64/uint64 cast of a call that has a long_ counterpart
+//
+// Problem: int64(length(x)) computes the 32-bit length FIRST and only then widens
+// it, so it still wraps past 2^31 — the cast buys nothing. long_length(x) is
+// 64-bit the whole way through.
+//
+// Bad pattern:
+//   let n = int64(length(arr))
+//
+// Good pattern:
+//   let n = long_length(arr)
+
+require daslib/linq
+
+// bad: int64 of array length (1 warning)
+def bad_int64_length(arr : array<int>) : int64 {
+    return int64(length(arr))
+}
+
+// bad: uint64 of array capacity (1 warning)
+def bad_uint64_capacity(arr : array<int>) : uint64 {
+    return uint64(capacity(arr))
+}
+
+// bad: int64 of string length (1 warning)
+def bad_int64_string_length(s : string) : int64 {
+    return int64(length(s))
+}
+
+// bad: int64 of table length (1 warning)
+def bad_int64_table_length(t : table<string; int>) : int64 {
+    return int64(length(t))
+}
+
+// bad: int64 of linq count (1 warning)
+def bad_int64_count(arr : array<int>) : int64 {
+    return int64(count(arr))
+}
+
+// good: 64-bit all the way through
+def good_long_length(arr : array<int>) : int64 {
+    return long_length(arr)
+}
+
+// good: a fixed array has no long_length twin, so the cast is the only spelling
+def good_fixed_array(fa : int[4]) : int64 {
+    return int64(length(fa))
+}
+
+// good: widening an ordinary int is not a truncation
+def good_plain_widen(n : int) : int64 {
+    return int64(n)
+}
@@ -0,0 +1,38 @@
+options gen2
+options auto_inline_functions = false   // lint fixtures assert SOURCE shapes; splices rewrite them
+// LINT018: narrowing the size argument of memcpy / memcmp
+//
+// Problem: int(n) truncates above 2^31, so the copy or compare silently covers
+// the wrong number of bytes. memcpy and memcmp both carry uint / int64 / uint64
+// size overloads, so the size can be passed straight through.
+//
+// Bad pattern:
+//   memcpy(dst, src, int(nbytes))   // nbytes : int64
+//
+// Good pattern:
+//   memcpy(dst, src, nbytes)
+
+// bad: int() narrowing of an int64 size (1 warning)
+def bad_memcpy_int64(dst, src : void?; nbytes : int64) {
+    unsafe(memcpy(dst, src, int(nbytes)))
+}
+
+// bad: int() narrowing of a uint64 size (1 warning)
+def bad_memcpy_uint64(dst, src : void?; nbytes : uint64) {
+    unsafe(memcpy(dst, src, int(nbytes)))
+}
+
+// bad: int() narrowing on memcmp (1 warning)
+def bad_memcmp_int64(dst, src : void?; nbytes : int64) : int {
+    return unsafe(memcmp(dst, src, int(nbytes)))
+}
+
+// good: the 64-bit size goes straight to the 64-bit overload
+def good_memcpy_int64(dst, src : void?; nbytes : int64) {
+    unsafe(memcpy(dst, src, nbytes))
+}
+
+// good: an int-typed size needs no cast at all
+def good_memcpy_int(dst, src : void?; nbytes : int) {
+    unsafe(memcpy(dst, src, nbytes))
+}