Merge branch 'master' into doc-search

rollup · Feb 1, 2023 · 1265b01 · 1265b01
2 parents 8cf20fc + ef25721
commit 1265b01
Show file tree

Hide file tree

Showing 32 changed files with 485 additions and 19 deletions.
diff --git a/src/Chunk.ts b/src/Chunk.ts
@@ -710,13 +710,15 @@ export default class Chunk {
 				alternativeReexportModule = importingModule.alternativeReexportModules.get(variable);
 				if (alternativeReexportModule) {
 					const exportingChunk = this.chunkByModule.get(alternativeReexportModule);
-					if (exportingChunk && exportingChunk !== exportChunk) {
+					if (exportingChunk !== exportChunk) {
 						this.inputOptions.onwarn(
 							errorCyclicCrossChunkReexport(
-								variableModule.getExportNamesByVariable().get(variable)![0],
+								// Namespaces do not have an export name
+								variableModule.getExportNamesByVariable().get(variable)?.[0] || '*',
 								variableModule.id,
 								alternativeReexportModule.id,
-								importingModule.id
+								importingModule.id,
+								this.outputOptions.preserveModules
 							)
 						);
 					}
@@ -732,8 +734,10 @@ export default class Chunk {
 		for (const exportedVariable of map.keys()) {
 			const isSynthetic = exportedVariable instanceof SyntheticNamedExportVariable;
 			const importedVariable = isSynthetic ? exportedVariable.getBaseVariable() : exportedVariable;
+			this.checkCircularDependencyImport(importedVariable, module);
+			// When preserving modules, we do not create namespace objects but directly
+			// use the actual namespaces, which would be broken by this logic.
 			if (!(importedVariable instanceof NamespaceVariable && this.outputOptions.preserveModules)) {
-				this.checkCircularDependencyImport(importedVariable, module);
 				const exportingModule = importedVariable.module;
 				if (exportingModule instanceof Module) {
 					const chunk = this.chunkByModule.get(exportingModule);
@@ -1164,7 +1168,8 @@ export default class Chunk {
 			indent,
 			namespaceToStringTag,
 			pluginDriver,
-			snippets
+			snippets,
+			useOriginalName: null
 		};
 
 		let usesTopLevelAwait = false;
@@ -1373,12 +1378,13 @@ export default class Chunk {
 			const chunk = this.chunkByModule.get(variable.module as Module);
 			if (chunk !== this) {
 				this.imports.add(variable);
-				if (
-					!(variable instanceof NamespaceVariable && this.outputOptions.preserveModules) &&
-					variable.module instanceof Module
-				) {
-					chunk!.exports.add(variable);
+				if (variable.module instanceof Module) {
 					this.checkCircularDependencyImport(variable, module);
+					// When preserving modules, we do not create namespace objects but directly
+					// use the actual namespaces, which would be broken by this logic.
+					if (!(variable instanceof NamespaceVariable && this.outputOptions.preserveModules)) {
+						chunk!.exports.add(variable);
+					}
 				}
 			}
 		}

diff --git a/src/ast/nodes/ClassDeclaration.ts b/src/ast/nodes/ClassDeclaration.ts
@@ -2,6 +2,7 @@ import type MagicString from 'magic-string';
 import type { RenderOptions } from '../../utils/renderHelpers';
 import { getSystemExportStatement } from '../../utils/systemJsRendering';
 import type ChildScope from '../scopes/ChildScope';
+import type Variable from '../variables/Variable';
 import Identifier, { type IdentifierWithVariable } from './Identifier';
 import type * as NodeType from './NodeType';
 import ClassNode from './shared/ClassNode';
@@ -43,7 +44,10 @@ export default class ClassDeclaration extends ClassNode {
 			const renderedVariable = variable.getName(getPropertyAccess);
 			if (renderedVariable !== name) {
 				this.superClass?.render(code, options);
-				this.body.render(code, options);
+				this.body.render(code, {
+					...options,
+					useOriginalName: (_variable: Variable) => _variable === variable
+				});
 				code.prependRight(this.start, `let ${renderedVariable}${_}=${_}`);
 				code.prependLeft(this.end, ';');
 				return;

diff --git a/src/ast/nodes/Identifier.ts b/src/ast/nodes/Identifier.ts
@@ -244,11 +244,11 @@ export default class Identifier extends NodeBase implements PatternNode {
 
 	render(
 		code: MagicString,
-		{ snippets: { getPropertyAccess } }: RenderOptions,
+		{ snippets: { getPropertyAccess }, useOriginalName }: RenderOptions,
 		{ renderedParentType, isCalleeOfRenderedParent, isShorthandProperty }: NodeRenderOptions = BLANK
 	): void {
 		if (this.variable) {
-			const name = this.variable.getName(getPropertyAccess);
+			const name = this.variable.getName(getPropertyAccess, useOriginalName);
 
 			if (name !== this.name) {
 				code.overwrite(this.start, this.end, name, {

diff --git a/src/ast/variables/Variable.ts b/src/ast/variables/Variable.ts
@@ -1,5 +1,6 @@
 import type ExternalModule from '../../ExternalModule';
 import type Module from '../../Module';
+import type { RenderOptions } from '../../utils/renderHelpers';
 import type { HasEffectsContext } from '../ExecutionContext';
 import type { NodeInteraction } from '../NodeInteractions';
 import { INTERACTION_ACCESSED } from '../NodeInteractions';
@@ -42,7 +43,13 @@ export default class Variable extends ExpressionEntity {
 		return this.renderBaseName || this.renderName || this.name;
 	}
 
-	getName(getPropertyAccess: (name: string) => string): string {
+	getName(
+		getPropertyAccess: (name: string) => string,
+		useOriginalName?: RenderOptions['useOriginalName']
+	): string {
+		if (useOriginalName?.(this)) {
+			return this.name;
+		}
 		const name = this.renderName || this.name;
 		return this.renderBaseName ? `${this.renderBaseName}${getPropertyAccess(name)}` : name;
 	}

diff --git a/src/utils/error.ts b/src/utils/error.ts
@@ -259,7 +259,8 @@ export function errorCyclicCrossChunkReexport(
 	exportName: string,
 	exporter: string,
 	reexporter: string,
-	importer: string
+	importer: string,
+	preserveModules: boolean
 ): RollupLog {
 	return {
 		code: CYCLIC_CROSS_CHUNK_REEXPORT,
@@ -271,7 +272,9 @@ export function errorCyclicCrossChunkReexport(
 			reexporter
 		)}" while both modules are dependencies of each other and will end up in different chunks by current Rollup settings. This scenario is not well supported at the moment as it will produce a circular dependency between chunks and will likely lead to broken execution order.\nEither change the import in "${relativeId(
 			importer
-		)}" to point directly to the exporting module or do not use "preserveModules" to ensure these modules end up in the same chunk.`,
+		)}" to point directly to the exporting module or ${
+			preserveModules ? 'do not use "output.preserveModules"' : 'reconfigure "output.manualChunks"'
+		} to ensure these modules end up in the same chunk.`,
 		reexporter
 	};
 }

diff --git a/src/utils/renderHelpers.ts b/src/utils/renderHelpers.ts
@@ -15,6 +15,7 @@ export interface RenderOptions {
 	namespaceToStringTag: boolean;
 	pluginDriver: PluginDriver;
 	snippets: GenerateCodeSnippets;
+	useOriginalName: ((variable: Variable) => boolean) | null;
 }
 
 export interface NodeRenderOptions {

diff --git a/test/form/samples/use-class-name-in-static-block/_config.js b/test/form/samples/use-class-name-in-static-block/_config.js
@@ -0,0 +1,3 @@
+module.exports = {
+	description: 'use the original class name instead of renderName in class body'
+};
diff --git a/test/form/samples/use-class-name-in-static-block/_expected/amd.js b/test/form/samples/use-class-name-in-static-block/_expected/amd.js
@@ -0,0 +1,36 @@
+define((function () { 'use strict';
+
+	let Test$1 = class Test {
+		constructor() {
+			assert.ok(Test.test);
+			assert.ok(this.getText());
+		}
+		getText() {
+			return Test.test;
+		}
+		static test = 'Test1';
+		static {
+			assert.ok(Test.test);
+			new Test();
+		}
+	};
+
+	class Test {
+		constructor() {
+			assert.ok(Test.test);
+			assert.ok(this.getText());
+		}
+		getText() {
+			return Test.test;
+		}
+		static test = 'Test2';
+		static {
+			assert.ok(Test.test);
+			new Test();
+		}
+	}
+
+	assert.ok(Test$1.test);
+	assert.ok(Test.test);
+
+}));
diff --git a/test/form/samples/use-class-name-in-static-block/_expected/cjs.js b/test/form/samples/use-class-name-in-static-block/_expected/cjs.js
@@ -0,0 +1,34 @@
+'use strict';
+
+let Test$1 = class Test {
+	constructor() {
+		assert.ok(Test.test);
+		assert.ok(this.getText());
+	}
+	getText() {
+		return Test.test;
+	}
+	static test = 'Test1';
+	static {
+		assert.ok(Test.test);
+		new Test();
+	}
+};
+
+class Test {
+	constructor() {
+		assert.ok(Test.test);
+		assert.ok(this.getText());
+	}
+	getText() {
+		return Test.test;
+	}
+	static test = 'Test2';
+	static {
+		assert.ok(Test.test);
+		new Test();
+	}
+}
+
+assert.ok(Test$1.test);
+assert.ok(Test.test);
diff --git a/test/form/samples/use-class-name-in-static-block/_expected/es.js b/test/form/samples/use-class-name-in-static-block/_expected/es.js
@@ -0,0 +1,32 @@
+let Test$1 = class Test {
+	constructor() {
+		assert.ok(Test.test);
+		assert.ok(this.getText());
+	}
+	getText() {
+		return Test.test;
+	}
+	static test = 'Test1';
+	static {
+		assert.ok(Test.test);
+		new Test();
+	}
+};
+
+class Test {
+	constructor() {
+		assert.ok(Test.test);
+		assert.ok(this.getText());
+	}
+	getText() {
+		return Test.test;
+	}
+	static test = 'Test2';
+	static {
+		assert.ok(Test.test);
+		new Test();
+	}
+}
+
+assert.ok(Test$1.test);
+assert.ok(Test.test);
diff --git a/test/form/samples/use-class-name-in-static-block/_expected/iife.js b/test/form/samples/use-class-name-in-static-block/_expected/iife.js
@@ -0,0 +1,37 @@
+(function () {
+	'use strict';
+
+	let Test$1 = class Test {
+		constructor() {
+			assert.ok(Test.test);
+			assert.ok(this.getText());
+		}
+		getText() {
+			return Test.test;
+		}
+		static test = 'Test1';
+		static {
+			assert.ok(Test.test);
+			new Test();
+		}
+	};
+
+	class Test {
+		constructor() {
+			assert.ok(Test.test);
+			assert.ok(this.getText());
+		}
+		getText() {
+			return Test.test;
+		}
+		static test = 'Test2';
+		static {
+			assert.ok(Test.test);
+			new Test();
+		}
+	}
+
+	assert.ok(Test$1.test);
+	assert.ok(Test.test);
+
+})();
diff --git a/test/form/samples/use-class-name-in-static-block/_expected/system.js b/test/form/samples/use-class-name-in-static-block/_expected/system.js
@@ -0,0 +1,41 @@
+System.register([], (function () {
+	'use strict';
+	return {
+		execute: (function () {
+
+			let Test$1 = class Test {
+				constructor() {
+					assert.ok(Test.test);
+					assert.ok(this.getText());
+				}
+				getText() {
+					return Test.test;
+				}
+				static test = 'Test1';
+				static {
+					assert.ok(Test.test);
+					new Test();
+				}
+			};
+
+			class Test {
+				constructor() {
+					assert.ok(Test.test);
+					assert.ok(this.getText());
+				}
+				getText() {
+					return Test.test;
+				}
+				static test = 'Test2';
+				static {
+					assert.ok(Test.test);
+					new Test();
+				}
+			}
+
+			assert.ok(Test$1.test);
+			assert.ok(Test.test);
+
+		})
+	};
+}));
diff --git a/test/form/samples/use-class-name-in-static-block/_expected/umd.js b/test/form/samples/use-class-name-in-static-block/_expected/umd.js
@@ -0,0 +1,39 @@
+(function (factory) {
+	typeof define === 'function' && define.amd ? define(factory) :
+	factory();
+})((function () { 'use strict';
+
+	let Test$1 = class Test {
+		constructor() {
+			assert.ok(Test.test);
+			assert.ok(this.getText());
+		}
+		getText() {
+			return Test.test;
+		}
+		static test = 'Test1';
+		static {
+			assert.ok(Test.test);
+			new Test();
+		}
+	};
+
+	class Test {
+		constructor() {
+			assert.ok(Test.test);
+			assert.ok(this.getText());
+		}
+		getText() {
+			return Test.test;
+		}
+		static test = 'Test2';
+		static {
+			assert.ok(Test.test);
+			new Test();
+		}
+	}
+
+	assert.ok(Test$1.test);
+	assert.ok(Test.test);
+
+}));
diff --git a/test/form/samples/use-class-name-in-static-block/main.js b/test/form/samples/use-class-name-in-static-block/main.js
@@ -0,0 +1,5 @@
+import { Test } from './test1.js';
+import { Test as Test2 } from './test2.js';
+
+assert.ok(Test.test);
+assert.ok(Test2.test);
diff --git a/test/form/samples/use-class-name-in-static-block/test1.js b/test/form/samples/use-class-name-in-static-block/test1.js
@@ -0,0 +1,14 @@
+export class Test {
+	constructor() {
+		assert.ok(Test.test);
+		assert.ok(this.getText());
+	}
+	getText() {
+		return Test.test;
+	}
+	static test = 'Test1';
+	static {
+		assert.ok(Test.test);
+		new Test();
+	}
+}