Experiment: Distribute Control Flow

internal/api/encoder/encoder.go

@@ -396,6 +396,9 @@ func getChildrenPropertyMask(node *ast.Node) uint8 {
 	case ast.KindIfStatement:
 		n := node.AsIfStatement()
 		return (boolToByte(n.Expression != nil) << 0) | (boolToByte(n.ThenStatement != nil) << 1) | (boolToByte(n.ElseStatement != nil) << 2)
+	case ast.KindDistributeStatement:
+		n := node.AsDistributeStatement()
+		return (boolToByte(n.Expression != nil) << 0) | (boolToByte(n.Statement != nil) << 1)
 	case ast.KindDoStatement:
 		n := node.AsDoStatement()
 		return (boolToByte(n.Statement != nil) << 0) | (boolToByte(n.Expression != nil) << 1)

internal/ast/ast.go

@@ -65,6 +65,7 @@ type NodeFactory struct {
 	heritageClausePool                core.Pool[HeritageClause]
 	identifierPool                    core.Pool[Identifier]
 	ifStatementPool                   core.Pool[IfStatement]
+	distributeStatementPool           core.Pool[DistributeStatement]
 	importSpecifierPool               core.Pool[ImportSpecifier]
 	indexedAccessTypeNodePool         core.Pool[IndexedAccessTypeNode]
 	interfaceDeclarationPool          core.Pool[InterfaceDeclaration]
@@ -389,6 +390,8 @@ func (n *Node) Expression() *Node {
 		return n.AsPartiallyEmittedExpression().Expression
 	case KindIfStatement:
 		return n.AsIfStatement().Expression
+	case KindDistributeStatement:
+		return n.AsDistributeStatement().Expression
 	case KindDoStatement:
 		return n.AsDoStatement().Expression
 	case KindWhileStatement:
@@ -1060,6 +1063,8 @@ func (n *Node) Statement() *Statement {
 		return n.AsWithStatement().Statement
 	case KindLabeledStatement:
 		return n.AsLabeledStatement().Statement
+	case KindDistributeStatement:
+		return n.AsDistributeStatement().Statement
 	}
 	panic("Unhandled case in Node.Statement: " + n.Kind.String())
 }
@@ -1346,6 +1351,10 @@ func (n *Node) AsIfStatement() *IfStatement {
 	return n.data.(*IfStatement)
 }
 
+func (n *Node) AsDistributeStatement() *DistributeStatement {
+	return n.data.(*DistributeStatement)
+}
+
 func (n *Node) AsWhileStatement() *WhileStatement {
 	return n.data.(*WhileStatement)
 }
@@ -2961,6 +2970,50 @@ func IsIfStatement(node *Node) bool {
 	return node.Kind == KindIfStatement
 }
 
+// DistributeStatement
+
+type DistributeStatement struct {
+	StatementBase
+	compositeNodeBase
+	Expression *Expression // Expression
+	Statement  *Statement  // Statement
+}
+
+func (f *NodeFactory) NewDistributeStatement(expression *Expression, statement *Statement) *Node {
+	data := f.distributeStatementPool.New()
+	data.Expression = expression
+	data.Statement = statement
+	return f.newNode(KindDistributeStatement, data)
+}
+
+func (f *NodeFactory) UpdateDistributeStatement(node *DistributeStatement, expression *Expression, statement *Statement) *Node {
+	if expression != node.Expression || statement != node.Statement {
+		return updateNode(f.NewDistributeStatement(expression, statement), node.AsNode(), f.hooks)
+	}
+	return node.AsNode()
+}
+
+func (node *DistributeStatement) ForEachChild(v Visitor) bool {
+	return visit(v, node.Expression) || visit(v, node.Statement)
+}
+
+func (node *DistributeStatement) VisitEachChild(v *NodeVisitor) *Node {
+	return v.Factory.UpdateDistributeStatement(node, v.visitNode(node.Expression), v.visitEmbeddedStatement(node.Statement))
+}
+
+func (node *DistributeStatement) Clone(f NodeFactoryCoercible) *Node {
+	return cloneNode(f.AsNodeFactory().NewDistributeStatement(node.Expression, node.Statement), node.AsNode(), f.AsNodeFactory().hooks)
+}
+
+func (node *DistributeStatement) computeSubtreeFacts() SubtreeFacts {
+	return propagateSubtreeFacts(node.Expression) |
+		propagateSubtreeFacts(node.Statement) | SubtreeContainsTypeScript | SubtreeContainsDistributeStatement
+}
+
+func IsDistributeStatement(node *Node) bool {
+	return node.Kind == KindDistributeStatement
+}
+
 // DoStatement
 
 type DoStatement struct {

internal/ast/flow.go

@@ -18,6 +18,7 @@ const (
 	FlowFlagsReduceLabel    FlowFlags = 1 << 10 // Temporarily reduce antecedents of label
 	FlowFlagsReferenced     FlowFlags = 1 << 11 // Referenced as antecedent once
 	FlowFlagsShared         FlowFlags = 1 << 12 // Referenced as antecedent more than once
+	FlowFlagsDistribute     FlowFlags = 1 << 13
 	FlowFlagsLabel                    = FlowFlagsBranchLabel | FlowFlagsLoopLabel
 	FlowFlagsCondition                = FlowFlagsTrueCondition | FlowFlagsFalseCondition
 )

internal/ast/kind.go

@@ -114,6 +114,7 @@ const (
 	KindForKeyword
 	KindFunctionKeyword
 	KindIfKeyword
+	KindDistributeKeyword
 	KindImportKeyword
 	KindInKeyword
 	KindInstanceOfKeyword
@@ -271,6 +272,7 @@ const (
 	KindVariableStatement
 	KindExpressionStatement
 	KindIfStatement
+	KindDistributeStatement
 	KindDoStatement
 	KindWhileStatement
 	KindForStatement