Merge pull request #3382 from github/robertbrignull/automodel-sort-order

Update method sort order to place auto-model predictions earlier

Author: robertbrignull

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

@@ -63,6 +63,7 @@ export class MethodsUsageDataProvider
     mode: Mode,
     modeledMethods: Readonly<Record<string, readonly ModeledMethod[]>>,
     modifiedMethodSignatures: ReadonlySet<string>,
+    processedByAutoModelMethods: ReadonlySet<string>,
   ): Promise<void> {
     if (
       this.methods !== methods ||
@@ -74,7 +75,13 @@ export class MethodsUsageDataProvider
     ) {
       this.methods = methods;
       this.sortedTreeItems = createTreeItems(
-        sortMethodsInGroups(methods, mode),
+        sortMethodsInGroups(
+          methods,
+          modeledMethods,
+          mode,
+          modifiedMethodSignatures,
+          processedByAutoModelMethods,
+        ),
       );
       this.databaseItem = databaseItem;
       this.sourceLocationPrefix =
@@ -246,15 +253,26 @@ function urlValueResolvablesAreEqual(
   return false;
 }
 
-function sortMethodsInGroups(methods: readonly Method[], mode: Mode): Method[] {
+function sortMethodsInGroups(
+  methods: readonly Method[],
+  modeledMethods: Readonly<Record<string, readonly ModeledMethod[]>>,
+  mode: Mode,
+  modifiedMethodSignatures: ReadonlySet<string>,
+  processedByAutoModelMethods: ReadonlySet<string>,
+): Method[] {
   const grouped = groupMethods(methods, mode);
 
   const sortedGroupNames = sortGroupNames(grouped);
 
   return sortedGroupNames.flatMap((groupName) => {
     const group = grouped[groupName];
 
-    return sortMethods(group);
+    return sortMethods(
+      group,
+      modeledMethods,
+      modifiedMethodSignatures,
+      processedByAutoModelMethods,
+    );
   });
 }
 

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

@@ -39,6 +39,7 @@ export class MethodsUsagePanel extends DisposableObject {
     mode: Mode,
     modeledMethods: Readonly<Record<string, readonly ModeledMethod[]>>,
     modifiedMethodSignatures: ReadonlySet<string>,
+    processedByAutoModelMethods: ReadonlySet<string>,
   ): Promise<void> {
     await this.dataProvider.setState(
       methods,
@@ -47,6 +48,7 @@ export class MethodsUsagePanel extends DisposableObject {
       mode,
       modeledMethods,
       modifiedMethodSignatures,
+      processedByAutoModelMethods,
     );
     const numOfApis = hideModeledMethods
       ? methods.filter((api) => !api.supported).length
@@ -120,6 +122,7 @@ export class MethodsUsagePanel extends DisposableObject {
         activeState.mode,
         activeState.modeledMethods,
         activeState.modifiedMethodSignatures,
+        activeState.processedByAutoModelMethods,
       );
     }
   }

extensions/ql-vscode/src/model-editor/shared/auto-model-candidates.ts

@@ -19,37 +19,35 @@ export function getCandidates(
   modeledMethodsBySignature: Record<string, readonly ModeledMethod[]>,
   processedByAutoModelMethods: Set<string>,
 ): MethodSignature[] {
-  // Filter out any methods already processed by auto-model
-  methods = methods.filter(
-    (m) => !processedByAutoModelMethods.has(m.signature),
-  );
-
-  // Sort the same way as the UI so we send the first ones listed in the UI first
-  const grouped = groupMethods(methods, mode);
-  const sortedGroupNames = sortGroupNames(grouped);
-  const sortedMethods = sortedGroupNames.flatMap((name) =>
-    sortMethods(grouped[name]),
-  );
-
-  const candidates: MethodSignature[] = [];
+  const candidateMethods = methods.filter((method) => {
+    // Filter out any methods already processed by auto-model
+    if (processedByAutoModelMethods.has(method.signature)) {
+      return false;
+    }
 
-  for (const method of sortedMethods) {
     const modeledMethods: ModeledMethod[] = [
       ...(modeledMethodsBySignature[method.signature] ?? []),
     ];
 
     // Anything that is modeled is not a candidate
     if (modeledMethods.some((m) => m.type !== "none")) {
-      continue;
+      return false;
     }
 
     // A method that is supported is modeled outside of the model file, so it is not a candidate.
     if (method.supported) {
-      continue;
+      return false;
     }
 
-    // The rest are candidates
-    candidates.push(method);
-  }
-  return candidates;
+    return true;
+  });
+
+  // Sort the same way as the UI so we send the first ones listed in the UI first
+  const grouped = groupMethods(candidateMethods, mode);
+  const sortedGroupNames = sortGroupNames(grouped);
+  return sortedGroupNames.flatMap((name) =>
+    // We can safely pass empty sets for `modifiedSignatures` and `processedByAutoModelMethods`
+    // because we've filtered out all methods that are already modeled or have already been processed by auto-model.
+    sortMethods(grouped[name], modeledMethodsBySignature, new Set(), new Set()),
+  );
 }

extensions/ql-vscode/src/model-editor/shared/sorting.ts

@@ -1,4 +1,6 @@
+import { canMethodBeModeled } from "../method";
 import type { Method } from "../method";
+import type { ModeledMethod } from "../modeled-method";
 import { Mode } from "./mode";
 import { calculateModeledPercentage } from "./modeled-percentage";
 
@@ -27,12 +29,84 @@ export function sortGroupNames(
   );
 }
 
-export function sortMethods(methods: readonly Method[]): Method[] {
+/**
+ * Primarily sorts methods into the following order:
+ * - Unsaved positive AutoModel predictions
+ * - Negative AutoModel predictions
+ * - Unsaved manual models + unmodeled methods
+ * - Saved models from this model pack (AutoModel and manual)
+ * - Methods not modelable in this model pack
+ *
+ * Secondary sort order is by number of usages descending, then by method signature ascending.
+ */
+export function sortMethods(
+  methods: readonly Method[],
+  modeledMethodsMap: Record<string, readonly ModeledMethod[]>,
+  modifiedSignatures: ReadonlySet<string>,
+  processedByAutoModelMethods: ReadonlySet<string>,
+): Method[] {
   const sortedMethods = [...methods];
-  sortedMethods.sort((a, b) => compareMethod(a, b));
+  sortedMethods.sort((a, b) => {
+    // First sort by the type of method
+    const methodAPrimarySortOrdinal = getMethodPrimarySortOrdinal(
+      a,
+      modeledMethodsMap[a.signature] ?? [],
+      modifiedSignatures.has(a.signature),
+      processedByAutoModelMethods.has(a.signature),
+    );
+    const methodBPrimarySortOrdinal = getMethodPrimarySortOrdinal(
+      b,
+      modeledMethodsMap[b.signature] ?? [],
+      modifiedSignatures.has(b.signature),
+      processedByAutoModelMethods.has(b.signature),
+    );
+    if (methodAPrimarySortOrdinal !== methodBPrimarySortOrdinal) {
+      return methodAPrimarySortOrdinal - methodBPrimarySortOrdinal;
+    }
+
+    // Then sort by number of usages descending
+    const usageDifference = b.usages.length - a.usages.length;
+    if (usageDifference !== 0) {
+      return usageDifference;
+    }
+
+    // Then sort by method signature ascending
+    return a.signature.localeCompare(b.signature);
+  });
   return sortedMethods;
 }
 
+/**
+ * Assigns numbers to the following classes of methods:
+ * - Unsaved positive AutoModel predictions => 0
+ * - Negative AutoModel predictions => 1
+ * - Unsaved manual models + unmodeled methods => 2
+ * - Saved models from this model pack (AutoModel and manual) => 3
+ * - Methods not modelable in this model pack => 4
+ */
+function getMethodPrimarySortOrdinal(
+  method: Method,
+  modeledMethods: readonly ModeledMethod[],
+  isUnsaved: boolean,
+  isProcessedByAutoModel: boolean,
+): number {
+  const canBeModeled = canMethodBeModeled(method, modeledMethods, isUnsaved);
+  const isModeled = modeledMethods.length > 0;
+  if (canBeModeled) {
+    if (isModeled && isUnsaved && isProcessedByAutoModel) {
+      return 0;
+    } else if (!isModeled && isProcessedByAutoModel) {
+      return 1;
+    } else if ((isModeled && isUnsaved) || !isModeled) {
+      return 2;
+    } else {
+      return 3;
+    }
+  } else {
+    return 4;
+  }
+}
+
 function compareGroups(
   a: readonly Method[],
   aName: string,
@@ -69,22 +143,3 @@ function compareGroups(
   // Then sort by number of usages descending
   return numberOfUsagesB - numberOfUsagesA;
 }
-
-function compareMethod(a: Method, b: Method): number {
-  // Sort first by supported, putting unmodeled methods first.
-  if (a.supported && !b.supported) {
-    return 1;
-  }
-  if (!a.supported && b.supported) {
-    return -1;
-  }
-
-  // Then sort by number of usages descending
-  const usageDifference = b.usages.length - a.usages.length;
-  if (usageDifference !== 0) {
-    return usageDifference;
-  }
-
-  // Then sort by method signature ascending
-  return a.signature.localeCompare(b.signature);
-}

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

@@ -48,7 +48,12 @@ export const ModeledMethodDataGrid = ({
   ] = useMemo(() => {
     const methodsWithModelability = [];
     let numHiddenMethods = 0;
-    for (const method of sortMethods(methods)) {
+    for (const method of sortMethods(
+      methods,
+      modeledMethodsMap,
+      modifiedSignatures,
+      processedByAutoModelMethods,
+    )) {
       const modeledMethods = modeledMethodsMap[method.signature] ?? [];
       const methodIsUnsaved = modifiedSignatures.has(method.signature);
       const methodCanBeModeled = canMethodBeModeled(
@@ -64,7 +69,13 @@ export const ModeledMethodDataGrid = ({
       }
     }
     return [methodsWithModelability, numHiddenMethods];
-  }, [hideModeledMethods, methods, modeledMethodsMap, modifiedSignatures]);
+  }, [
+    hideModeledMethods,
+    methods,
+    modeledMethodsMap,
+    modifiedSignatures,
+    processedByAutoModelMethods,
+  ]);
 
   const someMethodsAreVisible = methodsWithModelability.length > 0;