Merge branch 'main' into koesie10/access-paths-query-bqrs

Author: koesie10

extensions/ql-vscode/src/compare/sarif-diff.ts

@@ -1,5 +1,40 @@
 import type { Result } from "sarif";
 
+function toCanonicalResult(result: Result): Result {
+  const canonicalResult = {
+    ...result,
+  };
+
+  if (canonicalResult.locations) {
+    canonicalResult.locations = canonicalResult.locations.map((location) => {
+      if (location.physicalLocation?.artifactLocation?.index !== undefined) {
+        const canonicalLocation = {
+          ...location,
+        };
+
+        canonicalLocation.physicalLocation = {
+          ...canonicalLocation.physicalLocation,
+        };
+
+        canonicalLocation.physicalLocation.artifactLocation = {
+          ...canonicalLocation.physicalLocation.artifactLocation,
+        };
+
+        // The index is dependent on the result of the SARIF file and usually doesn't really tell
+        // us anything useful, so we remove it from the comparison.
+        delete canonicalLocation.physicalLocation.artifactLocation.index;
+
+        return canonicalLocation;
+      }
+
+      // Don't create a new object if we don't need to
+      return location;
+    });
+  }
+
+  return canonicalResult;
+}
+
 /**
  * Compare the alerts of two queries. Use deep equality to determine if
  * results have been added or removed across two invocations of a query.
@@ -25,9 +60,12 @@ export function sarifDiff(fromResults: Result[], toResults: Result[]) {
     throw new Error("CodeQL Compare: Target query has no results.");
   }
 
+  const canonicalFromResults = fromResults.map(toCanonicalResult);
+  const canonicalToResults = toResults.map(toCanonicalResult);
+
   const results = {
-    from: arrayDiff(fromResults, toResults),
-    to: arrayDiff(toResults, fromResults),
+    from: arrayDiff(canonicalFromResults, canonicalToResults),
+    to: arrayDiff(canonicalToResults, canonicalFromResults),
   };
 
   if (

extensions/ql-vscode/src/model-editor/languages/models-as-data.ts

@@ -44,6 +44,7 @@ type ModelsAsDataLanguageModelGeneration = {
 };
 
 type ModelsAsDataLanguageAccessPathSuggestions = {
+  queryConstraints: (mode: Mode) => QueryConstraints;
   parseResults: (
     // The results of a single predicate of the query.
     bqrs: DecodedBqrsChunk,

extensions/ql-vscode/src/model-editor/languages/ruby/index.ts

@@ -12,6 +12,7 @@ import {
   rubyPath,
 } from "./access-paths";
 import { parseAccessPathSuggestionsResults } from "./suggestions";
+import { modeTag } from "../../mode-tag";
 
 export const ruby: ModelsAsDataLanguage = {
   availableModes: [Mode.Framework],
@@ -170,6 +171,10 @@ export const ruby: ModelsAsDataLanguage = {
     parseResults: parseGenerateModelResults,
   },
   accessPathSuggestions: {
+    queryConstraints: (mode) => ({
+      kind: "table",
+      "tags contain all": ["modeleditor", "access-paths", modeTag(mode)],
+    }),
     parseResults: parseAccessPathSuggestionsResults,
   },
   getArgumentOptions: (method) => {

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

@@ -529,6 +529,7 @@ export class ModelEditorView extends AbstractWebview<
             modelsAsDataLanguage,
             this.app.logger,
           ),
+        queryConstraints: accessPathSuggestions.queryConstraints(mode),
         cliServer: this.cliServer,
         queryRunner: this.queryRunner,
         queryStorageDir: this.queryStorageDir,

extensions/ql-vscode/src/model-editor/suggestion-queries.ts

@@ -1,7 +1,7 @@
 import type { CodeQLCliServer } from "../codeql-cli/cli";
 import type { Mode } from "./shared/mode";
+import type { QueryConstraints } from "../local-queries";
 import { resolveQueriesFromPacks } from "../local-queries";
-import { modeTag } from "./mode-tag";
 import { getOnDiskWorkspaceFolders } from "../common/vscode/workspace-folders";
 import type { NotificationLogger } from "../common/logging";
 import { showAndLogExceptionWithTelemetry } from "../common/logging";
@@ -22,6 +22,7 @@ type RunQueryOptions = {
   parseResults: (
     results: DecodedBqrsChunk,
   ) => AccessPathSuggestionRow[] | Promise<AccessPathSuggestionRow[]>;
+  queryConstraints: QueryConstraints;
 
   cliServer: CodeQLCliServer;
   queryRunner: QueryRunner;
@@ -39,6 +40,7 @@ export async function runSuggestionsQuery(
   mode: Mode,
   {
     parseResults,
+    queryConstraints,
     cliServer,
     queryRunner,
     logger,
@@ -68,6 +70,7 @@ export async function runSuggestionsQuery(
     cliServer,
     databaseItem.language,
     mode,
+    queryConstraints,
   );
   if (!queryPath) {
     void showAndLogExceptionWithTelemetry(
@@ -141,13 +144,15 @@ export async function runSuggestionsQuery(
  * @param cliServer The CodeQL CLI server to use.
  * @param language The language of the query pack to use.
  * @param mode The mode to resolve the query for.
+ * @param queryConstraints Constraints to apply to the query.
  * @param additionalPackNames Additional pack names to search.
  * @param additionalPackPaths Additional pack paths to search.
  */
 async function resolveSuggestionsQuery(
   cliServer: CodeQLCliServer,
   language: string,
   mode: Mode,
+  queryConstraints: QueryConstraints,
   additionalPackNames: string[] = [],
   additionalPackPaths: string[] = [],
 ): Promise<string | undefined> {
@@ -156,14 +161,7 @@ async function resolveSuggestionsQuery(
   const queries = await resolveQueriesFromPacks(
     cliServer,
     packsToSearch,
-    {
-      kind: "table",
-      "tags contain all": [
-        "modeleditor",
-        "access-path-suggestions",
-        modeTag(mode),
-      ],
-    },
+    queryConstraints,
     additionalPackPaths,
   );
   if (queries.length > 1) {

extensions/ql-vscode/src/view/model-editor/MethodRow.tsx

@@ -278,6 +278,7 @@ const ModelableMethodRow = forwardRef<HTMLElement | undefined, MethodRowProps>(
                     <ModelInputSuggestBox
                       modeledMethod={modeledMethod}
                       suggestions={inputAccessPathSuggestions}
+                      typePathSuggestions={outputAccessPathSuggestions ?? []}
                       onChange={modeledMethodChangedHandlers[index]}
                     />
                   )}

extensions/ql-vscode/src/view/model-editor/ModelInputSuggestBox.tsx

@@ -4,7 +4,6 @@ import {
   calculateNewProvenance,
   modeledMethodSupportsInput,
 } from "../../model-editor/modeled-method";
-import { ReadonlyDropdown } from "../common/ReadonlyDropdown";
 import type { AccessPathOption } from "../../model-editor/suggestions";
 import { SuggestBox } from "../common/SuggestBox";
 import { useDebounceCallback } from "../common/useDebounceCallback";
@@ -14,10 +13,12 @@ import {
   validateAccessPath,
 } from "../../model-editor/shared/access-paths";
 import { ModelSuggestionIcon } from "./ModelSuggestionIcon";
+import { ModelTypePathSuggestBox } from "./ModelTypePathSuggestBox";
 
 type Props = {
   modeledMethod: ModeledMethod | undefined;
   suggestions: AccessPathOption[];
+  typePathSuggestions: AccessPathOption[];
   onChange: (modeledMethod: ModeledMethod) => void;
 };
 
@@ -33,6 +34,7 @@ const getDetails = (option: AccessPathOption) => option.details;
 export const ModelInputSuggestBox = ({
   modeledMethod,
   suggestions,
+  typePathSuggestions,
   onChange,
 }: Props) => {
   const [value, setValue] = useState<string | undefined>(
@@ -75,7 +77,13 @@ export const ModelInputSuggestBox = ({
   );
 
   if (modeledMethod?.type === "type") {
-    return <ReadonlyDropdown value={modeledMethod.path} aria-label="Path" />;
+    return (
+      <ModelTypePathSuggestBox
+        modeledMethod={modeledMethod}
+        suggestions={typePathSuggestions}
+        onChange={onChange}
+      />
+    );
   }
 
   return (

extensions/ql-vscode/src/view/model-editor/ModelOutputSuggestBox.tsx

@@ -4,7 +4,6 @@ import {
   calculateNewProvenance,
   modeledMethodSupportsOutput,
 } from "../../model-editor/modeled-method";
-import { ReadonlyDropdown } from "../common/ReadonlyDropdown";
 import type { AccessPathOption } from "../../model-editor/suggestions";
 import { SuggestBox } from "../common/SuggestBox";
 import { useDebounceCallback } from "../common/useDebounceCallback";
@@ -14,6 +13,7 @@ import {
   validateAccessPath,
 } from "../../model-editor/shared/access-paths";
 import { ModelSuggestionIcon } from "./ModelSuggestionIcon";
+import { ModelTypeTextbox } from "./ModelTypeTextbox";
 
 type Props = {
   modeledMethod: ModeledMethod | undefined;
@@ -76,8 +76,10 @@ export const ModelOutputSuggestBox = ({
 
   if (modeledMethod?.type === "type") {
     return (
-      <ReadonlyDropdown
-        value={modeledMethod.relatedTypeName}
+      <ModelTypeTextbox
+        modeledMethod={modeledMethod}
+        typeInfo="relatedTypeName"
+        onChange={onChange}
         aria-label="Related type name"
       />
     );

extensions/ql-vscode/src/view/model-editor/ModelTypePathSuggestBox.tsx

@@ -0,0 +1,68 @@
+import { useEffect, useState } from "react";
+import type { TypeModeledMethod } from "../../model-editor/modeled-method";
+import type { AccessPathOption } from "../../model-editor/suggestions";
+import { SuggestBox } from "../common/SuggestBox";
+import { useDebounceCallback } from "../common/useDebounceCallback";
+import type { AccessPathDiagnostic } from "../../model-editor/shared/access-paths";
+import {
+  parseAccessPathTokens,
+  validateAccessPath,
+} from "../../model-editor/shared/access-paths";
+import { ModelSuggestionIcon } from "./ModelSuggestionIcon";
+
+type Props = {
+  modeledMethod: TypeModeledMethod;
+  suggestions: AccessPathOption[];
+  onChange: (modeledMethod: TypeModeledMethod) => void;
+};
+
+const parseValueToTokens = (value: string) =>
+  parseAccessPathTokens(value).map((t) => t.text);
+
+const getIcon = (option: AccessPathOption) => (
+  <ModelSuggestionIcon name={option.icon} />
+);
+
+const getDetails = (option: AccessPathOption) => option.details;
+
+export const ModelTypePathSuggestBox = ({
+  modeledMethod,
+  suggestions,
+  onChange,
+}: Props) => {
+  const [value, setValue] = useState<string | undefined>(modeledMethod.path);
+
+  useEffect(() => {
+    setValue(modeledMethod.path);
+  }, [modeledMethod]);
+
+  // Debounce the callback to avoid updating the model too often.
+  // Not doing this results in a lot of lag when typing.
+  useDebounceCallback(
+    value,
+    (path: string | undefined) => {
+      if (path === undefined) {
+        return;
+      }
+
+      onChange({
+        ...modeledMethod,
+        path,
+      });
+    },
+    500,
+  );
+
+  return (
+    <SuggestBox<AccessPathOption, AccessPathDiagnostic>
+      value={value}
+      options={suggestions}
+      onChange={setValue}
+      parseValueToTokens={parseValueToTokens}
+      validateValue={validateAccessPath}
+      getIcon={getIcon}
+      getDetails={getDetails}
+      aria-label="Path"
+    />
+  );
+};