@ttsc/lint 0.28.6 → 0.29.0

package/README.md

@@ -1185,6 +1185,8 @@ func init() { rule.RegisterProject(noCycles{}) }
 
 Each project rule runs once per loaded Program, before file rules. `ctx.Identity` includes the invocation cwd, logical and physical config paths and roots, an optional explicit project root, the plugin-config origin, and a lifecycle id. `Report` marks the rule failed and emits one project finding; `Fail` marks it failed without a finding. Later file rules can call `ctx.ProjectResult(name)` and distinguish `absent`, `off`, `not_evaluated`, `passed`, and `failed`.
 
+`ctx.ReportSeverity(rule.SeverityWarn, message)` overrides the level of one project finding. An off rule or off finding remains silent. A warning still marks the project result failed, while only an error fails the command. Snapshots retain each finding's severity, and duplicate messages keep the strongest reported level. Hosts implementing only `ProjectReporter` receive the message at the rule's configured level; `ProjectSeverityReporter` is the optional extension for individual levels.
+
 When a project rule reads local files outside the TypeScript Program, implement `rule.ProjectInputRule` so watch and editor hosts can observe exactly those inputs:
 
 ```go

package/linthost/project_engine.go

@@ -50,7 +50,8 @@ type projectReporter struct {
   mu       sync.Mutex
   active   bool
   failed   bool
-  messages map[string]struct{}
+  messages map[string]publicrule.Severity
+  severity publicrule.Severity
   state    any
 }
 
@@ -66,19 +67,27 @@ func (r *projectReporter) Fail() {
 }
 
 func (r *projectReporter) Report(message string) {
+  if r != nil {
+    r.ReportSeverity(r.severity, message)
+  }
+}
+
+func (r *projectReporter) ReportSeverity(severity publicrule.Severity, message string) {
   if r == nil {
     return
   }
   r.mu.Lock()
   defer r.mu.Unlock()
-  if !r.active {
+  if !r.active || severity == publicrule.SeverityOff {
     return
   }
   r.failed = true
   if r.messages == nil {
-    r.messages = map[string]struct{}{}
+    r.messages = map[string]publicrule.Severity{}
+  }
+  if severity > r.messages[message] {
+    r.messages[message] = severity
   }
-  r.messages[message] = struct{}{}
 }
 
 func (r *projectReporter) SetState(state any) {
@@ -120,7 +129,7 @@ func (r *projectReporter) snapshotLocked(close bool) publicrule.ProjectRuleResul
   }
   findings := make([]publicrule.ProjectFinding, 0, len(messages))
   for _, message := range messages {
-    findings = append(findings, publicrule.ProjectFinding{Message: message})
+    findings = append(findings, publicrule.ProjectFinding{Message: message, Severity: r.messages[message]})
   }
   return publicrule.NewProjectRuleResult(status, r.state, findings, r)
 }
@@ -144,7 +153,7 @@ func (c *projectCycle) finalize() []*Finding {
       for _, finding := range result.Findings {
         c.findings = append(c.findings, &Finding{
           Rule:     name,
-          Severity: entry.severity,
+          Severity: Severity(finding.Severity),
           Message:  finding.Message,
         })
       }
@@ -193,7 +202,7 @@ func (e *Engine) evaluateProject(
     if adapter.declinesTypeChecker {
       ruleChecker = nil
     }
-    reporter := &projectReporter{active: true}
+    reporter := &projectReporter{active: true, severity: publicrule.Severity(setting.Severity)}
     context := publicrule.NewProjectContext(
       identity,
       sources,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.28.6",
+  "version": "0.29.0",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -37,7 +37,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.28.6"
+    "ttsc": "0.29.0"
   },
   "repository": {
     "type": "git",

package/rule/project.go

@@ -36,7 +36,8 @@ const (
 // ProjectFinding is a non-file finding retained in a project rule's cycle
 // result. Project findings never contain edits or source ranges.
 type ProjectFinding struct {
-  Message string
+  Message  string
+  Severity Severity
 }
 
 // ProjectRuleResult is one snapshot of a named project rule in the current
@@ -169,6 +170,13 @@ type ProjectReporter interface {
   Report(message string)
 }
 
+// ProjectSeverityReporter optionally accepts a severity for each finding.
+// Reporting still marks the rule failed, including for warnings, so consumers
+// cannot treat an incomplete project result as a clean one.
+type ProjectSeverityReporter interface {
+  ReportSeverity(severity Severity, message string)
+}
+
 // ProjectContext contains the immutable inputs for one project-rule check.
 //
 // Sources is a defensive copy of the user sources the host read for this cycle:
@@ -256,6 +264,19 @@ func (c *ProjectContext) Report(message string) {
   c.reporter.Report(message)
 }
 
+// ReportSeverity records a finding at an explicit level. An off rule or off
+// finding remains silent. Hosts without this extension use the rule's level.
+func (c *ProjectContext) ReportSeverity(severity Severity, message string) {
+  if c == nil || c.reporter == nil || c.Severity == SeverityOff || severity == SeverityOff {
+    return
+  }
+  if reporter, ok := c.reporter.(ProjectSeverityReporter); ok {
+    reporter.ReportSeverity(severity, message)
+  } else {
+    c.reporter.Report(message)
+  }
+}
+
 var projectRegistry []ProjectRule
 
 // RegisterProject adds a contributor project rule to the global registry.