expo-type-information 0.0.0 → 0.0.2

package/src/typeInformation.ts

@@ -0,0 +1,326 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import {
+  getSwiftFileTypeInformation,
+  preprocessSwiftFile,
+} from './swift/sourcekittenTypeInformation';
+import { taskAll } from './utils';
+
+export enum IdentifierKind {
+  BASIC,
+  ENUM,
+  RECORD,
+  CLASS,
+}
+
+export type ParametrizedType = {
+  name: TypeIdentifier;
+  types: Type[];
+};
+
+export type Argument = { name: string | undefined; type: Type };
+export type Field = Argument;
+
+export type RecordType = {
+  name: string;
+  fields: Field[];
+};
+
+export type EnumCase = string;
+
+export type EnumType = {
+  name: string;
+  cases: EnumCase[];
+};
+
+export type SumType = {
+  types: Type[];
+};
+
+export type DictionaryType = {
+  key: Type;
+  value: Type;
+};
+
+export type OptionalType = Type;
+export type ArrayType = Type;
+export type TypeIdentifier = string;
+export type AnonymousType = ParametrizedType | SumType | OptionalType | DictionaryType | ArrayType;
+
+export enum TypeKind {
+  BASIC,
+  IDENTIFIER,
+  SUM,
+  PARAMETRIZED,
+  OPTIONAL,
+  ARRAY,
+  DICTIONARY,
+}
+
+export enum BasicType {
+  ANY,
+  STRING,
+  NUMBER,
+  BOOLEAN,
+  VOID,
+  UNDEFINED,
+  UNRESOLVED,
+}
+
+export type Type = {
+  kind: TypeKind;
+  type: BasicType | TypeIdentifier | AnonymousType;
+};
+
+export type PropertyDeclaration = ConstantDeclaration;
+export type ViewDeclaration = ModuleClassDeclaration;
+export type EventDeclaration = string;
+
+/**
+ * Retain information of where the thing was defined in the file.
+ * As collecting type information is written in asynchronous way it is non-deterministic.
+ * To make it deterministic we just sort the declaration by the definitionOffset, maintianing the same ordering as in original file.
+ */
+export type DefinitionOffset = {
+  definitionOffset: number;
+};
+
+export type ConstantDeclaration = {
+  name: string;
+  type: Type;
+} & DefinitionOffset;
+
+export type FunctionDeclaration = {
+  name: string;
+  returnType: Type;
+  arguments: Argument[];
+  parameters: Type[];
+} & DefinitionOffset;
+
+export type PropDeclaration = {
+  name: string;
+  arguments: Argument[];
+} & DefinitionOffset;
+
+export type ConstructorDeclaration = {
+  arguments: Argument[];
+} & DefinitionOffset;
+
+export type ClassDeclaration = {
+  name: string;
+  constructor: ConstructorDeclaration | null;
+  methods: FunctionDeclaration[];
+  asyncMethods: FunctionDeclaration[];
+  properties: PropertyDeclaration[];
+} & DefinitionOffset;
+
+export type ModuleClassDeclaration = {
+  name: string;
+  constructor: ConstructorDeclaration | null;
+  constants: ConstantDeclaration[];
+  classes: ClassDeclaration[];
+  functions: FunctionDeclaration[];
+  asyncFunctions: FunctionDeclaration[];
+  properties: PropertyDeclaration[];
+  props: PropDeclaration[];
+  views: ViewDeclaration[];
+  events: EventDeclaration[];
+} & DefinitionOffset;
+
+export type IdentifierDefinition = {
+  kind: IdentifierKind;
+  definition: string | RecordType | EnumType | ClassDeclaration;
+};
+
+export type TypeIdentifierDefinitionMap = Map<string, IdentifierDefinition>;
+
+export type TypeIdentifierDefinitionList = [string, IdentifierDefinition][];
+
+export type FileTypeInformationSerialized = {
+  usedTypeIdentifiersList: string[];
+  declaredTypeIdentifiersList: string[];
+  inferredTypeParametersCountList: [string, number][];
+  typeIdentifierDefinitionList: TypeIdentifierDefinitionList;
+  moduleClasses: ModuleClassDeclaration[];
+  records: RecordType[];
+  enums: EnumType[];
+};
+
+/**
+ * FileTypeInformation object abstracts over type related information in a file.
+ * The abstraction is closely related to Typescript and expo NativeModules (both to be independent of the actual native side
+ * and to give accurate information about what and how we can use the given module).
+ */
+export type FileTypeInformation = {
+  /**
+   * @field Set of all type identifiers declared and used in the file.
+   */
+  usedTypeIdentifiers: Set<string>;
+  /**
+   * @field Set of all type identifiers declared in the file.
+   */
+  declaredTypeIdentifiers: Set<string>;
+  /**
+   * @field For parametrized types it is the maximum number of parameters this type is used with.
+   * This map is useful if we want to infer how many parameters a type declared in other file has.
+   *
+   * For example if `Set<string>` exists in a file then inferredTypeParametersCount['Set'] == 1.
+   * If `Map<number, string>` exists then inferredTypeParametersCount['Map'] == 2.
+   * If you use both `SomeParametrizedType<Type1, Type2>` and `SomeParametrizedType<Type3>` then inferredTypeParametersCount['SomeParametrizedType'] == 2.
+   */
+  inferredTypeParametersCount: Map<string, number>;
+  /**
+   * @field Maps string identifier to the appropriate declaration object. For now only enum and records identifiers are mapped.
+   */
+  typeIdentifierDefinitionMap: TypeIdentifierDefinitionMap;
+  /**
+   * @field Array of all module classes declared in the given file.
+   */
+  moduleClasses: ModuleClassDeclaration[];
+  /**
+   * @field Array of all record classes declared in the given file.
+   */
+  records: RecordType[];
+  /**
+   * @field Array of all enums declared in the given file.
+   */
+  enums: EnumType[];
+};
+
+/**
+ * Used for testing purposes, maps Sets and Maps to Arrays and returns FileTypeInformationSerialized object which can be written to a JSON.
+ * @param param0 FileTypeInformation object to serialize.
+ * @returns FileTypeInformationSerialized object.
+ */
+export function serializeTypeInformation({
+  usedTypeIdentifiers,
+  declaredTypeIdentifiers,
+  inferredTypeParametersCount,
+  typeIdentifierDefinitionMap,
+  moduleClasses,
+  records,
+  enums,
+}: FileTypeInformation): FileTypeInformationSerialized {
+  return {
+    usedTypeIdentifiersList: [...usedTypeIdentifiers.keys()].sort(),
+    declaredTypeIdentifiersList: [...declaredTypeIdentifiers.keys()].sort(),
+    inferredTypeParametersCountList: [...inferredTypeParametersCount.entries()].sort(),
+    typeIdentifierDefinitionList: [...typeIdentifierDefinitionMap.entries()].sort(),
+    moduleClasses,
+    records,
+    enums,
+  };
+}
+
+/**
+ * Used for testing purposes, maps Arrays to Sets and Maps depending on the field and returns FileTypeInformation object.
+ * @param param0 FileTypeInformationSerialized object to deserialize.
+ * @returns FileTypeInformation object.
+ */
+export function deserializeTypeInformation({
+  usedTypeIdentifiersList,
+  declaredTypeIdentifiersList,
+  inferredTypeParametersCountList,
+  typeIdentifierDefinitionList,
+  moduleClasses,
+  records,
+  enums,
+}: FileTypeInformationSerialized): FileTypeInformation {
+  return {
+    usedTypeIdentifiers: new Set<string>(usedTypeIdentifiersList),
+    declaredTypeIdentifiers: new Set<string>(declaredTypeIdentifiersList),
+    inferredTypeParametersCount: new Map<string, number>(inferredTypeParametersCountList),
+    typeIdentifierDefinitionMap: new Map(typeIdentifierDefinitionList),
+    moduleClasses,
+    records,
+    enums,
+  };
+}
+
+/**
+ * Defines the level of type inference to apply when extracting type information.
+ * Note: In case where type inference is on, it may take more then twice the time to compute the type information.
+ */
+export enum TypeInferenceOption {
+  /** No type inference will be performed. */
+  NO_INFERENCE,
+  /** Basic type inference will be applied. */
+  SIMPLE_INFERENCE,
+  /** Preprocesses the file by injecting returns to extract more type info from sourcekitten. */
+  PREPROCESS_AND_INFERENCE,
+}
+
+export type StringInputOption = {
+  type: 'string';
+  fileContent: string;
+  language: 'Swift';
+};
+
+export type FileInputOption = {
+  type: 'file';
+  inputFileAbsolutePaths: string[];
+};
+
+/**
+ * Options specifying the input source and inference level for retrieving type information.
+ */
+export type GetFileTypeInformationOptions = {
+  /** The input source, provided either as a direct string or a file path. */
+  input: StringInputOption | FileInputOption;
+  /** The desired level of type inference. Defaults to PREPROCESS_AND_INFERENCE if omitted. */
+  typeInference?: TypeInferenceOption;
+};
+
+async function mergeFileContents(absoluteFilePaths: string[]): Promise<string> {
+  const filesContents = await taskAll(absoluteFilePaths, (filePath) =>
+    fs.promises.readFile(filePath, 'utf-8')
+  );
+  return filesContents.join('');
+}
+
+async function withTempFile<T>(content: string, fn: (filePath: string) => Promise<T>): Promise<T> {
+  const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'type-gen-'));
+  const filePath = path.join(tempDir, 'TypeInformationTemporaryFile.swift');
+
+  try {
+    await fs.promises.writeFile(filePath, content, 'utf8');
+    return await fn(filePath);
+  } finally {
+    await fs.promises.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Reads and extracts `FileTypeInformation` from either a provided file path or a raw string of source code.
+ * If a raw string is provided, or if the `PREPROCESS_AND_INFERENCE` inference option is selected,
+ * the function will create a temporary file with the (optionally preprocessed) content to facilitate parsing.
+ * @param options - Configuration object containing the input source (file or string) and the desired level of type inference.
+ * @returns A promise that resolves to a `FileTypeInformation` object if the input was parsed successfully. Otherwise, it returns `null`.
+ */
+export async function getFileTypeInformation({
+  input,
+  typeInference,
+}: GetFileTypeInformationOptions): Promise<FileTypeInformation | null> {
+  const shouldPreprocessFile = typeInference === TypeInferenceOption.PREPROCESS_AND_INFERENCE;
+  const typeInferenceOn = typeInference !== TypeInferenceOption.NO_INFERENCE;
+  if (!shouldPreprocessFile && input.type === 'file' && input.inputFileAbsolutePaths.length === 0) {
+    return getSwiftFileTypeInformation(input.inputFileAbsolutePaths[0] as string, {
+      typeInference: typeInferenceOn,
+    });
+  }
+
+  const fileContent =
+    input.type === 'file'
+      ? await mergeFileContents(input.inputFileAbsolutePaths)
+      : input.fileContent;
+
+  const preprocessedContent = shouldPreprocessFile ? preprocessSwiftFile(fileContent) : fileContent;
+
+  return withTempFile(preprocessedContent, async (tempFilePath) => {
+    return getSwiftFileTypeInformation(tempFilePath, {
+      typeInference: typeInferenceOn,
+    });
+  });
+}

package/src/types.ts

@@ -0,0 +1,68 @@
+export type FileType = {
+  path: string;
+  content: string;
+};
+
+export type Attribute = {
+  'key.attribute': string;
+  'key.length': number;
+  'key.offset': number;
+};
+
+export type Structure = {
+  'key.substructure': Structure[];
+  'key.typename': string;
+  'key.name': string;
+  'key.kind': string;
+  'key.offset': number;
+  'key.length': number;
+  'key.nameoffset': number;
+  'key.inheritedtypes': { 'key.name': string }[];
+  'key.attributes': Attribute[];
+};
+
+export type CursorInfoOutput = {
+  'key.fully_annotated_decl': string;
+  'key.annotated_decl': string;
+};
+
+export type FullyAnnotatedDecl = {
+  'decl.function.free': {
+    'decl.var.parameter': {
+      'decl.var.parameter.argument_label': string;
+      'decl.var.parameter.type': string;
+    }[];
+    'decl.function.returntype': string;
+  };
+};
+
+export type ClosureTypes = {
+  parameters: {
+    name: any;
+    typename: any;
+  }[];
+  returnType: any;
+};
+
+export type Closure = {
+  name: string;
+  types: ClosureTypes | null;
+};
+
+export type Prop = {
+  name: string;
+  types: Omit<ClosureTypes, 'returnType'>;
+};
+
+export type OutputModuleDefinition = {
+  name: string;
+  views: OutputNestedClassDefinition[];
+  classes: OutputNestedClassDefinition[];
+  events: {
+    name: string;
+  }[];
+} & Record<'asyncFunctions' | 'functions' | 'properties', Closure[]> &
+  Record<'props', Prop[]>;
+
+// views and classes are a very similar structure, same as module but without more nesting levels
+export type OutputNestedClassDefinition = Omit<OutputModuleDefinition, 'views' | 'classes'>;