Refactor tree-shaking rendering

src/Chunk.ts

@@ -517,7 +517,7 @@ export default class Chunk {
 			forOwn(module.scope.variables, variable => {
 				if (!(<ExportDefaultVariable>variable).isDefault || !(<ExportDefaultVariable>variable).hasId) {
 					let safeName;
-					if (es || system || !variable.isReassigned) {
+					if (es || system || !variable.isReassigned || variable.isId) {
 						safeName = getSafeName(variable.name);
 					} else {
 						const safeExportName = this.exportedVariables.get(variable);

src/Module.ts

@@ -38,7 +38,7 @@ import { isTemplateLiteral } from './ast/nodes/TemplateLiteral';
 import { isLiteral } from './ast/nodes/Literal';
 import Chunk, { DynamicImportMechanism } from './Chunk';
 
-export interface IdMap { [key: string]: string; }
+export interface IdMap {[key: string]: string;}
 
 export interface CommentDescription {
 	block: boolean;
@@ -107,7 +107,15 @@ export interface RenderOptions {
 	freeze: boolean;
 	importMechanism?: DynamicImportMechanism;
 	systemBindings: boolean;
-};
+}
+
+export interface NodeRenderOptions {
+	start?: number,
+	end?: number,
+	isNoStatement?: boolean
+}
+
+export const NO_SEMICOLON: NodeRenderOptions = { isNoStatement: true };
 
 export default class Module {
 	type: 'Module';
@@ -251,7 +259,7 @@ export default class Module {
 
 		// export { name } from './other'
 		if (source) {
-			if (!~this.sources.indexOf(source)) this.sources.push(source);
+			if (this.sources.indexOf(source) === -1) this.sources.push(source);
 
 			if (node.type === NodeType.ExportAllDeclaration) {
 				// Store `export * from '...'` statements in an array of delegates.
@@ -343,7 +351,7 @@ export default class Module {
 	private addImport (node: ImportDeclaration) {
 		const source = node.source.value;
 
-		if (!~this.sources.indexOf(source)) this.sources.push(source);
+		if (this.sources.indexOf(source) === -1) this.sources.push(source);
 
 		node.specifiers.forEach(specifier => {
 			const localName = specifier.local.name;
@@ -369,20 +377,13 @@ export default class Module {
 	}
 
 	private analyse () {
-		enhance(this.ast, this, this.comments, this.dynamicImports);
-
-		// discover this module's imports and exports
-		let lastNode: Node;
-
+		enhance(this.ast, this, this.dynamicImports);
 		this.ast.body.forEach(node => {
 			if ((<ImportDeclaration>node).isImportDeclaration) {
 				this.addImport(<ImportDeclaration>node);
 			} else if ((<ExportDefaultDeclaration | ExportNamedDeclaration | ExportAllDeclaration>node).isExportDeclaration) {
 				this.addExport((<ExportDefaultDeclaration | ExportNamedDeclaration | ExportAllDeclaration>node));
 			}
-
-			if (lastNode) lastNode.next = node.leadingCommentStart || node.start;
-			lastNode = node;
 		});
 	}
 
@@ -588,10 +589,7 @@ export default class Module {
 
 	render (options: RenderOptions): MagicString {
 		const magicString = this.magicString.clone();
-
-		this.ast.body.forEach(node => {
-			node.render(magicString, options);
-		});
+		this.ast.render(magicString, options);
 
 		if (this.namespace().needsNamespaceBlock) {
 			magicString.append(
@@ -648,7 +646,7 @@ export default class Module {
 			// namespace
 			if (name.length === 1) {
 				return this.namespace();
-			// export * from 'external'
+				// export * from 'external'
 			} else {
 				const module = <ExternalModule>this.graph.moduleById.get(name.slice(1));
 				return module.traceExport('*');

src/ast/enhance.ts

@@ -3,31 +3,13 @@ import UnknownNode from './nodes/UnknownNode';
 import keys from './keys';
 import { Node } from './nodes/shared/Node';
 import Module from '../Module';
-import Comment from './comment';
 import MagicString from 'magic-string';
 import Import from './nodes/Import';
 
-const newline = /\n/;
-
-export default function enhance (ast: any, module: Module, comments: Comment[], dynamicImportReturnList: Import[]) {
+export default function enhance (ast: any, module: Module, dynamicImportReturnList: Import[]) {
 	enhanceNode(ast, {}, module, module.magicString, dynamicImportReturnList);
 
-	let comment = comments.shift();
-
 	for (const node of ast.body) {
-		if (comment && comment.start < node.start) {
-			node.leadingCommentStart = comment.start;
-		}
-
-		while (comment && comment.end < node.end) comment = comments.shift();
-
-		// if the next comment is on the same line as the end of the node,
-		// treat is as a trailing comment
-		if (comment && !newline.test(module.code.slice(node.end, comment.start))) {
-			node.trailingCommentEnd = comment.end; // TODO is node.trailingCommentEnd used anywhere?
-			comment = comments.shift();
-		}
-
 		node.initialise(module.scope);
 	}
 }

src/ast/nodes/BlockStatement.ts

@@ -3,10 +3,10 @@ import { UNKNOWN_EXPRESSION } from '../values';
 import ExecutionPathOptions from '../ExecutionPathOptions';
 import Scope from '../scopes/Scope';
 import MagicString from 'magic-string';
-import { Node } from './shared/Node';
-import { StatementBase, StatementNode } from './shared/Statement';
+import { Node, StatementBase, StatementNode } from './shared/Node';
 import { NodeType } from './NodeType';
 import { RenderOptions } from '../../Module';
+import { renderStatementList } from '../../utils/renderHelpers';
 
 export function isBlockStatement (node: Node): node is BlockStatement {
 	return node.type === NodeType.BlockStatement;
@@ -48,12 +48,8 @@ export default class BlockStatement extends StatementBase {
 	}
 
 	initialiseChildren (_parentScope: Scope) {
-		let lastNode;
 		for (const node of this.body) {
 			node.initialise(this.scope);
-
-			if (lastNode) lastNode.next = node.start;
-			lastNode = node;
 		}
 	}
 
@@ -63,9 +59,7 @@ export default class BlockStatement extends StatementBase {
 
 	render (code: MagicString, options: RenderOptions) {
 		if (this.body.length) {
-			for (const node of this.body) {
-				node.render(code, options);
-			}
+			renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
 		} else {
 			super.render(code, options);
 		}

src/ast/nodes/BreakStatement.ts

@@ -1,7 +1,7 @@
 import ExecutionPathOptions from '../ExecutionPathOptions';
 import Identifier from './Identifier';
-import { StatementBase } from './shared/Statement';
 import { NodeType } from './NodeType';
+import { StatementBase } from './shared/Node';
 
 export default class BreakStatement extends StatementBase {
 	type: NodeType.BreakStatement;

src/ast/nodes/ClassDeclaration.ts

@@ -4,28 +4,29 @@ import Identifier from './Identifier';
 import MagicString from 'magic-string';
 import { NodeType } from './NodeType';
 import { RenderOptions } from '../../Module';
+import { Node } from './shared/Node';
+
+export function isClassDeclaration (node: Node): node is ClassDeclaration {
+	return node.type === NodeType.ClassDeclaration;
+}
 
 export default class ClassDeclaration extends ClassNode {
 	type: NodeType.ClassDeclaration;
 	id: Identifier;
 
 	initialiseChildren (parentScope: Scope) {
 		// Class declarations are like let declarations: Not hoisted, can be reassigned, cannot be redeclared
-		this.id && this.id.initialiseAndDeclare(parentScope, 'class', this);
+		if (this.id) {
+			this.id.initialiseAndDeclare(parentScope, 'class', this);
+			this.id.variable.isId = true;
+		}
 		super.initialiseChildren(parentScope);
 	}
 
 	render (code: MagicString, options: RenderOptions) {
-		if (!this.module.graph.treeshake || this.included) {
-			if (options.systemBindings && this.id.variable.exportName) {
-				code.appendRight(this.end, ` exports('${this.id.variable.exportName}', ${this.id.variable.getName()});`);
-			}
-			super.render(code, options);
-		} else {
-			code.remove(
-				this.leadingCommentStart || this.start,
-				this.next || this.end
-			);
+		if (options.systemBindings && this.id.variable.exportName) {
+			code.appendRight(this.end, ` exports('${this.id.variable.exportName}', ${this.id.variable.getName()});`);
 		}
+		super.render(code, options);
 	}
 }

src/ast/nodes/DoWhileStatement.ts

@@ -1,6 +1,5 @@
 import ExecutionPathOptions from '../ExecutionPathOptions';
-import { StatementBase, StatementNode } from './shared/Statement';
-import { ExpressionNode } from './shared/Node';
+import { ExpressionNode, StatementNode, StatementBase } from './shared/Node';
 import { NodeType } from './NodeType';
 
 export default class DoWhileStatement extends StatementBase {

src/ast/nodes/EmptyStatement.ts

@@ -1,7 +1,7 @@
 import MagicString from 'magic-string';
-import { StatementBase } from './shared/Statement';
 import { NodeType } from './NodeType';
 import { RenderOptions } from '../../Module';
+import { StatementBase } from './shared/Node';
 
 export default class EmptyStatement extends StatementBase {
 	type: NodeType.EmptyStatement;

src/ast/nodes/ExportAllDeclaration.ts

@@ -2,18 +2,19 @@ import { NodeBase } from './shared/Node';
 import Literal from './Literal';
 import MagicString from 'magic-string';
 import { NodeType } from './NodeType';
-import { RenderOptions } from '../../Module';
+import { NodeRenderOptions, RenderOptions } from '../../Module';
+import { BLANK } from '../../utils/object';
 
 export default class ExportAllDeclaration extends NodeBase {
 	type: NodeType.ExportAllDeclaration;
 	source: Literal<string>;
 	isExportDeclaration: true;
+	needsBoundaries: true;
 
-	initialiseNode () {
-		this.isExportDeclaration = true;
-	}
-
-	render (code: MagicString, _options: RenderOptions) {
-		code.remove(this.leadingCommentStart || this.start, this.next || this.end);
+	render (code: MagicString, _options: RenderOptions, { start, end }: NodeRenderOptions = BLANK) {
+		code.remove(start, end);
 	}
 }
+
+ExportAllDeclaration.prototype.needsBoundaries = true;
+ExportAllDeclaration.prototype.isExportDeclaration = true;