Use new raw result types for variant analyses

Author: koesie10

extensions/ql-vscode/src/common/bqrs-result.ts

@@ -4,26 +4,30 @@ import {
   ColumnKindCode,
   DecodedBqrsChunk,
   EntityValue as BqrsEntityValue,
+  LineColumnLocation,
   ResultSetSchema,
   UrlValue as BqrsUrlValue,
+  WholeFileLocation,
 } from "./bqrs-cli-types";
 import {
   CellValue,
   Column,
   ColumnKind,
   EntityValue,
   RawResultSet,
-  Tuple,
+  Row,
   UrlValue,
+  UrlValueResolvable,
 } from "./raw-result-types";
 import { assertNever } from "./helpers-pure";
+import { isEmptyPath } from "./bqrs-utils";
 
 export function bqrsToResultSet(
   schema: ResultSetSchema,
   chunk: DecodedBqrsChunk,
 ): RawResultSet {
   const name = schema.name;
-  const rows = schema.rows;
+  const totalRowCount = schema.rows;
   const nextPageOffset = chunk.next;
 
   const columns = schema.columns.map(
@@ -33,15 +37,15 @@ export function bqrsToResultSet(
     }),
   );
 
-  const tuples = chunk.tuples.map(
-    (tuple): Tuple => tuple.map((cell): CellValue => mapCellValue(cell)),
+  const rows = chunk.tuples.map(
+    (tuple): Row => tuple.map((cell): CellValue => mapCellValue(cell)),
   );
 
   return {
     name,
-    rows,
+    totalRowCount,
     columns,
-    tuples,
+    rows,
     nextPageOffset,
   };
 }
@@ -98,15 +102,27 @@ function mapEntityValue(cellValue: BqrsEntityValue): EntityValue {
   };
 }
 
