tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/transformers/legacy-decorators.js

@@ -58,50 +58,50 @@ export class LegacyDecorators extends Transformer {
         switch (node.kind) {
             case 79 /* SyntaxKind.Identifier */:
                 return node instanceof Identifier ? this.visitIdentifier(node) : node;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 if (node instanceof PropertyAccessExpression) {
                     // Property names are never substituted.
                     const expression = this.visitNode(node.expression);
                     return this.factory.updatePropertyAccessExpression(node, expression, node.questionDotToken, node.name, node.flags);
                 }
                 break;
-            case 171 /* SyntaxKind.Decorator */:
+            case 172 /* SyntaxKind.Decorator */:
                 // Emitted as part of the class.
                 return undefined;
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 if (node instanceof ClassDeclaration)
                     return this.visitClassDeclaration(node);
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 if (node instanceof ClassExpression)
                     // Legacy decorators don't apply to class expressions.
                     return this.factory.updateClassExpression(node, this.visitModifiers(node.modifiers), node.name, undefined, this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 if (node instanceof ConstructorDeclaration)
                     return this.factory.updateConstructorDeclaration(node, this.visitModifiers(node.modifiers), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (node instanceof MethodDeclaration)
                     return this.finishClassElement(this.factory.updateMethodDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.visitPropertyNameOfClassElement(node), undefined, undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body)), node);
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration)
                     return this.finishClassElement(this.factory.updateGetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.visitPropertyNameOfClassElement(node), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body)), node);
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration)
                     return this.finishClassElement(this.factory.updateSetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.visitPropertyNameOfClassElement(node), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body)), node);
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (node instanceof PropertyDeclaration)
                     return this.visitPropertyDeclaration(node);
                 break;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 if (node instanceof ParameterDeclaration)
                     return this.visitParameter(node);
                 break;
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile)
                     return this.visitSourceFile(node);
                 break;
@@ -495,8 +495,8 @@ function elideModifiers(transformer, modifiers) {
     return replacement;
 }
 function isClassStaticBlockDeclarationOrStaticProperty(node) {
-    return (node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
-        (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasSyntacticModifier(node, 256 /* ModifierFlags.Static */)));
+    return (node.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+        (node.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasSyntacticModifier(node, 256 /* ModifierFlags.Static */)));
 }
 function getAllDecoratorsOfClass(node) {
     const decorators = getDecorators(node);
@@ -507,12 +507,12 @@ function getAllDecoratorsOfClass(node) {
 }
 function getAllDecoratorsOfClassElement(member, parent) {
     switch (member.kind) {
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             return getAllDecoratorsOfAccessors(member, parent);
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return getAllDecoratorsOfMethod(member);
-        case 173 /* SyntaxKind.PropertyDeclaration */: {
+        case 174 /* SyntaxKind.PropertyDeclaration */: {
             const decorators = getDecorators(member);
             return decorators.length === 0 ? undefined : new AllDecorators(decorators, []);
         }

package/dist/api/compiler/transformers/module.js

@@ -105,27 +105,27 @@ export class ESModuleTransformer extends Transformer {
     }
     visit(node) {
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile)
                     return this.visitSourceFile(node);
                 break;
-            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
                 if (node instanceof ImportDeclaration)
                     return this.visitImportDeclaration(node);
                 break;
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (node instanceof ImportEqualsDeclaration)
                     return this.visitImportEqualsDeclaration(node);
                 break;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 if (node instanceof ExportAssignment)
                     return this.visitExportAssignment(node);
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 if (node instanceof ExportDeclaration)
                     return this.visitExportDeclaration(node);
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 if (node instanceof CallExpression)
                     return this.visitCallExpression(node);
                 break;
@@ -237,7 +237,7 @@ export class ESModuleTransformer extends Transformer {
         // ES2015 has no `export * as ns`: import the namespace and export it.
         const name = clause.name;
         const generated = factory.createGeneratedNameForNode(name, 0, '', '');
-        const importDeclaration = factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamespaceImport(generated)))), specifier, this.importAttributes(node.attributes)));
+        const importDeclaration = factory.created(new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamespaceImport(generated)))), specifier, this.importAttributes(node.attributes)));
         this.context.setOriginal(importDeclaration, clause);
         const exportDeclaration = name instanceof Identifier && name.text === 'default'
             ? factory.created(new ExportAssignment(undefined, false, undefined, generated))
