Remove some unused BQRS methods/argument type unions

Author: koesie10

extensions/ql-vscode/src/common/bqrs-cli-types.ts

@@ -90,19 +90,6 @@ export interface RawResultSet {
   readonly rows: readonly ResultRow[];
 }
 
-// TODO: This function is not necessary. It generates a tuple that is slightly easier
-// to handle than the ResultSetSchema and DecodedBqrsChunk. But perhaps it is unnecessary
-// boilerplate.
-export function transformBqrsResultSet(
-  schema: ResultSetSchema,
-  page: DecodedBqrsChunk,
-): RawResultSet {
-  return {
-    schema,
-    rows: Array.from(page.tuples),
-  };
-}
-
 export type BqrsKind =
   | "String"
   | "Float"

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

@@ -102,7 +102,7 @@ function mapEntityValue(cellValue: BqrsEntityValue): EntityValue {
   };
 }
 
-function mapUrlValue(urlValue: BqrsUrlValue): UrlValue | undefined {
+export function mapUrlValue(urlValue: BqrsUrlValue): UrlValue | undefined {
   if (typeof urlValue === "string") {
     const location = tryGetLocationFromString(urlValue);
     if (location !== undefined) {

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

@@ -1,9 +1,5 @@
 import { createRemoteFileRef } from "../common/location-link-utils";
-import {
-  isUrlValueResolvable,
-  UrlValue,
-  UrlValueResolvable,
-} from "./raw-result-types";
+import { isUrlValueResolvable, UrlValue } from "./raw-result-types";
 import {
   LineColumnLocation,
   UrlValue as BqrsUrlValue,
@@ -18,82 +14,6 @@ export function isEmptyPath(uriStr: string) {
   return !uriStr || uriStr === "file:/";
 }
 
-/**
- * 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]+)/;
-/**
- * Gets a resolvable source file location for the specified `LocationValue`, if possible.
- * @param loc The location to test.
- */
-export function tryGetResolvableLocation(
-  loc: BqrsUrlValue | undefined,
-): UrlValueResolvable | undefined {
-  let resolvedLoc: UrlValueResolvable | undefined;
-  if (loc === undefined) {
-    resolvedLoc = undefined;
-  } 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 {
-    resolvedLoc = undefined;
-  }
-
-  return resolvedLoc;
-}
-
-export 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]),
-      };
-    }
-  } else {
-    return undefined;
-  }
-}
-
-function isWholeFileMatch(matches: RegExpExecArray): boolean {
-  return (
-    matches[2] === "0" &&
-    matches[3] === "0" &&
-    matches[4] === "0" &&
-    matches[5] === "0"
-  );
-}
-
 export function isLineColumnLoc(loc: BqrsUrlValue): loc is LineColumnLocation {
   return (
     typeof loc !== "string" &&
@@ -115,20 +35,6 @@ 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,

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

@@ -1,8 +1,5 @@
 import * as sarif from "sarif";
-import {
-  ResultSetSchema,
-  ResolvableLocationValue,
-} from "../common/bqrs-cli-types";
+import { ResultSetSchema } from "../common/bqrs-cli-types";
 import {
   VariantAnalysis,
   VariantAnalysisScannedRepositoryResult,
@@ -215,7 +212,7 @@ export type FromResultsViewMsg =
  */
 interface ViewSourceFileMsg {
   t: "viewSourceFile";
-  loc: ResolvableLocationValue | UrlValueResolvable;
+  loc: UrlValueResolvable;
   databaseUri: string;
 }
 

extensions/ql-vscode/src/databases/local-databases/locations.ts

@@ -9,15 +9,10 @@ import {
   window as Window,
   workspace,
 } from "vscode";
-import {
-  ResolvableLocationValue,
-  UrlValue as BqrsUrlValue,
-} from "../../common/bqrs-cli-types";
 import { assertNever, getErrorMessage } from "../../common/helpers-pure";
 import { Logger } from "../../common/logging";
 import { DatabaseItem } from "./database-item";
 import { DatabaseManager } from "./database-manager";
-import { tryGetResolvableLocation } from "../../common/bqrs-utils";
 import {
   UrlValueLineColumnLocation,
   UrlValueResolvable,
@@ -74,49 +69,32 @@ function resolveWholeFileLocation(
   return new Location(databaseItem.resolveSourceFile(loc.uri), range);
 }
 
-function isUrlValueResolvable(
-  loc: BqrsUrlValue | UrlValueResolvable | undefined,
-): loc is UrlValueResolvable {
-  if (!loc) {
-    return false;
-  }
-
-  if (typeof loc !== "object") {
-    return false;
-  }
-
-  return "type" in loc;
-}
-
 /**
  * Try to resolve the specified CodeQL location to a URI into the source archive. If no exact location
  * can be resolved, returns `undefined`.
  * @param loc CodeQL location to resolve
  * @param databaseItem Database in which to resolve the file location.
  */
 export function tryResolveLocation(
-  loc: BqrsUrlValue | UrlValueResolvable | undefined,
+  loc: UrlValueResolvable | undefined,
   databaseItem: DatabaseItem,
 ): Location | undefined {
-  const resolvableLoc = isUrlValueResolvable(loc)
-    ? loc
-    : tryGetResolvableLocation(loc);
-  if (!resolvableLoc) {
+  if (!loc) {
     return;
   }
 
-  switch (resolvableLoc.type) {
+  switch (loc.type) {
     case "wholeFileLocation":
-      return resolveWholeFileLocation(resolvableLoc, databaseItem);
+      return resolveWholeFileLocation(loc, databaseItem);
     case "lineColumnLocation":
-      return resolveFivePartLocation(resolvableLoc, databaseItem);
+      return resolveFivePartLocation(loc, databaseItem);
     default:
-      assertNever(resolvableLoc);
+      assertNever(loc);
   }
 }
 
 export async function showResolvableLocation(
-  loc: ResolvableLocationValue | UrlValueResolvable,
+  loc: UrlValueResolvable,
   databaseItem: DatabaseItem,
   logger: Logger,
 ): Promise<void> {
@@ -174,7 +152,7 @@ export async function showLocation(location?: Location) {
 
 export async function jumpToLocation(
   databaseUri: string,
-  loc: ResolvableLocationValue | UrlValueResolvable,
+  loc: UrlValueResolvable,
   databaseManager: DatabaseManager,
   logger: Logger,
 ) {

extensions/ql-vscode/src/model-editor/bqrs.ts

@@ -1,11 +1,13 @@
-import { DecodedBqrsChunk } from "../common/bqrs-cli-types";
-import { Call, CallClassification, Method } from "./method";
+import { DecodedBqrsChunk, EntityValue } from "../common/bqrs-cli-types";
+import { CallClassification, Method, Usage } from "./method";
 import { ModeledMethodType } from "./modeled-method";
 import { parseLibraryFilename } from "./library";
 import { Mode } from "./shared/mode";
 import { ApplicationModeTuple, FrameworkModeTuple } from "./queries/query";
 import { QueryLanguage } from "../common/query-language";
 import { getModelsAsDataLanguage } from "./languages";
+import { mapUrlValue } from "../common/bqrs-result";
+import { isUrlValueResolvable } from "../common/raw-result-types";
 
 export function decodeBqrsToMethods(
   chunk: DecodedBqrsChunk,
@@ -17,7 +19,7 @@ export function decodeBqrsToMethods(
   const definition = getModelsAsDataLanguage(language);
 
   chunk?.tuples.forEach((tuple) => {
-    let usage: Call;
+    let usageEntityValue: EntityValue;
     let packageName: string;
     let typeName: string;
     let methodName: string;
@@ -30,7 +32,7 @@ export function decodeBqrsToMethods(
 
     if (mode === Mode.Application) {
       [
-        usage,
+        usageEntityValue,
         packageName,
         typeName,
         methodName,
@@ -43,7 +45,7 @@ export function decodeBqrsToMethods(
       ] = tuple as ApplicationModeTuple;
     } else {
       [
-        usage,
+        usageEntityValue,
         packageName,
         typeName,
         methodName,
@@ -97,11 +99,25 @@ export function decodeBqrsToMethods(
       });
     }
 
+    if (usageEntityValue.url === undefined) {
+      return;
+    }
+
+    const usageUrl = mapUrlValue(usageEntityValue.url);
+    if (!usageUrl || !isUrlValueResolvable(usageUrl)) {
+      return;
+    }
+
+    if (!usageEntityValue.label) {
+      return;
+    }
+
     const method = methodsByApiName.get(signature)!;
-    const usages = [
+    const usages: Usage[] = [
       ...method.usages,
       {
-        ...usage,
+        label: usageEntityValue.label,
+        url: usageUrl,
         classification,
       },
     ];

extensions/ql-vscode/src/model-editor/method.ts

@@ -1,9 +1,9 @@
-import { ResolvableLocationValue } from "../common/bqrs-cli-types";
 import { ModeledMethod, ModeledMethodType } from "./modeled-method";
+import { UrlValueResolvable } from "../common/raw-result-types";
 
 export type Call = {
   readonly label: string;
-  readonly url: Readonly<ResolvableLocationValue>;
+  readonly url: Readonly<UrlValueResolvable>;
 };
 
 export enum CallClassification {

extensions/ql-vscode/src/model-editor/methods-usage/methods-usage-data-provider.ts

@@ -19,6 +19,7 @@ import { assertNever } from "../../common/helpers-pure";
 import { ModeledMethod } from "../modeled-method";
 import { groupMethods, sortGroupNames, sortMethods } from "../shared/sorting";
 import { INITIAL_MODE, Mode } from "../shared/mode";
+import { UrlValueResolvable } from "../../common/raw-result-types";
 
 export class MethodsUsageDataProvider
   extends DisposableObject
@@ -99,11 +100,16 @@ export class MethodsUsageDataProvider
     } else {
       const { method, usage } = item;
 
+      const description =
+        usage.url.type === "wholeFileLocation"
+          ? this.relativePathWithinDatabase(usage.url.uri)
+          : `${this.relativePathWithinDatabase(usage.url.uri)} [${
+              usage.url.startLine
+            }, ${usage.url.endLine}]`;
+
       return {
         label: usage.label,
-        description: `${this.relativePathWithinDatabase(usage.url.uri)} [${
-          usage.url.startLine
-        }, ${usage.url.endLine}]`,
+        description,
         collapsibleState: TreeItemCollapsibleState.None,
         command: {
           title: "Show usage",
@@ -211,14 +217,35 @@ function usagesAreEqual(u1: Usage, u2: Usage): boolean {
   return (
     u1.label === u2.label &&
     u1.classification === u2.classification &&
-    u1.url.uri === u2.url.uri &&
-    u1.url.startLine === u2.url.startLine &&
-    u1.url.startColumn === u2.url.startColumn &&
-    u1.url.endLine === u2.url.endLine &&
-    u1.url.endColumn === u2.url.endColumn
+    urlValueResolvablesAreEqual(u1.url, u2.url)
   );
 }
 
+function urlValueResolvablesAreEqual(
+  u1: UrlValueResolvable,
+  u2: UrlValueResolvable,
+): boolean {
+  if (u1.type !== u2.type) {
+    return false;
+  }
+
+  if (u1.type === "wholeFileLocation" && u2.type === "wholeFileLocation") {
+    return u1.uri === u2.uri;
+  }
+
+  if (u1.type === "lineColumnLocation" && u2.type === "lineColumnLocation") {
+    return (
+      u1.uri === u2.uri &&
+      u1.startLine === u2.startLine &&
+      u1.startColumn === u2.startColumn &&
+      u1.endLine === u2.endLine &&
+      u1.endColumn === u2.endColumn
+    );
+  }
+
+  return false;
+}
+
 function sortMethodsInGroups(methods: readonly Method[], mode: Mode): Method[] {
   const grouped = groupMethods(methods, mode);