SC-43473 Handle file-level issues in gRPC like AnalysisProcessor (#6572)

Author: vdiez

packages/grpc/src/proto/language_analyzer.proto

@@ -8,7 +8,9 @@ package analyzer;
 
 // Language Analyzer Service
 service LanguageAnalyzerService {
-  // Analyze a file
+  // Analyzes one or more source files in the context of a single analysis job.
+  // A single request may contain multiple source files (multi-file analysis).
+  // This RPC may be called concurrently by multiple clients — implementations must be thread-safe.
   rpc Analyze(AnalyzeRequest) returns (AnalyzeResponse);
 }
 
@@ -28,10 +30,13 @@ message AnalyzeRequest {
 //             When provided, it takes precedence over any scope deduced from the context.
 //             When not provided, the scope should be deduced from the context if available.
 //             When neither is provided, the analyzer should perform best effort to determine the scope.
+// sonar_language: the language key of the file (e.g., "java", "js", "ts"), following Sonar plugins definition. This is optional but recommended
+//           for proper analysis. When not provided, the analyzer may attempt to detect the language.
 message SourceFile {
   string relative_path = 1;
   string content = 2;
   optional FileScope file_scope = 3;
+  optional string sonar_language = 4;
 }
 
 // Enum for file scope
@@ -47,6 +52,13 @@ message AnalyzeResponse {
   repeated FileMeasures measures = 3;
 }
 
+// Represents a problem encountered during analysis
+message AnalysisProblem {
+  AnalysisProblemType type = 1;    // Type of the problem
+  string message = 2;              // Description of the problem
+  string file_path = 3;            // Optional path to the file where the problem occurred
+}
+
 // Represents measures for a file
 message FileMeasures {
   string file_path = 1;
@@ -65,13 +77,6 @@ message Measure {
   }
 }
 
-// Represents a problem encountered during analysis
-message AnalysisProblem {
-  AnalysisProblemType type = 1;    // Type of the problem
-  string message = 2;              // Description of the problem
-  string file_path = 3;            // Optional path to the file where the problem occurred
-}
-
 // Enum for analysis problem types
 enum AnalysisProblemType {
   ANALYSIS_PROBLEM_TYPE_UNDEFINED = 0;
@@ -132,5 +137,5 @@ message Flow {
 message FlowLocation {
   TextRange text_range = 1;
   string message = 2;              // Description of the step
-  string file = 3;                 // File path where this location exists
+  string file_path = 3;            // File path where this location exists
 }

packages/grpc/src/transformers/response.ts

@@ -30,6 +30,34 @@ import type { NormalizedAbsolutePath } from '../../../jsts/src/rules/helpers/fil
  */
 const PARSING_ERROR_RULE_KEY = 'S2260';
 
+function isValidOneBasedLine(line: number): line is number {
+  return line >= 1;
+}
+
+function toTextRange(
+  line: number,
+  column: number,
+  endLine: number | undefined,
+  endColumn: number | undefined,
+): analyzer.ITextRange | undefined {
+  if (!isValidOneBasedLine(line)) {
+    return undefined;
+  }
+
+  const resolvedEndLine = endLine ?? line;
+  if (!isValidOneBasedLine(resolvedEndLine)) {
+    return undefined;
+  }
+
+  const startLineOffset = column ?? 0;
+  return {
+    startLine: line,
+    startLineOffset,
+    endLine: resolvedEndLine,
+    endLineOffset: endColumn ?? startLineOffset,
+  };
+}
+
 /**
  * Transform a single Issue from the internal format to the gRPC Issue format.
  *
@@ -52,32 +80,31 @@ const PARSING_ERROR_RULE_KEY = 'S2260';
  * @returns gRPC Issue object ready for protobuf serialization
  */
 function transformIssue(issue: JsTsIssue): analyzer.IIssue {
-  const textRange: analyzer.ITextRange = {
-    startLine: issue.line,
-    startLineOffset: issue.column,
-    endLine: issue.endLine ?? issue.line,
-    endLineOffset: issue.endColumn ?? issue.column,
-  };
+  const textRange = toTextRange(issue.line, issue.column, issue.endLine, issue.endColumn);
 
   // Transform secondary locations into flows
   const flows: analyzer.IFlow[] = [];
   if (issue.secondaryLocations && issue.secondaryLocations.length > 0) {
-    const locations: analyzer.IFlowLocation[] = issue.secondaryLocations.map(loc => ({
-      textRange: {
-        startLine: loc.line,
-        startLineOffset: loc.column,
-        endLine: loc.endLine,
-        endLineOffset: loc.endColumn,
-      },
-      message: loc.message ?? '',
-      file: issue.filePath,
-    }));
-
-    flows.push({
-      type: analyzer.FlowType.FLOW_TYPE_DATA,
-      description: '',
-      locations,
-    });
+    const locations: analyzer.IFlowLocation[] = [];
+
+    for (const loc of issue.secondaryLocations) {
+      const range = toTextRange(loc.line, loc.column, loc.endLine, loc.endColumn);
+      if (range !== undefined) {
+        locations.push({
+          textRange: range,
+          message: loc.message ?? '',
+          filePath: issue.filePath,
+        });
+      }
+    }
+
+    if (locations.length > 0) {
+      flows.push({
+        type: analyzer.FlowType.FLOW_TYPE_DATA,
+        description: '',
+        locations,
+      });
+    }
   }
 
   const repo = issue.language === 'js' ? 'javascript' : 'typescript';
@@ -112,12 +139,27 @@ function transformCssIssue(issue: CssIssue, filePath: string): analyzer.IIssue {
     filePath,
     message: issue.message,
     rule: { repo: 'css', rule: sqKey },
-    textRange: {
-      startLine: issue.line,
-      startLineOffset: issue.column,
-      endLine: issue.endLine ?? issue.line,
-      endLineOffset: issue.endColumn ?? issue.column,
-    },
+    textRange: toTextRange(issue.line, issue.column, issue.endLine, issue.endColumn),
+    flows: [],
+  };
+}
+
+/**
+ * Transform a parsing error into a gRPC issue.
+ *
+ * Mirrors Java-side behavior: when line is missing, the issue is file-level
+ * and does not carry a text range.
+ */
+function transformParsingErrorIssue(
+  message: string,
+  filePath: NormalizedAbsolutePath,
+  line: number | undefined,
+): analyzer.IIssue {
+  return {
+    filePath,
+    message,
+    rule: { repo: 'javascript', rule: PARSING_ERROR_RULE_KEY },
+    textRange: line !== undefined ? toTextRange(line, 0, undefined, undefined) : undefined,
     flows: [],
   };
 }
@@ -158,6 +200,7 @@ function restorePath(filePath: NormalizedAbsolutePath, pathMap: Map<string, stri
  * ```
  *
  * @param output - The ProjectAnalysisOutput from analyzeProject()
+ * @param pathMap - Optional mapping from normalized absolute paths to original request paths
  * @returns gRPC IAnalyzeResponse ready for protobuf serialization
  */
 export function transformProjectOutputToResponse(
@@ -198,16 +241,7 @@ export function transformProjectOutputToResponse(
       });
 
       issues.push(
-        transformIssue({
-          ruleId: PARSING_ERROR_RULE_KEY,
-          message,
-          line: line ?? 1,
-          column: 0,
-          language: 'js',
-          secondaryLocations: [],
-          ruleESLintKeys: [],
-          filePath: originalPath as NormalizedAbsolutePath,
-        }),
+        transformParsingErrorIssue(message, originalPath as NormalizedAbsolutePath, line),
       );
       continue;
     }

packages/grpc/tests/transformers.test.ts

@@ -621,6 +621,67 @@ describe('transformProjectOutputToResponse', () => {
     });
   });
 
+  it('should omit textRange for file-level JS/TS issues', () => {
+    const output = makeOutput({
+      '/project/src/file.js': {
+        issues: [
+          {
+            ruleId: 'S1451',
+            language: 'js',
+            line: 0,
+            column: 0,
+            endLine: 0,
+            endColumn: 0,
+            message: 'Add or update the header of this file.',
+            secondaryLocations: [
+              {
+                line: 0,
+                column: 0,
+                endLine: 0,
+                endColumn: 0,
+                message: 'Secondary',
+              },
+            ],
+            ruleESLintKeys: [],
+            filePath: '/project/src/file.js',
+          },
+        ],
+      },
+    });
+
+    const result = transformProjectOutputToResponse(output);
+
+    expect(result.issues?.length).toBe(1);
+    expect(result.issues?.[0].textRange).toBeUndefined();
+    expect(result.issues?.[0].flows).toEqual([]);
+  });
+
+  it('should omit textRange for parsing error issues when parser returns line 0', () => {
+    const output = makeOutput({
+      '/project/src/broken.js': {
+        parsingError: { message: 'Unexpected token', code: 'PARSING', line: 0 },
+      },
+    });
+
+    const result = transformProjectOutputToResponse(output);
+
+    expect(result.issues?.length).toBe(1);
+    expect(result.issues?.[0].textRange).toBeUndefined();
+  });
+
+  it('should omit textRange for parsing error issues when parser line is missing', () => {
+    const output = makeOutput({
+      '/project/src/broken.js': {
+        parsingError: { message: 'Unexpected token', code: 'PARSING' },
+      },
+    });
+
+    const result = transformProjectOutputToResponse(output);
+
+    expect(result.issues?.length).toBe(1);
+    expect(result.issues?.[0].textRange).toBeUndefined();
+  });
+
   it('should restore original paths using pathMap for JS/TS issues', () => {
     const output = makeOutput({
       '/app/src/file.ts': {

packages/jsts/src/linter/issues/issue.ts

@@ -37,8 +37,6 @@ import type { BaseIssue } from '../../../../shared/src/types/analysis.js';
  */
 export interface JsTsIssue extends BaseIssue {
   language: JsTsLanguage;
-  endLine?: number;
-  endColumn?: number;
   cost?: number;
   secondaryLocations: Location[];
   quickFixes?: QuickFix[];