@@ -273,7 +273,7 @@ export class ESModuleTransformer extends Transformer {
             const flags = 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */;
             // import { createRequire as _createRequire } from "module";
             const createRequireName = factory.createUniqueName('_createRequire', flags);
-            const importStatement = factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamedImports(factory.createNodeList([
+            const importStatement = factory.created(new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamedImports(factory.createNodeList([
                 factory.created(new ImportSpecifier(false, factory.createIdentifier('createRequire'), createRequireName)),
             ]))))), factory.createStringLiteral('module', 0 /* TokenFlags.None */), undefined));
             this.context.addEmitFlags(importStatement, 65536 /* EmitFlags.CustomPrologue */);

package/dist/api/compiler/transformers/named-evaluation.js

@@ -44,15 +44,15 @@ export function isAnonymousFunctionDefinition(context, node, filter) {
         return false;
     node = skipOuterExpressions(node, 63 /* OuterExpressionKinds.All */);
     switch (node.kind) {
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             if (classHasDeclaredOrExplicitlyAssignedName(context, node))
                 return false;
             break;
-        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
             if (node instanceof FunctionExpression && node.name !== undefined)
                 return false;
             break;
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             break;
         default:
             return false;
@@ -117,7 +117,7 @@ function namedEvaluationValue(node) {
 }
 function getAssignedNameOfIdentifier(context, name, expression) {
     const original = context.mostOriginal(skipOuterExpressions(expression, 63 /* OuterExpressionKinds.All */));
-    if ((original.kind === 264 /* SyntaxKind.ClassDeclaration */ || original.kind === 263 /* SyntaxKind.FunctionDeclaration */) &&
+    if ((original.kind === 265 /* SyntaxKind.ClassDeclaration */ || original.kind === 264 /* SyntaxKind.FunctionDeclaration */) &&
         getName(original) === undefined &&
         hasSyntacticModifier(original, 2048 /* ModifierFlags.Default */))
         return context.factory.createStringLiteral('default', 0 /* TokenFlags.None */);

package/dist/api/compiler/transformers/object-rest-spread.js

@@ -32,35 +32,35 @@ export class ObjectRestSpreadTransformer extends Transformer {
     }
     visitWorker(node, expressionResultIsUnused) {
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 return this.visitSourceFile(node);
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 return this.visitObjectLiteralExpression(node);
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 return this.visitBinaryExpression(node, expressionResultIsUnused);
-            case 245 /* SyntaxKind.ExpressionStatement */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
                 this.expressionResultIsUnused = true;
                 return this.visitEachChild(node);
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 this.expressionResultIsUnused = expressionResultIsUnused;
                 return this.visitEachChild(node);
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 return this.visitForOfStatement(node);
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 return this.visitVariableStatement(node);
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 return this.visitVariableDeclaration(node);
-            case 300 /* SyntaxKind.CatchClause */:
+            case 301 /* SyntaxKind.CatchClause */:
                 return this.visitCatchClause(node);
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 return this.visitParameter(node);
-            case 177 /* SyntaxKind.Constructor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 219 /* SyntaxKind.FunctionExpression */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 220 /* SyntaxKind.FunctionExpression */:
                 return this.visitFunctionLike(node);
         }
         return this.visitEachChild(node);
@@ -307,7 +307,7 @@ export class ObjectRestSpreadTransformer extends Transformer {
             !(isAssignmentPattern(initializer) && this.facts.containsObjectRestOrSpread(initializer)))
             return this.visitEachChild(node);
         const head = skipParentheses(initializer);
-        if (head.kind !== 262 /* SyntaxKind.VariableDeclarationList */ && !isAssignmentPattern(head))
+        if (head.kind !== 263 /* SyntaxKind.VariableDeclarationList */ && !isAssignmentPattern(head))
             return this.visitEachChild(node);
         const temp = factory.createTempVariable(0);
         const statements = [];
@@ -364,7 +364,7 @@ export class ObjectRestSpreadTransformer extends Transformer {
         // `Object.assign(Object.assign({ a }, o), { b })`.
         const factory = this.factory;
         const objects = this.chunkObjectLiteralElements(node.properties.nodes);
-        if (objects.length > 0 && objects[0].kind !== 211 /* SyntaxKind.ObjectLiteralExpression */)
+        if (objects.length > 0 && objects[0].kind !== 212 /* SyntaxKind.ObjectLiteralExpression */)
             objects.unshift(factory.createObjectLiteral([], false));
         let expression = objects[0];
         if (objects.length > 1) {
@@ -404,7 +404,7 @@ export class ObjectRestSpreadTransformer extends Transformer {
     }
 }
 function isAssignmentPattern(node) {
-    return node.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || node.kind === 210 /* SyntaxKind.ArrayLiteralExpression */;
+    return node.kind === 212 /* SyntaxKind.ObjectLiteralExpression */ || node.kind === 211 /* SyntaxKind.ArrayLiteralExpression */;
 }
 function declarationsOf(node) {
     return node instanceof SyntaxList ? node.children : [node];

package/dist/api/compiler/transformers/optional-chain.js

@@ -14,14 +14,14 @@ export class OptionalChainTransformer extends Transformer {
         if (!this.facts.has(node, 32 /* SubtreeFacts.ContainsOptionalChaining */))
             return node;
         switch (node.kind) {
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 return this.visitCallExpression(node, false);
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 if ((node.flags & 32 /* NodeFlags.OptionalChain */) !== 0)
                     return this.visitOptionalExpression(node, false, false);
                 break;
-            case 221 /* SyntaxKind.DeleteExpression */:
+            case 222 /* SyntaxKind.DeleteExpression */:
                 if (node instanceof DeleteExpression &&
                     (skipParentheses(node.expression).flags & 32 /* NodeFlags.OptionalChain */) !== 0)
                     return this.visitNonOptionalExpression(node.expression, false, true);
@@ -85,12 +85,12 @@ export class OptionalChainTransformer extends Transformer {
     }
     visitNonOptionalExpression(node, captureThisArg, isDelete) {
         switch (node.kind) {
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 return this.visitParenthesizedExpression(node, captureThisArg, isDelete);
-            case 213 /* SyntaxKind.ElementAccessExpression */:
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 return this.visitPropertyOrElementAccessExpression(node, captureThisArg, isDelete);
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 return this.visitCallExpression(node, captureThisArg);
         }
         return this.visitNode(node);
@@ -106,7 +106,7 @@ export class OptionalChainTransformer extends Transformer {
             chain.unshift(link);
         }
         const expression = accessedExpression(link);
-        const left = this.visitNonOptionalExpression(skipPartiallyEmittedExpressions(expression), chain[0].kind === 214 /* SyntaxKind.CallExpression */ && (chain[0].flags & 32 /* NodeFlags.OptionalChain */) !== 0, false);
+        const left = this.visitNonOptionalExpression(skipPartiallyEmittedExpressions(expression), chain[0].kind === 215 /* SyntaxKind.CallExpression */ && (chain[0].flags & 32 /* NodeFlags.OptionalChain */) !== 0, false);
         let leftThisArg = undefined;
         let capturedLeft = left;
         if (left instanceof SyntheticReferenceExpression) {
@@ -122,7 +122,7 @@ export class OptionalChainTransformer extends Transformer {
         let thisArg = undefined;
         for (let i = 0; i < chain.length; i++) {
             const segment = chain[i];
-            const access = segment.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || segment.kind === 213 /* SyntaxKind.ElementAccessExpression */;
+            const access = segment.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || segment.kind === 214 /* SyntaxKind.ElementAccessExpression */;
             if (access) {
                 if (i === chain.length - 1 && captureThisArg) {
                     if (isSimpleCopiableExpression(rightExpression))

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

@@ -81,8 +81,14 @@ export declare class ReferenceResolver {
     isTypeOnlyAliasSymbol(symbol: Symbol): boolean;
     /** Whether an alias is declared type-only; as in the checker, a default import counts only if its module resolves. */
     private isTypeOnlyAlias;
-    /** Whether a module's export `name` comes from another module through an `export type *` on the way. */
+    /**
+     * Whether a module's export `name` comes from another module through an `export type *`, as tsgo's
+     * getExportsOfModuleWorker decides: a module reached through a type-only `export *` has its exports marked, and a
+     * module reached without one, even if already visited, clears the mark of its own exports.
+     */
     private isExportedThroughTypeOnlyStar;
+    /** Visits a module of an `export *` walk; returns whether it exports the walk's name. */
+    private visitExportStars;
     /** Whether a symbol is declared in the global scope. */
     isGlobalSymbol(symbol: Symbol): boolean;
     /** Whether a symbol is a value at runtime: const enums aren't unless preserved. */
@@ -111,6 +117,11 @@ export declare class ReferenceResolver {
     private getExportFromTable;
     /** The symbol an identifier or dotted name refers to with `meaning`, through aliases unless `dontResolveAlias`. */
     resolveEntityName(name: Node, meaning: SymbolFlags, dontResolveAlias: boolean): Symbol | undefined;
+    /**
+     * The symbol an entity name expression such as `E.A` refers to as an expression: tsgo takes the symbol its checker
+     * resolves the expression to, where each name on the left is a value, so a local `let E` hides a const enum `E`.
+     */
+    private resolveValueEntityName;
     /** The value of an enum member, computing the values of its whole declaration. */
     getEnumMemberValue(member: Node): Evaluation;
     /** The inlined value of a const enum member access such as `E.A` or `E["A"]`. */