Fix emit for leading 'var' declarations for synthesized namespaces

src/compiler/transformers/ts.ts

@@ -2639,9 +2639,6 @@ namespace ts {
         /**
          * Records that a declaration was emitted in the current scope, if it was the first
          * declaration for the provided symbol.
-         *
-         * NOTE: if there is ever a transformation above this one, we may not be able to rely
-         *       on symbol names.
          */
         function recordEmittedDeclarationInScope(node: Node) {
             const name = node.symbol && node.symbol.escapedName;
@@ -2657,18 +2654,22 @@ namespace ts {
         }
 
         /**
-         * Determines whether a declaration is the first declaration with the same name emitted
-         * in the current scope.
+         * Determines whether a declaration is *could* be the first declaration with
+         * the same name emitted in the current scope. Only returns false if we are absolutely
+         * certain a previous declaration has been emitted.
          */
-        function isFirstEmittedDeclarationInScope(node: Node) {
+        function isPotentiallyFirstEmittedDeclarationInScope(node: Node) {
+            // If the node has a named symbol, then we have enough knowledge to determine
+            // whether a prior declaration has been emitted.
             if (currentScopeFirstDeclarationsOfName) {
                 const name = node.symbol && node.symbol.escapedName;
                 if (name) {
                     return currentScopeFirstDeclarationsOfName.get(name) === node;
                 }
             }
 
-            return false;
+            // Otherwise, we can't be sure. For example, this node could be synthetic.
+            return true;
         }
 
         /**
@@ -2690,7 +2691,7 @@ namespace ts {
             setOriginalNode(statement, node);
 
             recordEmittedDeclarationInScope(node);
-            if (isFirstEmittedDeclarationInScope(node)) {
+            if (isPotentiallyFirstEmittedDeclarationInScope(node)) {
                 // Adjust the source map emit to match the old emitter.
                 if (node.kind === SyntaxKind.EnumDeclaration) {
                     setSourceMapRange(statement.declarationList, node);

src/harness/unittests/transform.ts

@@ -74,6 +74,32 @@ namespace ts {
                 }
             }).outputText;
         });
+
+        testBaseline("synthesizedNamespace", () => {
+            return ts.transpileModule(`namespace Reflect { const x = 1; }`, {
+                transformers: {
+                    before: [forceSyntheticModuleDeclaration],
+                },
+                compilerOptions: {
+                    newLine: NewLineKind.CarriageReturnLineFeed,
+                }
+            }).outputText;
+
+            function forceSyntheticModuleDeclaration(context: ts.TransformationContext) {
+                return (sourceFile: ts.SourceFile): ts.SourceFile => {
+                    return visitNode(sourceFile);
+
+                    function visitNode<T extends ts.Node>(node: T): T {
+                        if (node.kind === ts.SyntaxKind.ModuleBlock) {
+                            const block = node as T & ts.ModuleBlock;
+                            const statements = ts.createNodeArray([...block.statements]);
+                            return ts.updateModuleBlock(block, statements) as typeof block;
+                        }
+                        return ts.visitEachChild(node, visitNode, context);
+                    }
+                };
+            }
+        });
     });
 }
 

tests/baselines/reference/parserEnumDeclaration4.js

@@ -3,6 +3,7 @@ enum void {
 }
 
 //// [parserEnumDeclaration4.js]
+var ;
 (function () {
 })( || ( = {}));
 void {};

tests/baselines/reference/reservedWords2.js

@@ -35,6 +35,7 @@ debugger;
 if ()
     ;
 [1, 2];
+var ;
 (function () {
 })( || ( = {}));
 void {};

tests/baselines/reference/transformApi/transformsCorrectly.synthesizedNamespace.js

@@ -0,0 +1,4 @@
+var Reflect;
+(function (Reflect) {
+    var x = 1;
+})(Reflect || (Reflect = {}));