@runtyped/type-compiler 1.0.20-alpha.1

package/src/reflection-ast.ts

@@ -0,0 +1,335 @@
+/*
+ * Runtyped Framework
+ * Copyright (c) Deepkit UG, Marc J. Schmidt
+ * Copyright (c) Jacopo Scazzosi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License.
+ *
+ * You should have received a copy of the MIT License along with this program.
+ */
+
+import ts, {
+    __String,
+    ArrowFunction,
+    BigIntLiteral,
+    BinaryExpression,
+    EntityName,
+    Expression,
+    Identifier,
+    ImportDeclaration,
+    isBigIntLiteral,
+    JSDoc,
+    JSDocImportTag,
+    ModifierLike,
+    Node,
+    NodeArray,
+    NodeFactory,
+    NumericLiteral,
+    PrivateIdentifier,
+    PropertyAccessExpression,
+    PropertyName,
+    QualifiedName,
+    StringLiteral,
+    StringLiteralLike,
+    SymbolTable,
+} from 'typescript';
+import { cloneNode as tsNodeClone, CloneNodeHook } from '@marcj/ts-clone-node';
+import { SourceFile } from './ts-types.js';
+
+const {
+    isArrowFunction,
+    isComputedPropertyName,
+    isIdentifier,
+    isNamedImports,
+    isNumericLiteral,
+    isPrivateIdentifier,
+    isStringLiteral,
+    isStringLiteralLike,
+    setOriginalNode,
+    getLeadingCommentRanges,
+    isNoSubstitutionTemplateLiteral,
+    NodeFlags,
+    SyntaxKind,
+} = ts;
+
+export type PackExpression = Expression | string | number | boolean | bigint;
+
+function is__String(value: any): value is __String {
+    return typeof value === 'string';
+}
+
+export function getIdentifierName(node: Identifier | PrivateIdentifier | StringLiteral | __String): string {
+    if (is__String(node)) return node as string;
+    if (isIdentifier(node) || isPrivateIdentifier(node)) {
+        return ts.unescapeLeadingUnderscores(node.escapedText);
+    }
+    if (isStringLiteral(node)) return node.text;
+    return '';
+}
+
+export function getEscapedText(node: Identifier | PrivateIdentifier | StringLiteral | __String): string {
+    if (is__String(node)) return node as string;
+    if (isIdentifier(node) || isPrivateIdentifier(node)) return node.escapedText as string;
+    return getIdentifierName(node);
+}
+
+export function findSourceFile(node: Node): SourceFile | undefined {
+    if (node.kind === SyntaxKind.SourceFile) return node as SourceFile;
+    let current = node.parent;
+    while (current && current.kind !== SyntaxKind.SourceFile) {
+        current = current.parent;
+    }
+    return current as SourceFile;
+}
+
+export function joinQualifiedName(name: EntityName): string {
+    if (isIdentifier(name)) return getIdentifierName(name);
+    return joinQualifiedName(name.left) + '_' + getIdentifierName(name.right);
+}
+
+export function getCommentOfNode(sourceFile: SourceFile, node: Node): string | undefined {
+    const comment = getLeadingCommentRanges(sourceFile.text, node.pos);
+    if (!comment) return;
+
+    return comment.map(v => sourceFile.text.substring(v.pos, v.end)).join('\n');
+}
+
+export function parseJSDocAttributeFromText(comment: string, attribute: string): string | undefined {
+    // no regex
+    const index = comment.indexOf('@' + attribute + ' ');
+    if (index === -1) {
+        let start = 0;
+        while (true) {
+            const withoutContent = comment.indexOf('@' + attribute, start);
+            if (withoutContent === -1) return undefined;
+            //make sure next character is space or end of comment
+            const nextCharacter = comment[withoutContent + attribute.length + 1];
+            if (!nextCharacter || nextCharacter === ' ' || nextCharacter === '\n' || nextCharacter === '\r' || nextCharacter === '\t') {
+                return '';
+            }
+            start = withoutContent + attribute.length + 1;
+        }
+        return undefined;
+    }
+
+    const start = index + attribute.length + 2;
+    // end is either next attribute @ or end of comment.
+    const nextAttribute = comment.indexOf('@', start);
+    const endOfComment = comment.indexOf('*/', start);
+    const end = nextAttribute === -1 ? endOfComment : Math.min(nextAttribute, endOfComment);
+    const content = comment.substring(start, end).trim();
+
+    // make sure multiline comments are supported, and each line is trimmed and `\s\s\s\*` removed
+    return content.split('\n').map(v => {
+        const indexOfStar = v.indexOf('*');
+        if (indexOfStar === -1) return v.trim();
+        return v.substring(indexOfStar + 1).trim();
+    }).join('\n');
+}
+
+export function extractJSDocAttribute(sourceFile: SourceFile, node: Node | undefined, attribute: string): string | undefined {
+    // in TypeScript 5.3 they made JSDoc parsing optional and disabled by default.
+    // we need to read the comments manually and then parse @{attribute} {value} manually.
+    // we need reference to SourceFile, since Node.getSourceFile() although available in types,
+    // is not available at runtime sometimes (works in tests, but fails with tsc).
+    if (!node) return undefined;
+    const comment = getCommentOfNode(sourceFile, node);
+    if (!comment) return undefined;
+
+    return parseJSDocAttributeFromText(comment, attribute);
+}
+
+export function getPropertyName(f: NodeFactory, node?: PropertyName): string | symbol | number | ArrowFunction {
+    if (!node) return '';
+
+    if (isIdentifier(node)) return getIdentifierName(node);
+    if (isStringLiteral(node)) return node.text;
+    if (isNumericLiteral(node)) return +node.text;
+    if (isNoSubstitutionTemplateLiteral(node)) return node.text;
+    if (isComputedPropertyName(node)) {
+        return f.createArrowFunction(undefined, undefined, [], undefined, undefined, node.expression);
+    }
+    if (isPrivateIdentifier(node)) return getIdentifierName(node);
+
+    return '';
+}
+
+export function getNameAsString(node?: PropertyName | QualifiedName): string {
+    if (!node) return '';
+    if (isIdentifier(node)) return getIdentifierName(node);
+    if (isStringLiteral(node)) return node.text;
+    if (isNumericLiteral(node)) return node.text;
+    if (isBigIntLiteral(node)) return node.text;
+    if (isNoSubstitutionTemplateLiteral(node)) return node.text;
+    if (isComputedPropertyName(node)) {
+        if (isStringLiteralLike(node) || isNumericLiteral(node)) return (node as StringLiteralLike | NumericLiteral).text;
+        return '';
+    }
+    if (isPrivateIdentifier(node)) return getIdentifierName(node);
+
+    return joinQualifiedName(node);
+}
+
+export function hasModifier(node: Node & { modifiers?: NodeArray<ModifierLike> }, modifier: ts.SyntaxKind): boolean {
+    if (!node.modifiers) return false;
+    return node.modifiers.some(v => v.kind === modifier);
+}
+
+const cloneHook = <T extends Node>(node: T, payload: { depth: number }): CloneNodeHook<T> | undefined => {
+    if (isIdentifier(node)) {
+        //ts-clone-node wants to read `node.text` which does not exist. we hook into it and provide the correct value.
+        return {
+            text: () => {
+                return getIdentifierName(node);
+            },
+        } as any;
+    }
+    return;
+};
+
+export class NodeConverter {
+    constructor(protected f: NodeFactory) {
+    }
+
+    toExpression<T extends PackExpression | PackExpression[]>(node?: T): Expression {
+        if (node === undefined) return this.f.createIdentifier('undefined');
+
+        if (Array.isArray(node)) {
+            return this.f.createArrayLiteralExpression(this.f.createNodeArray(node.map(v => this.toExpression(v))) as NodeArray<Expression>);
+        }
+
+        if ('string' === typeof node) return this.f.createStringLiteral(node, true);
+        if ('number' === typeof node) return this.f.createNumericLiteral(node);
+        if ('bigint' === typeof node) return this.f.createBigIntLiteral(String(node));
+        if ('boolean' === typeof node) return node ? this.f.createTrue() : this.f.createFalse();
+
+        if (node.pos === -1 && node.end === -1 && node.parent === undefined) {
+            if (isArrowFunction(node)) {
+                if (node.body.pos === -1 && node.body.end === -1 && node.body.parent === undefined) return node;
+                return this.f.createArrowFunction(node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, this.toExpression(node.body as Expression));
+            }
+            return node;
+        }
+        switch (node.kind) {
+            case SyntaxKind.Identifier:
+                return finish(node, this.f.createIdentifier(getIdentifierName(node as Identifier)));
+            case SyntaxKind.StringLiteral:
+                return finish(node, this.f.createStringLiteral((node as StringLiteral).text));
+            case SyntaxKind.NumericLiteral:
+                return finish(node, this.f.createNumericLiteral((node as NumericLiteral).text));
+            case SyntaxKind.BigIntLiteral:
+                return finish(node, this.f.createBigIntLiteral((node as BigIntLiteral).text));
+            case SyntaxKind.TrueKeyword:
+                return finish(node, this.f.createTrue());
+            case SyntaxKind.FalseKeyword:
+                return finish(node, this.f.createFalse());
+        }
+
+        //todo: ts-node-clone broke with ts 4.8,
+        // => TypeError: Cannot read properties of undefined (reading 'emitNode')
+        // which is probably due a broken node clone. We need to figure out which node it is
+        // and see what the issue is. since ts-node-clone is not really maintained anymore,
+        // we need to fork it
+        try {
+            return tsNodeClone(node, {
+                preserveComments: false,
+                factory: this.f,
+                setOriginalNodes: true,
+                preserveSymbols: true,
+                setParents: true,
+                hook: cloneHook,
+            }) as Expression;
+        } catch (error) {
+            console.error('could not clone node', node);
+            throw error;
+        }
+
+    }
+}
+
+function isExternalOrCommonJsModule(file: SourceFile): boolean {
+    //both attributes are internal and not yet public
+    return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== undefined;
+}
+
+export function isNodeWithLocals(node: Node): node is (Node & { locals: SymbolTable | undefined }) {
+    return 'locals' in node;
+}
+
+//logic copied from typescript
+export function getGlobalsOfSourceFile(file: SourceFile): SymbolTable | void {
+    if (file.redirectInfo) return;
+    if (!isNodeWithLocals(file)) return;
+    if (!isExternalOrCommonJsModule(file)) return file.locals;
+    if (file.jsGlobalAugmentations) return file.jsGlobalAugmentations;
+    if (file.symbol && file.symbol.globalExports) return file.symbol.globalExports;
+}
+
+/**
+ * For imports that can removed (like a class import only used as type only, like `p: Model[]`) we have
+ * to modify the import so TS does not remove it.
+ */
+export function ensureImportIsEmitted(importDeclaration: ImportDeclaration | JSDocImportTag, specifierName?: Identifier) {
+    if (specifierName && importDeclaration.importClause && importDeclaration.importClause.namedBindings) {
+        // const binding = importDeclaration.importClause.namedBindings;
+        if (isNamedImports(importDeclaration.importClause.namedBindings)) {
+            for (const element of importDeclaration.importClause.namedBindings.elements) {
+                if (element.name.escapedText === specifierName.escapedText) {
+                    (element.flags as any) |= NodeFlags.Synthesized;
+                    return;
+                }
+            }
+        }
+    }
+
+    (importDeclaration.flags as any) |= NodeFlags.Synthesized;
+}
+
+
+/**
+ * Serializes an entity name as an expression for decorator type metadata.
+ *
+ * @param node The entity name to serialize.
+ */
+export function serializeEntityNameAsExpression(f: NodeFactory, node: EntityName): SerializedEntityNameAsExpression {
+    switch (node.kind) {
+        case SyntaxKind.Identifier:
+            return finish(node, f.createIdentifier(getIdentifierName(node)));
+        case SyntaxKind.QualifiedName:
+            return finish(node, serializeQualifiedNameAsExpression(f, node));
+    }
+    return node;
+}
+
+type SerializedEntityNameAsExpression = Identifier | BinaryExpression | PropertyAccessExpression;
+
+/**
+ * Serializes an qualified name as an expression for decorator type metadata.
+ *
+ * @param node The qualified name to serialize.
+ * @param useFallback A value indicating whether to use logical operators to test for the
+ *                    qualified name at runtime.
+ */
+function serializeQualifiedNameAsExpression(f: NodeFactory, node: QualifiedName): SerializedEntityNameAsExpression {
+    return f.createPropertyAccessExpression(serializeEntityNameAsExpression(f, node.left), node.right);
+}
+
+export type MetaNode = Node & {
+    jsDoc?: JSDoc[];
+    _original?: MetaNode;
+    original?: MetaNode;
+    _symbol?: Symbol;
+    symbol?: Symbol;
+    _parent?: MetaNode;
+    localSymbol?: Symbol;
+};
+
+function finish<T extends MetaNode>(oldNode: MetaNode, newNode: T): T {
+    setOriginalNode(newNode, oldNode);
+    newNode._original = newNode.original;
+
+    newNode._symbol = oldNode._symbol ?? oldNode.symbol;
+    newNode.symbol = newNode._symbol;
+    return newNode;
+}

