fix bug with re-export names when bundling

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+* Fix re-exports when bundling
+
+    This is similar to the fix for re-exports in version 0.5.6 except that it applies when bundling, instead of just when transforming. It needed to be fixed differently because of how cross-file linking works when bundling.
+
 ## 0.5.6
 
 * Fix re-export statements ([#190](https://github.com/evanw/esbuild/issues/190))

internal/ast/ast.go

@@ -854,6 +854,11 @@ type ClauseItem struct {
 	Alias    string
 	AliasLoc Loc
 	Name     LocRef
+
+	// This is needed for "export {foo as bar} from 'path'" statements. This case
+	// is a re-export and "foo" and "bar" are both aliases. We need to preserve
+	// both aliases in case the symbol is renamed.
+	OriginalName string
 }
 
 type Decl struct {

internal/bundler/bundler_test.go

@@ -5350,6 +5350,46 @@ export {
 	})
 }
 
+func TestReExportDefaultExternal(t *testing.T) {
+	expectBundled(t, bundled{
+		files: map[string]string{
+			"/entry.js": `
+				export {default as foo} from 'foo'
+				export {bar} from './bar'
+			`,
+			"/bar.js": `
+				export {default as bar} from 'bar'
+			`,
+		},
+		entryPaths: []string{"/entry.js"},
+		parseOptions: parser.ParseOptions{
+			IsBundling: true,
+		},
+		bundleOptions: BundleOptions{
+			IsBundling:    true,
+			AbsOutputFile: "/out.js",
+		},
+		resolveOptions: resolver.ResolveOptions{
+			ExternalModules: map[string]bool{
+				"foo": true,
+				"bar": true,
+			},
+		},
+		expected: map[string]string{
+			"/out.js": `// /bar.js
+import {default as default2} from "bar";
+
+// /entry.js
+import {default as default3} from "foo";
+export {
+  default2 as bar,
+  default3 as foo
+};
+`,
+		},
+	})
+}
+
 func TestReExportDefaultNoBundle(t *testing.T) {
 	expectBundled(t, bundled{
 		files: map[string]string{

internal/bundler/linker.go

@@ -1754,6 +1754,9 @@ func (c *linkerContext) convertStmtsForChunk(sourceIndex uint32, stmtList *stmtL
 
 			if shouldStripExports {
 				// Turn this statement into "import {foo} from 'path'"
+				for i, item := range s.Items {
+					s.Items[i].Alias = item.OriginalName
+				}
 				stmt.Data = &ast.SImport{
 					NamespaceRef:      s.NamespaceRef,
 					Items:             &s.Items,
@@ -2378,13 +2381,6 @@ func (c *linkerContext) markExportsAsUnbound(sourceIndex uint32) {
 				hasImportOrExport = true
 
 			case *ast.SExportFrom:
-				// This is a re-export and the symbols created here are used to reference
-				// names in another file. This means the symbols are really aliases. The
-				// symbols are marked as "unbound" so that they aren't accidentally renamed
-				// by the code that avoids symbol name collisions.
-				for _, item := range s.Items {
-					c.symbols.Get(item.Name.Ref).Kind = ast.SymbolUnbound
-				}
 				hasImportOrExport = true
 			}
 		}

internal/parser/parser.go

@@ -3745,6 +3745,7 @@ func (p *parser) parseImportClause() ([]ast.ClauseItem, bool) {
 		alias := p.lexer.Identifier
 		aliasLoc := p.lexer.Loc()
 		name := ast.LocRef{aliasLoc, p.storeNameInRef(alias)}
+		originalName := alias
 
 		// The alias may be a keyword
 		isIdentifier := p.lexer.Token == lexer.TIdentifier
@@ -3755,14 +3756,15 @@ func (p *parser) parseImportClause() ([]ast.ClauseItem, bool) {
 
 		if p.lexer.IsContextualKeyword("as") {
 			p.lexer.Next()
-			name = ast.LocRef{p.lexer.Loc(), p.storeNameInRef(p.lexer.Identifier)}
+			originalName := p.lexer.Identifier
+			name = ast.LocRef{p.lexer.Loc(), p.storeNameInRef(originalName)}
 			p.lexer.Expect(lexer.TIdentifier)
 		} else if !isIdentifier {
 			// An import where the name is a keyword must have an alias
 			p.lexer.Unexpected()
 		}
 
-		items = append(items, ast.ClauseItem{alias, aliasLoc, name})
+		items = append(items, ast.ClauseItem{alias, aliasLoc, name, originalName})
 
 		if p.lexer.Token != lexer.TComma {
 			break
@@ -3793,6 +3795,7 @@ func (p *parser) parseExportClause() ([]ast.ClauseItem, bool) {
 		alias := p.lexer.Identifier
 		aliasLoc := p.lexer.Loc()
 		name := ast.LocRef{aliasLoc, p.storeNameInRef(alias)}
+		originalName := alias
 
 		// The name can actually be a keyword if we're really an "export from"
 		// statement. However, we won't know until later. Allow keywords as
@@ -3826,7 +3829,7 @@ func (p *parser) parseExportClause() ([]ast.ClauseItem, bool) {
 			p.lexer.Next()
 		}
 
-		items = append(items, ast.ClauseItem{alias, aliasLoc, name})
+		items = append(items, ast.ClauseItem{alias, aliasLoc, name, originalName})
 
 		if p.lexer.Token != lexer.TComma {
 			break
@@ -9310,8 +9313,9 @@ func (p *parser) scanForImportsAndExports(stmts []ast.Stmt, isBundling bool) []a
 						if items == nil {
 							items = &[]ast.ClauseItem{}
 						}
-						for name, item := range importItems {
-							*items = append(*items, ast.ClauseItem{name, item.Loc, item})
+						for alias, name := range importItems {
+							originalName := p.symbols[name.Ref.InnerIndex].Name
+							*items = append(*items, ast.ClauseItem{alias, name.Loc, name, originalName})
 						}
 						s.Items = items
 					}

internal/printer/printer.go

@@ -2199,15 +2199,78 @@ func (p *printer) printStmt(stmt ast.Stmt) {
 		p.printSpaceBeforeIdentifier()
 		p.print("export")
 		p.printSpace()
-		p.printExportClause(s.Items, s.IsSingleLine)
+		p.print("{")
+
+		if !s.IsSingleLine {
+			p.options.Indent++
+		}
+
+		for i, item := range s.Items {
+			if i != 0 {
+				p.print(",")
+				if s.IsSingleLine {
+					p.printSpace()
+				}
+			}
+
+			if !s.IsSingleLine {
+				p.printNewline()
+				p.printIndent()
+			}
+			name := p.symbolName(item.Name.Ref)
+			p.print(name)
+			if name != item.Alias {
+				p.print(" as ")
+				p.print(item.Alias)
+			}
+		}
+
+		if !s.IsSingleLine {
+			p.options.Indent--
+			p.printNewline()
+			p.printIndent()
+		}
+
+		p.print("}")
 		p.printSemicolonAfterStatement()
 
 	case *ast.SExportFrom:
 		p.printIndent()
 		p.printSpaceBeforeIdentifier()
 		p.print("export")
 		p.printSpace()
-		p.printExportClause(s.Items, s.IsSingleLine)
+		p.print("{")
+
+		if !s.IsSingleLine {
+			p.options.Indent++
+		}
+
+		for i, item := range s.Items {
+			if i != 0 {
+				p.print(",")
+				if s.IsSingleLine {
+					p.printSpace()
+				}
+			}
+
+			if !s.IsSingleLine {
+				p.printNewline()
+				p.printIndent()
+			}
+			p.print(item.OriginalName)
+			if item.OriginalName != item.Alias {
+				p.print(" as ")
+				p.print(item.Alias)
+			}
+		}
+
+		if !s.IsSingleLine {
+			p.options.Indent--
+			p.printNewline()
+			p.printIndent()
+		}
+
+		p.print("}")
 		p.printSpace()
 		p.print("from")
 		p.printSpace()
@@ -2556,40 +2619,6 @@ func (p *printer) printStmt(stmt ast.Stmt) {
 	}
 }
 
-func (p *printer) printExportClause(items []ast.ClauseItem, isSingleLine bool) {
-	p.print("{")
-	if !isSingleLine {
-		p.options.Indent++
-	}
-
-	for i, item := range items {
-		if i != 0 {
-			p.print(",")
-			if isSingleLine {
-				p.printSpace()
-			}
-		}
-
-		if !isSingleLine {
-			p.printNewline()
-			p.printIndent()
-		}
-		name := p.symbolName(item.Name.Ref)
-		p.print(name)
-		if name != item.Alias {
-			p.print(" as ")
-			p.print(item.Alias)
-		}
-	}
-
-	if !isSingleLine {
-		p.options.Indent--
-		p.printNewline()
-		p.printIndent()
-	}
-	p.print("}")
-}
-
 type PrintOptions struct {
 	OutputFormat      Format
 	RemoveWhitespace  bool