Remove EndOfDeclarationMarker and MergeDeclarationMarker nodes (#53901)

Author: rbuckton

src/compiler/checker.ts

@@ -3037,6 +3037,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // (it refers to the constant type of the expression instead)
                 return undefined;
             }
+            if (isModuleDeclaration(location) && lastLocation && location.name === lastLocation) {
+                // If this is the name of a namespace, skip the parent since it will have is own locals that could
+                // conflict.
+                lastLocation = location;
+                location = location.parent;
+            }
             // Locals of a source file are not in scope (because they get merged into the global symbol table)
             if (canHaveLocals(location) && location.locals && !isGlobalSourceFile(location)) {
                 if (result = lookup(location.locals, name, meaning)) {
@@ -3331,6 +3337,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         }
                     }
                     break;
+                case SyntaxKind.ExportSpecifier:
+                    // External module export bindings shouldn't be resolved to local symbols.
+                    if (lastLocation &&
+                        lastLocation === (location as ExportSpecifier).propertyName &&
+                        (location as ExportSpecifier).parent.parent.moduleSpecifier) {
+                        location = location.parent.parent.parent;
+                    }
+                    break;
             }
             if (isSelfReferenceLocation(location)) {
                 lastSelfReferenceLocation = location;
@@ -46474,6 +46488,43 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return undefined;
     }
 
+    function getReferencedValueDeclarations(referenceIn: Identifier): Declaration[] | undefined {
+        if (!isGeneratedIdentifier(referenceIn)) {
+            const reference = getParseTreeNode(referenceIn, isIdentifier);
+            if (reference) {
+                const symbol = getReferencedValueSymbol(reference);
+                if (symbol) {
+                    return filter(getExportSymbolOfValueSymbolIfExported(symbol).declarations, declaration => {
+                        switch (declaration.kind) {
+                            case SyntaxKind.VariableDeclaration:
+                            case SyntaxKind.Parameter:
+                            case SyntaxKind.BindingElement:
+                            case SyntaxKind.PropertyDeclaration:
+                            case SyntaxKind.PropertyAssignment:
+                            case SyntaxKind.ShorthandPropertyAssignment:
+                            case SyntaxKind.EnumMember:
+                            case SyntaxKind.ObjectLiteralExpression:
+                            case SyntaxKind.FunctionDeclaration:
+                            case SyntaxKind.FunctionExpression:
+                            case SyntaxKind.ArrowFunction:
+                            case SyntaxKind.ClassDeclaration:
+                            case SyntaxKind.ClassExpression:
+                            case SyntaxKind.EnumDeclaration:
+                            case SyntaxKind.MethodDeclaration:
+                            case SyntaxKind.GetAccessor:
+                            case SyntaxKind.SetAccessor:
+                            case SyntaxKind.ModuleDeclaration:
+                                return true;
+                        }
+                        return false;
+                    });
+                }
+            }
+        }
+
+        return undefined;
+    }
+
     function isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean {
         if (isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node)) {
             return isFreshLiteralType(getTypeOfSymbol(getSymbolOfDeclaration(node)));
@@ -46581,6 +46632,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             },
             collectLinkedAliases,
             getReferencedValueDeclaration,
+            getReferencedValueDeclarations,
             getTypeReferenceSerializationKind,
             isOptionalParameter,
             moduleExportsSomeValue,

src/compiler/emitter.ts

@@ -1155,6 +1155,7 @@ export const notImplementedResolver: EmitResolver = {
     // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant
     getConstantValue: notImplemented,
     getReferencedValueDeclaration: notImplemented,
+    getReferencedValueDeclarations: notImplemented,
     getTypeReferenceSerializationKind: notImplemented,
     isOptionalParameter: notImplemented,
     moduleExportsSomeValue: notImplemented,
@@ -2178,8 +2179,6 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
 
                 // Transformation nodes
                 case SyntaxKind.NotEmittedStatement:
-                case SyntaxKind.EndOfDeclarationMarker:
-                case SyntaxKind.MergeDeclarationMarker:
                     return;
             }
             if (isExpression(node)) {
@@ -2298,9 +2297,6 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
                     return emitPartiallyEmittedExpression(node as PartiallyEmittedExpression);
                 case SyntaxKind.CommaListExpression:
                     return emitCommaList(node as CommaListExpression);
-                case SyntaxKind.MergeDeclarationMarker:
-                case SyntaxKind.EndOfDeclarationMarker:
-                    return;
                 case SyntaxKind.SyntheticReferenceExpression:
                     return Debug.fail("SyntheticReferenceExpression should not be printed");
             }

src/compiler/factory/nodeFactory.ts

