tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/transformers/emit-resolver.d.ts

@@ -0,0 +1,61 @@
+import { Identifier, type EntityName, type Node, SourceFile } from '../ast.js';
+import type { CompilerOptions } from '../options.js';
+import type { Evaluation, ReferenceResolver } from './reference-resolver.js';
+import { type TypeReferenceSerializationKind } from './type-serialization.js';
+export declare abstract class EmitResolver {
+    /** Called once per file before the alias queries. */
+    abstract markLinkedReferences(file: SourceFile): boolean;
+    /** Whether an import (clause, namespace import, specifier or `import =`) is referenced as a value. */
+    abstract isReferencedAliasDeclaration(node: Node): boolean;
+    /** Whether an export specifier or `export default`/`export =` names a value. */
+    abstract isValueAliasDeclaration(node: Node): boolean;
+    /** Whether `import x = a.b` at the top level names a value. */
+    abstract isTopLevelValueImportEqualsWithEntityName(node: Node): boolean;
+    /** How decorator metadata serializes a reference to `typeName`, resolved from `location`. */
+    abstract getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;
+    /** The source file, namespace or enum exporting what `node` refers to; with `prefixLocals`, also exports with a local name. */
+    abstract getReferencedExportContainer(node: Identifier, prefixLocals: boolean): Node | undefined;
+    /** The import declaring the alias `node` refers to. */
+    abstract getReferencedImportDeclaration(node: Identifier): Node | undefined;
+    abstract getReferencedValueDeclaration(node: Identifier): Node | undefined;
+    abstract getReferencedValueDeclarations(node: Identifier): Node[] | undefined;
+    /** The constant value of an enum member. */
+    abstract getEnumMemberValue(member: Node): Evaluation;
+    /** Records the import a generated name such as the JSX transform's `_jsx` refers to. */
+    abstract setReferencedImportDeclaration(name: Identifier, declaration: Node): void;
+    /** The JSX factory from an `@jsx` pragma or `jsxFactory`, if either is an entity name. */
+    abstract getJsxFactoryEntity(file: SourceFile): EntityName | undefined;
+    /** The JSX fragment factory from an `@jsxFrag` pragma or `jsxFragmentFactory`. */
+    abstract getJsxFragmentFactoryEntity(file: SourceFile): EntityName | undefined;
+    /** The value to inline for a const enum member access such as `E.A`. */
+    abstract getConstantValue(node: Node): Evaluation;
+}
+export declare class SyntacticEmitResolver extends EmitResolver {
+    readonly options: CompilerOptions;
+    readonly referenceResolver: ReferenceResolver;
+    private file;
+    /** Aliases of the current file used as values. */
+    private referenced;
+    /** Imports referenced by generated names. */
+    private readonly generatedImports;
+    constructor(options: CompilerOptions, referenceResolver: ReferenceResolver);
+    markLinkedReferences(file: SourceFile): boolean;
+    private jsxRuntimeResolves;
+    isReferencedAliasDeclaration(node: Node): boolean;
+    /** Whether the alias declared by `node` is used as a value. */
+    private isReferencedAlias;
+    /** Whether the alias declared by `node` resolves to a value; `unresolved` if it doesn't resolve. */
+    private isAliasOfValue;
+    isValueAliasDeclaration(node: Node): boolean;
+    isTopLevelValueImportEqualsWithEntityName(node: Node): boolean;
+    getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;
+    getReferencedExportContainer(node: Identifier, prefixLocals: boolean): Node | undefined;
+    getReferencedImportDeclaration(node: Identifier): Node | undefined;
+    getReferencedValueDeclaration(node: Identifier): Node | undefined;
+    getReferencedValueDeclarations(node: Identifier): Node[] | undefined;
+    getEnumMemberValue(member: Node): Evaluation;
+    getConstantValue(node: Node): Evaluation;
+    setReferencedImportDeclaration(name: Identifier, declaration: Node): void;
+    getJsxFactoryEntity(file: SourceFile): EntityName | undefined;
+    getJsxFragmentFactoryEntity(file: SourceFile): EntityName | undefined;
+}

package/dist/api/compiler/transformers/emit-resolver.js

