fix(linter): fix false negatives in typescript/no-require-imports

[wagenet]

Summary

The typescript/no-require-imports rule had two false negatives:

require() with dynamic arguments was not flagged:

const m = require(someVariable);        // not flagged (should be)
const m = require(path.join(dir, file)); // not flagged (should be)
const m = require('./foo');              // correctly flagged

require() inside a class method named require was not flagged:

class Foo {
  require(module: string) {
    return require(module); // not flagged (should be)
  }
}

Both cases share the same root cause: the rule used CallExpression::is_require_call() to detect require calls, which only matches when the argument is a StringLiteral or TemplateLiteral. Calls with dynamic arguments were silently skipped.

Fix: Replace is_require_call() with a direct callee identifier check. The rule now flags any CallExpression where the callee is the unqualified identifier require resolving to the global, regardless of argument type.

Also fixed: double-diagnostics when the allow config option is set. Non-matching string/template literal arguments previously emitted a diagnostic on the argument span and then fell through to emit a second diagnostic on the call expression span. Now a single diagnostic is emitted on the call expression span. The same issue was present in the TSImportEqualsDeclaration path and is fixed there too.

Test plan

• Added fail cases: require(someVariable), require(path.join(dir, file)), require(module) and require('foo') inside a class method named require
• Updated snapshot to reflect single diagnostic per call and new cases
• cargo test -p oxc_linter --lib no_require_imports passes

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR fixes false negatives in the typescript/no-require-imports linter rule where dynamic require() calls and require calls inside class methods named require were not being flagged. The root cause was the use of CallExpression::is_require_call() which only matches when the argument is a string or template literal.

Changes:

• Replaced is_require_call() check with direct callee identifier validation to catch all require(...) calls regardless of argument type
• Fixed duplicate diagnostics when allow config is set by only emitting on call expression span
• Added comprehensive test coverage for dynamic arguments and class method scenarios

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
crates/oxc_linter/src/rules/typescript/no_require_imports.rs	Refactored require call detection logic to check callee identifier directly instead of using is_require_call(), reordered scope checks for efficiency, and simplified allow pattern checking to eliminate duplicate diagnostics
crates/oxc_linter/src/snapshots/typescript_no_require_imports.snap	Removed duplicate diagnostic entries (previously emitted on both argument and call spans) and added new diagnostics for the fixed false negative cases

[codspeed-hq]

Merging this PR will not alter performance

✅ 47 untouched benchmarks
⏩ 3 skipped benchmarks¹

---

_{Comparing wagenet:worktree-fix-no-require-imports (32775a5) with main (7958b56)}

Footnotes

1. 3 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[camc314]

thank you!