Implement ES2017 (async) transforms

internal/ast/ast.go

@@ -2670,6 +2670,12 @@ func (node *Token) computeSubtreeFacts() SubtreeFacts {
 		return SubtreeContainsTypeScript
 	case KindAccessorKeyword:
 		return SubtreeContainsClassFields
+	case KindAsyncKeyword:
+		return SubtreeContainsAnyAwait
+	case KindSuperKeyword:
+		return SubtreeContainsLexicalSuper
+	case KindThisKeyword:
+		return SubtreeContainsLexicalThis
 	case KindAsteriskAsteriskToken, KindAsteriskAsteriskEqualsToken:
 		return SubtreeContainsExponentiationOperator
 	case KindQuestionQuestionToken:

internal/ast/functionflags.go

@@ -0,0 +1,37 @@
+package ast
+
+type FunctionFlags uint32
+
+const (
+	FunctionFlagsNormal         FunctionFlags = 0
+	FunctionFlagsGenerator      FunctionFlags = 1 << 0
+	FunctionFlagsAsync          FunctionFlags = 1 << 1
+	FunctionFlagsInvalid        FunctionFlags = 1 << 2
+	FunctionFlagsAsyncGenerator FunctionFlags = FunctionFlagsAsync | FunctionFlagsGenerator
+)
+
+func GetFunctionFlags(node *Node) FunctionFlags {
+	if node == nil {
+		return FunctionFlagsInvalid
+	}
+	data := node.BodyData()
+	if data == nil {
+		return FunctionFlagsInvalid
+	}
+	flags := FunctionFlagsNormal
+	switch node.Kind {
+	case KindFunctionDeclaration, KindFunctionExpression, KindMethodDeclaration:
+		if data.AsteriskToken != nil {
+			flags |= FunctionFlagsGenerator
+		}
+		fallthrough
+	case KindArrowFunction:
+		if HasSyntacticModifier(node, ModifierFlagsAsync) {
+			flags |= FunctionFlagsAsync
+		}
+	}
+	if data.Body == nil {
+		flags |= FunctionFlagsInvalid
+	}
+	return flags
+}

internal/ast/utilities.go

@@ -3850,7 +3850,7 @@ func TryGetPropertyNameOfBindingOrAssignmentElement(bindingElement *Node) *Node
 		// `1` in `let { 1: b } = ...`
 		if bindingElement.PropertyName() != nil {
 			propertyName := bindingElement.PropertyName()
-			// if ast.IsPrivateIdentifier(propertyName) {
+			// if IsPrivateIdentifier(propertyName) {
 			// 	return Debug.failBadSyntaxKind(propertyName) // !!!
 			// }
 			if IsComputedPropertyName(propertyName) && IsStringOrNumericLiteralLike(propertyName.Expression()) {
@@ -3865,7 +3865,7 @@ func TryGetPropertyNameOfBindingOrAssignmentElement(bindingElement *Node) *Node
 		// `1` in `({ 1: b } = ...)`
 		if bindingElement.Name() != nil {
 			propertyName := bindingElement.Name()
-			// if ast.IsPrivateIdentifier(propertyName) {
+			// if IsPrivateIdentifier(propertyName) {
 			// 	return Debug.failBadSyntaxKind(propertyName) // !!!
 			// }
 			if IsComputedPropertyName(propertyName) && IsStringOrNumericLiteralLike(propertyName.Expression()) {
@@ -3875,7 +3875,7 @@ func TryGetPropertyNameOfBindingOrAssignmentElement(bindingElement *Node) *Node
 		}
 	case KindSpreadAssignment:
 		// `a` in `({ ...a } = ...)`
-		// if ast.IsPrivateIdentifier(bindingElement.Name()) {
+		// if IsPrivateIdentifier(bindingElement.Name()) {
 		// 	return Debug.failBadSyntaxKind(bindingElement.Name()) // !!!
 		// }
 		return bindingElement.Name()
@@ -4188,7 +4188,7 @@ func GetAllAccessorDeclarationsForDeclaration(accessor *AccessorDeclaration, dec
 	} else {
 		panic(fmt.Sprintf("Unexpected node kind %q", accessor.Kind))
 	}
-	// otherAccessor := ast.GetDeclarationOfKind(c.getSymbolOfDeclaration(accessor), otherKind)
+	// otherAccessor := GetDeclarationOfKind(c.getSymbolOfDeclaration(accessor), otherKind)
 	var otherAccessor *AccessorDeclaration
 	for _, d := range declarationsOfSymbol {
 		if d.Kind == otherKind {
@@ -4357,3 +4357,9 @@ func findCloneInNode(node *Node, original *Node) *Node {
 		}
 	}
 }
+
+// IsSuperProperty checks if a node is super.x or super[x].
+func IsSuperProperty(node *Node) bool {
+	return (IsPropertyAccessExpression(node) || IsElementAccessExpression(node)) &&
+		node.Expression().Kind == KindSuperKeyword
+}

internal/checker/grammarchecks.go

@@ -1249,7 +1249,7 @@ func (c *Checker) checkGrammarForInOrForOfStatement(forInOrOfStatement *ast.ForI
 					diagnostic := createDiagnosticForNode(forInOrOfStatement.AwaitModifier, diagnostics.X_for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules)
 					containingFunc := ast.GetContainingFunction(forInOrOfStatement.AsNode())
 					if containingFunc != nil && containingFunc.Kind != ast.KindConstructor {
-						debug.Assert((getFunctionFlags(containingFunc)&FunctionFlagsAsync) == 0, "Enclosing function should never be an async function.")
+						debug.Assert((ast.GetFunctionFlags(containingFunc)&ast.FunctionFlagsAsync) == 0, "Enclosing function should never be an async function.")
 						if hasAsyncModifier(containingFunc) {
 							panic("Enclosing function should never be an async function.")
 						}

internal/checker/relater.go

@@ -661,7 +661,7 @@ func (c *Checker) elaborateArrowFunction(node *ast.Node, source *Type, target *T
 		if target.symbol != nil && len(target.symbol.Declarations) != 0 {
 			diagnostic.AddRelatedInfo(createDiagnosticForNode(target.symbol.Declarations[0], diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature))
 		}
-		if getFunctionFlags(node)&FunctionFlagsAsync == 0 && c.getTypeOfPropertyOfType(sourceReturn, "then") == nil && c.checkTypeRelatedTo(c.createPromiseType(sourceReturn), targetReturn, relation, nil /*errorNode*/) {
+		if ast.GetFunctionFlags(node)&ast.FunctionFlagsAsync == 0 && c.getTypeOfPropertyOfType(sourceReturn, "then") == nil && c.checkTypeRelatedTo(c.createPromiseType(sourceReturn), targetReturn, relation, nil /*errorNode*/) {
 			diagnostic.AddRelatedInfo(createDiagnosticForNode(node, diagnostics.Did_you_mean_to_mark_this_function_as_async))
 		}
 		c.reportDiagnostic(diagnostic, diagnosticOutput)

internal/checker/types.go

@@ -310,9 +310,6 @@ const (
 	NodeCheckFlagsSuperInstance                            NodeCheckFlags = 1 << 4  // Instance 'super' reference
 	NodeCheckFlagsSuperStatic                              NodeCheckFlags = 1 << 5  // Static 'super' reference
 	NodeCheckFlagsContextChecked                           NodeCheckFlags = 1 << 6  // Contextual types have been assigned
-	NodeCheckFlagsMethodWithSuperPropertyAccessInAsync     NodeCheckFlags = 1 << 7  // A method that contains a SuperProperty access in an async context.
-	NodeCheckFlagsMethodWithSuperPropertyAssignmentInAsync NodeCheckFlags = 1 << 8  // A method that contains a SuperProperty assignment in an async context.
-	NodeCheckFlagsCaptureArguments                         NodeCheckFlags = 1 << 9  // Lexical 'arguments' used in body
 	NodeCheckFlagsEnumValuesComputed                       NodeCheckFlags = 1 << 10 // Values for enum members have been computed, and any errors have been reported for them.
 	NodeCheckFlagsLoopWithCapturedBlockScopedBinding       NodeCheckFlags = 1 << 12 // Loop that contains block scoped variable captured in closure
 	NodeCheckFlagsContainsCapturedBlockScopeBinding        NodeCheckFlags = 1 << 13 // Part of a loop that contains block scoped variable captured in closure

internal/checker/utilities.go

@@ -1027,15 +1027,6 @@ func isSuperCall(n *ast.Node) bool {
 	return ast.IsCallExpression(n) && n.Expression().Kind == ast.KindSuperKeyword
 }
 
-/**
- * Determines whether a node is a property or element access expression for `super`.
- *
- * @internal
- */
-func isSuperProperty(node *ast.Node) bool {
-	return ast.IsAccessExpression(node) && node.Expression().Kind == ast.KindSuperKeyword
-}
-
 func getMembersOfDeclaration(node *ast.Node) []*ast.Node {
 	switch node.Kind {
 	case ast.KindInterfaceDeclaration, ast.KindClassDeclaration, ast.KindClassExpression, ast.KindTypeLiteral:
@@ -1046,42 +1037,6 @@ func getMembersOfDeclaration(node *ast.Node) []*ast.Node {
 	return nil
 }
 
-type FunctionFlags uint32
-
-const (
-	FunctionFlagsNormal         FunctionFlags = 0
-	FunctionFlagsGenerator      FunctionFlags = 1 << 0
-	FunctionFlagsAsync          FunctionFlags = 1 << 1
-	FunctionFlagsInvalid        FunctionFlags = 1 << 2
-	FunctionFlagsAsyncGenerator FunctionFlags = FunctionFlagsAsync | FunctionFlagsGenerator
-)
-
-func getFunctionFlags(node *ast.Node) FunctionFlags {
-	if node == nil {
-		return FunctionFlagsInvalid
-	}
-	data := node.BodyData()
-	if data == nil {
-		return FunctionFlagsInvalid
-	}
-	flags := FunctionFlagsNormal
-	switch node.Kind {
-	case ast.KindFunctionDeclaration, ast.KindFunctionExpression, ast.KindMethodDeclaration:
-		if data.AsteriskToken != nil {
-			flags |= FunctionFlagsGenerator
-		}
-		fallthrough
-	case ast.KindArrowFunction:
-		if ast.HasSyntacticModifier(node, ast.ModifierFlagsAsync) {
-			flags |= FunctionFlagsAsync
-		}
-	}
-	if data.Body == nil {
-		flags |= FunctionFlagsInvalid
-	}
-	return flags
-}
-
 func isInRightSideOfImportOrExportAssignment(node *ast.EntityName) bool {
 	for node.Parent.Kind == ast.KindQualifiedName {
 		node = node.Parent

internal/printer/emitflags.go

@@ -27,6 +27,7 @@ const (
 	EFNeverApplyImportHelper                          // Do not apply an import helper to this node
 	EFStartOnNewLine                                  // Start this node on a new line
 	EFIndirectCall                                    // Emit CallExpression as an indirect call: `(0, f)()`
+	EFAsyncFunctionBody                               // The node was originally an async function body.
 )
 
 const (

internal/printer/factory.go

@@ -280,6 +280,24 @@ func (f *NodeFactory) InlineExpressions(expressions []*ast.Expression) *ast.Expr
 // Utilities
 //
 
+func (f *NodeFactory) CreateExpressionFromEntityName(node *ast.Node) *ast.Expression {
+	if ast.IsQualifiedName(node) {
+		left := f.CreateExpressionFromEntityName(node.AsQualifiedName().Left)
+		right := node.AsQualifiedName().Right.Clone(f.AsNodeFactory())
+		right.Loc = node.AsQualifiedName().Right.Loc
+		// TODO(rbuckton): Does this need to be parented?
+		right.Parent = node.AsQualifiedName().Right.Parent
+		propAccess := f.NewPropertyAccessExpression(left, nil, right, ast.NodeFlagsNone)
+		propAccess.Loc = node.Loc
+		return propAccess
+	}
+	res := node.Clone(f.AsNodeFactory())
+	res.Loc = node.Loc
+	// TODO(rbuckton): Does this need to be parented?
+	res.Parent = node.Parent
+	return res
+}
+
 func (f *NodeFactory) NewTypeCheck(value *ast.Node, tag string) *ast.Node {
 	if tag == "null" {
 		return f.NewStrictEqualityExpression(value, f.NewKeywordExpression(ast.KindNullKeyword))
@@ -650,6 +668,64 @@ func (f *NodeFactory) NewRestHelper(value *ast.Expression, elements []*ast.Node,
 
 // !!! ES2017 Helpers
 
+// Allocates a new Call expression to the `__awaiter` helper.
+func (f *NodeFactory) NewAwaiterHelper(
+	hasLexicalThis bool,
+	argumentsExpression *ast.Expression,
+	parameters *ast.NodeList,
+	body *ast.BlockNode,
+) *ast.Expression {
+	f.emitContext.RequestEmitHelper(awaiterHelper)
+
+	var params *ast.NodeList
+	if parameters != nil {
+		params = parameters
+	} else {
+		params = f.NewNodeList([]*ast.Node{})
+	}
+
+	generatorFunc := f.NewFunctionExpression(
+		nil, /*modifiers*/
+		f.NewToken(ast.KindAsteriskToken),
+		nil, /*name*/
+		nil, /*typeParameters*/
+		params,
+		nil, /*returnType*/
+		nil, /*fullSignature*/
+		body,
+	)
+
+	// Mark this node as originally an async function body
+	f.emitContext.AddEmitFlags(generatorFunc, EFAsyncFunctionBody|EFReuseTempVariableScope)
+
+	var thisArg *ast.Expression
+	if hasLexicalThis {
+		thisArg = f.NewKeywordExpression(ast.KindThisKeyword)
+	} else {
+		thisArg = f.NewVoidZeroExpression()
+	}
+
+	var argsArg *ast.Expression
+	if argumentsExpression != nil {
+		argsArg = argumentsExpression
+	} else {
+		argsArg = f.NewVoidZeroExpression()
+	}
+
+	return f.NewCallExpression(
+		f.NewUnscopedHelperName("__awaiter"),
+		nil, /*questionDotToken*/
+		nil, /*typeArguments*/
+		f.NewNodeList([]*ast.Expression{
+			thisArg,
+			argsArg,
+			f.NewVoidZeroExpression(),
+			generatorFunc,
+		}),
+		ast.NodeFlagsNone,
+	)
+}
+
 // ES2015 Helpers
 
 func (f *NodeFactory) NewPropKeyHelper(expr *ast.Expression) *ast.Expression {

internal/printer/helpers.go

@@ -154,6 +154,41 @@ var restHelper = &EmitHelper{
 
 // !!! ES2017 Helpers
 
+var awaiterHelper = &EmitHelper{
+	Name:       "typescript:awaiter",
+	ImportName: "__awaiter",
+	Scoped:     false,
+	Priority:   &Priority{5},
+	Text: `var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};`,
+}
+
+var AsyncSuperHelper = &EmitHelper{
+	Name:   "typescript:async-super",
+	Scoped: true,
+	TextCallback: func(makeUniqueName func(string) string) string {
+		return "\nconst " + makeUniqueName("_superIndex") + " = name => super[name];"
+	},
+}
+
+var AdvancedAsyncSuperHelper = &EmitHelper{
+	Name:   "typescript:advanced-async-super",
+	Scoped: true,
+	TextCallback: func(makeUniqueName func(string) string) string {
+		return "\nconst " + makeUniqueName("_superIndex") + " = (function (geti, seti) {\n" +
+			"    const cache = Object.create(null);\n" +
+			"    return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n" +
+			"})(name => super[name], (name, value) => super[name] = value);"
+	},
+}
+
 // ES2015 Helpers
 
 var propKeyHelper = &EmitHelper{

internal/printer/namegenerator.go

@@ -340,6 +340,10 @@ func (g *NameGenerator) makeUniqueName(baseName string, checkFn func(name string
 	}
 }
 
+func (g *NameGenerator) MakeFileLevelOptimisticUniqueName(name string) string {
+	return g.makeUniqueName(name, g.IsFileLevelUniqueNameInCurrentFile, true /*optimistic*/, false /*scoped*/, false /*privateName*/, "" /*prefix*/, "" /*suffix*/)
+}
+
 func (g *NameGenerator) checkUniqueName(name string, privateName bool, checkFn func(name string, privateName bool) bool) bool {
 	if checkFn != nil {
 		return checkFn(name, privateName)

internal/printer/printer.go

@@ -176,6 +176,9 @@ func NewPrinter(options PrinterOptions, handlers PrintHandlers, emitContext *Emi
 	printer.nameGenerator.Context = printer.emitContext
 	printer.nameGenerator.GetTextOfNode = func(node *ast.Node) string { return printer.getTextOfNode(node, false) }
 	printer.nameGenerator.IsFileLevelUniqueNameInCurrentFile = printer.isFileLevelUniqueNameInCurrentFile
+	printer.makeFileLevelOptimisticUniqueName = func(name string) string {
+		return printer.nameGenerator.MakeFileLevelOptimisticUniqueName(name)
+	}
 	printer.containerPos = -1
 	printer.containerEnd = -1
 	printer.declarationListContainerEnd = -1
@@ -1502,7 +1505,14 @@ func canEmitSimpleArrowHead(parentNode *ast.Node, parameters *ast.ParameterList)
 	parent := parentNode.AsArrowFunction()
 	parameter := parameters.Nodes[0].AsParameterDeclaration()
 
-	return parameter.Pos() == greatestEnd(parent.Pos(), parent.Modifiers()) && // may not have parsed tokens between modifiers/start of parent and parameter
+	// Only use modifiers for position check if they actually contain nodes.
+	// After transformation (e.g., async removal), modifiers may be an empty list with stale source positions.
+	modifiers := parent.Modifiers()
+	if modifiers != nil && len(modifiers.Nodes) == 0 {
+		modifiers = nil
+	}
+
+	return parameter.Pos() == greatestEnd(parent.Pos(), modifiers) && // may not have parsed tokens between modifiers/start of parent and parameter
 		parent.TypeParameters == nil && // parent may not have type parameters
 		parent.Type == nil && // parent may not have return type annotation
 		!parameters.HasTrailingComma() && // parameters may not have a trailing comma
@@ -2715,6 +2725,7 @@ func (p *Printer) getBinaryExpressionPrecedence(node *ast.BinaryExpression) (lef
 	case ast.OperatorPrecedenceAssignment:
 		// assignment is right-associative
 		leftPrec = ast.OperatorPrecedenceLeftHandSide
+		rightPrec = ast.OperatorPrecedenceYield
 	case ast.OperatorPrecedenceLogicalOR:
 		rightPrec = ast.OperatorPrecedenceLogicalAND
 	case ast.OperatorPrecedenceLogicalAND: