nitrogen 0.2.24 → 0.29.5

package/src/syntax/c++/CppStruct.ts

@@ -0,0 +1,129 @@
+import type { FileWithReferencedTypes } from '../SourceFile.js'
+import { indent } from '../../utils.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
+import type { NamedType } from '../types/Type.js'
+import { includeHeader, includeNitroHeader } from './includeNitroHeader.js'
+import { NitroConfig } from '../../config/NitroConfig.js'
+import type { GetFunctionCodeOptions } from '../types/FunctionType.js'
+
+export function createCppStruct(
+  typename: string,
+  properties: NamedType[]
+): FileWithReferencedTypes {
+  // Namespace typename
+  const fullyQualifiedTypename = NitroConfig.current.getCxxNamespace(
+    'c++',
+    typename
+  )
+  // Get C++ code for all struct members
+  const cppStructProps = properties
+    .map((p) => `${p.getCode('c++')} ${p.escapedName}     SWIFT_PRIVATE;`)
+    .join('\n')
+  const cppConstructorParams = properties
+    .map((p) => `${p.getCode('c++')} ${p.escapedName}`)
+    .join(', ')
+  const cppInitializerParams = properties
+    .map((p) => `${p.escapedName}(${p.escapedName})`)
+    .join(', ')
+  // Get C++ code for converting each member from a jsi::Value
+  const codeOptions: GetFunctionCodeOptions = {
+    fullyQualified: true,
+    includeNameInfo: false,
+  }
+  const cppFromJsiParams = properties
+    .map(
+      (p) =>
+        `JSIConverter<${p.getCode('c++', codeOptions)}>::fromJSI(runtime, obj.getProperty(runtime, "${p.name}"))`
+    )
+    .join(',\n')
+  // Get C++ code for converting each member to a jsi::Value
+  const cppToJsiCalls = properties
+    .map(
+      (p) =>
+        `obj.setProperty(runtime, "${p.name}", JSIConverter<${p.getCode('c++', codeOptions)}>::toJSI(runtime, arg.${p.escapedName}));`
+    )
+    .join('\n')
+  // Get C++ code for verifying if jsi::Value can be converted to type
+  const cppCanConvertCalls = properties
+    .map(
+      (p) =>
+        `if (!JSIConverter<${p.getCode('c++', codeOptions)}>::canConvert(runtime, obj.getProperty(runtime, "${p.name}"))) return false;`
+    )
+    .join('\n')
+
+  // Get C++ includes for each extra-file we need to include
+  const includedTypes = properties.flatMap((r) => r.getRequiredImports('c++'))
+  const cppForwardDeclarations = includedTypes
+    .map((i) => i.forwardDeclaration)
+    .filter((v) => v != null)
+    .filter(isNotDuplicate)
+  const cppExtraIncludes = includedTypes
+    .map((i) => includeHeader(i))
+    .filter(isNotDuplicate)
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+
+  const cppCode = `
+${createFileMetadataString(`${typename}.hpp`)}
+
+#pragma once
+
+${includeNitroHeader('JSIConverter.hpp')}
+${includeNitroHeader('NitroDefines.hpp')}
+
+${cppForwardDeclarations.join('\n')}
+
+${cppExtraIncludes.join('\n')}
+
+namespace ${cxxNamespace} {
+
+  /**
+   * A struct which can be represented as a JavaScript object (${typename}).
+   */
+  struct ${typename} {
+  public:
+    ${indent(cppStructProps, '    ')}
+
+  public:
+    ${typename}() = default;
+    explicit ${typename}(${cppConstructorParams}): ${cppInitializerParams} {}
+  };
+
+} // namespace ${cxxNamespace}
+
+namespace margelo::nitro {
+
+  // C++ ${typename} <> JS ${typename} (object)
+  template <>
+  struct JSIConverter<${fullyQualifiedTypename}> final {
+    static inline ${fullyQualifiedTypename} fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return ${fullyQualifiedTypename}(
+        ${indent(cppFromJsiParams, '        ')}
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const ${fullyQualifiedTypename}& arg) {
+      jsi::Object obj(runtime);
+      ${indent(cppToJsiCalls, '      ')}
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      ${indent(cppCanConvertCalls, '      ')}
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
+  `
+  return {
+    content: cppCode,
+    name: `${typename}.hpp`,
+    subdirectory: [],
+    language: 'c++',
+    referencedTypes: properties,
+    platform: 'shared',
+  }
+}

