Handle codeql-pack.yml files everywhere

This will add support for the `codeql-pack.yml` filename in all places
where we currently support `qlpack.yml`. It centralizes the list of the
supported filenames in a single place and a method that can figure out
the correct filename to use.

Author: koesie10

extensions/ql-vscode/src/contextual/queryResolver.ts

@@ -9,6 +9,7 @@ import {
   getOnDiskWorkspaceFolders,
   QlPacksForLanguage,
   showAndLogExceptionWithTelemetry,
+  QLPACK_FILENAMES,
 } from "../helpers";
 import { KeyType, kindOfKeyType, nameOfKeyType, tagOfKeyType } from "./keyType";
 import { CodeQLCliServer } from "../cli";
@@ -113,7 +114,7 @@ async function resolveContextualQuery(
   // Work out the enclosing pack.
   const packContents = await cli.packPacklist(query, false);
   const packFilePath = packContents.find((p) =>
-    ["codeql-pack.yml", "qlpack.yml"].includes(basename(p)),
+    QLPACK_FILENAMES.includes(basename(p)),
   );
   if (packFilePath === undefined) {
     // Should not happen; we already resolved this query.

extensions/ql-vscode/src/extension.ts

@@ -845,6 +845,7 @@ async function activateWithInstalledDistribution(
       documentSelector: [
         { language: "ql", scheme: "file" },
         { language: "yaml", scheme: "file", pattern: "**/qlpack.yml" },
+        { language: "yaml", scheme: "file", pattern: "**/codeql-pack.yml" },
       ],
       synchronize: {
         configurationSection: "codeQL",

extensions/ql-vscode/src/helpers.ts

@@ -387,17 +387,22 @@ async function findDbschemePack(
 ): Promise<{ name: string; isLibraryPack: boolean }> {
   for (const { packDir, packName } of packs) {
     if (packDir !== undefined) {
-      const qlpack = load(
-        await readFile(join(packDir, "qlpack.yml"), "utf8"),
-      ) as { dbscheme?: string; library?: boolean };
-      if (
-        qlpack.dbscheme !== undefined &&
-        basename(qlpack.dbscheme) === basename(dbschemePath)
-      ) {
-        return {
-          name: packName,
-          isLibraryPack: qlpack.library === true,
+      const qlpackPath = await getQlPackPath(packDir);
+
+      if (qlpackPath !== undefined) {
+        const qlpack = load(await readFile(qlpackPath, "utf8")) as {
+          dbscheme?: string;
+          library?: boolean;
         };
+        if (
+          qlpack.dbscheme !== undefined &&
+          basename(qlpack.dbscheme) === basename(dbschemePath)
+        ) {
+          return {
+            name: packName,
+            isLibraryPack: qlpack.library === true,
+          };
+        }
       }
     }
   }
@@ -737,3 +742,20 @@ export async function* walkDirectory(
     }
   }
 }
+
+export const QLPACK_FILENAMES = ["qlpack.yml", "codeql-pack.yml"];
+export const FALLBACK_QLPACK_FILENAME = QLPACK_FILENAMES[0];
+
+export async function getQlPackPath(
+  packRoot: string,
+): Promise<string | undefined> {
+  for (const filename of QLPACK_FILENAMES) {
+    const path = join(packRoot, filename);
+
+    if (await pathExists(path)) {
+      return path;
+    }
+  }
+
+  return undefined;
+}

extensions/ql-vscode/src/quick-query.ts

@@ -12,9 +12,11 @@ import { LSPErrorCodes, ResponseError } from "vscode-languageclient";
 import { CodeQLCliServer } from "./cli";
 import { DatabaseUI } from "./databases-ui";
 import {
+  FALLBACK_QLPACK_FILENAME,
   getInitialQueryContents,
   getPrimaryDbscheme,
   getQlPackForDbscheme,
+  getQlPackPath,
   showBinaryChoiceDialog,
 } from "./helpers";
 import { ProgressCallback, UserCancellationException } from "./commandRunner";
@@ -112,7 +114,7 @@ export async function displayQuickQuery(
     const dbscheme = await getPrimaryDbscheme(datasetFolder);
     const qlpack = (await getQlPackForDbscheme(cliServer, dbscheme))
       .dbschemePack;
-    const qlPackFile = join(queriesDir, "qlpack.yml");
+    const qlPackFile = await getQlPackPath(queriesDir);
     const qlFile = join(queriesDir, QUICK_QUERY_QUERY_NAME);
     const shouldRewrite = await checkShouldRewrite(qlPackFile, qlpack);
 
@@ -126,7 +128,7 @@ export async function displayQuickQuery(
         },
       };
       await writeFile(
-        qlPackFile,
+        qlPackFile ?? join(queriesDir, FALLBACK_QLPACK_FILENAME),
         QLPACK_FILE_HEADER + dump(quickQueryQlpackYaml),
         "utf8",
       );
@@ -158,7 +160,13 @@ export async function displayQuickQuery(
   }
 }
 
-async function checkShouldRewrite(qlPackFile: string, newDependency: string) {
+async function checkShouldRewrite(
+  qlPackFile: string | undefined,
+  newDependency: string,
+) {
+  if (!qlPackFile) {
+    return true;
+  }
   if (!(await pathExists(qlPackFile))) {
     return true;
   }

extensions/ql-vscode/src/remote-queries/run-remote-query.ts

@@ -1,14 +1,17 @@
 import { CancellationToken, Uri, window } from "vscode";
 import { relative, join, sep, dirname, parse, basename } from "path";
 import { dump, load } from "js-yaml";
-import { pathExists, copy, writeFile, readFile, mkdirp } from "fs-extra";
+import { copy, writeFile, readFile, mkdirp } from "fs-extra";
 import { dir, tmpName } from "tmp-promise";
 import {
   askForLanguage,
   findLanguage,
   getOnDiskWorkspaceFolders,
   tryGetQueryMetadata,
   tmpDir,
+  FALLBACK_QLPACK_FILENAME,
+  getQlPackPath,
+  QLPACK_FILENAMES,
 } from "../helpers";
 import { Credentials } from "../common/authentication";
 import * as cli from "../cli";
@@ -67,7 +70,7 @@ async function generateQueryPack(
   const targetQueryFileName = join(queryPackDir, packRelativePath);
 
   let language: string | undefined;
-  if (await getExistingPackFile(originalPackRoot)) {
+  if (await getQlPackPath(originalPackRoot)) {
     // don't include ql files. We only want the queryFile to be copied.
     const toCopy = await cliServer.packPacklist(originalPackRoot, false);
 
@@ -120,7 +123,10 @@ async function generateQueryPack(
       },
       defaultSuite: generateDefaultSuite(packRelativePath),
     };
-    await writeFile(join(queryPackDir, "qlpack.yml"), dump(syntheticQueryPack));
+    await writeFile(
+      join(queryPackDir, FALLBACK_QLPACK_FILENAME),
+      dump(syntheticQueryPack),
+    );
   }
   if (!language) {
     throw new UserCancellationException("Could not determine language.");
@@ -163,7 +169,7 @@ async function generateQueryPack(
 async function findPackRoot(queryFile: string): Promise<string> {
   // recursively find the directory containing qlpack.yml
   let dir = dirname(queryFile);
-  while (!(await getExistingPackFile(dir))) {
+  while (!(await getQlPackPath(dir))) {
     dir = dirname(dir);
     if (isFileSystemRoot(dir)) {
       // there is no qlpack.yml in this directory or any parent directory.
@@ -175,16 +181,6 @@ async function findPackRoot(queryFile: string): Promise<string> {
   return dir;
 }
 
-async function getExistingPackFile(dir: string) {
-  if (await pathExists(join(dir, "qlpack.yml"))) {
-    return join(dir, "qlpack.yml");
-  }
-  if (await pathExists(join(dir, "codeql-pack.yml"))) {
-    return join(dir, "codeql-pack.yml");
-  }
-  return undefined;
-}
-
 function isFileSystemRoot(dir: string): boolean {
   const pathObj = parse(dir);
   return pathObj.root === dir && pathObj.base === "";
@@ -319,12 +315,14 @@ async function fixPackFile(
   queryPackDir: string,
   packRelativePath: string,
 ): Promise<void> {
-  const packPath = await getExistingPackFile(queryPackDir);
+  const packPath = await getQlPackPath(queryPackDir);
 
   // This should not happen since we create the pack ourselves.
   if (!packPath) {
     throw new Error(
-      `Could not find qlpack.yml or codeql-pack.yml file in '${queryPackDir}'`,
+      `Could not find ${QLPACK_FILENAMES.join(
+        " or ",
+      )} file in '${queryPackDir}'`,
     );
   }
   const qlpack = load(await readFile(packPath, "utf8")) as QlPack;