tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/transformers/declarations-tracker.d.ts

@@ -0,0 +1,46 @@
+import { type Node, type SourceFile } from '../ast.js';
+import { type Diagnostic } from '../diagnostics.js';
+import { type Symbol, SymbolFlags } from '../symbol.js';
+import { DiagnosticContext } from './declarations-diagnostics.js';
+import { type DeclarationEmitResolver, type SymbolAccessibilityResult, SymbolTracker } from './declarations-resolver.js';
+export declare class DeclarationTracker extends SymbolTracker {
+    readonly resolver: DeclarationEmitResolver;
+    readonly isolatedDeclarations: boolean;
+    readonly stripInternal: boolean;
+    diagnostics: Diagnostic[];
+    /** Unexported statements that names in the output refer to, to emit after the first pass. */
+    lateMarkedStatements: Node[];
+    /** How inaccessible names in the declaration being written are reported. */
+    diagnosticContext: DiagnosticContext;
+    /** The name of the declaration being written, where errors are reported. */
+    errorNameNode: Node | undefined;
+    currentSourceFile: SourceFile | undefined;
+    /** A class expression whose own name is allowed in its members' types; see `classSymbolTracked`. */
+    watchedClassSymbol: Symbol | undefined;
+    classSymbolTracked: boolean;
+    private readonly fallbackStack;
+    constructor(resolver: DeclarationEmitResolver, isolatedDeclarations: boolean, stripInternal: boolean);
+    addDiagnostic(diagnostic: Diagnostic): boolean;
+    pushErrorFallbackNode(node: Node): boolean;
+    popErrorFallbackNode(): boolean;
+    private errorFallbackNode;
+    private errorLocation;
+    private errorDeclarationName;
+    private reportAtErrorLocation;
+    reportCyclicStructureError(): boolean;
+    reportInaccessibleThisError(): boolean;
+    reportInaccessibleUniqueSymbolError(): boolean;
+    reportLikelyUnsafeImportRequiredError(specifier: string, symbolName: string): boolean;
+    reportNonSerializableProperty(propertyName: string): boolean;
+    reportPrivateInBaseOfClassExpression(propertyName: string): boolean;
+    reportTruncationError(): boolean;
+    reportNonlocalAugmentation(containingFile: SourceFile, parentSymbol: Symbol, augmentingSymbol: Symbol): boolean;
+    reportInferenceFallback(node: Node): boolean;
+    /** Under isolatedDeclarations, reports the properties assigned to a function. */
+    reportExpandoFunctionErrors(node: Node): boolean;
+    private isChildOfBoundExpando;
+    private isBoundExpando;
+    trackSymbol(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): boolean;
+    /** Queues aliases an accessible name needs, or reports an inaccessible one; true if reported. */
+    handleSymbolAccessibilityError(result: SymbolAccessibilityResult): boolean;
+}

package/dist/api/compiler/transformers/declarations-tracker.js

@@ -0,0 +1,197 @@
+// The symbol tracker of declaration emit: collects its diagnostics and the unexported
+// declarations that names in the output refer to.
+import { BinaryExpression, ExportAssignment, Identifier, getExpression } from '../ast.js';
+import { getNameOfDeclaration, getSourceFileOfNode } from '../binder-utilities.js';
+import { createDiagnosticForNode, createIsolatedDeclarationError, getSymbolAccessibilityDiagnostic, nameToString, noDiagnosticContext, textOfNode, } from './declarations-diagnostics.js';
+import { SymbolTracker, } from './declarations-resolver.js';
+export class DeclarationTracker extends SymbolTracker {
+    resolver;
+    isolatedDeclarations;
+    stripInternal;
+    diagnostics;
+    /** Unexported statements that names in the output refer to, to emit after the first pass. */
+    lateMarkedStatements;
+    /** How inaccessible names in the declaration being written are reported. */
+    diagnosticContext;
+    /** The name of the declaration being written, where errors are reported. */
+    errorNameNode;
+    currentSourceFile;
+    /** A class expression whose own name is allowed in its members' types; see `classSymbolTracked`. */
+    watchedClassSymbol;
+    classSymbolTracked;
+    fallbackStack;
+    constructor(resolver, isolatedDeclarations, stripInternal) {
+        super();
+        this.resolver = resolver;
+        this.isolatedDeclarations = isolatedDeclarations;
+        this.stripInternal = stripInternal;
+        this.diagnostics = [];
+        this.lateMarkedStatements = [];
+        this.diagnosticContext = noDiagnosticContext;
+        this.errorNameNode = undefined;
+        this.currentSourceFile = undefined;
+        this.watchedClassSymbol = undefined;
+        this.classSymbolTracked = false;
+        this.fallbackStack = [];
+    }
+    addDiagnostic(diagnostic) {
+        this.diagnostics.push(diagnostic);
+        return true;
+    }
+    pushErrorFallbackNode(node) {
+        this.fallbackStack.push(node);
+        return true;
+    }
+    popErrorFallbackNode() {
+        this.fallbackStack.pop();
+        return true;
+    }
+    errorFallbackNode() {
+        const stack = this.fallbackStack;
+        return stack.length > 0 ? stack[stack.length - 1] : undefined;
+    }
+    errorLocation() {
+        return this.errorNameNode ?? this.errorFallbackNode();
+    }
+    errorDeclarationName() {
+        if (this.errorNameNode !== undefined)
+            return nameToString(this.errorNameNode);
+        const fallback = this.errorFallbackNode();
+        if (fallback !== undefined) {
+            const name = getNameOfDeclaration(fallback);
+            if (name !== undefined)
+                return nameToString(name);
+            if (fallback instanceof ExportAssignment)
+                return fallback.isExportEquals ? 'export=' : 'default';
+        }
+        return '(Missing)';
+    }
+    reportAtErrorLocation(message, args) {
+        const location = this.errorLocation();
+        if (location === undefined)
+            return false;
+        return this.addDiagnostic(createDiagnosticForNode(location, message, args));
+    }
+    reportCyclicStructureError() {
+        return this.reportAtErrorLocation(1162 /* Diagnostics.The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary */, [this.errorDeclarationName()]);
+    }
+    reportInaccessibleThisError() {
+        return this.reportAtErrorLocation(685 /* Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary */, [this.errorDeclarationName(), 'this']);
+    }
+    reportInaccessibleUniqueSymbolError() {
+        return this.reportAtErrorLocation(685 /* Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary */, [this.errorDeclarationName(), 'unique symbol']);
+    }
+    reportLikelyUnsafeImportRequiredError(specifier, symbolName) {
+        if (symbolName !== '')
+            return this.reportAtErrorLocation(1003 /* Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_2_from_1_This_is_likely_not_portable_A_type_annotation_is_necessary */, [this.errorDeclarationName(), specifier, symbolName]);
+        return this.reportAtErrorLocation(874 /* Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary */, [this.errorDeclarationName(), specifier]);
+    }
+    reportNonSerializableProperty(propertyName) {
+        return this.reportAtErrorLocation(1104 /* Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized */, [propertyName]);
+    }
+    reportPrivateInBaseOfClassExpression(propertyName) {
+        const location = this.errorLocation();
+        if (location === undefined)
+            return false;
+        const diagnostic = createDiagnosticForNode(location, 1080 /* Diagnostics.Property_0_of_exported_anonymous_class_type_may_not_be_private_or_protected */, [propertyName]);
+        if (location.parent !== undefined && location.parent.kind === 261 /* SyntaxKind.VariableDeclaration */)
+            diagnostic.addRelatedInfo(createDiagnosticForNode(location, 1791 /* Diagnostics.Add_a_type_annotation_to_the_variable_0 */, [
+                this.errorDeclarationName(),
+            ]));
+        return this.addDiagnostic(diagnostic);
+    }
+    reportTruncationError() {
+        return this.reportAtErrorLocation(1727 /* Diagnostics.The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed */, []);
+    }
+    reportNonlocalAugmentation(containingFile, parentSymbol, augmentingSymbol) {
+        let primary = undefined;
+        for (const declaration of parentSymbol.declarations)
+            if (getSourceFileOfNode(declaration) === containingFile) {
+                primary = declaration;
+                break;
+            }
+        if (primary === undefined)
+            return false;
+        for (const augmentation of augmentingSymbol.declarations) {
+            if (getSourceFileOfNode(augmentation) === containingFile)
+                continue;
+            const diagnostic = createDiagnosticForNode(augmentation, 1384 /* Diagnostics.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized */, []);
+            diagnostic.addRelatedInfo(createDiagnosticForNode(primary, 1385 /* Diagnostics.This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file */, []));
+            this.addDiagnostic(diagnostic);
+        }
+        return true;
+    }
+    reportInferenceFallback(node) {
+        if (!this.isolatedDeclarations || getSourceFileOfNode(node) !== this.currentSourceFile)
+            return false;
+        if (this.resolver.isExpandoFunctionDeclaration(node))
+            this.reportExpandoFunctionErrors(node);
+        // Expando properties get an error when their function is reported; skip follow-on errors.
+        if (this.isChildOfBoundExpando(node))
+            return false;
+        return this.addDiagnostic(createIsolatedDeclarationError(node, node.kind === 170 /* SyntaxKind.Parameter */ && this.resolver.requiresAddingImplicitUndefined(node, undefined)));
+    }
+    /** Under isolatedDeclarations, reports the properties assigned to a function. */
+    reportExpandoFunctionErrors(node) {
+        if (!this.isolatedDeclarations)
+            return false;
+        for (const declaration of this.resolver.getExpandoPropertyDeclarations(node)) {
+            const target = declaration instanceof BinaryExpression ? declaration.left : declaration;
+            this.addDiagnostic(createDiagnosticForNode(target, 1788 /* Diagnostics.Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function */, []));
+        }
+        return true;
+    }
+    isChildOfBoundExpando(node) {
+        for (let current = node; current !== undefined; current = current.parent) {
+            if (current.kind === 307 /* SyntaxKind.SourceFile */ || current.kind === 242 /* SyntaxKind.Block */)
+                return false;
+            if (this.isBoundExpando(current))
+                return true;
+        }
+        return false;
+    }
+    isBoundExpando(node) {
+        if (!(node instanceof BinaryExpression) || node.left.kind !== 212 /* SyntaxKind.PropertyAccessExpression */)
+            return false;
+        if (node.operatorToken.kind !== 63 /* SyntaxKind.EqualsToken */)
+            return false;
+        let leftmost = node.left;
+        while (leftmost.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ||
+            leftmost.kind === 213 /* SyntaxKind.ElementAccessExpression */)
+            leftmost = getExpression(leftmost);
+        if (!(leftmost instanceof Identifier))
+            return false;
+        const declaration = this.resolver.getReferencedValueDeclaration(leftmost);
+        return declaration !== undefined && this.resolver.isExpandoFunctionDeclaration(declaration);
+    }
+    trackSymbol(symbol, enclosingDeclaration, meaning) {
+        if ((symbol.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
+            return false;
+        // A class expression's own name is handled by wrapping it in a namespace.
+        if (symbol === this.watchedClassSymbol) {
+            this.classSymbolTracked = true;
+            return false;
+        }
+        return this.handleSymbolAccessibilityError(this.resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, true));
+    }
+    /** Queues aliases an accessible name needs, or reports an inaccessible one; true if reported. */
+    handleSymbolAccessibilityError(result) {
+        if (result.accessibility === 0 /* SymbolAccessibility.Accessible */) {
+            for (const alias of result.aliasesToMakeVisible)
+                if (this.lateMarkedStatements.indexOf(alias) < 0)
+                    this.lateMarkedStatements.push(alias);
+            return false;
+        }
+        // The checker reports unresolved names.
+        if (result.accessibility === 3 /* SymbolAccessibility.NotResolved */)
+            return false;
+        const info = getSymbolAccessibilityDiagnostic(this.diagnosticContext, result);
+        if (info === undefined)
+            return false;
+        const node = result.errorNode ?? info.errorNode;
+        const args = info.typeName !== undefined
+            ? [textOfNode(info.typeName), result.errorSymbolName, result.errorModuleName]
+            : [result.errorSymbolName, result.errorModuleName];
+        return this.addDiagnostic(createDiagnosticForNode(node, info.message, args));
+    }
+}

package/dist/api/compiler/transformers/declarations.d.ts

@@ -0,0 +1,175 @@
+import { type Node } from '../ast.js';
+import { type Diagnostic } from '../diagnostics.js';
+import type { CompilerOptions } from '../options.js';
+import { type OutputPathsHost } from '../output-paths.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { type DeclarationEmitResolver } from './declarations-resolver.js';
+import { DeclarationTracker } from './declarations-tracker.js';
+import { Transformer } from './transformer.js';
+export declare class DeclarationTransformer extends Transformer {
+    readonly host: OutputPathsHost;
+    readonly options: CompilerOptions;
+    readonly resolver: DeclarationEmitResolver;
+    readonly tracker: DeclarationTracker;
+    private readonly declarationFilePath;
+    private needsDeclare;
+    private needsScopeFixMarker;
+    private resultHasScopeMarker;
+    private resultHasExternalModuleIndicator;
+    private enclosingDeclaration;
+    /** Whether types are inside an object type, where new diagnostic contexts aren't entered. */
+    private suppressNewDiagnosticContexts;
+    private inClassExpressionDeclaration;
+    /** Transformed top-level declarations by original node; undefined for removed ones. */
+    private lateStatementReplacements;
+    /** Functions with assigned properties (`f.x = 1`), transformed, by statement. */
+    private readonly expandoHosts;
+    /** The namespace members for the assigned properties of each function, by statement. */
+    private readonly expandoMembers;
+    /** The `export =` for a CommonJS `module.exports = …`. */
+    private cjsExportAssignment;
+    /** The exports for CommonJS `exports.x = …` assignments. */
+    private cjsExportMembers;
+    /** The name of the `module.exports` value, which `exports.x` members are nested in. */
+    private cjsExportAssignmentName;
+    private readonly witnessedCjsExports;
+    /** `this.x` members found in a JavaScript class, and their keys. */
+    private thisPropertyAssignments;
+    private readonly seenProperties;
+    constructor(context: EmitContext, host: OutputPathsHost, options: CompilerOptions, resolver: DeclarationEmitResolver, declarationFilePath: string);
+    get diagnostics(): Diagnostic[];
+    visit(node: Node): Node | undefined;
+    private visitSourceFile;
+    private originalSourceFile;
+    private appendCjsExports;
+    private reportMultipleModuleExports;
+    private createEmptyExports;
+    /** `/// <reference path>` directives with `preserve="true"`, relative to the output. */
+    private getReferencedFiles;
+    /**
+     * Replaces top-level declarations with their transformed forms. Transforming a declaration can
+     * mark more unexported declarations as referenced, so this runs until none are left.
+     */
+    private transformAndReplaceLatePaintedStatements;
+    private enterDiagnosticContext;
+    private exitDiagnosticContext;
+    private visitDeclarationSubtree;
+    private transformDeclarationSubtree;
+    private createUnion;
+    private replaceWith;
+    private keyword;
+    private checkName;
+    private checkEntityNameVisibility;
+    private transformMappedType;
+    private transformHeritageClause;
+    private transformImportType;
+    private transformConstructorType;
+    private transformFunctionType;
+    private transformConditionalType;
+    private transformTypeParameter;
+    private transformVariableDeclaration;
+    private recreateBindingPattern;
+    private recreateBindingElement;
+    private transformIndexSignature;
+    private transformCallSignature;
+    private transformPropertySignature;
+    /** Writes the description of a property from a JSDoc `@property` tag as its comment. */
+    private preservePartialJsDoc;
+    private transformPropertyDeclaration;
+    private transformSetAccessor;
+    private transformGetAccessor;
+    private updateAccessorParamList;
+    private transformConstructor;
+    private transformConstructSignature;
+    /** A private method is written as a property without a type. */
+    private omitPrivateMethodType;
+    private transformMethodSignature;
+    private transformMethodDeclaration;
+    private visitDeclarationStatement;
+    /** `export =`, `export default` or `module.exports =` of `expression`. */
+    transformExportAssignment(input: Node, assignment: Node, expression: Node, isExportEquals: boolean): Node | undefined;
+    private createConstStatement;
+    private transformFunctionLikeToDeclaration;
+    /** A class expression as a declaration, for `export default (class {})` and CommonJS exports. */
+    private transformClassExpressionToDeclaration;
+    private declareModifiers;
+    /** The name of the variable for an exported expression: its own name if it has one, else `_default`. */
+    private getNameOfExportedExpression;
+    /** The name of a named function or class expression, unique if it would shadow something. */
+    private tryGetNameOfAssignedExpression;
+    private rewriteModuleSpecifier;
+    private tryGetResolutionModeOverride;
+    /** The replacement statements for a direct child of a source file or module block. */
+    private transformTopLevelDeclaration;
+    private transformTypeAlias;
+    private transformInterface;
+    private transformFunctionDeclaration;
+    private transformModuleDeclaration;
+    private stripExportModifiersOfList;
+    private stripExportModifiers;
+    /** `node` with other modifiers; for statements that can be exported. */
+    private replaceModifiers;
+    /** Class members: parameter properties, a `#private` marker and the visited members. */
+    /** The members of a class declaration or expression. */
+    private buildClassMembers;
+    private walkBindingPattern;
+    private transformClassDeclaration;
+    private transformVariableStatement;
+    private transformEnumDeclaration;
+    /** A number as an expression: a literal, `-literal`, `Infinity`, `-Infinity` or `NaN`. */
+    createNumber(value: number): Node;
+    /** `const x = require("m")` as `import x = require("m")`, `const { a } = require("m")` as `import { a } from "m"`. */
+    private transformCjsRequireVariableDeclaration;
+    /** Finds `module.exports =` assignments anywhere in the file. */
+    visitModuleExportsAssignment(node: Node): boolean;
+    /** Finds assigned properties (`f.x = 1`) and CommonJS exports (`exports.x = 1`) anywhere in the file. */
+    visitNestedExpression(node: Node): boolean;
+    /** A property name as an identifier when it can be one; keywords other than `default` stay strings. */
+    private getNameExpressionPreferringIdentifier;
+    private transformCommonJSExport;
+    private transformCommonJSExportWorker;
+    /** `exports.K = class K {}` as a class declaration, in a namespace if its name differs or is used inside. */
+    private transformCommonJSClassExport;
+    private createExportDeclaration;
+    /** `exports.x = y` and `f.x = y` as `export { y as x }`. */
+    private transformBinaryExpressionToExportDeclaration;
+    /** CommonJS exports of a file with `module.exports =` are members of a namespace of its name. */
+    private wrapInCJSExportNamespace;
+    private stripDeclareModifier;
+    /** Writes `f.x = 1` as a namespace member of `f`, kept with `f` if it's emitted. */
+    private transformExpandoAssignment;
+    private tryGetPropertyName;
+    private getExpandoHostId;
+    /** The function a property is assigned to, written as a declaration once. */
+    private transformExpandoHost;
+    /** A function with its assigned properties as a namespace of the same name. */
+    private createFullExpandoBlock;
+    /** The `this.x = …` members of a JavaScript class, as property declarations. */
+    private collectThisPropertyAssignments;
+    /** Collects a `this.x = …` assignment of a member of `classNode`. */
+    visitThisPropertyAssignment(node: Node, classNode: Node): boolean;
+    private createModifiers;
+    private ensureModifiers;
+    private ensureModifierFlags;
+    private ensureTypeParams;
+    private updateParamList;
+    private ensureParameterNode;
+    private ensureParameter;
+    private visitBindingName;
+    /** The type of a declaration: its annotation, or the resolver's type; `any` if neither. */
+    private ensureType;
+    private nodeBuilderFlags;
+    private shouldPrintWithInitializer;
+    private canHaveLiteralInitializer;
+    private ensureNoInitializer;
+    private transformImportEquals;
+    private transformImportDeclaration;
+    private updateImport;
+    private parseNode;
+    private isPrivate;
+    private isDeclarationAndNotVisible;
+    private getBindingNameVisible;
+    private shouldStripInternal;
+    /** Whether a declaration has an `@internal` comment. */
+    private isInternalDeclaration;
+}