package/src/syntax/c++/CppUnion.ts

@@ -0,0 +1,105 @@
+import type { SourceFile } from '../SourceFile.js'
+import { createFileMetadataString } from './../helpers.js'
+import { indent, toLowerCamelCase } from '../../utils.js'
+import type { EnumMember } from '../types/EnumType.js'
+import { includeNitroHeader } from './includeNitroHeader.js'
+import { NitroConfig } from '../../config/NitroConfig.js'
+
+/**
+ * Creates a C++ enum that converts to a TypeScript union (aka just strings).
+ */
+export function createCppUnion(
+  typename: string,
+  enumMembers: EnumMember[]
+): SourceFile {
+  // Namespace typename
+  const fullyQualifiedTypename = NitroConfig.current.getCxxNamespace(
+    'c++',
+    typename
+  )
+  const cppEnumMembers = enumMembers
+    .map(
+      (m, i) => `${m.name}      SWIFT_NAME(${toLowerCamelCase(m.name)}) = ${i},`
+    )
+    .join('\n')
+  const cppFromJsiHashCases = enumMembers
+    .map((v) =>
+      `case hashString("${v.stringValue}"): return ${fullyQualifiedTypename}::${v.name};`.trim()
+    )
+    .join('\n')
+  const cppToJsiCases = enumMembers
+    .map(
+      (v) =>
+        `case ${fullyQualifiedTypename}::${v.name}: return JSIConverter<std::string>::toJSI(runtime, "${v.stringValue}");`
+    )
+    .join('\n')
+  const cppCanConvertCases = enumMembers
+    .map((m) => `case hashString("${m.stringValue}"):`)
+    .join('\n')
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+
+  const cppCode = `
+${createFileMetadataString(`${typename}.hpp`)}
+
+#pragma once
+
+${includeNitroHeader('NitroHash.hpp')}
+${includeNitroHeader('JSIConverter.hpp')}
+${includeNitroHeader('NitroDefines.hpp')}
+
+namespace ${cxxNamespace} {
+
+  /**
+   * An enum which can be represented as a JavaScript union (${typename}).
+   */
+  enum class ${typename} {
+    ${indent(cppEnumMembers, '    ')}
+  } CLOSED_ENUM;
+
+} // namespace ${cxxNamespace}
+
+namespace margelo::nitro {
+
+  // C++ ${typename} <> JS ${typename} (union)
+  template <>
+  struct JSIConverter<${fullyQualifiedTypename}> final {
+    static inline ${fullyQualifiedTypename} fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        ${indent(cppFromJsiHashCases, '        ')}
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \\"" + unionValue + "\\" to enum ${typename} - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, ${fullyQualifiedTypename} arg) {
+      switch (arg) {
+        ${indent(cppToJsiCases, '        ')}
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert ${typename} to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        ${indent(cppCanConvertCases, '        ')}
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro
+          `
+  return {
+    content: cppCode,
+    name: `${typename}.hpp`,
+    subdirectory: [],
+    language: 'c++',
+    platform: 'shared',
+  }
+}

package/src/syntax/c++/getForwardDeclaration.ts

@@ -0,0 +1,19 @@
+type DeclarationKind = 'class' | 'struct' | 'enum class'
+
+export function getForwardDeclaration(
+  kind: DeclarationKind,
+  className: string,
+  namespace?: string
+): string {
+  if (namespace != null) {
+    return `
+// Forward declaration of \`${className}\` to properly resolve imports.
+namespace ${namespace} { ${kind} ${className}; }
+  `.trim()
+  } else {
+    return `
+// Forward declaration of \`${className}\` to properly resolve imports.
+${kind} ${className};
+    `.trim()
+  }
+}

