Add QC009 lint rule: fix wrong asset class API for forex/crypto pairs

- Detect forex tickers (EUR/USD, EURUSD, GBP/CHF, etc.) passed to
  add_equity() and auto-fix to add_forex()
- Detect crypto tickers (BTCUSD, ETH/USD, etc.) passed to
  add_equity() and auto-fix to add_crypto()
- Supports both slash and no-slash formats, single and double quotes
- Runs after QC001 so PascalCase AddEquity is already normalized
- 9 new tests (46 total linter tests, all passing)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: SL-Mar

quantcoder/core/qc_linter.py

@@ -19,7 +19,7 @@
 
 @dataclass
 class LintIssue:
-    rule_id: str       # "QC001"–"QC008"
+    rule_id: str       # "QC001"–"QC009"
     line: int
     message: str
     severity: str      # "error" | "warning"
@@ -386,6 +386,88 @@ def _rule_qc006(code: str, issues: List[LintIssue]) -> str:
 })
 
 
+# ---------------------------------------------------------------------------
+# QC009 — Wrong asset class API (e.g. add_equity for forex pairs)
+# ---------------------------------------------------------------------------
+
+# ISO 4217 major currency codes used in forex pairs
+_FOREX_CURRENCIES = frozenset({
+    "EUR", "USD", "GBP", "JPY", "CHF", "AUD", "NZD", "CAD",
+    "SEK", "NOK", "DKK", "SGD", "HKD", "ZAR", "MXN", "TRY",
+    "PLN", "CZK", "HUF", "INR", "CNY", "CNH", "KRW", "BRL",
+})
+
+# Common crypto base tickers
+_CRYPTO_BASES = frozenset({
+    "BTC", "ETH", "LTC", "XRP", "BCH", "ADA", "DOT", "LINK",
+    "SOL", "AVAX", "DOGE", "SHIB", "MATIC", "UNI", "AAVE",
+    "ATOM", "XLM", "ALGO", "FIL", "NEAR",
+})
+
+# Matches: self.add_equity("EUR/USD" ...) or self.add_equity("EURUSD" ...)
+# Captures the full call including open paren, quote char, ticker, and quote char
+_ADD_EQUITY_TICKER = re.compile(
+    r'(self\.add_equity\s*\(\s*)(["\'])([A-Z]{3,10}(?:/[A-Z]{2,5})?)\2'
+)
+
+
+def _is_forex_pair(ticker: str) -> bool:
+    """Check if ticker looks like a forex pair (e.g. EUR/USD, EURUSD)."""
+    if "/" in ticker:
+        parts = ticker.split("/")
+        return (len(parts) == 2
+                and parts[0] in _FOREX_CURRENCIES
+                and parts[1] in _FOREX_CURRENCIES)
+    # No slash: EURUSD style (6 chars, both halves are currencies)
+    if len(ticker) == 6:
+        return (ticker[:3] in _FOREX_CURRENCIES
+                and ticker[3:] in _FOREX_CURRENCIES)
+    return False
+
+
+def _is_crypto_pair(ticker: str) -> bool:
+    """Check if ticker looks like a crypto pair (e.g. BTCUSD, BTC/USD)."""
+    if "/" in ticker:
+        base = ticker.split("/")[0]
+    elif len(ticker) >= 6:
+        base = ticker[:-3]  # assume 3-char quote (USD, EUR, etc.)
+    else:
+        return False
+    return base in _CRYPTO_BASES
+
+
+def _rule_qc009(code: str, issues: List[LintIssue]) -> str:
+    """Fix add_equity() used with forex or crypto tickers."""
+    # Process each match from right to left to preserve offsets
+    matches = list(_ADD_EQUITY_TICKER.finditer(code))
+    for m in reversed(matches):
+        ticker = m.group(3)
+        if _is_forex_pair(ticker):
+            lineno = code[:m.start()].count('\n') + 1
+            old = m.group()
+            new = m.group().replace("self.add_equity", "self.add_forex", 1)
+            issues.append(LintIssue(
+                rule_id="QC009", line=lineno,
+                message=f"Forex pair {ticker} should use self.add_forex(), not self.add_equity()",
+                severity="error", fixed=True,
+                original=old, replacement=new,
+            ))
+            code = code[:m.start()] + new + code[m.end():]
+        elif _is_crypto_pair(ticker):
+            lineno = code[:m.start()].count('\n') + 1
+            old = m.group()
+            new = m.group().replace("self.add_equity", "self.add_crypto", 1)
+            issues.append(LintIssue(
+                rule_id="QC009", line=lineno,
+                message=f"Crypto pair {ticker} should use self.add_crypto(), not self.add_equity()",
+                severity="error", fixed=True,
+                original=old, replacement=new,
+            ))
+            code = code[:m.start()] + new + code[m.end():]
+
+    return code
+
+
 def _rule_qc008(code: str, issues: List[LintIssue]) -> str:
     """Warn about self.xxx = ... where xxx is a QCAlgorithm indicator method."""
     try:
