tsc-ts 0.0.9 → 0.1.0

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

@@ -166,7 +166,7 @@ function setValueDeclaration(symbol, node) {
     if (current === undefined ||
         (!((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && (current.flags & 8388608 /* NodeFlags.Ambient */) === 0) &&
             current.kind !== node.kind &&
-            current.kind === 268 /* SyntaxKind.ModuleDeclaration */))
+            current.kind === 269 /* SyntaxKind.ModuleDeclaration */))
         symbol.valueDeclaration = node;
     return true;
 }
@@ -327,7 +327,7 @@ export class ReferenceResolver {
     getReferencedExportContainer(node, prefixLocals) {
         const parent = node.parent;
         const startInDeclarationContainer = parent !== undefined &&
-            (parent.kind === 268 /* SyntaxKind.ModuleDeclaration */ || parent.kind === 267 /* SyntaxKind.EnumDeclaration */) &&
+            (parent.kind === 269 /* SyntaxKind.ModuleDeclaration */ || parent.kind === 268 /* SyntaxKind.EnumDeclaration */) &&
             isSameNode(getName(parent), node);
         let symbol = this.getReferencedValueSymbol(node, startInDeclarationContainer);
         if (symbol === undefined)
@@ -349,10 +349,10 @@ export class ReferenceResolver {
         const valueDeclaration = parentSymbol.valueDeclaration;
         if ((parentSymbol.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
             valueDeclaration !== undefined &&
-            valueDeclaration.kind === 307 /* SyntaxKind.SourceFile */)
+            valueDeclaration.kind === 308 /* SyntaxKind.SourceFile */)
             return valueDeclaration === getSourceFileOfNode(node) ? valueDeclaration : undefined;
         for (let current = node.parent; current !== undefined; current = current.parent) {
-            if ((current.kind === 268 /* SyntaxKind.ModuleDeclaration */ || current.kind === 267 /* SyntaxKind.EnumDeclaration */) &&
+            if ((current.kind === 269 /* SyntaxKind.ModuleDeclaration */ || current.kind === 268 /* SyntaxKind.EnumDeclaration */) &&
                 this.getSymbolOfDeclaration(current) === parentSymbol)
                 return current;
         }
@@ -433,28 +433,41 @@ export class ReferenceResolver {
         if (imported === undefined || moduleDeclaration === undefined)
             return false;
         const moduleSymbol = this.resolveModuleSpecifier(declaration, getModuleSpecifierOf(moduleDeclaration));
-        return moduleSymbol !== undefined && this.isExportedThroughTypeOnlyStar(moduleSymbol, imported, new Set());
+        return moduleSymbol !== undefined && this.isExportedThroughTypeOnlyStar(moduleSymbol, imported);
     }
-    /** Whether a module's export `name` comes from another module through an `export type *` on the way. */
-    isExportedThroughTypeOnlyStar(moduleSymbol, name, visited) {
-        if (visited.has(moduleSymbol))
+    /**
+     * 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.
+     */
+    isExportedThroughTypeOnlyStar(moduleSymbol, name) {
+        if (name === "default" /* InternalSymbolName.Default */)
             return false;
-        visited.add(moduleSymbol);
-        const exports = moduleSymbol.exports;
-        if (exports === undefined || exports.has(name) || name === "default" /* InternalSymbolName.Default */)
+        const walk = new TypeOnlyStarWalk(name);
+        this.visitExportStars(walk, moduleSymbol, false, false);
+        return walk.typeOnly && !walk.nonTypeOnly;
+    }
+    /** Visits a module of an `export *` walk; returns whether it exports the walk's name. */
+    visitExportStars(walk, symbol, starIsTypeOnly, isTypeOnly) {
+        const exports = symbol === undefined ? undefined : symbol.exports;
+        if (!isTypeOnly && exports !== undefined && exports.has(walk.name))
+            walk.nonTypeOnly = true;
+        if (symbol === undefined || exports === undefined || walk.visited.has(symbol))
             return false;
+        walk.visited.add(symbol);
+        let found = exports.has(walk.name);
         const star = exports.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
-        if (star === undefined)
-            return false;
-        for (const declaration of getDeclarations(star)) {
-            if (!(declaration instanceof ExportDeclaration))
-                continue;
-            const target = this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier));
-            if (target === undefined || this.getExportFromTable(target, name, new Set()) === undefined)
-                continue;
-            return declaration.isTypeOnly || this.isExportedThroughTypeOnlyStar(target, name, visited);
-        }
-        return false;
+        if (star !== undefined)
+            for (const declaration of getDeclarations(star)) {
+                if (!(declaration instanceof ExportDeclaration))
+                    continue;
+                const target = this.resolveExternalModuleSymbol(this.resolveModuleSpecifier(declaration, declaration.moduleSpecifier));
+                if (this.visitExportStars(walk, target, declaration.isTypeOnly, isTypeOnly || declaration.isTypeOnly))
+                    found = true;
+            }
+        if (starIsTypeOnly && found)
+            walk.typeOnly = true;
+        return found;
     }
     /** Whether a symbol is declared in the global scope. */
     isGlobalSymbol(symbol) {
@@ -605,7 +618,7 @@ export class ReferenceResolver {
         }
         if (node instanceof ExportAssignment) {
             const expression = node.expression;
-            if (expression.kind === 79 /* SyntaxKind.Identifier */ || expression.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+            if (expression.kind === 79 /* SyntaxKind.Identifier */ || expression.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
                 return this.resolveEntityName(expression, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true);
             return getSymbol(node);
         }
@@ -614,7 +627,7 @@ export class ReferenceResolver {
     /** The module an implicit import of `file`, such as the JSX runtime, refers to. */
     resolveImplicitImport(file, name) {
         const specifier = new StringLiteral(name, 0 /* TokenFlags.None */);
-        const declaration = new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
+        const declaration = new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
         specifier.parent = declaration;
         declaration.parent = file;
         return this.resolveModuleSpecifier(specifier, specifier);
@@ -698,7 +711,7 @@ export class ReferenceResolver {
             const resolved = this.resolveName(name, name.text, meaning | 2097152 /* SymbolFlags.Alias */);
             symbol = resolved === undefined ? undefined : this.getMergedSymbol(resolved);
         }
-        else if (name.kind === 167 /* SyntaxKind.QualifiedName */ || name.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        else if (name.kind === 168 /* SyntaxKind.QualifiedName */ || name.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
             const left = entityNameLeft(name);
             const right = entityNameRight(name);
             if (left === undefined || !(right instanceof Identifier))
@@ -730,6 +743,40 @@ export class ReferenceResolver {
         return symbol;
     }
     // Constant values
+    /**
+     * 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`.
+     */
+    resolveValueEntityName(name) {
+        let symbol;
+        if (name instanceof Identifier) {
+            const resolved = this.resolveName(name, name.text, 111551 /* SymbolFlags.Value */ | 2097152 /* SymbolFlags.Alias */);
+            symbol = resolved === undefined ? undefined : this.getMergedSymbol(resolved);
+        }
+        else if (name instanceof PropertyAccessExpression) {
+            const left = this.resolveValueEntityName(name.expression);
+            const right = name.name;
+            if (left === undefined || !(right instanceof Identifier))
+                return undefined;
+            let member = left.exports === undefined ? undefined : left.exports.get(right.text);
+            // A namespace merged with an alias also has the members of what the alias names, as its type does.
+            if (member === undefined && (left.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+                const target = this.resolveAlias(left);
+                const targetExports = target === undefined ? undefined : target.exports;
+                if (targetExports !== undefined)
+                    member = targetExports.get(right.text);
+            }
+            if (member === undefined || (member.flags & (111551 /* SymbolFlags.Value */ | 2097152 /* SymbolFlags.Alias */)) === 0)
+                return undefined;
+            symbol = this.getMergedSymbol(member);
+        }
+        else
+            return undefined;
+        if (symbol === undefined || (symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+            return symbol;
+        const target = this.resolveAlias(symbol);
+        return target === undefined ? undefined : this.getMergedSymbol(target);
+    }
     /** The value of an enum member, computing the values of its whole declaration. */
     getEnumMemberValue(member) {
         const declaration = member.parent;
@@ -745,12 +792,12 @@ export class ReferenceResolver {
         let symbol;
         if (node instanceof PropertyAccessExpression) {
             if (isEntityNameExpressionNode(node))
-                symbol = this.resolveEntityName(node, 111551 /* SymbolFlags.Value */, false);
+                symbol = this.resolveValueEntityName(node);
         }
         else if (node instanceof ElementAccessExpression) {
             const argument = stringLiteralText(node.argumentExpression);
             if (isEntityNameExpressionNode(node.expression) && argument !== undefined) {
-                const root = this.resolveEntityName(node.expression, 111551 /* SymbolFlags.Value */, false);
+                const root = this.resolveValueEntityName(node.expression);
                 const exports = root === undefined ? undefined : root.exports;
                 const member = exports === undefined ? undefined : exports.get(argument);
                 if (member !== undefined)
@@ -1003,7 +1050,7 @@ function isDeclaredBeforeUse(declaration, usage) {
     if ((usage.flags & (4194304 /* NodeFlags.JSDoc */ | 8388608 /* NodeFlags.Ambient */)) !== 0)
         return true;
     if (declaration.pos <= usage.pos) {
-        if (declaration.kind === 209 /* SyntaxKind.BindingElement */) {
+        if (declaration.kind === 210 /* SyntaxKind.BindingElement */) {
             const root = getRootDeclaration(declaration);
             return root === declaration || isDeclaredBeforeUse(root, usage);
         }
@@ -1033,12 +1080,12 @@ function isInInitializerOf(declaration, usage) {
 function getDeclarationContainer(node) {
     for (let current = getRootDeclaration(node); current !== undefined; current = current.parent) {
         switch (current.kind) {
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 262 /* SyntaxKind.VariableDeclarationList */:
-            case 277 /* SyntaxKind.ImportSpecifier */:
-            case 276 /* SyntaxKind.NamedImports */:
-            case 275 /* SyntaxKind.NamespaceImport */:
-            case 274 /* SyntaxKind.ImportClause */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 263 /* SyntaxKind.VariableDeclarationList */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
+            case 277 /* SyntaxKind.NamedImports */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 275 /* SyntaxKind.ImportClause */:
                 continue;
         }
         return current.parent;
@@ -1054,16 +1101,16 @@ function isNonLocalAlias(symbol, excludes) {
 }
 function isAliasSymbolDeclaration(node) {
     switch (node.kind) {
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
-        case 275 /* SyntaxKind.NamespaceImport */:
-        case 281 /* SyntaxKind.NamespaceExport */:
-        case 277 /* SyntaxKind.ImportSpecifier */:
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 276 /* SyntaxKind.NamespaceImport */:
+        case 282 /* SyntaxKind.NamespaceExport */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             return true;
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return node instanceof ImportClause && node.name !== undefined;
-        case 278 /* SyntaxKind.ExportAssignment */:
+        case 279 /* SyntaxKind.ExportAssignment */:
             return true;
     }
     return false;
@@ -1076,28 +1123,43 @@ export function getDeclarationOfAliasSymbol(symbol) {
     }
     return undefined;
 }
+/** The state of `isExportedThroughTypeOnlyStar`'s walk over the `export *` declarations of modules for one name. */
+class TypeOnlyStarWalk {
+    name;
+    visited;
+    /** Whether a module reached through a type-only `export *` exports the name. */
+    typeOnly;
+    /** Whether a module reached without one exports the name itself. */
+    nonTypeOnly;
+    constructor(name) {
+        this.name = name;
+        this.visited = new Set();
+        this.typeOnly = false;
+        this.nonTypeOnly = false;
+    }
+}
 function isTypeOnlyAlias(symbol) {
     let node = getDeclarationOfAliasSymbol(symbol);
     while (node !== undefined) {
         switch (node.kind) {
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 return getIsTypeOnly(node);
-            case 274 /* SyntaxKind.ImportClause */:
+            case 275 /* SyntaxKind.ImportClause */:
                 if (node instanceof ImportClause && node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */)
                     return true;
                 node = node.parent;
                 continue;
-            case 277 /* SyntaxKind.ImportSpecifier */:
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 if (getIsTypeOnly(node))
                     return true;
                 node = node.parent;
                 continue;
-            case 275 /* SyntaxKind.NamespaceImport */:
-            case 281 /* SyntaxKind.NamespaceExport */:
-            case 276 /* SyntaxKind.NamedImports */:
-            case 280 /* SyntaxKind.NamedExports */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 282 /* SyntaxKind.NamespaceExport */:
+            case 277 /* SyntaxKind.NamedImports */:
+            case 281 /* SyntaxKind.NamedExports */:
                 node = node.parent;
                 continue;
         }
@@ -1107,24 +1169,24 @@ function isTypeOnlyAlias(symbol) {
 }
 function isValueDeclarationKind(kind) {
     switch (kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 209 /* SyntaxKind.BindingElement */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 306 /* SyntaxKind.EnumMember */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 307 /* SyntaxKind.EnumMember */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
             return true;
     }
     return false;

package/dist/api/compiler/transformers/runtime-syntax.js

@@ -4,8 +4,9 @@ import { Block, CatchClause, PrivateIdentifier, getBody, getName, getParameters,
 import { ModuleKind, getEmitModuleKind, shouldPreserveConstEnums } from '../options.js';
 import { isPrologueDirective } from '../printer/utilities.js';
 import { AssignmentFactory, convertVariableDeclarationToAssignment, flattenDestructuringAssignment, } from './destructuring.js';
+import { nodeIsDecorated } from './decorator-utilities.js';
 import { Transformer } from './transformer.js';
-import { getInnermostModuleDeclaration, hasDecorators, hasSyntacticModifier, isIdentifierReference, isInstantiatedModule, isParameterPropertyDeclaration, isSameNode, } from './utilities.js';
+import { getInnermostModuleDeclaration, hasDecorators, hasSyntacticModifier, isIdentifierReference, isInstantiatedModule, isParameterPropertyDeclaration, isSameNode, modifierFlagsOf, } from './utilities.js';
 const typeScriptModifiers = 128 /* ModifierFlags.Ambient */ |
     1 /* ModifierFlags.Public */ |
     2 /* ModifierFlags.Private */ |
@@ -62,21 +63,21 @@ export class RuntimeSyntax extends Transformer {
     }
     enterScope(node) {
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 this.currentScope = node;
                 if (node instanceof SourceFile)
                     this.currentSourceFile = node;
                 this.firstDeclarations = undefined;
                 break;
-            case 270 /* SyntaxKind.CaseBlock */:
-            case 269 /* SyntaxKind.ModuleBlock */:
-            case 242 /* SyntaxKind.Block */:
+            case 271 /* SyntaxKind.CaseBlock */:
+            case 270 /* SyntaxKind.ModuleBlock */:
+            case 243 /* SyntaxKind.Block */:
                 this.currentScope = node;
                 this.firstDeclarations = undefined;
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 this.recordDeclarationInScope(node);
                 break;
         }
@@ -92,46 +93,46 @@ export class RuntimeSyntax extends Transformer {
             case 148 /* SyntaxKind.ReadonlyKeyword */:
             case 164 /* SyntaxKind.OverrideKeyword */:
                 return undefined;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (node instanceof EnumDeclaration)
                     return this.visitEnumDeclaration(node);
                 break;
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 if (node instanceof ModuleDeclaration)
                     return this.visitModuleDeclaration(node);
                 break;
-            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)
                     return this.factory.updateClassExpression(node, this.visitModifiers(this.extractModifiers(node.modifiers, ~exportDefault)), node.name, undefined, this.visitNodes(node.heritageClauses), this.classMembers(node.members));
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 if (node instanceof ConstructorDeclaration)
                     return this.visitConstructor(node);
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 if (node instanceof FunctionDeclaration)
                     return this.visitFunctionDeclaration(node);
                 break;
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 if (node instanceof VariableStatement)
                     return this.visitVariableStatement(node);
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 274 /* SyntaxKind.ImportClause */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 275 /* SyntaxKind.ImportClause */:
                 // ES imports and exports are illegal in a namespace.
                 if (this.inNamespaceBody())
                     return undefined;
                 return this.visitEachChild(node);
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (node instanceof ImportEqualsDeclaration) {
                     const external = node.moduleReference instanceof ExternalModuleReference;
                     if (this.currentNamespace !== undefined && this.currentScope !== undefined) {
-                        const inBlock = this.currentScope.kind === 242 /* SyntaxKind.Block */;
+                        const inBlock = this.currentScope.kind === 243 /* SyntaxKind.Block */;
                         if (external !== inBlock)
                             return undefined;
                     }
@@ -142,7 +143,7 @@ export class RuntimeSyntax extends Transformer {
                 if (node instanceof Identifier && isIdentifierReference(node, this.parentNode))
                     return this.visitExpressionIdentifier(node);
                 return node;
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                 if (node instanceof ShorthandPropertyAssignment)
                     return this.visitShorthandPropertyAssignment(node);
                 break;
@@ -152,7 +153,7 @@ export class RuntimeSyntax extends Transformer {
     inNamespaceBody() {
         return (this.currentNamespace !== undefined &&
             this.currentScope !== undefined &&
-            this.currentScope.kind !== 242 /* SyntaxKind.Block */);
+            this.currentScope.kind !== 243 /* SyntaxKind.Block */);
     }
     // Scopes
     recordDeclarationInScope(node) {
@@ -187,7 +188,7 @@ export class RuntimeSyntax extends Transformer {
     }
     isExportOfNamespace(node) {
         return (this.currentNamespace !== undefined &&
-            (this.currentScope === undefined || this.currentScope.kind !== 242 /* SyntaxKind.Block */) &&
+            (this.currentScope === undefined || this.currentScope.kind !== 243 /* SyntaxKind.Block */) &&
             hasSyntacticModifier(node, 32 /* ModifierFlags.Export */));
     }
     // Names
@@ -463,7 +464,10 @@ export class RuntimeSyntax extends Transformer {
         const visitedName = this.visitNode(node.name);
         let name = visitedName instanceof Identifier ? visitedName : undefined;
         if (name === undefined &&
-            (exported || childIsDecorated(this.options.experimentalDecorators === true, node.members)))
+            (exported ||
+                childIsDecorated(this.options.experimentalDecorators === true, node.members) ||
+                ((modifierFlagsOf(node) & exportDefault) !== exportDefault &&
+                    nodeIsDecorated(this.options.experimentalDecorators === true, node, undefined, undefined))))
             name = this.factory.createGeneratedNameForNode(node, 0, '', '');
         const updated = this.factory.updateClassDeclaration(node, modifiers, name, undefined, this.visitNodes(node.heritageClauses), this.classMembers(node.members));
         if (!exported)
@@ -691,9 +695,9 @@ function childIsDecorated(legacy, members) {
     return false;
 }
 function hasDecoratedParameter(member) {
-    if (member.kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
-        member.kind !== 179 /* SyntaxKind.SetAccessor */ &&
-        member.kind !== 177 /* SyntaxKind.Constructor */)
+    if (member.kind !== 176 /* SyntaxKind.MethodDeclaration */ &&
+        member.kind !== 180 /* SyntaxKind.SetAccessor */ &&
+        member.kind !== 178 /* SyntaxKind.Constructor */)
         return false;
     const parameters = getParameters(member);
     if (parameters === undefined || getBody(member) === undefined)
@@ -707,11 +711,11 @@ function memberCanBeDecorated(legacy, member) {
     if (legacy && getName(member) instanceof PrivateIdentifier)
         return false;
     switch (member.kind) {
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return legacy || !hasSyntacticModifier(member, 64 /* ModifierFlags.Abstract */ | 128 /* ModifierFlags.Ambient */);
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return getBody(member) !== undefined;
     }
     return false;