Fix linter gaps: chained Schedule/DateRules/TimeRules API, RollingWindow .Add(), and false-positive .Bars[]

QC001 now catches self.Schedule.On(), self.DateRules.EveryDay(),
self.TimeRules.AfterMarketOpen() and 8 more chained scheduling patterns.
Also fixes .Add() → .add() on RollingWindow variables. QC005 no longer
flags data.Bars[] which is valid Slice access in on_data.

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

Author: SL-Mar

quantcoder/core/qc_linter.py

@@ -117,6 +117,22 @@ def unfixable_hints(self) -> List[str]:
     ".Volume": ".volume",
 }
 
+# self.Attr.Method( → self.attr.method( (chained scheduling API)
+# Ordered longest-first to avoid partial matches (EveryDay before Every)
+_CHAINED_MAP = {
+    "self.Schedule.On": "self.schedule.on",
+    "self.DateRules.EveryDay": "self.date_rules.every_day",
+    "self.DateRules.MonthStart": "self.date_rules.month_start",
+    "self.DateRules.MonthEnd": "self.date_rules.month_end",
+    "self.DateRules.WeekStart": "self.date_rules.week_start",
+    "self.DateRules.WeekEnd": "self.date_rules.week_end",
+    "self.DateRules.Every": "self.date_rules.every",
+    "self.TimeRules.AfterMarketOpen": "self.time_rules.after_market_open",
+    "self.TimeRules.BeforeMarketClose": "self.time_rules.before_market_close",
+    "self.TimeRules.At": "self.time_rules.at",
+    "self.TimeRules.Every": "self.time_rules.every",
+}
+
 # def MethodName(self → def method_name(self
 _DEF_MAP = {
     "Initialize": "initialize",
@@ -157,6 +173,33 @@ def _rule_qc001(code: str, issues: List[LintIssue]) -> str:
             ))
         code = pattern.sub(snake, code)
 
+    # Chained scheduling API: self.Schedule.On( → self.schedule.on(
+    for pascal, snake in _CHAINED_MAP.items():
+        pattern = re.compile(re.escape(pascal) + r'(?=\s*\()')
+        for m in pattern.finditer(code):
+            lineno = code[:m.start()].count('\n') + 1
+            issues.append(LintIssue(
+                rule_id="QC001", line=lineno,
+                message=f"PascalCase chained API {pascal}() → {snake}()",
+                severity="error", fixed=True,
+                original=m.group(), replacement=snake,
+            ))
+        code = pattern.sub(snake, code)
+
+    # RollingWindow .Add( → .add(
+    rw_names = set(_RW_DECL.findall(code))
+    for name in rw_names:
+        pattern = re.compile(r'(self\.' + re.escape(name) + r')\.Add(?=\s*\()')
+        for m in pattern.finditer(code):
+            lineno = code[:m.start()].count('\n') + 1
+            issues.append(LintIssue(
+                rule_id="QC001", line=lineno,
+                message=f"self.{name}.Add() → self.{name}.add() (RollingWindow)",
+                severity="error", fixed=True,
+                original=f"self.{name}.Add", replacement=f"self.{name}.add",
+            ))
+        code = pattern.sub(rf'\1.add', code)
+
     # Method definitions: def PascalCase(self
     for pascal, snake in _DEF_MAP.items():
         pattern = re.compile(r'(def\s+)' + pascal + r'(\s*\(\s*self)')
@@ -280,8 +323,9 @@ def _rule_qc003(code: str, issues: List[LintIssue]) -> str:
 # ---------------------------------------------------------------------------
 
 _HISTORY_SLICE_PATTERNS = [
-    re.compile(r'\.Bars\s*\['),
+    # .Bars[ is valid Slice access in on_data — only flag History-specific C# patterns
     re.compile(r'\.ForEach\s*\('),
+    re.compile(r'\.GetValue\s*\('),
 ]
 
 

tests/test_qc_linter.py

@@ -84,6 +84,58 @@ def test_portfolio_invested(self):
         assert ".invested" in result.code
         assert ".Invested" not in result.code
 