-function mapUrlValue(urlValue: BqrsUrlValue): UrlValue {
+function mapUrlValue(urlValue: BqrsUrlValue): UrlValue | undefined {
   if (typeof urlValue === "string") {
+    const location = tryGetLocationFromString(urlValue);
+    if (location !== undefined) {
+      return location;
+    }
+
     return {
       type: "string",
       value: urlValue,
     };
   }
 
-  if (urlValue.startLine) {
+  if (isWholeFileLoc(urlValue)) {
+    return {
+      type: "wholeFileLocation",
+      uri: urlValue.uri,
+    };
+  }
+
+  if (isLineColumnLoc(urlValue)) {
     return {
       type: "lineColumnLocation",
       uri: urlValue.uri,
@@ -117,8 +133,64 @@ function mapUrlValue(urlValue: BqrsUrlValue): UrlValue {
     };
   }
 
-  return {
-    type: "wholeFileLocation",
-    uri: urlValue.uri,
-  };
+  return undefined;
+}
+
+function isLineColumnLoc(loc: BqrsUrlValue): loc is LineColumnLocation {
+  return (
+    typeof loc !== "string" &&
+    !isEmptyPath(loc.uri) &&
+    "startLine" in loc &&
+    "startColumn" in loc &&
+    "endLine" in loc &&
+    "endColumn" in loc
+  );
+}
+
+function isWholeFileLoc(loc: BqrsUrlValue): loc is WholeFileLocation {
+  return (
+    typeof loc !== "string" && !isEmptyPath(loc.uri) && !isLineColumnLoc(loc)
+  );
+}
+
+/**
+ * The CodeQL filesystem libraries use this pattern in `getURL()` predicates
+ * to describe the location of an entire filesystem resource.
+ * Such locations appear as `StringLocation`s instead of `FivePartLocation`s.
+ *
+ * Folder resources also get similar URLs, but with the `folder` scheme.
+ * They are deliberately ignored here, since there is no suitable location to show the user.
+ */
+const FILE_LOCATION_REGEX = /file:\/\/(.+):([0-9]+):([0-9]+):([0-9]+):([0-9]+)/;
+
+function tryGetLocationFromString(loc: string): UrlValueResolvable | undefined {
+  const matches = FILE_LOCATION_REGEX.exec(loc);
+  if (matches && matches.length > 1 && matches[1]) {
+    if (isWholeFileMatch(matches)) {
+      return {
+        type: "wholeFileLocation",
+        uri: matches[1],
+      };
+    } else {
+      return {
+        type: "lineColumnLocation",
+        uri: matches[1],
+        startLine: Number(matches[2]),
+        startColumn: Number(matches[3]),
+        endLine: Number(matches[4]),
+        endColumn: Number(matches[5]),
+      };
+    }
+  }
+
+  return undefined;
+}
+
+function isWholeFileMatch(matches: RegExpExecArray): boolean {
+  return (
+    matches[2] === "0" &&
+    matches[3] === "0" &&
+    matches[4] === "0" &&
+    matches[5] === "0"
+  );
 }

extensions/ql-vscode/src/common/bqrs-utils.ts

@@ -1,10 +1,22 @@
+import { createRemoteFileRef } from "../common/location-link-utils";
 import {
+  isUrlValueResolvable,
   UrlValue,
-  ResolvableLocationValue,
+  UrlValueResolvable,
+} from "./raw-result-types";
+import {
   LineColumnLocation,
+  UrlValue as BqrsUrlValue,
   WholeFileLocation,
 } from "./bqrs-cli-types";
-import { createRemoteFileRef } from "../common/location-link-utils";
+
+/**
+ * Checks whether the file path is empty. If so, we do not want to render this location
+ * as a link.
+ */
+export function isEmptyPath(uriStr: string) {
+  return !uriStr || uriStr === "file:/";
+}
 
 /**
  * The CodeQL filesystem libraries use this pattern in `getURL()` predicates
@@ -20,13 +32,25 @@ const FILE_LOCATION_REGEX = /file:\/\/(.+):([0-9]+):([0-9]+):([0-9]+):([0-9]+)/;
  * @param loc The location to test.
  */
 export function tryGetResolvableLocation(
-  loc: UrlValue | undefined,
-): ResolvableLocationValue | undefined {
-  let resolvedLoc;
+  loc: BqrsUrlValue | undefined,
+): UrlValueResolvable | undefined {
+  let resolvedLoc: UrlValueResolvable | undefined;
   if (loc === undefined) {
     resolvedLoc = undefined;
-  } else if (isWholeFileLoc(loc) || isLineColumnLoc(loc)) {
-    resolvedLoc = loc as ResolvableLocationValue;
+  } else if (isWholeFileLoc(loc)) {
+    resolvedLoc = {
+      type: "wholeFileLocation",
+      uri: loc.uri,
+    };
+  } else if (isLineColumnLoc(loc)) {
+    resolvedLoc = {
+      type: "lineColumnLocation",
+      uri: loc.uri,
+      startLine: loc.startLine,
+      startColumn: loc.startColumn,
+      endLine: loc.endLine,
+      endColumn: loc.endColumn,
+    };
   } else if (isStringLoc(loc)) {
     resolvedLoc = tryGetLocationFromString(loc);
   } else {
@@ -38,15 +62,17 @@ export function tryGetResolvableLocation(
 
 export function tryGetLocationFromString(
   loc: string,
-): ResolvableLocationValue | undefined {
+): UrlValueResolvable | undefined {
   const matches = FILE_LOCATION_REGEX.exec(loc);
   if (matches && matches.length > 1 && matches[1]) {
     if (isWholeFileMatch(matches)) {
       return {
+        type: "wholeFileLocation",
         uri: matches[1],
-      } as WholeFileLocation;
+      };
     } else {
       return {
+        type: "lineColumnLocation",
         uri: matches[1],
         startLine: Number(matches[2]),
         startColumn: Number(matches[3]),
@@ -68,17 +94,7 @@ function isWholeFileMatch(matches: RegExpExecArray): boolean {
   );
 }
 
-/**
- * Checks whether the file path is empty. If so, we do not want to render this location
- * as a link.
- *
- * @param uri A file uri
- */
-export function isEmptyPath(uriStr: string) {
-  return !uriStr || uriStr === "file:/";
-}
-
-export function isLineColumnLoc(loc: UrlValue): loc is LineColumnLocation {
+export function isLineColumnLoc(loc: BqrsUrlValue): loc is LineColumnLocation {
   return (
     typeof loc !== "string" &&
     !isEmptyPath(loc.uri) &&
@@ -89,23 +105,36 @@ export function isLineColumnLoc(loc: UrlValue): loc is LineColumnLocation {
   );
 }
 
-export function isWholeFileLoc(loc: UrlValue): loc is WholeFileLocation {
+export function isWholeFileLoc(loc: BqrsUrlValue): loc is WholeFileLocation {
   return (
     typeof loc !== "string" && !isEmptyPath(loc.uri) && !isLineColumnLoc(loc)
   );
 }
 
-export function isStringLoc(loc: UrlValue): loc is string {
+export function isStringLoc(loc: BqrsUrlValue): loc is string {
   return typeof loc === "string";
 }
 
+export function tryGetBqrsRemoteLocation(
+  loc: BqrsUrlValue | undefined,
+  fileLinkPrefix: string,
+  sourceLocationPrefix: string | undefined,
+): string | undefined {
+  const resolvedLoc = tryGetResolvableLocation(loc);
+
+  return tryGetRemoteLocation(
+    resolvedLoc,
+    fileLinkPrefix,
+    sourceLocationPrefix,
+  );
+}
+
 export function tryGetRemoteLocation(
   loc: UrlValue | undefined,
   fileLinkPrefix: string,
   sourceLocationPrefix: string | undefined,
 ): string | undefined {
-  const resolvableLocation = tryGetResolvableLocation(loc);
-  if (!resolvableLocation) {
+  if (!loc || !isUrlValueResolvable(loc)) {
     return undefined;
   }
 
@@ -115,34 +144,36 @@ export function tryGetRemoteLocation(
   // "file:${sourceLocationPrefix}/relative/path/to/file"
   // So we need to strip off the first part to get the relative path.
   if (sourceLocationPrefix) {
-    if (!resolvableLocation.uri.startsWith(`file:${sourceLocationPrefix}/`)) {
+    if (!loc.uri.startsWith(`file:${sourceLocationPrefix}/`)) {
       return undefined;
     }
-    trimmedLocation = resolvableLocation.uri.replace(
-      `file:${sourceLocationPrefix}/`,
-      "",
-    );
+    trimmedLocation = loc.uri.replace(`file:${sourceLocationPrefix}/`, "");
   } else {
     // If the source location prefix is empty (e.g. for older remote queries), we assume that the database
     // was created on a Linux actions runner and has the format:
     // "file:/home/runner/work/<repo>/<repo>/relative/path/to/file"
     // So we need to drop the first 6 parts of the path.
-    if (!resolvableLocation.uri.startsWith("file:/home/runner/work/")) {
+    if (!loc.uri.startsWith("file:/home/runner/work/")) {
       return undefined;
     }
-    const locationParts = resolvableLocation.uri.split("/");
+    const locationParts = loc.uri.split("/");
     trimmedLocation = locationParts.slice(6, locationParts.length).join("/");
   }
 
   const fileLink = {
     fileLinkPrefix,
     filePath: trimmedLocation,
   };
+
+  if (loc.type === "wholeFileLocation") {
+    return createRemoteFileRef(fileLink);
+  }
+
   return createRemoteFileRef(
     fileLink,
-    resolvableLocation.startLine,
-    resolvableLocation.endLine,
-    resolvableLocation.startColumn,
-    resolvableLocation.endColumn,
+    loc.startLine,
+    loc.endLine,
+    loc.startColumn,
+    loc.endColumn,
   );
 }

extensions/ql-vscode/src/common/interface-types.ts

@@ -25,6 +25,7 @@ import {
 } from "../model-editor/shared/view-state";
 import { Mode } from "../model-editor/shared/mode";
 import { QueryLanguage } from "./query-language";
+import { UrlValueResolvable } from "./raw-result-types";
 
 /**
  * This module contains types and code that are shared between
@@ -208,7 +209,7 @@ export type FromResultsViewMsg =
  */
 interface ViewSourceFileMsg {
   t: "viewSourceFile";
-  loc: ResolvableLocationValue;
+  loc: ResolvableLocationValue | UrlValueResolvable;
   databaseUri: string;
 }
 

extensions/ql-vscode/src/common/raw-result-types.ts

@@ -31,11 +31,20 @@ export type UrlValueLineColumnLocation = {
   endColumn: number;
 };
 
-export type UrlValue =
-  | UrlValueString
+export type UrlValueResolvable =
   | UrlValueWholeFileLocation
   | UrlValueLineColumnLocation;
 
+export function isUrlValueResolvable(
+  value: UrlValue,
+): value is UrlValueResolvable {
+  return (
+    value.type === "wholeFileLocation" || value.type === "lineColumnLocation"
+  );
+}
+
+export type UrlValue = UrlValueString | UrlValueResolvable;
+
 export type EntityValue = {
   url?: UrlValue;
   label?: string;
@@ -68,14 +77,14 @@ export type CellValue =
   | CellValueString
   | CellValueBoolean;
 
-export type Tuple = CellValue[];
+export type Row = CellValue[];
 
 export type RawResultSet = {
   name: string;
-  rows: number;
+  totalRowCount: number;
 
   columns: Column[];
-  tuples: Tuple[];
+  rows: Row[];
 
   nextPageOffset?: number;
 };