package/src/syntax/c++/includeNitroHeader.ts

@@ -0,0 +1,40 @@
+import type { SourceImport } from '../SourceFile.js'
+
+/**
+ * Generates C++ code for including a `NitroModules` header.
+ * @example `Hash.hpp` -> `#include <NitroModules/Hash.hpp>`
+ */
+export function includeNitroHeader(headerName: string): string {
+  return `
+#if __has_include(<NitroModules/${headerName}>)
+#include <NitroModules/${headerName}>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+  `.trim()
+}
+
+export function includeHeader(
+  sourceImport: SourceImport,
+  force = true
+): string {
+  const header = getHeader(sourceImport.name, sourceImport.space)
+  if (force) {
+    return `#include ${header}`
+  } else {
+    return `
+#if __has_include(${header})
+ #include ${header}
+#endif
+    `.trim()
+  }
+}
+
+function getHeader(name: string, space: 'user' | 'system'): string {
+  switch (space) {
+    case 'user':
+      return `"${name}"`
+    case 'system':
+      return `<${name}>`
+  }
+}

package/src/syntax/createType.ts

@@ -0,0 +1,365 @@
+import { ts, Type as TSMorphType, type Signature } from 'ts-morph'
+import type { Type } from './types/Type.js'
+import { NullType } from './types/NullType.js'
+import { BooleanType } from './types/BooleanType.js'
+import { NumberType } from './types/NumberType.js'
+import { StringType } from './types/StringType.js'
+import { BigIntType } from './types/BigIntType.js'
+import { VoidType } from './types/VoidType.js'
+import { ArrayType } from './types/ArrayType.js'
+import { FunctionType } from './types/FunctionType.js'
+import { PromiseType } from './types/PromiseType.js'
+import { RecordType } from './types/RecordType.js'
+import { ArrayBufferType } from './types/ArrayBufferType.js'
+import { EnumType } from './types/EnumType.js'
+import { HybridObjectType } from './types/HybridObjectType.js'
+import { StructType } from './types/StructType.js'
+import { OptionalType } from './types/OptionalType.js'
+import { NamedWrappingType } from './types/NamedWrappingType.js'
+import { getInterfaceProperties } from './getInterfaceProperties.js'
+import { VariantType } from './types/VariantType.js'
+import { MapType } from './types/MapType.js'
+import { TupleType } from './types/TupleType.js'
+import {
+  isAnyHybridSubclass,
+  isDirectlyHybridObject,
+  isHybridView,
+  type Language,
+} from '../getPlatformSpecs.js'
+import { HybridObjectBaseType } from './types/HybridObjectBaseType.js'
+import { ErrorType } from './types/ErrorType.js'
+import { getBaseTypes, getHybridObjectNitroModuleConfig } from '../utils.js'
+import { DateType } from './types/DateType.js'
+import { NitroConfig } from '../config/NitroConfig.js'
+import { CustomType } from './types/CustomType.js'
+import {
+  isSyncFunction,
+  isArrayBuffer,
+  isCustomType,
+  isDate,
+  isError,
+  isMap,
+  isPromise,
+  isRecord,
+} from './isCoreType.js'
+import { getCustomTypeConfig } from './getCustomTypeConfig.js'
+
+function getHybridObjectName(type: TSMorphType): string {
+  const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol()
+  if (symbol == null) {
+    throw new Error(
+      `Cannot get name of \`${type.getText()}\` - symbol not found!`
+    )
+  }
+  return symbol.getEscapedName()
+}
+
+function getFunctionCallSignature(func: TSMorphType): Signature {
+  const callSignatures = func.getCallSignatures()
+  const callSignature = callSignatures[0]
+  if (callSignatures.length !== 1 || callSignature == null) {
+    throw new Error(
+      `Function overloads are not supported in Nitrogen! (in ${func.getText()})`
+    )
+  }
+  return callSignature
+}
+
+function removeDuplicates(types: Type[]): Type[] {
+  return types.filter((t1, index, array) => {
+    const firstIndexOfType = array.findIndex(
+      (t2) => t1.getCode('c++') === t2.getCode('c++')
+    )
+    return firstIndexOfType === index
+  })
+}
+
+type Tuple<
+  T,
+  N extends number,
+  R extends unknown[] = [],
+> = R['length'] extends N ? R : Tuple<T, N, [T, ...R]>
+function getArguments<N extends number>(
+  type: TSMorphType,
+  typename: string,
+  count: N
+): Tuple<TSMorphType<ts.Type>, N> {
+  const typeArguments = type.getTypeArguments()
+  if (typeArguments.length === count) {
+    return typeArguments as Tuple<TSMorphType<ts.Type>, N>
+  }
+
+  const aliasTypeArguments = type.getAliasTypeArguments()
+  if (aliasTypeArguments.length === count) {
+    return aliasTypeArguments as Tuple<TSMorphType<ts.Type>, N>
+  }
+
+  throw new Error(
+    `Type ${type.getText()} looks like a ${typename}, but has ${typeArguments.length} or ${aliasTypeArguments.length} type arguments instead of ${count}!`
+  )
+}
+
+export function createNamedType(
+  language: Language,
+  name: string,
+  type: TSMorphType,
+  isOptional: boolean
+) {
+  if (name.startsWith('__')) {
+    throw new Error(
+      `Name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${type.getText()})`
+    )
+  }
+  return new NamedWrappingType(name, createType(language, type, isOptional))
+}
+
+export function createVoidType(): Type {
+  return new VoidType()
+}
+
+// Caches complex types (types that have a symbol)
+type TypeId = string
+const knownTypes: Record<Language, Map<TypeId, Type>> = {
+  'c++': new Map<TypeId, Type>(),
+  'swift': new Map<TypeId, Type>(),
+  'kotlin': new Map<TypeId, Type>(),
+}
+
+/**
+ * Get a list of all currently known complex types.
+ */
+export function getAllKnownTypes(language?: Language): Type[] {
+  if (language != null) {
+    // Get types for the given language
+    return Array.from(knownTypes[language].values())
+  } else {
+    // Get types for all languages alltogether
+    const allMaps = Object.values(knownTypes)
+    return allMaps.flatMap((m) => Array.from(m.values()))
+  }
+}
+
+function getTypeId(type: TSMorphType, isOptional: boolean): string {
+  const symbol = type.getSymbol()
+  let key = type.getText()
+  if (symbol != null) {
+    key += '_' + symbol.getFullyQualifiedName()
+  }
+  if (isOptional) key += '?'
+  return key
+}
+
+export function addKnownType(
+  key: string,
+  type: Type,
+  language: Language
+): void {
+  if (knownTypes[language].has(key)) {
+    // type is already known
+    return
+  }
+  knownTypes[language].set(key, type)
+}
+
+/**
+ * Create a new type (or return it from cache if it is already known)
+ */
+export function createType(
+  language: Language,
+  type: TSMorphType,
+  isOptional: boolean
+): Type {
+  const key = getTypeId(type, isOptional)
+  if (key != null && knownTypes[language].has(key)) {
+    const known = knownTypes[language].get(key)!
+    if (isOptional === known instanceof OptionalType) {
+      return known
+    }
+  }
+
+  const get = () => {
+    if (isOptional) {
+      const wrapping = createType(language, type, false)
+      return new OptionalType(wrapping)
+    }
+
+    if (type.isNull() || type.isUndefined()) {
+      return new NullType()
+    } else if (type.isBoolean() || type.isBooleanLiteral()) {
+      return new BooleanType()
+    } else if (type.isNumber() || type.isNumberLiteral()) {
+      if (type.isEnumLiteral()) {
+        // enum literals are technically just numbers - but we treat them differently in C++.
+        return createType(language, type.getBaseTypeOfLiteralType(), isOptional)
+      }
+      return new NumberType()
+    } else if (type.isString()) {
+      return new StringType()
+    } else if (type.isBigInt() || type.isBigIntLiteral()) {
+      return new BigIntType()
+    } else if (type.isVoid()) {
+      return new VoidType()
+    } else if (type.isArray()) {
+      const arrayElementType = type.getArrayElementTypeOrThrow()
+      const elementType = createType(language, arrayElementType, false)
+      return new ArrayType(elementType)
+    } else if (type.isTuple()) {
+      const itemTypes = type
+        .getTupleElements()
+        .map((t) => createType(language, t, t.isNullable()))
+      return new TupleType(itemTypes)
+    } else if (type.getCallSignatures().length > 0) {
+      // It's a function!
+      const callSignature = getFunctionCallSignature(type)
+      const funcReturnType = callSignature.getReturnType()
+      const returnType = createType(
+        language,
+        funcReturnType,
+        funcReturnType.isNullable()
+      )
+      const parameters = callSignature.getParameters().map((p) => {
+        const declaration = p.getValueDeclarationOrThrow()
+        const parameterType = p.getTypeAtLocation(declaration)
+        const isNullable = parameterType.isNullable() || p.isOptional()
+        return createNamedType(language, p.getName(), parameterType, isNullable)
+      })
+      const isSync = isSyncFunction(type)
+      return new FunctionType(returnType, parameters, isSync)
+    } else if (isPromise(type)) {
+      // It's a Promise!
+      const [promiseResolvingType] = getArguments(type, 'Promise', 1)
+      const resolvingType = createType(
+        language,
+        promiseResolvingType,
+        promiseResolvingType.isNullable()
+      )
+      return new PromiseType(resolvingType)
+    } else if (isRecord(type)) {
+      // Record<K, V> -> unordered_map<K, V>
+      const [keyTypeT, valueTypeT] = getArguments(type, 'Record', 2)
+      const keyType = createType(language, keyTypeT, false)
+      const valueType = createType(language, valueTypeT, false)
+      return new RecordType(keyType, valueType)
+    } else if (isArrayBuffer(type)) {
+      // ArrayBuffer
+      return new ArrayBufferType()
+    } else if (isMap(type)) {
+      // Map
+      return new MapType()
+    } else if (isDate(type)) {
+      // Date
+      return new DateType()
+    } else if (isError(type)) {
+      // Error
+      return new ErrorType()
+    } else if (isCustomType(type)) {
+      // Custom C++ type (manually written)
+      const { name, config } = getCustomTypeConfig(type)
+      return new CustomType(name, config)
+    } else if (type.isEnum()) {
+      // It is an enum. We need to generate a C++ declaration for the enum
+      const typename = type.getSymbolOrThrow().getEscapedName()
+      const declaration = type.getSymbolOrThrow().getValueDeclarationOrThrow()
+      const enumDeclaration = declaration.asKindOrThrow(
+        ts.SyntaxKind.EnumDeclaration
+      )
+      return new EnumType(typename, enumDeclaration)
+    } else if (type.isUnion()) {
+      // It is some kind of union;
+      // - of string literals (then it's an enum)
+      // - of type `T | undefined` (then it's just optional `T`)
+      // - of different types (then it's a variant `A | B | C`)
+      const types = type.getUnionTypes()
+      const nonNullTypes = types.filter(
+        (t) => !t.isNull() && !t.isUndefined() && !t.isVoid()
+      )
+      const isEnumUnion = nonNullTypes.every((t) => t.isStringLiteral())
+      if (isEnumUnion) {
+        // It consists only of string literaly - that means it's describing an enum!
+        const symbol = type.getNonNullableType().getAliasSymbol()
+        if (symbol == null) {
+          // If there is no alias, it is an inline union instead of a separate type declaration!
+          throw new Error(
+            `Inline union types ("${type.getText()}") are not supported by Nitrogen!\n` +
+              `Extract the union to a separate type, and re-run nitrogen!`
+          )
+        }
+        const typename = symbol.getEscapedName()
+        return new EnumType(typename, type)
+      } else {
+        // It consists of different types - that means it's a variant!
+        let variants = type
+          .getUnionTypes()
+          // Filter out any nulls or undefineds, as those are already treated as `isOptional`.
+          .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
+          .map((t) => createType(language, t, false))
+        variants = removeDuplicates(variants)
+
+        if (variants.length === 1) {
+          // It's just one type with undefined/null variant(s) - so we treat it like a simple optional.
+          return variants[0]!
+        }
+
+        const name = type.getAliasSymbol()?.getName()
+        return new VariantType(variants, name)
+      }
+    } else if (isAnyHybridSubclass(type)) {
+      // It is another HybridObject being referenced!
+      const typename = getHybridObjectName(type)
+      const baseTypes = getBaseTypes(type)
+        .filter((t) => isAnyHybridSubclass(t))
+        .map((b) => createType(language, b, false))
+      const baseHybrids = baseTypes.filter((b) => b instanceof HybridObjectType)
+      const sourceConfig =
+        getHybridObjectNitroModuleConfig(type) ?? NitroConfig.current
+      return new HybridObjectType(typename, language, baseHybrids, sourceConfig)
+    } else if (isDirectlyHybridObject(type)) {
+      // It is a HybridObject directly/literally. Base type
+      return new HybridObjectBaseType()
+    } else if (type.isInterface()) {
+      // It is an `interface T { ... }`, which is a `struct`
+      const typename = type.getSymbolOrThrow().getName()
+      const properties = getInterfaceProperties(language, type)
+      return new StructType(typename, properties)
+    } else if (type.isObject()) {
+      // It is an object. If it has a symbol/name, it is a `type T = ...` declaration, so a `struct`.
+      // Otherwise, it is an anonymous/inline object, which cannot be represented in native.
+      const symbol = type.getAliasSymbol()
+      if (symbol != null) {
+        // it has a `type T = ...` declaration
+        const typename = symbol.getName()
+        const properties = getInterfaceProperties(language, type)
+        return new StructType(typename, properties)
+      } else {
+        // It's an anonymous object (`{ ... }`)
+        throw new Error(
+          `Anonymous objects cannot be represented in C++! Extract "${type.getText()}" to a separate interface/type declaration.`
+        )
+      }
+    } else if (type.isStringLiteral()) {
+      throw new Error(
+        `String literal ${type.getText()} cannot be represented in C++ because it is ambiguous between a string and a discriminating union enum.`
+      )
+    } else {
+      if (type.getSymbol() == null) {
+        // There is no declaration for it!
+        // Could be an invalid import, e.g. an alias
+        throw new Error(
+          `The TypeScript type "${type.getText()}" cannot be resolved - is it imported properly? ` +
+            `Make sure to import it properly using fully specified relative or absolute imports, no aliases.`
+        )
+      } else {
+        // A different error
+        throw new Error(
+          `The TypeScript type "${type.getText()}" cannot be represented in C++!`
+        )
+      }
+    }
+  }
+
+  const result = get()
+  if (key != null) {
+    knownTypes[language].set(key, result)
+  }
+  return result
+}

package/src/syntax/getAllTypes.ts

@@ -0,0 +1,18 @@
+import type { HybridObjectSpec } from './HybridObjectSpec.js'
+import type { Type } from './types/Type.js'
+
+// TODO: Structs or other HybridObjects may reference other types recursively - we need to add a `referencedTypes` prop to each `Type` to be able to resolve that.
+export function getAllTypes(spec: HybridObjectSpec): Type[] {
+  const types: Type[] = []
+
+  // 1. Properties
+  types.push(...spec.properties.map((p) => p.type))
+
+  // 2. Method return types
+  types.push(...spec.methods.map((m) => m.returnType))
+
+  // 3. Method parameters
+  types.push(...spec.methods.flatMap((m) => m.parameters.map((p) => p.type)))
+
+  return types
+}