+    def test_chained_schedule_api_fixed(self):
+        code = (
+            "self.Schedule.On(self.DateRules.EveryDay(), "
+            "self.TimeRules.AfterMarketOpen('SPY', 30), self.rebalance)\n"
+        )
+        result = lint_qc_code(code)
+        assert result.had_fixes
+        assert "self.schedule.on(" in result.code
+        assert "self.date_rules.every_day()" in result.code
+        assert "self.time_rules.after_market_open(" in result.code
+        assert "self.Schedule.On" not in result.code
+        assert "self.DateRules" not in result.code
+        assert "self.TimeRules" not in result.code
+
+    def test_chained_time_rules_variants(self):
+        code = (
+            "self.Schedule.On(self.DateRules.MonthStart(), "
+            "self.TimeRules.BeforeMarketClose('SPY', 5), self.close)\n"
+        )
+        result = lint_qc_code(code)
+        assert "self.date_rules.month_start()" in result.code
+        assert "self.time_rules.before_market_close(" in result.code
+
+    def test_chained_every_day_vs_every(self):
+        """EveryDay should not partially match Every."""
+        code = (
+            "a = self.DateRules.EveryDay()\n"
+            "b = self.DateRules.Every(DayOfWeek.MONDAY)\n"
+        )
+        result = lint_qc_code(code)
+        assert "self.date_rules.every_day()" in result.code
+        assert "self.date_rules.every(DayOfWeek" in result.code
+
+    def test_rolling_window_add_fixed(self):
+        code = (
+            "self.prices = RollingWindow[float](20)\n"
+            "self.prices.Add(data['SPY'].close)\n"
+        )
+        result = lint_qc_code(code)
+        assert result.had_fixes
+        assert "self.prices.add(" in result.code
+        assert "self.prices.Add(" not in result.code
+
+    def test_clean_schedule_api_unchanged(self):
+        code = (
+            "self.schedule.on(self.date_rules.every_day(), "
+            "self.time_rules.after_market_open('SPY', 30), self.rebalance)\n"
+        )
+        result = lint_qc_code(code)
+        qc001_issues = _issues_by_rule(result, "QC001")
+        assert len(qc001_issues) == 0
+
 
 # ---------------------------------------------------------------------------
 # QC002 — len() on RollingWindow
@@ -180,20 +232,27 @@ def test_no_action_no_change(self):
 class TestQC005HistorySlice:
     """Warn about C# History iteration patterns."""
 
-    def test_bars_access_warned(self):
-        code = "history.Bars[symbol].Close\n"
+    def test_foreach_warned(self):
+        code = "history.ForEach(lambda x: x)\n"
         result = lint_qc_code(code)
         qc005_issues = _issues_by_rule(result, "QC005")
         assert len(qc005_issues) == 1
         assert qc005_issues[0].severity == "warning"
         assert not qc005_issues[0].fixed
 
-    def test_foreach_warned(self):
-        code = "history.ForEach(lambda x: x)\n"
+    def test_getvalue_warned(self):
+        code = "history.GetValue(symbol)\n"
         result = lint_qc_code(code)
         qc005_issues = _issues_by_rule(result, "QC005")
         assert len(qc005_issues) == 1
 
+    def test_bars_access_not_warned(self):
+        """data.Bars[symbol] is valid Slice access in on_data, not a History issue."""
+        code = "if data.Bars.ContainsKey(self.symbol):\n    price = data.Bars[self.symbol].close\n"
+        result = lint_qc_code(code)
+        qc005_issues = _issues_by_rule(result, "QC005")
+        assert len(qc005_issues) == 0
+
     def test_clean_history_no_warning(self):
         code = "df = self.history(self.symbol, 20, Resolution.DAILY)\n"
         result = lint_qc_code(code)
@@ -319,14 +378,15 @@ def test_full_pascal_algo(self):
             "        self.spy = spy.Symbol\n"
             "        self.rsi = self.RSI(self.spy, 14, Resolution.Daily)\n"
             "        self.prices = RollingWindow[float](20)\n"
-            "        self.schedule.on(\n"
-            "            self.date_rules.every_day(),\n"
-            "            self.time_rules.at(10, 0),\n"
+            "        self.Schedule.On(\n"
+            "            self.DateRules.EveryDay(),\n"
+            "            self.TimeRules.AfterMarketOpen('SPY', 30),\n"
             "            Action(self.trade)\n"
             "        )\n"
             "\n"
             "    def OnData(self, data):\n"
             "        if self.rsi.IsReady:\n"
+            "            self.prices.Add(data['SPY'].close)\n"
             "            if len(self.prices) >= 20:\n"
             "                avg = sum(self.prices.Values) / 20\n"
             "\n"
@@ -345,6 +405,16 @@ def test_full_pascal_algo(self):
         assert ".invested" in result.code
         assert "self.liquidate" in result.code
 
+        # QC001 chained API fixes
+        assert "self.schedule.on(" in result.code
+        assert "self.date_rules.every_day()" in result.code
+        assert "self.time_rules.after_market_open(" in result.code
+        assert "self.Schedule.On" not in result.code
+
+        # QC001 .Add() fix
+        assert "self.prices.add(" in result.code
+        assert "self.prices.Add(" not in result.code
+
         # QC007 fixes
         assert "Resolution.DAILY" in result.code
         assert "Resolution.Daily" not in result.code