@@ -79,7 +79,6 @@ import {
     EmitNode,
     emptyArray,
     EmptyStatement,
-    EndOfDeclarationMarker,
     EndOfFileToken,
     EntityName,
     EnumDeclaration,
@@ -121,6 +120,7 @@ import {
     getLineAndCharacterOfPosition,
     getNameOfDeclaration,
     getNodeId,
+    getNonAssignedNameOfDeclaration,
     getSourceMapRange,
     getSyntheticLeadingComments,
     getSyntheticTrailingComments,
@@ -298,7 +298,6 @@ import {
     MemberName,
     memoize,
     memoizeOne,
-    MergeDeclarationMarker,
     MetaProperty,
     MethodDeclaration,
     MethodSignature,
@@ -946,8 +945,6 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
         updatePartiallyEmittedExpression,
         createCommaListExpression,
         updateCommaListExpression,
-        createEndOfDeclarationMarker,
-        createMergeDeclarationMarker,
         createSyntheticReferenceExpression,
         updateSyntheticReferenceExpression,
         cloneNode,
@@ -6210,30 +6207,6 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
             : node;
     }
 
-    /**
-     * Creates a synthetic element to act as a placeholder for the end of an emitted declaration in
-     * order to properly emit exports.
-     */
-    // @api
-    function createEndOfDeclarationMarker(original: Node) {
-        const node = createBaseNode<EndOfDeclarationMarker>(SyntaxKind.EndOfDeclarationMarker);
-        node.emitNode = {} as EmitNode;
-        node.original = original;
-        return node;
-    }
-
-    /**
-     * Creates a synthetic element to act as a placeholder for the beginning of a merged declaration in
-     * order to properly emit exports.
-     */
-    // @api
-    function createMergeDeclarationMarker(original: Node) {
-        const node = createBaseNode<MergeDeclarationMarker>(SyntaxKind.MergeDeclarationMarker);
-        node.emitNode = {} as EmitNode;
-        node.original = original;
-        return node;
-    }
-
     // @api
     function createSyntheticReferenceExpression(expression: Expression, thisArg: Expression) {
         const node = createBaseNode<SyntheticReferenceExpression>(SyntaxKind.SyntheticReferenceExpression);
@@ -6672,8 +6645,8 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
             : reduceLeft(expressions, factory.createComma)!;
     }
 
-    function getName(node: Declaration | undefined, allowComments?: boolean, allowSourceMaps?: boolean, emitFlags: EmitFlags = 0) {
-        const nodeName = getNameOfDeclaration(node);
+    function getName(node: Declaration | undefined, allowComments?: boolean, allowSourceMaps?: boolean, emitFlags: EmitFlags = 0, ignoreAssignedName?: boolean) {
+        const nodeName = ignoreAssignedName ? node && getNonAssignedNameOfDeclaration(node) : getNameOfDeclaration(node);
         if (nodeName && isIdentifier(nodeName) && !isGeneratedIdentifier(nodeName)) {
             // TODO(rbuckton): Does this need to be parented?
             const name = setParent(setTextRange(cloneNode(nodeName), nodeName), nodeName.parent);
@@ -6710,9 +6683,10 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode
      * @param node The declaration.
      * @param allowComments A value indicating whether comments may be emitted for the name.
      * @param allowSourceMaps A value indicating whether source maps may be emitted for the name.
+     * @param ignoreAssignedName Indicates that the assigned name of a declaration shouldn't be considered.
      */
-    function getLocalName(node: Declaration, allowComments?: boolean, allowSourceMaps?: boolean) {
-        return getName(node, allowComments, allowSourceMaps, EmitFlags.LocalName);
+    function getLocalName(node: Declaration, allowComments?: boolean, allowSourceMaps?: boolean, ignoreAssignedName?: boolean) {
+        return getName(node, allowComments, allowSourceMaps, EmitFlags.LocalName, ignoreAssignedName);
     }
 
     /**

src/compiler/factory/nodeTests.ts

@@ -46,7 +46,6 @@ import {
     DotDotDotToken,
     ElementAccessExpression,
     EmptyStatement,
-    EndOfDeclarationMarker,
     EnumDeclaration,
     EnumMember,
     EqualsGreaterThanToken,
@@ -137,7 +136,6 @@ import {
     LabeledStatement,
     LiteralTypeNode,
     MappedTypeNode,
-    MergeDeclarationMarker,
     MetaProperty,
     MethodDeclaration,
     MethodSignature,
@@ -902,16 +900,6 @@ export function isSyntheticReference(node: Node): node is SyntheticReferenceExpr
     return node.kind === SyntaxKind.SyntheticReferenceExpression;
 }
 
-/** @internal */
-export function isMergeDeclarationMarker(node: Node): node is MergeDeclarationMarker {
-    return node.kind === SyntaxKind.MergeDeclarationMarker;
-}
-
-/** @internal */
-export function isEndOfDeclarationMarker(node: Node): node is EndOfDeclarationMarker {
-    return node.kind === SyntaxKind.EndOfDeclarationMarker;
-}
-
 // Module References
 
 export function isExternalModuleReference(node: Node): node is ExternalModuleReference {

src/compiler/transformers/classFields.ts

@@ -93,6 +93,7 @@ import {
     isConstructorDeclaration,
     isDestructuringAssignment,
     isElementAccessExpression,
+    isExportOrDefaultModifier,
     isExpression,
     isExpressionStatement,
     isForInitializer,
@@ -1843,25 +1844,13 @@ export function transformClassFields(context: TransformationContext): (x: Source
             }
         }
 
-        const modifiers = visitNodes(node.modifiers, modifierVisitor, isModifier);
+        const isExport = hasSyntacticModifier(node, ModifierFlags.Export);
+        const isDefault = hasSyntacticModifier(node, ModifierFlags.Default);
+        let modifiers = visitNodes(node.modifiers, modifierVisitor, isModifier);
         const heritageClauses = visitNodes(node.heritageClauses, heritageClauseVisitor, isHeritageClause);
         const { members, prologue } = transformClassMembers(node);
-        const classDecl = factory.updateClassDeclaration(
-            node,
-            modifiers,
-            node.name,
-            /*typeParameters*/ undefined,
-            heritageClauses,
-            members
-        );
 
         const statements: Statement[] = [];
-        if (prologue) {
-            statements.push(factory.createExpressionStatement(prologue));
-        }
-
-        statements.push(classDecl);
-
         if (pendingClassReferenceAssignment) {
             getPendingExpressions().unshift(pendingClassReferenceAssignment);
         }
@@ -1884,6 +1873,29 @@ export function transformClassFields(context: TransformationContext): (x: Source
             }
         }
 
+        if (statements.length > 0 && isExport && isDefault) {
+            modifiers = visitNodes(modifiers, node => isExportOrDefaultModifier(node) ? undefined : node, isModifier);
+            statements.push(factory.createExportAssignment(
+                /*modifiers*/ undefined,
+                /*isExportEquals*/ false,
+                factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true)
+            ));
+        }
+
+        const classDecl = factory.updateClassDeclaration(
+            node,
+            modifiers,
+            node.name,
+            /*typeParameters*/ undefined,
+            heritageClauses,
+            members
+        );
+        statements.unshift(classDecl);
+
+        if (prologue) {
+            statements.unshift(factory.createExpressionStatement(prologue));
+        }
+
         return statements;
     }
 

src/compiler/transformers/es2015.ts

@@ -966,13 +966,6 @@ export function transformES2015(context: TransformationContext): (x: SourceFile
             statements.push(exportStatement);
         }
 
-        const emitFlags = getEmitFlags(node);
-        if ((emitFlags & EmitFlags.HasEndOfDeclarationMarker) === 0) {
-            // Add a DeclarationMarker as a marker for the end of the declaration
-            statements.push(factory.createEndOfDeclarationMarker(node));
-            setEmitFlags(statement, emitFlags | EmitFlags.HasEndOfDeclarationMarker);
-        }
-
         return singleOrMany(statements);
     }
 

src/compiler/transformers/esDecorators.ts

@@ -640,7 +640,7 @@ export function transformESDecorators(context: TransformationContext): (x: Sourc
     function transformClassLike(node: ClassLikeDeclaration, className: Expression) {
         startLexicalEnvironment();
 
-        const classReference = node.name ?? factory.getGeneratedNameForNode(node);
+        const classReference = factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ false, /*ignoreAssignedName*/ true);
         const classInfo = createClassInfo(node);
         const classDefinitionStatements: Statement[] = [];
         let leadingBlockStatements: Statement[] | undefined;
@@ -1013,6 +1013,8 @@ export function transformESDecorators(context: TransformationContext): (x: Sourc
                     factory.getInternalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true) :
                     factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true);
                 const varDecl = factory.createVariableDeclaration(declName, /*exclamationToken*/ undefined, /*type*/ undefined, iife);
+                setOriginalNode(varDecl, node);
+
                 const varDecls = factory.createVariableDeclarationList([varDecl], NodeFlags.Let);
                 const statement = factory.createVariableStatement(modifiers, varDecls);
                 setOriginalNode(statement, node);