@@ -0,0 +1,197 @@
+// What emit needs to know about names: which imports are used as values, which exports name
+// values, what identifiers refer to and constant values of enum members. The checker provides
+// the full answers; `SyntacticEmitResolver` answers from syntax and the binder's symbols.
+import { ExportAssignment, ExportSpecifier, Identifier, ImportClause, ImportEqualsDeclaration, ImportSpecifier, NamespaceImport, SourceFile, getSymbol, } from '../ast.js';
+import { parseIsolatedEntityName } from '../parser.js';
+import { getJSXImplicitImportBase, getJSXRuntimeImport } from '../program-utilities.js';
+import { isParseTreeNode } from '../printer/utilities.js';
+import { nodeIsMissing } from '../ast-utilities.js';
+import { AliasReferences } from './alias-references.js';
+import { getTypeReferenceSerializationKind } from './type-serialization.js';
+import { hasSyntacticModifier } from './utilities.js';
+export class EmitResolver {
+}
+export class SyntacticEmitResolver extends EmitResolver {
+    options;
+    referenceResolver;
+    file;
+    /** Aliases of the current file used as values. */
+    referenced;
+    /** Imports referenced by generated names. */
+    generatedImports;
+    constructor(options, referenceResolver) {
+        super();
+        this.options = options;
+        this.referenceResolver = referenceResolver;
+        this.file = undefined;
+        this.referenced = new Set();
+        this.generatedImports = new Map();
+    }
+    markLinkedReferences(file) {
+        if (this.file === file)
+            return false;
+        this.file = file;
+        const marker = new AliasReferences(this.options, this.referenceResolver, jsxNamespace(file, this.options), jsxFragmentNamespace(file, this.options), this.jsxRuntimeResolves(file));
+        marker.markFile(file);
+        this.referenced = marker.referenced;
+        return true;
+    }
+    jsxRuntimeResolves(file) {
+        if (file.scriptKind !== 2 /* ScriptKind.JSX */ && file.scriptKind !== 4 /* ScriptKind.TSX */)
+            return false;
+        const runtime = getJSXRuntimeImport(getJSXImplicitImportBase(this.options, file), this.options);
+        return runtime !== '' && this.referenceResolver.resolveImplicitImport(file, runtime) !== undefined;
+    }
+    isReferencedAliasDeclaration(node) {
+        if (node instanceof ImportClause)
+            return node.name !== undefined && this.isReferencedAlias(node);
+        if (node instanceof NamespaceImport)
+            return this.isReferencedAlias(node);
+        if (node instanceof ImportSpecifier)
+            return !node.isTypeOnly && this.isReferencedAlias(node);
+        if (node instanceof ImportEqualsDeclaration) {
+            if (node.isTypeOnly)
+                return false;
+            if (this.isReferencedAlias(node))
+                return true;
+            // `export import x = a.b` is referenced by its export when it names a value.
+            return hasSyntacticModifier(node, 32 /* ModifierFlags.Export */) && this.isAliasOfValue(node, false);
+        }
+        return true;
+    }
+    /** Whether the alias declared by `node` is used as a value. */
+    isReferencedAlias(node) {
+        const symbol = this.referenceResolver.getSymbolOfDeclaration(node);
+        return symbol !== undefined && this.referenced.has(symbol);
+    }
+    /** Whether the alias declared by `node` resolves to a value; `unresolved` if it doesn't resolve. */
+    isAliasOfValue(node, unresolved) {
+        const symbol = this.referenceResolver.getSymbolOfDeclaration(node);
+        if (symbol === undefined)
+            return false;
+        if (this.referenceResolver.resolveAlias(symbol) === undefined)
+            return unresolved;
+        return this.referenceResolver.isAliasResolvedToValue(symbol, false);
+    }
+    isValueAliasDeclaration(node) {
+        if (node instanceof ExportSpecifier) {
+            if (node.isTypeOnly)
+                return false;
+            const symbol = getSymbol(node);
+            return symbol === undefined || this.referenceResolver.isAliasResolvedToValue(symbol, true);
+        }
+        if (node instanceof ExportAssignment) {
+            if (!(node.expression instanceof Identifier))
+                return true;
+            const symbol = getSymbol(node);
+            return symbol === undefined || this.referenceResolver.isAliasResolvedToValue(symbol, true);
+        }
+        return true;
+    }
+    isTopLevelValueImportEqualsWithEntityName(node) {
+        if (!(node instanceof ImportEqualsDeclaration) ||
+            node.isTypeOnly ||
+            node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */ ||
+            nodeIsMissing(node.moduleReference) ||
+            !(node.parent instanceof SourceFile))
+            return false;
+        // An unresolved target might be a value.
+        return this.isAliasOfValue(node, true);
+    }
+    getTypeReferenceSerializationKind(typeName, location) {
+        return getTypeReferenceSerializationKind(this.referenceResolver, typeName, location);
+    }
+    getReferencedExportContainer(node, prefixLocals) {
+        return this.referenceResolver.getReferencedExportContainer(node, prefixLocals);
+    }
+    getReferencedImportDeclaration(node) {
+        if (!isParseTreeNode(node))
+            return this.generatedImports.get(node);
+        return this.referenceResolver.getReferencedImportDeclaration(node);
+    }
+    getReferencedValueDeclaration(node) {
+        return this.referenceResolver.getReferencedValueDeclaration(node);
+    }
+    getReferencedValueDeclarations(node) {
+        return this.referenceResolver.getReferencedValueDeclarations(node);
+    }
+    getEnumMemberValue(member) {
+        return this.referenceResolver.getEnumMemberValue(member);
+    }
+    getConstantValue(node) {
+        return this.referenceResolver.getConstantValue(node);
+    }
+    setReferencedImportDeclaration(name, declaration) {
+        this.generatedImports.set(name, declaration);
+    }
+    getJsxFactoryEntity(file) {
+        const pragma = lastPragma(file, 'jsx');
+        if (pragma !== undefined) {
+            const entity = parseIsolatedEntityName(pragmaArgument(pragma, 'factory'));
+            if (entity !== undefined)
+                return entity;
+        }
+        const option = this.options.jsxFactory;
+        return option !== undefined && option !== '' ? parseIsolatedEntityName(option) : undefined;
+    }
+    getJsxFragmentFactoryEntity(file) {
+        const pragma = lastPragma(file, 'jsxfrag');
+        if (pragma !== undefined)
+            return parseIsolatedEntityName(pragmaArgument(pragma, 'factory'));
+        const option = this.options.jsxFragmentFactory;
+        return option !== undefined && option !== '' ? parseIsolatedEntityName(option) : undefined;
+    }
+}
+/** The root name of the JSX factory: from an `@jsx` pragma, `jsxFactory`, `reactNamespace` or `React`. */
+function jsxNamespace(file, options) {
+    const factory = pragmaFactory(file, 'jsx');
+    return factory !== undefined ? rootName(factory) : defaultJsxNamespace(options);
+}
+/** The root name of the JSX fragment factory: from an `@jsxFrag` pragma or `jsxFragmentFactory`. */
+function jsxFragmentNamespace(file, options) {
+    const factory = pragmaFactory(file, 'jsxfrag');
+    if (factory !== undefined)
+        return isEntityName(factory) ? rootName(factory) : defaultJsxNamespace(options);
+    const option = options.jsxFragmentFactory;
+    if (option !== undefined && option !== '' && isEntityName(option))
+        return rootName(option);
+    return defaultJsxNamespace(options);
+}
+function defaultJsxNamespace(options) {
+    if (options.jsxFactory !== undefined && options.jsxFactory !== '')
+        return rootName(options.jsxFactory);
+    if (options.reactNamespace !== undefined && options.reactNamespace !== '')
+        return options.reactNamespace;
+    return 'React';
+}
+function pragmaFactory(file, name) {
+    for (const pragma of file.pragmas) {
+        if (pragma.name !== name)
+            continue;
+        const factory = pragma.args.get('factory');
+        if (factory !== undefined)
+            return factory.value;
+    }
+    return undefined;
+}
+/** The last pragma named `name`, which wins over earlier ones. */
+function lastPragma(file, name) {
+    let result = undefined;
+    for (const pragma of file.pragmas)
+        if (pragma.name === name)
+            result = pragma;
+    return result;
+}
+function pragmaArgument(pragma, name) {
+    if (pragma === undefined)
+        return '';
+    const argument = pragma.args.get(name);
+    return argument !== undefined ? argument.value : '';
+}
+function isEntityName(text) {
+    return /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(text);
+}
+function rootName(entityName) {
+    const dot = entityName.indexOf('.');
+    return dot < 0 ? entityName : entityName.substring(0, dot);
+}

