// buildMapExpression builds the CodeDOM for a map expression.
func (db *domBuilder) buildMapExpression(node compilergraph.GraphNode) codedom.Expression {
mapScope, _ := db.scopegraph.GetScope(node)
mapType := mapScope.ResolvedTypeRef(db.scopegraph.TypeGraph())
eit := node.StartQuery().
Out(parser.NodeMapExpressionChildEntry).
BuildNodeIterator()
var keyExprs = make([]codedom.Expression, 0)
var valueExprs = make([]codedom.Expression, 0)
for eit.Next() {
entryNode := eit.Node()
keyExprs = append(keyExprs, db.getExpression(entryNode, parser.NodeMapExpressionEntryKey))
valueExprs = append(valueExprs, db.getExpression(entryNode, parser.NodeMapExpressionEntryValue))
}
if len(valueExprs) == 0 {
// Empty map. Call the new() constructor directly.
constructor, _ := mapType.ResolveMember("new", typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(mapType, node), constructor, node),
constructor,
[]codedom.Expression{},
node)
}
constructor, _ := mapType.ResolveMember("forArrays", typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(mapType, node), constructor, node),
constructor,
[]codedom.Expression{codedom.ArrayLiteral(keyExprs, node), codedom.ArrayLiteral(valueExprs, node)},
node)
}
// buildMappingInitializerExpression builds the CodeDOM for initializing a mapping literal expression.
func (db *domBuilder) buildMappingInitializerExpression(mappingType typegraph.TypeReference, initializers map[string]codedom.Expression, node compilergraph.GraphNode) codedom.Expression {
var entries = make([]codedom.ObjectLiteralEntryNode, 0)
for name, expr := range initializers {
entries = append(entries,
codedom.ObjectLiteralEntryNode{
codedom.LiteralValue(strconv.Quote(name), expr.BasisNode()),
expr,
expr.BasisNode(),
})
}
if len(entries) == 0 {
// Empty mapping. Call the Empty() constructor directly.
constructor, _ := mappingType.ResolveMember("Empty", typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(mappingType, node), constructor, node),
constructor,
[]codedom.Expression{},
node)
}
constructor, _ := mappingType.ResolveMember("overObject", typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(mappingType, node), constructor, node),
constructor,
[]codedom.Expression{codedom.ObjectLiteral(entries, node)},
node)
}
// buildMappingLiteralExpression builds the CodeDOM for a mapping literal expression.
func (db *domBuilder) buildMappingLiteralExpression(node compilergraph.GraphNode) codedom.Expression {
mappingScope, _ := db.scopegraph.GetScope(node)
mappingType := mappingScope.ResolvedTypeRef(db.scopegraph.TypeGraph())
eit := node.StartQuery().
Out(parser.NodeMappingLiteralExpressionEntryRef).
BuildNodeIterator()
var entries = make([]codedom.ObjectLiteralEntryNode, 0)
for eit.Next() {
entryNode := eit.Node()
// The key expression must be a string when produced. We either reference it directly (if a string)
// or call .String() (if a Stringable).
keyNode := entryNode.GetNode(parser.NodeMappingLiteralExpressionEntryKey)
keyScope, _ := db.scopegraph.GetScope(keyNode)
keyType := keyScope.ResolvedTypeRef(db.scopegraph.TypeGraph())
var keyExpr = db.buildExpression(keyNode)
if !keyType.HasReferredType(db.scopegraph.TypeGraph().StringType()) {
stringMethod, _ := keyType.ResolveMember("String", typegraph.MemberResolutionInstance)
keyExpr = codedom.MemberCall(
codedom.MemberReference(db.buildExpression(keyNode), stringMethod, node),
stringMethod,
[]codedom.Expression{},
keyNode)
}
// Get the expression for the value.
valueExpr := db.getExpression(entryNode, parser.NodeMappingLiteralExpressionEntryValue)
// Build an object literal expression with the (native version of the) key string and the
// created value.
entryExpr := codedom.ObjectLiteralEntryNode{
codedom.NominalUnwrapping(keyExpr, db.scopegraph.TypeGraph().StringTypeReference(), keyNode),
valueExpr,
entryNode,
}
entries = append(entries, entryExpr)
}
if len(entries) == 0 {
// Empty mapping. Call the Empty() constructor directly.
constructor, _ := mappingType.ResolveMember("Empty", typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(mappingType, node), constructor, node),
constructor,
[]codedom.Expression{},
node)
}
constructor, _ := mappingType.ResolveMember("overObject", typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(mappingType, node), constructor, node),
constructor,
[]codedom.Expression{codedom.ObjectLiteral(entries, node)},
node)
}
// buildTemplateStringCall builds the CodeDOM representing the call to a template string function.
func (db *domBuilder) buildTemplateStringCall(node compilergraph.GraphNode, funcExpr codedom.Expression, isTagged bool) codedom.Expression {
pit := node.StartQuery().
Out(parser.NodeTemplateStringPiece).
BuildNodeIterator()
var pieceExprs = make([]codedom.Expression, 0)
var valueExprs = make([]codedom.Expression, 0)
var isPiece = true
for pit.Next() {
if isPiece {
pieceExprs = append(pieceExprs, db.buildExpression(pit.Node()))
} else {
valueExprs = append(valueExprs, db.buildExpression(pit.Node()))
}
isPiece = !isPiece
}
// Handle common case: No literal string piece at all.
if len(pieceExprs) == 0 {
return codedom.NominalWrapping(codedom.LiteralValue("''", node), db.scopegraph.TypeGraph().StringType(), node)
}
// Handle common case: A single literal string piece with no values.
if len(pieceExprs) == 1 && len(valueExprs) == 0 {
return pieceExprs[0]
}
pieceSliceType := db.scopegraph.TypeGraph().SliceTypeReference(db.scopegraph.TypeGraph().StringTypeReference())
valueSliceType := db.scopegraph.TypeGraph().SliceTypeReference(db.scopegraph.TypeGraph().StringableTypeReference())
constructor, _ := pieceSliceType.ResolveMember("overArray", typegraph.MemberResolutionStatic)
pieceSliceExpr := codedom.MemberCall(
codedom.MemberReference(
codedom.TypeLiteral(pieceSliceType, node), constructor, node),
constructor,
[]codedom.Expression{codedom.ArrayLiteral(pieceExprs, node)},
node)
valueSliceExpr := codedom.MemberCall(
codedom.MemberReference(
codedom.TypeLiteral(valueSliceType, node), constructor, node),
constructor,
[]codedom.Expression{codedom.ArrayLiteral(valueExprs, node)},
node)
return codedom.AwaitPromise(codedom.FunctionCall(funcExpr, []codedom.Expression{pieceSliceExpr, valueSliceExpr}, node), node)
}
// buildStructInitializerExpression builds an initializer expression for a struct type.
func (db *domBuilder) buildStructInitializerExpression(structType typegraph.TypeReference, initializers map[string]codedom.Expression, node compilergraph.GraphNode) codedom.Expression {
staticType := structType.ReferredType()
var arguments = make([]codedom.Expression, 0)
for _, field := range staticType.RequiredFields() {
arguments = append(arguments, initializers[field.Name()])
delete(initializers, field.Name())
}
constructor, found := structType.ResolveMember("new", typegraph.MemberResolutionStatic)
if !found {
panic(fmt.Sprintf("Missing new constructor on type %v", structType))
}
newCall := codedom.MemberCall(
codedom.MemberReference(
codedom.TypeLiteral(structType, node),
constructor,
node),
constructor,
arguments,
node)
// If there are no initializers, then just return the new value directly.
if len(initializers) == 0 {
return newCall
}
return db.buildInitializationCompoundExpression(structType, initializers, newCall, node)
}
// buildBinaryOperatorExpression builds the CodeDOM for a binary operator.
func (db *domBuilder) buildBinaryOperatorExpression(node compilergraph.GraphNode, modifier exprModifier) codedom.Expression {
scope, _ := db.scopegraph.GetScope(node)
operator, _ := scope.CalledOperator(db.scopegraph.TypeGraph())
if operator.IsNative() {
return db.buildNativeBinaryExpression(node, operatorMap[node.Kind()])
}
leftExpr := db.getExpression(node, parser.NodeBinaryExpressionLeftExpr)
rightExpr := db.getExpression(node, parser.NodeBinaryExpressionRightExpr)
leftScope, _ := db.scopegraph.GetScope(node.GetNode(parser.NodeBinaryExpressionLeftExpr))
parentType := leftScope.ResolvedTypeRef(db.scopegraph.TypeGraph())
optimized, wasOptimized := db.buildOptimizedBinaryOperatorExpression(node, parentType, leftExpr, rightExpr)
if wasOptimized {
return optimized
}
callExpr := codedom.MemberCall(codedom.StaticMemberReference(operator, parentType, node), operator, []codedom.Expression{leftExpr, rightExpr}, node)
if modifier != nil {
return modifier(callExpr)
}
return callExpr
}
// generateMemberAssignment generates the expression source for a member assignment.
func (eg *expressionGenerator) generateMemberAssignment(memberAssign *codedom.MemberAssignmentNode, context generationContext) esbuilder.ExpressionBuilder {
basisNode := memberAssign.BasisNode()
// If the target member is an operator, then we need to invoke it as a function call, with the first
// argument being the argument to the child call, and the second argument being the assigned child
// expression.
if memberAssign.Target.IsOperator() {
childCall := memberAssign.NameExpression.(*codedom.MemberCallNode)
memberRef := childCall.ChildExpression.(*codedom.MemberReferenceNode)
// If this is a native operator, change it into a native indexing and assignment.
if memberAssign.Target.IsNative() {
nativeAssign := codedom.NativeAssign(
codedom.NativeIndexing(memberRef.ChildExpression,
childCall.Arguments[0], basisNode),
memberAssign.Value,
basisNode)
return eg.generateExpression(nativeAssign, context)
} else {
memberCall := codedom.MemberCall(
codedom.NativeAccess(memberRef.ChildExpression, eg.pather.GetMemberName(memberAssign.Target), memberRef.BasisNode()),
memberAssign.Target,
[]codedom.Expression{childCall.Arguments[0], memberAssign.Value},
basisNode)
return eg.generateExpression(memberCall, context)
}
}
// If the target member is implicitly called, then this is a property that needs to be assigned via a call.
if memberAssign.Target.IsImplicitlyCalled() {
memberRef := memberAssign.NameExpression.(*codedom.MemberReferenceNode)
memberCall := codedom.MemberCall(
codedom.NativeAccess(memberRef.ChildExpression, eg.pather.GetSetterName(memberRef.Member), memberRef.BasisNode()),
memberAssign.Target,
[]codedom.Expression{memberAssign.Value},
basisNode)
return eg.generateExpression(memberCall, context)
}
value := eg.generateExpression(memberAssign.Value, context)
targetExpr := eg.generateExpression(memberAssign.NameExpression, context)
return esbuilder.Assignment(targetExpr, value)
}
// buildInCollectionExpression builds the CodeDOM for an in collection operator.
func (db *domBuilder) buildInCollectionExpression(node compilergraph.GraphNode) codedom.Expression {
valueExpr := db.getExpression(node, parser.NodeBinaryExpressionLeftExpr)
childExpr := db.getExpression(node, parser.NodeBinaryExpressionRightExpr)
scope, _ := db.scopegraph.GetScope(node)
operator, _ := scope.CalledOperator(db.scopegraph.TypeGraph())
return codedom.MemberCall(codedom.MemberReference(childExpr, operator, node), operator, []codedom.Expression{valueExpr}, node)
}
// buildIndexerExpression builds the CodeDOM for an indexer call.
func (db *domBuilder) buildIndexerExpression(node compilergraph.GraphNode) codedom.Expression {
indexExpr := db.getExpression(node, parser.NodeSliceExpressionIndex)
childExpr := db.getExpression(node, parser.NodeSliceExpressionChildExpr)
scope, _ := db.scopegraph.GetScope(node)
operator, _ := scope.CalledOperator(db.scopegraph.TypeGraph())
opExpr := codedom.MemberReference(childExpr, operator, node)
return codedom.MemberCall(opExpr, operator, []codedom.Expression{indexExpr}, node)
}
// buildCollectionInitializerExpression builds a literal collection expression.
func (db *domBuilder) buildCollectionInitializerExpression(collectionType typegraph.TypeReference, valueExprs []codedom.Expression, emptyConstructorName string, arrayConstructorName string, node compilergraph.GraphNode) codedom.Expression {
if len(valueExprs) == 0 {
// Empty collection. Call the empty constructor directly.
constructor, _ := collectionType.ResolveMember(emptyConstructorName, typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(collectionType, node), constructor, node),
constructor,
[]codedom.Expression{},
node)
}
arrayExpr := codedom.ArrayLiteral(valueExprs, node)
constructor, _ := collectionType.ResolveMember(arrayConstructorName, typegraph.MemberResolutionStatic)
return codedom.MemberCall(
codedom.MemberReference(codedom.TypeLiteral(collectionType, node), constructor, node),
constructor,
[]codedom.Expression{arrayExpr},
node)
}
// buildSlicerExpression builds the CodeDOM for a slice call.
func (db *domBuilder) buildSlicerExpression(node compilergraph.GraphNode) codedom.Expression {
childExpr := db.getExpression(node, parser.NodeSliceExpressionChildExpr)
leftExpr := db.getExpressionOrDefault(node, parser.NodeSliceExpressionLeftIndex, codedom.LiteralValue("null", node))
rightExpr := db.getExpressionOrDefault(node, parser.NodeSliceExpressionRightIndex, codedom.LiteralValue("null", node))
scope, _ := db.scopegraph.GetScope(node)
operator, _ := scope.CalledOperator(db.scopegraph.TypeGraph())
opExpr := codedom.MemberReference(childExpr, operator, node)
return codedom.MemberCall(opExpr, operator, []codedom.Expression{leftExpr, rightExpr}, node)
}
// buildFunctionCall builds the CodeDOM for a function call.
func (db *domBuilder) buildFunctionCall(node compilergraph.GraphNode) codedom.Expression {
childExprNode := node.GetNode(parser.NodeFunctionCallExpressionChildExpr)
childScope, _ := db.scopegraph.GetScope(childExprNode)
// Check if the child expression has a static scope. If so, this is a type conversion between
// a nominal type and a base type.
if childScope.GetKind() == proto.ScopeKind_STATIC {
wrappedExprNode := node.GetNode(parser.NodeFunctionCallArgument)
wrappedExprScope, _ := db.scopegraph.GetScope(wrappedExprNode)
wrappedExprType := wrappedExprScope.ResolvedTypeRef(db.scopegraph.TypeGraph())
wrappedExpr := db.buildExpression(wrappedExprNode)
targetTypeRef := childScope.StaticTypeRef(db.scopegraph.TypeGraph())
// If the targetTypeRef is not nominal or structural, then we know we are unwrapping.
if !targetTypeRef.IsNominalOrStruct() {
return codedom.NominalUnwrapping(wrappedExpr, wrappedExprType, node)
} else {
return codedom.NominalRefWrapping(wrappedExpr, wrappedExprType, targetTypeRef, node)
}
}
// Collect the expressions for the arguments.
ait := node.StartQuery().
Out(parser.NodeFunctionCallArgument).
BuildNodeIterator()
arguments := db.buildExpressions(ait, buildExprCheckNominalShortcutting)
childExpr := db.buildExpression(childExprNode)
// If the function call is to a member, then we return a MemberCall.
namedRef, isNamed := db.scopegraph.GetReferencedName(childScope)
if isNamed && !namedRef.IsLocal() {
member, _ := namedRef.Member()
if childExprNode.Kind() == parser.NodeNullableMemberAccessExpression {
return codedom.NullableMemberCall(childExpr, member, arguments, node)
}
return codedom.MemberCall(childExpr, member, arguments, node)
}
// Otherwise, this is a normal function call with an await.
return codedom.AwaitPromise(codedom.FunctionCall(childExpr, arguments, node), node)
}
// buildUnaryOperatorExpression builds the CodeDOM for a unary operator.
func (db *domBuilder) buildUnaryOperatorExpression(node compilergraph.GraphNode, modifier exprModifier) codedom.Expression {
scope, _ := db.scopegraph.GetScope(node)
operator, _ := scope.CalledOperator(db.scopegraph.TypeGraph())
if operator.IsNative() {
return db.buildNativeUnaryExpression(node, operatorMap[node.Kind()])
}
childScope, _ := db.scopegraph.GetScope(node.GetNode(parser.NodeUnaryExpressionChildExpr))
parentType := childScope.ResolvedTypeRef(db.scopegraph.TypeGraph())
childExpr := db.getExpression(node, parser.NodeUnaryExpressionChildExpr)
callExpr := codedom.MemberCall(codedom.StaticMemberReference(operator, parentType, node), operator, []codedom.Expression{childExpr}, node)
if modifier != nil {
return modifier(callExpr)
}
return callExpr
}
// generateMemberReference generates the expression for a reference to a module or type member.
func (eg *expressionGenerator) generateMemberReference(memberReference *codedom.MemberReferenceNode, context generationContext) esbuilder.ExpressionBuilder {
// If the target member is implicitly called, then this is a property that needs to be accessed via a call.
if memberReference.Member.IsImplicitlyCalled() {
basisNode := memberReference.BasisNode()
memberCall := codedom.MemberCall(
codedom.NativeAccess(memberReference.ChildExpression, memberReference.Member.Name(), basisNode),
memberReference.Member,
[]codedom.Expression{},
basisNode)
return eg.generateExpression(memberCall, context)
}
// This handles the native new case for WebIDL. We should probably handle this directly.
if memberReference.Member.IsStatic() && !memberReference.Member.IsPromising() {
return eg.generateExpression(codedom.StaticMemberReference(memberReference.Member, eg.scopegraph.TypeGraph().AnyTypeReference(), memberReference.BasisNode()), context)
}
childExpr := eg.generateExpression(memberReference.ChildExpression, context)
return childExpr.Member(eg.pather.GetMemberName(memberReference.Member))
}
// buildStructCloneExpression builds a clone expression for a struct type.
func (db *domBuilder) buildStructCloneExpression(structType typegraph.TypeReference, initializers map[string]codedom.Expression, node compilergraph.GraphNode) codedom.Expression {
cloneMethod, found := structType.ResolveMember("Clone", typegraph.MemberResolutionInstance)
if !found {
panic(fmt.Sprintf("Missing Clone() method on type %v", structType))
}
cloneCall := codedom.MemberCall(
codedom.MemberReference(
db.getExpression(node, parser.NodeStructuralNewTypeExpression),
cloneMethod,
node),
cloneMethod,
[]codedom.Expression{},
node)
// If there are no initializers, then just return the cloned value directly.
if len(initializers) == 0 {
return cloneCall
}
return db.buildInitializationCompoundExpression(structType, initializers, cloneCall, node)
}
// buildLoopStatement builds the CodeDOM for a loop statement.
func (db *domBuilder) buildLoopStatement(node compilergraph.GraphNode) (codedom.Statement, codedom.Statement) {
startStatement := codedom.EmptyStatement(node)
startStatement.MarkReferenceable()
finalStatement := codedom.EmptyStatement(node)
// Save initial continue and break statements for the loop.
db.continueStatementMap[node.NodeId] = startStatement
db.breakStatementMap[node.NodeId] = finalStatement
// A loop statement is buildd as a start statement which conditionally jumps to either the loop body
// (on true) or, on false, jumps to a final state after the loop.
if loopExpr, hasLoopExpr := db.tryGetExpression(node, parser.NodeLoopStatementExpression); hasLoopExpr {
// Check for a named value under the loop. If found, this is a loop over a stream or streamable.
namedValue, hasNamedValue := node.TryGetNode(parser.NodeStatementNamedValue)
if hasNamedValue {
namedValueName := namedValue.Get(parser.NodeNamedValueName)
resultVarName := db.generateScopeVarName(node)
namedValueScope, _ := db.scopegraph.GetScope(namedValue)
// Create the stream variable.
streamVarName := db.generateScopeVarName(node)
var streamVariable = codedom.VarDefinitionWithInit(streamVarName, loopExpr, node)
// If the expression is Streamable, first call .Stream() on the expression to get the stream
// for the variable.
if namedValueScope.HasLabel(proto.ScopeLabel_STREAMABLE_LOOP) {
// Call .Stream() on the expression.
streamableMember, _ := db.scopegraph.TypeGraph().StreamableType().GetMember("Stream")
streamExpr := codedom.MemberCall(
codedom.MemberReference(loopExpr, streamableMember, namedValue),
streamableMember,
[]codedom.Expression{},
namedValue)
streamVariable = codedom.VarDefinitionWithInit(streamVarName, streamExpr, node)
}
// Create variables to hold the named value (as requested in the SRG) and the loop result.
namedVariable := codedom.VarDefinition(namedValueName, node)
resultVariable := codedom.VarDefinition(resultVarName, node)
// Create an expression statement to set the result variable to a call to Next().
streamMember, _ := db.scopegraph.TypeGraph().StreamType().GetMember("Next")
nextCallExpr := codedom.MemberCall(
codedom.MemberReference(codedom.LocalReference(streamVarName, node), streamMember, node),
streamMember,
[]codedom.Expression{},
namedValue)
resultExpressionStatement := codedom.ExpressionStatement(codedom.LocalAssignment(resultVarName, nextCallExpr, namedValue), namedValue)
resultExpressionStatement.MarkReferenceable()
// Set the continue statement to call Next() again.
db.continueStatementMap[node.NodeId] = resultExpressionStatement
// Create an expression statement to set the named variable to the first part of the tuple.
namedExpressionStatement := codedom.ExpressionStatement(
codedom.LocalAssignment(namedValueName,
codedom.NativeAccess(
codedom.LocalReference(resultVarName, namedValue), "First", namedValue),
namedValue),
namedValue)
// Jump to the body state if the second part of the tuple in the result variable is true.
bodyStart, bodyEnd := db.getStatements(node, parser.NodeLoopStatementBlock)
checkJump := codedom.ConditionalJump(
codedom.NativeAccess(codedom.LocalReference(resultVarName, node), "Second", node),
bodyStart,
finalStatement,
node)
// Steps:
// 1) Empty statement
// 2) Create the stream's variable (with no value)
// 3) Create the named value variable (with no value)
// 4) Create the result variable (with no value)
// 5) (loop starts here) Pull the Next() result out of the stream
// 6) Pull the true/false bool out of the result
// 7) Pull the named value out of the result
// 8) Jump based on the true/false boolean value
codedom.AssignNextStatement(startStatement, streamVariable)
codedom.AssignNextStatement(streamVariable, namedVariable)
codedom.AssignNextStatement(namedVariable, resultVariable)
codedom.AssignNextStatement(resultVariable, resultExpressionStatement)
codedom.AssignNextStatement(resultExpressionStatement, namedExpressionStatement)
codedom.AssignNextStatement(namedExpressionStatement, checkJump)
// Jump to the result checking expression once the loop body completes.
directJump := codedom.UnconditionalJump(resultExpressionStatement, node)
codedom.AssignNextStatement(bodyEnd, directJump)
return startStatement, finalStatement
} else {
bodyStart, bodyEnd := db.getStatements(node, parser.NodeLoopStatementBlock)
// Loop over a direct boolean expression which is evaluated on each iteration.
initialJump := codedom.ConditionalJump(loopExpr, bodyStart, finalStatement, node)
directJump := codedom.UnconditionalJump(initialJump, node)
codedom.AssignNextStatement(bodyEnd, directJump)
codedom.AssignNextStatement(startStatement, initialJump)
return startStatement, finalStatement
}
} else {
bodyStart, bodyEnd := db.getStatements(node, parser.NodeLoopStatementBlock)
// A loop without an expression just loops infinitely over the body.
directJump := codedom.UnconditionalJump(bodyStart, node)
codedom.AssignNextStatement(bodyEnd, directJump)
codedom.AssignNextStatement(startStatement, bodyStart)
return startStatement, directJump
}
}