Actual show filtered results

Author: asgerf

extensions/ql-vscode/src/view/results/ResultTable.tsx

@@ -6,17 +6,24 @@ import { AlertTableNoResults } from "./AlertTableNoResults";
 import { AlertTableHeader } from "./AlertTableHeader";
 
 export function ResultTable(props: ResultTableProps) {
-  const { resultSet, userSettings } = props;
+  const { resultSet, userSettings, filteredRawRows, filteredSarifResults } =
+    props;
   switch (resultSet.t) {
-    case "RawResultSet":
-      return <RawTable {...props} resultSet={resultSet.resultSet} />;
+    case "RawResultSet": {
+      const filteredResultSet = {
+        ...resultSet.resultSet,
+        rows: filteredRawRows ?? resultSet.resultSet.rows,
+      };
+      return <RawTable {...props} resultSet={filteredResultSet} />;
+    }
     case "InterpretedResultSet": {
       const data = resultSet.interpretation.data;
       switch (data.t) {
         case "SarifInterpretationData": {
+          const results = filteredSarifResults ?? data.runs[0].results ?? [];
           return (
             <AlertTable
-              results={data.runs[0].results ?? []}
+              results={results}
               databaseUri={props.databaseUri}
               sourceLocationPrefix={
                 resultSet.interpretation.sourceLocationPrefix

extensions/ql-vscode/src/view/results/ResultTables.tsx

@@ -16,12 +16,16 @@ import {
   GRAPH_TABLE_NAME,
   SELECT_TABLE_NAME,
 } from "../../common/interface-types";
-import { tableHeaderClassName } from "./result-table-utils";
+import {
+  filterRawRows,
+  filterSarifResults,
+  tableHeaderClassName,
+} from "./result-table-utils";
 import { vscode } from "../vscode-api";
 import { sendTelemetry } from "../common/telemetry";
 import { ResultTable } from "./ResultTable";
 import { ResultTablesHeader } from "./ResultTablesHeader";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useMemo } from "react";
 import { ResultCount } from "./ResultCount";
 import { ProblemsViewCheckbox } from "./ProblemsViewCheckbox";
 import { SelectionFilterCheckbox } from "./SelectionFilterCheckbox";
@@ -196,6 +200,44 @@ export function ResultTables(props: ResultTablesProps) {
   const isLoadingFilteredResults =
     selectionFilter != null && fileFilteredResults == null;
 
+  // Filter rows at line granularity (if filtering is enabled)
+  const filteredRawRows = useMemo(() => {
+    if (!selectionFilter || !resultSet || resultSet.t !== "RawResultSet") {
+      return undefined;
+    }
+    const sourceRows = fileFilteredResults?.rawRows;
+    if (sourceRows == null) {
+      return undefined;
+    }
+    return filterRawRows(sourceRows, selectionFilter);
+  }, [selectionFilter, fileFilteredResults, resultSet]);
+
+  // Filter SARIF results at line granularity (if filtering is enabled)
+  const filteredSarifResults = useMemo(() => {
+    if (
+      !selectionFilter ||
+      !resultSet ||
+      resultSet.t !== "InterpretedResultSet"
+    ) {
+      return undefined;
+    }
+    const data = resultSet.interpretation.data;
+    if (data.t !== "SarifInterpretationData") {
+      return undefined;
+    }
+    const sourceResults =
+      fileFilteredResults?.sarifResults !== undefined
+        ? fileFilteredResults.sarifResults
+        : (data.runs[0].results ?? []);
+    return filterSarifResults(
+      sourceResults,
+      resultSet.interpretation.sourceLocationPrefix,
+      selectionFilter,
+    );
+  }, [selectionFilter, fileFilteredResults, resultSet]);
+
+  const filteredCount = filteredRawRows?.length ?? filteredSarifResults?.length;
+
   return (
     <div>
       <ResultTablesHeader {...props} selectedTable={selectedTable} />
@@ -224,8 +266,12 @@ export function ResultTables(props: ResultTablesProps) {
             Updating results…
           </span>
         ) : null}
+        {isLoadingFilteredResults && (
+          <span className={UPDATING_RESULTS_TEXT_CLASS_NAME}>
+            Updating filtered results…
+          </span>
+        )}
       </div>
-      {isLoadingFilteredResults && <span>Loading filtered results…</span>}
       {!isLoadingFilteredResults && resultSet && resultSetName && (
         <ResultTable
           key={resultSetName}
@@ -241,6 +287,8 @@ export function ResultTables(props: ResultTablesProps) {
           }}
           offset={offset}
           selectionFilter={selectionFilter}
+          filteredRawRows={filteredRawRows}
+          filteredSarifResults={filteredSarifResults}
         />
       )}
     </div>

extensions/ql-vscode/src/view/results/result-table-utils.ts

@@ -1,4 +1,5 @@
 import type {
+  EditorSelection,
   QueryMetadata,
   RawResultsSortState,
   ResultSet,
@@ -7,7 +8,16 @@ import type {
 import { SortDirection } from "../../common/interface-types";
 import { assertNever } from "../../common/helpers-pure";
 import { vscode } from "../vscode-api";
-import type { UrlValueResolvable } from "../../common/raw-result-types";
+import type {
+  CellValue,
+  Row,
+  UrlValueResolvable,
+} from "../../common/raw-result-types";
+import type { Result } from "sarif";
+import {
+  getLocationsFromSarifResult,
+  normalizeFileUri,
+} from "../../common/sarif-utils";
 
 export interface ResultTableProps {
   resultSet: ResultSet;
@@ -30,6 +40,8 @@ export interface ResultTableProps {
    */
   showRawResults: () => void;
 
+  filteredRawRows?: Row[];
+  filteredSarifResults?: Result[];
   selectionFilter?: EditorSelection;
 }
 
@@ -109,3 +121,110 @@ export function nextSortDirection(
       return assertNever(direction);
   }
 }
+
+/**
+ * Extracts all resolvable locations from a raw result row.
+ */
+function getLocationsFromRawRow(
+  row: Row,
+): Array<{ uri: string; startLine?: number; endLine?: number }> {
+  const locations: Array<{
+    uri: string;
+    startLine?: number;
+    endLine?: number;
+  }> = [];
+
+  for (const cell of row) {
+    const loc = getLocationFromCell(cell);
+    if (loc) {
+      locations.push(loc);
+    }
+  }
+
+  return locations;
+}
+
+function getLocationFromCell(
+  cell: CellValue,
+): { uri: string; startLine?: number; endLine?: number } | undefined {
+  if (cell.type !== "entity") {
+    return undefined;
+  }
+  const url = cell.value.url;
+  if (!url) {
+    return undefined;
+  }
+  if (url.type === "wholeFileLocation") {
+    return { uri: url.uri };
+  }
+  if (url.type === "lineColumnLocation") {
+    return {
+      uri: url.uri,
+      startLine: url.startLine,
+      endLine: url.endLine,
+    };
+  }
+  return undefined;
+}
+
+/**
+ * Checks if a result location overlaps with the editor selection.
+ * If the selection is empty (just a cursor), matches any result in the same file.
+ */
+function doesLocationOverlapSelection(
+  loc: { uri: string; startLine?: number; endLine?: number },
+  selection: EditorSelection,
+): boolean {
+  const normalizedLocUri = normalizeFileUri(loc.uri);
+  const normalizedSelUri = normalizeFileUri(selection.fileUri);
+
+  if (normalizedLocUri !== normalizedSelUri) {
+    return false;
+  }
+
+  // If selection is empty (just a cursor), match the whole file
+  if (selection.isEmpty) {
+    return true;
+  }
+
+  // If the result location has no line info, it's a whole-file location — include it
+  if (loc.startLine === undefined) {
+    return true;
+  }
+
+  // Only include results whose starting line falls within the selection range
+  return (
+    loc.startLine >= selection.startLine && loc.startLine <= selection.endLine
+  );
+}
+
+/**
+ * Filters raw result rows to those with at least one location overlapping the selection.
+ */
+export function filterRawRows(
+  rows: readonly Row[],
+  selection: EditorSelection,
+): Row[] {
+  return rows.filter((row) => {
+    const locations = getLocationsFromRawRow(row);
+    return locations.some((loc) =>
+      doesLocationOverlapSelection(loc, selection),
+    );
+  });
+}
+
+/**
+ * Filters SARIF results to those with at least one location overlapping the selection.
+ */
+export function filterSarifResults(
+  results: Result[],
+  sourceLocationPrefix: string,
+  selection: EditorSelection,
+): Result[] {
+  return results.filter((result) => {
+    const locations = getLocationsFromSarifResult(result, sourceLocationPrefix);
+    return locations.some((loc) =>
+      doesLocationOverlapSelection(loc, selection),
+    );
+  });
+}