package/src/resolver.ts

@@ -0,0 +1,113 @@
+import micromatch from 'micromatch';
+import {
+    CompilerHost,
+    CompilerOptions,
+    ExportDeclaration,
+    Expression,
+    ImportDeclaration, JSDocImportTag,
+    ResolvedModule,
+    SourceFile,
+    StringLiteral,
+} from 'typescript';
+import ts from 'typescript';
+
+const { createSourceFile, resolveModuleName, isStringLiteral, JSDocParsingMode, ScriptTarget } = ts;
+
+export function patternMatch(path: string, patterns: string[], base?: string): boolean {
+    const include = patterns.filter(pattern => pattern[0] !== '!');
+
+    const exclude = patterns.filter(pattern => pattern[0] === '!').map(pattern => pattern.substring(1));
+
+    return micromatch.isMatch(path, include, {
+        ignore: exclude,
+    });
+}
+
+/**
+ * A utility to resolve a module path and its declaration.
+ *
+ * It automatically reads a SourceFile, binds and caches it.
+ */
+export class Resolver {
+    constructor(
+        public compilerOptions: CompilerOptions,
+        public host: CompilerHost,
+        protected sourceFiles: { [fileName: string]: SourceFile },
+    ) {}
+
+    resolve(from: SourceFile, importOrExportNode: ExportDeclaration | ImportDeclaration | JSDocImportTag): SourceFile | undefined {
+        const moduleSpecifier: Expression | undefined = importOrExportNode.moduleSpecifier;
+        if (!moduleSpecifier) return;
+        if (!isStringLiteral(moduleSpecifier)) return;
+
+        return this.resolveSourceFile(from, moduleSpecifier);
+    }
+
+    protected resolveImpl(modulePath: StringLiteral, sourceFile: SourceFile): ResolvedModule | undefined {
+        if (this.host.resolveModuleNameLiterals !== undefined) {
+            const results = this.host.resolveModuleNameLiterals(
+                [modulePath],
+                sourceFile.fileName,
+                /*reusedNames*/ undefined,
+                this.compilerOptions,
+                sourceFile,
+                undefined,
+            );
+            if (results[0]) return results[0].resolvedModule;
+            return;
+        }
+        if (this.host.resolveModuleNames !== undefined) {
+            return this.host.resolveModuleNames(
+                [modulePath.text],
+                sourceFile.fileName,
+                /*reusedNames*/ undefined,
+                /*redirectedReference*/ undefined,
+                this.compilerOptions,
+            )[0];
+        }
+        const result = resolveModuleName(modulePath.text, sourceFile.fileName, this.compilerOptions, this.host);
+        return result.resolvedModule;
+    }
+
+    /**
+     * Tries to resolve the .ts/d.ts file path for a given module path.
+     * Scans relative paths. Looks into package.json "types" and "exports" (with new 4.7 support)
+     *
+     * @param sourceFile the SourceFile of the file that contains the import. modulePath is relative to that.
+     * @param modulePath the x in 'from x'.
+     */
+    resolveSourceFile(sourceFile: SourceFile, modulePath: StringLiteral): SourceFile | undefined {
+        const result = this.resolveImpl(modulePath, sourceFile);
+        if (!result) return;
+
+        // only .ts, .tsx and .d.ts files are supported
+        if (!result.resolvedFileName.endsWith('.ts')
+            && !result.resolvedFileName.endsWith('.tsx')
+            && !result.resolvedFileName.endsWith('.d.ts')) {
+            return;
+        }
+
+        const fileName = result.resolvedFileName;
+        if (this.sourceFiles[fileName]) return this.sourceFiles[fileName];
+
+        const source = this.host.readFile(result.resolvedFileName);
+        if (!source) return;
+        const moduleSourceFile = (this.sourceFiles[fileName] = createSourceFile(
+            fileName,
+            source,
+            {
+                languageVersion: this.compilerOptions.target || ScriptTarget.ES2018,
+                // JSDocParsingMode is not available in TS < 5.3
+                jsDocParsingMode: JSDocParsingMode ? JSDocParsingMode.ParseNone : undefined,
+            },
+            true,
+        ));
+
+        this.sourceFiles[fileName] = moduleSourceFile;
+
+        //@ts-ignore
+        ts.bindSourceFile(moduleSourceFile, this.compilerOptions);
+
+        return moduleSourceFile;
+    }
+}

