hakorune/tools/hako_check/rules/rule_arity_mismatch.hako

// tools/hako_check/rules/rule_arity_mismatch.hako — HC015: Arity Mismatch (MVP)
// Detects method calls with incorrect number of arguments (arity mismatch).
// MVP version: detects clear Box.method() calls with wrong arity.

static box RuleArityMismatchBox {
  method apply_ir(ir, path, out) {
    local calls = ir.get("calls")
    if calls == null { return 0 }

    local methods = ir.get("methods")
    if methods == null { return 0 }

    // Check each call for arity mismatch
    local ci = 0
    while ci < calls.size() {
      local call = calls.get(ci)
      if call == null { ci = ci + 1; continue }

      local to = call.get("to")
      if to == null { ci = ci + 1; continue }

      // to format: "Box.method/arity"
      // Extract box, method, and called arity
      local parts = me._parse_qualified(to)
      if parts == null { ci = ci + 1; continue }

      local box_name = parts.get("box")
      local method_name = parts.get("method")
      local called_arity = parts.get("arity")

      // Find if a method with same box.method but different arity exists
      local expected_arity = me._find_method_arity(methods, box_name, method_name)
      if expected_arity < 0 {
        // Method not found - could be external or plugin method, skip
        ci = ci + 1
        continue
      }

      // Check arity mismatch
      if expected_arity != called_arity {
        local msg = "[HC015] arity mismatch: " + box_name + "." + method_name
        msg = msg + " expects " + me._itoa(expected_arity)
        msg = msg + " arguments, got " + me._itoa(called_arity)
        msg = msg + " :: " + to
        out.push(msg)
      }

      ci = ci + 1
    }
    return out.size()
  }

  _find_method_arity(methods, box_name, method_name) {
    // Search for method with given box.method prefix
    // Returns arity if found, -1 if not found
    local prefix = box_name + "." + method_name + "/"
    local mi = 0
    while mi < methods.size() {
      local m = methods.get(mi)
      if m != null {
        if m.indexOf(prefix) == 0 {
          // Extract arity from "Box.method/arity"
          local slash_pos = m.lastIndexOf("/")
          if slash_pos >= 0 {
            local arity_str = m.substring(slash_pos + 1)
            return me._atoi(arity_str)
          }
        }
      }
      mi = mi + 1
    }
    return -1
  }

  _parse_qualified(qualified) {
    // Parse "Box.method/arity" into components
    if qualified == null { return null }

    local slash_pos = qualified.lastIndexOf("/")
    if slash_pos < 0 { return null }

    local arity_str = qualified.substring(slash_pos + 1)
    local arity = me._atoi(arity_str)

    local dot_pos = qualified.lastIndexOf(".")
    if dot_pos < 0 { return null }

    local box_name = qualified.substring(0, dot_pos)
    local method_name = qualified.substring(dot_pos + 1, slash_pos)

    local result = new MapBox()
    result.set("box", box_name)
    result.set("method", method_name)
    result.set("arity", arity)
    return result
  }

  _itoa(n) {
    local v = 0 + n
    if v == 0 { return "0" }
    local out = ""
    local digits = "0123456789"
    local tmp = ""
    while v > 0 {
      local d = v % 10
      tmp = digits.substring(d, d+1) + tmp
      v = v / 10
    }
    out = tmp
    return out
  }

  _atoi(s) {
    if s == null { return 0 }
    local n = s.length()
    if n == 0 { return 0 }
    local i = 0
    local v = 0
    local digits = "0123456789"
    while i < n {
      local ch = s.substring(i, i+1)
      if ch < "0" || ch > "9" { break }
      local pos = digits.indexOf(ch)
      if pos < 0 { break }
      v = v * 10 + pos
      i = i + 1
    }
    return v
  }
}

static box RuleArityMismatchMain { method main(args) { return 0 } }