implement experimentalTopLevelAwait option (#2235)

src/Chunk.ts

@@ -1057,6 +1057,16 @@ export default class Chunk {
 				dep => dep.reexports && dep.reexports.length !== 0
 			);
 
+		const usesTopLevelAwait = this.orderedModules.some(module => module.usesTopLevelAwait);
+		if (usesTopLevelAwait && options.format !== 'es' && options.format !== 'system') {
+			error({
+				code: 'INVALID_TLA_FORMAT',
+				message: `Module format ${
+					options.format
+				} does not support top-level await. Use the "es" or "system" output formats rather.`
+			});
+		}
+
 		const magicString = finalise(
 			this.renderedSource,
 			{
@@ -1070,7 +1080,8 @@ export default class Chunk {
 				dependencies: this.renderedDeclarations.dependencies,
 				exports: this.renderedDeclarations.exports,
 				graph: this.graph,
-				isEntryModuleFacade: this.isEntryModuleFacade
+				isEntryModuleFacade: this.isEntryModuleFacade,
+				usesTopLevelAwait
 			},
 			options
 		);

src/Graph.ts

@@ -218,6 +218,10 @@ export default class Graph {
 		this.acornOptions.plugins.dynamicImport = true;
 		this.acornOptions.plugins.importMeta = true;
 
+		if (options.experimentalTopLevelAwait) {
+			(<any>this.acornOptions).allowAwaitOutsideFunction = true;
+		}
+
 		acornPluginsToInject.push(...ensureArray(options.acornInjectPlugins));
 		this.acornParse = acornPluginsToInject.reduce((acc, plugin) => plugin(acc), acorn).parse;
 	}

src/Module.ts

@@ -95,6 +95,7 @@ export interface AstContext {
 	traceExport: (name: string) => Variable;
 	traceVariable: (name: string) => Variable;
 	treeshake: boolean;
+	usesTopLevelAwait: boolean;
 	varOrConst: string;
 	warn: (warning: RollupWarning, pos: number) => void;
 }
@@ -177,6 +178,7 @@ export default class Module {
 	entryPointsHash: Uint8Array;
 	chunk: Chunk;
 	exportAllModules: (Module | ExternalModule)[];
+	usesTopLevelAwait: boolean = false;
 
 	private ast: Program;
 	private astContext: AstContext;
@@ -265,8 +267,8 @@ export default class Module {
 			getReexports: this.getReexports.bind(this),
 			getModuleExecIndex: () => this.execIndex,
 			getModuleName: this.basename.bind(this),
-			includeNamespace: this.includeNamespace.bind(this),
 			imports: this.imports,
+			includeNamespace: this.includeNamespace.bind(this),
 			isCrossChunkImport: importDescription => importDescription.module.chunk !== this.chunk,
 			magicString: this.magicString,
 			moduleContext: this.context,
@@ -278,6 +280,7 @@ export default class Module {
 			traceExport: this.traceExport.bind(this),
 			traceVariable: this.traceVariable.bind(this),
 			treeshake: this.graph.treeshake,
+			usesTopLevelAwait: false,
 			varOrConst: this.graph.varOrConst,
 			warn: this.warn.bind(this)
 		};
@@ -639,6 +642,7 @@ export default class Module {
 	render(options: RenderOptions): MagicString {
 		const magicString = this.magicString.clone();
 		this.ast.render(magicString, options);
+		this.usesTopLevelAwait = this.astContext.usesTopLevelAwait;
 		return magicString;
 	}
 

src/ast/nodes/AwaitExpression.ts

@@ -1,12 +1,32 @@
+import MagicString from 'magic-string';
+import { RenderOptions } from '../../utils/renderHelpers';
 import { ExecutionPathOptions } from '../ExecutionPathOptions';
+import ArrowFunctionExpression from './ArrowFunctionExpression';
 import * as NodeType from './NodeType';
+import FunctionNode from './shared/FunctionNode';
+import { Node } from './shared/Node';
 import { ExpressionNode, NodeBase } from './shared/Node';
 
 export default class AwaitExpression extends NodeBase {
 	type: NodeType.tAwaitExpression;
 	argument: ExpressionNode;
 
+	include() {
+		super.include();
+		if (!this.context.usesTopLevelAwait) {
+			let parent = this.parent;
+			do {
+				if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression) return;
+			} while ((parent = <Node>(<Node>parent).parent));
+			this.context.usesTopLevelAwait = true;
+		}
+	}
+
 	hasEffects(options: ExecutionPathOptions) {
 		return super.hasEffects(options) || !options.ignoreReturnAwaitYield();
 	}
+
+	render(code: MagicString, options: RenderOptions) {
+		super.render(code, options);
+	}
 }

src/ast/nodes/shared/FunctionNode.ts

@@ -1,7 +1,7 @@
 import CallOptions from '../../CallOptions';
 import { ExecutionPathOptions } from '../../ExecutionPathOptions';
-import BlockScope from '../../scopes/FunctionScope';
 import FunctionScope from '../../scopes/FunctionScope';
+import BlockScope from '../../scopes/FunctionScope';
 import Scope from '../../scopes/Scope';
 import { ObjectPath, UNKNOWN_EXPRESSION } from '../../values';
 import BlockStatement from '../BlockStatement';
@@ -78,10 +78,8 @@ export default class FunctionNode extends NodeBase {
 	}
 
 	parseNode(esTreeNode: GenericEsTreeNode) {
-		this.body = <BlockStatement>new this.context.nodeConstructors.BlockStatement(
-			esTreeNode.body,
-			this,
-			new Scope(this.scope)
+		this.body = <BlockStatement>(
+			new this.context.nodeConstructors.BlockStatement(esTreeNode.body, this, new Scope(this.scope))
 		);
 		super.parseNode(esTreeNode);
 	}

src/finalisers/index.ts

@@ -21,6 +21,7 @@ export interface FinaliserOptions {
 	exports: ChunkExports;
 	graph: Graph;
 	isEntryModuleFacade: boolean;
+	usesTopLevelAwait: boolean;
 }
 
 export type Finaliser = (

src/finalisers/system.ts

@@ -19,7 +19,15 @@ function getStarExcludes({ dependencies, exports }: ModuleDeclarations) {
 
 export default function system(
 	magicString: MagicStringBundle,
-	{ graph, indentString: t, intro, outro, dependencies, exports }: FinaliserOptions,
+	{
+		graph,
+		indentString: t,
+		intro,
+		outro,
+		dependencies,
+		exports,
+		usesTopLevelAwait
+	}: FinaliserOptions,
 	options: OutputOptions
 ) {
 	const n = options.compact ? '' : '\n';
@@ -143,7 +151,9 @@ export default function system(
 					.join(`,${_}`)}],`
 			: ''
 	}${n}`;
-	wrapperStart += `${t}${t}execute:${_}function${_}()${_}{${n}${n}`;
+	wrapperStart += `${t}${t}execute:${_}${
+		usesTopLevelAwait ? `async${_}` : ''
+	}function${_}()${_}{${n}${n}`;
 	if (hoistedExports.length)
 		wrapperStart += `${t}${t}${t}` + hoistedExports.join(`${n}${t}${t}${t}`) + n + n;
 

src/rollup/types.d.ts

@@ -210,8 +210,9 @@ export interface InputOptions {
 	context?: string;
 	moduleContext?: string | ((id: string) => string) | { [id: string]: string };
 	watch?: WatcherOptions;
-	inlineDynamicImports?: boolean;
 	experimentalCodeSplitting?: boolean;
+	experimentalDynamicImport?: boolean;
+	experimentalTopLevelAwait?: boolean;
 	preserveSymlinks?: boolean;
 	experimentalPreserveModules?: boolean;
 	optimizeChunks?: boolean;

src/utils/mergeOptions.ts

@@ -202,6 +202,7 @@ function getInputOptions(
 		context: config.context,
 		experimentalCodeSplitting: getOption('experimentalCodeSplitting'),
 		experimentalPreserveModules: getOption('experimentalPreserveModules'),
+		experimentalTopLevelAwait: getOption('experimentalTopLevelAwait'),
 		external: getExternal(config, command),
 		inlineDynamicImports: getOption('inlineDynamicImports', false),
 		input: getOption('input'),

test/form/index.js

@@ -79,7 +79,7 @@ function runTestCaseInDir(dir) {
 				return runRollupTest(dir + '/_actual.js', dir + '/_expected.js', 'esm');
 			}
 
-			FORMATS.forEach(format =>
+			(config.formats || FORMATS).forEach(format =>
 				it('generates ' + format, () =>
 					runRollupTest(
 						dir + '/_actual/' + format + '.js',

test/form/samples/tla/_config.js

@@ -0,0 +1,7 @@
+module.exports = {
+	description: 'top-level await support',
+	formats: ['system', 'es'],
+	options: {
+		experimentalTopLevelAwait: true
+	}
+};

test/form/samples/tla/_expected/es.js

@@ -0,0 +1 @@
+await operation();

test/form/samples/tla/_expected/system.js

@@ -0,0 +1,10 @@
+System.register([], function (exports, module) {
+	'use strict';
+	return {
+		execute: async function () {
+
+			await operation();
+
+		}
+	};
+});

test/form/samples/tla/main.js

@@ -0,0 +1,4 @@
+await operation();
+
+if (false)
+	await treeshakenOperation();