Add supported endpoint types

Author: koesie10

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

@@ -1,4 +1,4 @@
-import type { MethodArgument, MethodDefinition } from "../method";
+import type { EndpointType, MethodArgument, MethodDefinition } from "../method";
 import type {
   ModeledMethod,
   NeutralModeledMethod,
@@ -23,6 +23,11 @@ type ReadModeledMethod = (row: DataTuple[]) => ModeledMethod;
 export type ModelsAsDataLanguagePredicate<T> = {
   extensiblePredicate: string;
   supportedKinds?: string[];
+  /**
+   * The endpoint types that this predicate supports. If not specified, the predicate supports all
+   * endpoint types.
+   */
+  supportedEndpointTypes?: EndpointType[];
   generateMethodDefinition: GenerateMethodDefinition<T>;
   readModeledMethod: ReadModeledMethod;
 };

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

@@ -64,6 +64,11 @@ export function rubyPath(methodName: string, path: string) {
   return `${methodPath}.${path}`;
 }
 
-export function rubyEndpointType(methodName: string) {
+export function rubyEndpointType(typeName: string, methodName: string) {
+  if (typeName.endsWith("!") && methodName === "new") {
+    // This is a constructor
+    return EndpointType.Constructor;
+  }
+
   return methodName === "" ? EndpointType.Class : EndpointType.Method;
 }

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

@@ -3,7 +3,7 @@ import { sharedExtensiblePredicates, sharedKinds } from "../shared";
 import { Mode } from "../../shared/mode";
 import { parseGenerateModelResults } from "./generate";
 import type { MethodArgument } from "../../method";
-import { getArgumentsList } from "../../method";
+import { EndpointType, getArgumentsList } from "../../method";
 import {
   parseRubyAccessPath,
   parseRubyMethodFromPath,
@@ -23,6 +23,7 @@ export const ruby: ModelsAsDataLanguage = {
     source: {
       extensiblePredicate: sharedExtensiblePredicates.source,
       supportedKinds: sharedKinds.source,
+      supportedEndpointTypes: [EndpointType.Method, EndpointType.Class],
       // extensible predicate sourceModel(
       //   string type, string path, string kind
       // );
@@ -42,7 +43,7 @@ export const ruby: ModelsAsDataLanguage = {
           kind: row[2] as string,
           provenance: "manual",
           signature: rubyMethodSignature(typeName, methodName),
-          endpointType: rubyEndpointType(methodName),
+          endpointType: rubyEndpointType(typeName, methodName),
           packageName: "",
           typeName,
           methodName,
@@ -53,6 +54,7 @@ export const ruby: ModelsAsDataLanguage = {
     sink: {
       extensiblePredicate: sharedExtensiblePredicates.sink,
       supportedKinds: sharedKinds.sink,
+      supportedEndpointTypes: [EndpointType.Method, EndpointType.Constructor],
       // extensible predicate sinkModel(
       //   string type, string path, string kind
       // );
@@ -74,7 +76,7 @@ export const ruby: ModelsAsDataLanguage = {
           kind: row[2] as string,
           provenance: "manual",
           signature: rubyMethodSignature(typeName, methodName),
-          endpointType: rubyEndpointType(methodName),
+          endpointType: rubyEndpointType(typeName, methodName),
           packageName: "",
           typeName,
           methodName,
@@ -85,6 +87,7 @@ export const ruby: ModelsAsDataLanguage = {
     summary: {
       extensiblePredicate: sharedExtensiblePredicates.summary,
       supportedKinds: sharedKinds.summary,
+      supportedEndpointTypes: [EndpointType.Method, EndpointType.Constructor],
       // extensible predicate summaryModel(
       //   string type, string path, string input, string output, string kind
       // );
@@ -105,7 +108,7 @@ export const ruby: ModelsAsDataLanguage = {
           kind: row[4] as string,
           provenance: "manual",
           signature: rubyMethodSignature(typeName, methodName),
-          endpointType: rubyEndpointType(methodName),
+          endpointType: rubyEndpointType(typeName, methodName),
           packageName: "",
           typeName,
           methodName,
@@ -132,7 +135,7 @@ export const ruby: ModelsAsDataLanguage = {
           kind: row[2] as string,
           provenance: "manual",
           signature: rubyMethodSignature(typeName, methodName),
-          endpointType: rubyEndpointType(methodName),
+          endpointType: rubyEndpointType(typeName, methodName),
           packageName: "",
           typeName,
           methodName,
@@ -157,7 +160,7 @@ export const ruby: ModelsAsDataLanguage = {
           relatedTypeName: row[0] as string,
           path,
           signature: rubyMethodSignature(typeName, methodName),
-          endpointType: rubyEndpointType(methodName),
+          endpointType: rubyEndpointType(typeName, methodName),
           packageName: "",
           typeName,
           methodName,

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

@@ -68,7 +68,7 @@ export function parseAccessPathSuggestionsResults(
       return {
         method: {
           packageName: "",
-          endpointType: rubyEndpointType(methodName),
+          endpointType: rubyEndpointType(type, methodName),
           typeName: type,
           methodName,
           methodParameters: "",

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

@@ -17,9 +17,16 @@ export type Usage = Call & {
   readonly classification: CallClassification;
 };
 
+/**
+ * Endpoint types are generic and can be used to represent different types of endpoints in different languages.
+ *
+ * For a reference of symbol kinds used in the LSP protocol (which is a good reference for widely supported features), see
+ * https://github.com/microsoft/vscode-languageserver-node/blob/4c8115f40b52f2e13adab41109c5b1208fc155ab/types/src/main.ts#L2890-L2920
+ */
 export enum EndpointType {
-  Method = "method",
   Class = "class",
+  Method = "method",
+  Constructor = "constructor",
 }
 
 export interface MethodDefinition {

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

@@ -12,7 +12,8 @@ import type { Method } from "../../model-editor/method";
 import { createEmptyModeledMethod } from "../../model-editor/modeled-method-empty";
 import type { Mutable } from "../../common/mutable";
 import { ReadonlyDropdown } from "../common/ReadonlyDropdown";
-import { QueryLanguage } from "../../common/query-language";
+import type { QueryLanguage } from "../../common/query-language";
+import type { ModelsAsDataLanguagePredicates } from "../../model-editor/languages";
 import { getModelsAsDataLanguage } from "../../model-editor/languages";
 import type { ModelingStatus } from "../../model-editor/shared/modeling-status";
 import { InputDropdown } from "./InputDropdown";
@@ -25,6 +26,16 @@ type Props = {
   onChange: (modeledMethod: ModeledMethod) => void;
 };
 
+const typeLabels: Record<keyof ModelsAsDataLanguagePredicates, string> = {
+  source: "Source",
+  sink: "Sink",
+  summary: "Flow summary",
+  neutral: "Neutral",
+  type: "Type",
+};
+
+type Option = { value: ModeledMethodType; label: string };
+
 export const ModelTypeDropdown = ({
   language,
   method,
@@ -33,19 +44,31 @@ export const ModelTypeDropdown = ({
   onChange,
 }: Props): React.JSX.Element => {
   const options = useMemo(() => {
-    const baseOptions: Array<{ value: ModeledMethodType; label: string }> = [
+    const modelsAsDataLanguage = getModelsAsDataLanguage(language);
+
+    const baseOptions: Option[] = [
       { value: "none", label: "Unmodeled" },
-      { value: "source", label: "Source" },
-      { value: "sink", label: "Sink" },
-      { value: "summary", label: "Flow summary" },
-      { value: "neutral", label: "Neutral" },
+      ...Object.entries(modelsAsDataLanguage.predicates)
+        .map(([predicateKey, predicate]): Option | null => {
+          const type = predicateKey as keyof ModelsAsDataLanguagePredicates;
+
+          if (
+            predicate.supportedEndpointTypes &&
+            !predicate.supportedEndpointTypes.includes(method.endpointType)
+          ) {
+            return null;
+          }
+
+          return {
+            value: type,
+            label: typeLabels[type],
+          };
+        })
+        .filter((option): option is Option => option !== null),
     ];
-    if (language === QueryLanguage.Ruby) {
-      baseOptions.push({ value: "type", label: "Type" });
-    }
 
     return baseOptions;
-  }, [language]);
+  }, [language, method.endpointType]);
 
   const handleChange = useCallback(
     (e: ChangeEvent<HTMLSelectElement>) => {