@@ -417,14 +499,15 @@ def _rule_qc008(code: str, issues: List[LintIssue]) -> str:
 
 # Rule execution order: case normalization first, then structural fixes, then warnings
 _RULES = [
-    _rule_qc001,
-    _rule_qc007,
-    _rule_qc004,
-    _rule_qc002,
-    _rule_qc003,
-    _rule_qc005,
-    _rule_qc006,
-    _rule_qc008,
+    _rule_qc001,   # PascalCase → snake_case (must run first)
+    _rule_qc007,   # Resolution casing
+    _rule_qc009,   # Wrong asset class API (runs after QC001 normalizes add_equity)
+    _rule_qc004,   # Action() wrapper
+    _rule_qc002,   # len() on RollingWindow
+    _rule_qc003,   # .Values on RollingWindow
+    _rule_qc005,   # History as Slice (warning)
+    _rule_qc006,   # history() in on_data() (warning)
+    _rule_qc008,   # Indicator shadowing (warning)
 ]
 
 

tests/test_qc_linter.py

@@ -361,6 +361,83 @@ def test_multiple_indicators_warned(self):
 # Integration / composition tests
 # ---------------------------------------------------------------------------
 
+# ---------------------------------------------------------------------------
+# QC009 — Wrong asset class API
+# ---------------------------------------------------------------------------
+
+class TestQC009AssetClass:
+    """add_equity() with forex/crypto tickers → add_forex()/add_crypto()."""
+
+    def test_forex_slash_fixed(self):
+        code = (
+            "class Algo(QCAlgorithm):\n"
+            "    def initialize(self):\n"
+            "        self.add_equity(\"EUR/USD\", Resolution.TICK)\n"
+            "        self.add_equity(\"USD/JPY\", Resolution.TICK)\n"
+        )
+        result = lint_qc_code(code)
+        assert result.had_fixes
+        assert "self.add_forex(\"EUR/USD\"" in result.code
+        assert "self.add_forex(\"USD/JPY\"" in result.code
+        assert "self.add_equity" not in result.code
+
+    def test_forex_noslash_fixed(self):
+        code = "self.add_equity(\"EURUSD\", Resolution.MINUTE)\n"
+        result = lint_qc_code(code)
+        assert result.had_fixes
+        assert "self.add_forex(\"EURUSD\"" in result.code
+
+    def test_forex_single_quotes(self):
+        code = "self.add_equity('GBP/CHF', Resolution.DAILY)\n"
+        result = lint_qc_code(code)
+        assert result.had_fixes
+        assert "self.add_forex('GBP/CHF'" in result.code
+
+    def test_crypto_fixed(self):
+        code = "self.add_equity(\"BTCUSD\", Resolution.DAILY)\n"
+        result = lint_qc_code(code)
+        assert result.had_fixes
+        assert "self.add_crypto(\"BTCUSD\"" in result.code
+
+    def test_crypto_slash_fixed(self):
+        code = "self.add_equity(\"ETH/USD\", Resolution.HOUR)\n"
+        result = lint_qc_code(code)
+        assert result.had_fixes
+        assert "self.add_crypto(\"ETH/USD\"" in result.code
+
+    def test_equity_ticker_unchanged(self):
+        code = "self.add_equity(\"SPY\", Resolution.DAILY)\n"
+        result = lint_qc_code(code)
+        qc009_issues = _issues_by_rule(result, "QC009")
+        assert len(qc009_issues) == 0
+        assert "self.add_equity(\"SPY\"" in result.code
+
+    def test_already_add_forex_unchanged(self):
+        code = "self.add_forex(\"EUR/USD\", Resolution.TICK)\n"
+        result = lint_qc_code(code)
+        qc009_issues = _issues_by_rule(result, "QC009")
+        assert len(qc009_issues) == 0
+
+    def test_pascalcase_addequity_forex_chain(self):
+        """QC001 normalizes AddEquity first, then QC009 fixes to add_forex."""
+        code = "self.AddEquity(\"EUR/GBP\", Resolution.Daily)\n"
+        result = lint_qc_code(code)
+        assert "self.add_forex(\"EUR/GBP\"" in result.code
+        assert "Resolution.DAILY" in result.code
+
+    def test_multiple_pairs_all_fixed(self):
+        code = (
+            "for pair in ['EUR/USD', 'GBP/JPY', 'AUD/NZD']:\n"
+            "    pass\n"
+            "self.add_equity(\"EUR/USD\", Resolution.TICK)\n"
+            "self.add_equity(\"GBP/JPY\", Resolution.TICK)\n"
+            "self.add_equity(\"AUD/NZD\", Resolution.TICK)\n"
+        )
+        result = lint_qc_code(code)
+        assert result.code.count("self.add_forex") == 3
+        assert "self.add_equity" not in result.code
+
+
 class TestComposition:
     """Multiple rules apply to the same code."""