package/src/ts-types.ts

@@ -0,0 +1,28 @@
+//Contains types and makes certain properties available that are currently marked as @internal and thus not part of the public TS API.
+//Certain interfaces do not contain all properties/methods from all internal TS types, because we add only those we actually use.
+//This helps to identity which types are actually needed and maybe can be brought up to the TS team as candidates to make them public.
+
+import type { SourceFile as TSSourceFile, ScriptKind, Symbol, SymbolTable, Node } from 'typescript';
+
+/**
+ * Contains @internal properties that are not yet in the public API of TS.
+ */
+export interface SourceFile extends TSSourceFile {
+    /**
+     * If two source files are for the same version of the same package, one will redirect to the other.
+     * (See `createRedirectSourceFile` in program.ts.)
+     * The redirect will have this set. The redirected-to source file will be in `redirectTargetsMap`.
+     */
+    redirectInfo?: any;
+
+    scriptKind?: ScriptKind;
+
+    externalModuleIndicator?: Node;
+    // The first node that causes this file to be a CommonJS module
+    commonJsModuleIndicator?: Node;
+    // JS identifier-declarations that are intended to merge with globals
+    jsGlobalAugmentations?: SymbolTable;
+
+    //part of Node
+    symbol?: Symbol;                       // Symbol declared by node (initialized by binding)
+}

package/tsconfig.esm.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "module": "ES2020",
+    "tsBuildInfoFile": ".esm.tsbuildinfo"
+  },
+  "references": [
+    {
+      "path": "../type-spec/tsconfig.esm.json"
+    },
+    {
+      "path": "../expect/tsconfig.esm.json"
+    }
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "types": [
+      "lz-string",
+      "micromatch",
+      "node"
+    ],
+    "tsBuildInfoFile": ".cjs.tsbuildinfo"
+  },
+  "include": [
+    "src",
+    "tests",
+    "install-transformer.ts",
+    "compiler-debug.ts",
+    "index.ts"
+  ],
+  "references": [
+    {
+      "path": "../type-spec/tsconfig.json"
+    },
+    {
+      "path": "../expect/tsconfig.json"
+    }
+  ]
+}