package/dist/api/compiler/transformers/es-decorators.d.ts

@@ -0,0 +1,118 @@
+import { type Node } from '../ast.js';
+import { type CompilerOptions } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+import { VisitorBase } from './visitor-base.js';
+/** Replaces lexical `this` with `_outerThis`, for expressions moved into a class `static {}` block. */
+declare class OuterThisVisitor extends VisitorBase {
+    private readonly owner;
+    constructor(owner: ESDecorators);
+    visit(node: Node): Node | undefined;
+}
+/** Whether ES decorators need lowering for these options. */
+export declare function shouldTransformESDecorators(options: CompilerOptions): boolean;
+export declare class ESDecorators extends Transformer {
+    private readonly facts;
+    private readonly outerThisVisitor;
+    private top;
+    private classInfo;
+    private classThis;
+    private classSuper;
+    private pendingExpressions;
+    private outerThis;
+    private shouldTransformPrivateStaticElementsInFile;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    private updateState;
+    private enterClass;
+    private exitClass;
+    private enterClassElement;
+    private exitClassElement;
+    private enterName;
+    private exitName;
+    private enterOther;
+    private exitOther;
+    private shouldVisitNode;
+    visit(node: Node): Node | undefined;
+    private visitSourceFile;
+    /** `this` as `_outerThis`, for the outer-this visitor. */
+    visitOuterThis(node: Node, visitor: OuterThisVisitor): Node | undefined;
+    private visitClassElement;
+    /** Visits a node whose value is discarded, such as an expression statement's expression. */
+    private visitDiscarded;
+    private visitDiscardedNode;
+    private visitListItem;
+    /** Visits each node of a list with the visitor `mode` names; the list itself if nothing changed. */
+    private visitList;
+    private filterModifiers;
+    private createHelperVariable;
+    private createFileLevelName;
+    private createLet;
+    private createEmptyArray;
+    private setRangePastDecoratorsOrName;
+    private createClassInfo;
+    private transformClassLike;
+    private addMemberInfoDeclarations;
+    private visitClassDeclaration;
+    private visitClassExpression;
+    /**
+     * The `__runInitializers()` call for instance extra initializers, when no instance field
+     * initializer carries it.
+     */
+    private prepareConstructor;
+    /** Visits constructor statements, adding the initializers after the `super()` call `superPath` leads to. */
+    private transformConstructorBody;
+    private visitConstructorDeclaration;
+    private finishClassElement;
+    private partialTransformClassElement;
+    private appendDecorationStatement;
+    private visitMethodDeclaration;
+    private visitGetAccessorDeclaration;
+    private visitSetAccessorDeclaration;
+    private visitClassStaticBlockDeclaration;
+    private visitPropertyDeclaration;
+    private visitCallExpression;
+    private visitTaggedTemplateExpression;
+    private visitPropertyAccessExpression;
+    private visitElementAccessExpression;
+    private visitParameterDeclaration;
+    private visitNamedEvaluationSite;
+    private visitForStatement;
+    private visitBinaryExpression;
+    private visitPreOrPostfixUnaryExpression;
+    /** Sets the result's referenced name, for the decorator context, and its visited name. */
+    private visitReferencedPropertyName;
+    private visitPropertyName;
+    private visitComputedPropertyName;
+    private visitDestructuringAssignmentTarget;
+    private visitAssignmentElement;
+    private visitArrayAssignmentElement;
+    private visitObjectAssignmentElement;
+    private visitAssignmentPattern;
+    private visitParenthesizedExpression;
+    private visitPartiallyEmittedExpression;
+    /** `pending` evaluated before `expression`, inside its parentheses. */
+    private prependExpressions;
+    private injectPendingExpressions;
+    private injectPendingInitializers;
+    private transformAllDecoratorsOfDeclaration;
+    private transformDecorator;
+    private createCallBinding;
+    /** A `value`, `get` or `set` method of a pseudo-descriptor: `kind: __setFunctionName(function () {}, "#x")`. */
+    private createDescriptorMethod;
+    private createDescriptorObject;
+    /** `get name() { return _descriptor.value; }` */
+    private createMethodDescriptorForwarder;
+    /** `get name() { return _descriptor.get.call(this); }` */
+    private createGetAccessorDescriptorForwarder;
+    /** `set name(value) { return _descriptor.set.call(this, value); }` */
+    private createSetAccessorDescriptorForwarder;
+    private createClassElementContextObject;
+    private createAccess;
+    /** `const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(superMetadata) : void 0;` */
+    private createMetadata;
+    private createSymbolMetadataAccess;
+    /** `if (metadata) Object.defineProperty(target, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: metadata });` */
+    private createSymbolMetadata;
+}
+export {};