Add front end support for map values

ast/expressions.go

@@ -281,6 +281,25 @@
 		PositionalArgs []BLangExpression
 		// TODO: Add support for NamedArgs
 	}
+
+	BLangMappingKey struct {
+		BLangNodeBase
+		Expr        BLangExpression
+		ComputedKey bool
+	}
+
+	BLangMappingKeyValueField struct {
+		BLangNodeBase
+		Key       *BLangMappingKey
+		ValueExpr BLangExpression
+		Readonly  bool
+	}
+
+	BLangMappingConstructorExpr struct {
+		BLangExpressionBase
+		Fields     []model.MappingField
+		AtomicType semtypes.MappingAtomicType
+	}
 )
 
 var (
@@ -293,7 +312,7 @@
 	_ model.LiteralNode                                            = &BLangConstRef{}
 	_ model.LiteralNode                                            = &BLangLiteral{}
 	_ BLangExpression                                              = &BLangLiteral{}
-	_ model.RecordVarNameFieldNode                                 = &BLangConstRef{}
+	_ model.MappingVarNameFieldNode                                = &BLangConstRef{}
 	_ model.DynamicArgNode                                         = &BLangDynamicArgExpr{}
 	_ model.ElvisExpressionNode                                    = &BLangElvisExpr{}
 	_ model.MarkdownDocumentationTextAttributeNode                 = &BLangMarkdownDocumentationLine{}
@@ -316,6 +335,12 @@
 	_ BLangExpression                                              = &BLangTypeConversionExpr{}
 	_ BLangExpression                                              = &BLangErrorConstructorExpr{}
 	_ BLangNode                                                    = &BLangErrorConstructorExpr{}
+	_ model.MappingConstructor                                     = &BLangMappingConstructorExpr{}
+	_ model.MappingKeyValueFieldNode                               = &BLangMappingKeyValueField{}
+	_ BLangExpression                                              = &BLangMappingConstructorExpr{}
+	_ BLangNode                                                    = &BLangMappingConstructorExpr{}
+	_ model.Node                                                   = &BLangMappingKey{}
+	_ BLangNode                                                    = &BLangMappingKey{}
 )
 
 var (
@@ -348,6 +373,9 @@
 	_ BLangNode = &BLangIndexBasedAccess{}
 	_ BLangNode = &BLangListConstructorExpr{}
 	_ BLangNode = &BLangTypeConversionExpr{}
+	_ BLangNode = &BLangMappingConstructorExpr{}
+	_ BLangNode = &BLangMappingKeyValueField{}
+	_ BLangNode = &BLangMappingKey{}
 )
 
 var (
@@ -954,6 +982,41 @@
 	panic("not implemented")
 }
 
+func (this *BLangMappingKey) GetKind() model.NodeKind {
+	panic("BLangMappingKey has no NodeKind")
+}
+
+func (this *BLangMappingKeyValueField) GetKind() model.NodeKind {
+	return model.NodeKind_RECORD_LITERAL_KEY_VALUE
+}
+
+func (this *BLangMappingKeyValueField) GetKey() model.ExpressionNode {
+	if this.Key == nil {
+		return nil
+	}
+	return this.Key.Expr
+}
+
+func (this *BLangMappingKeyValueField) GetValue() model.ExpressionNode {
+	return this.ValueExpr
+}
+
+func (this *BLangMappingKeyValueField) IsKeyValueField() bool {
+	return true
+}
+
+func (this *BLangMappingConstructorExpr) GetKind() model.NodeKind {
+	return model.NodeKind_RECORD_LITERAL_EXPR
+}
+
+func (this *BLangMappingConstructorExpr) GetFields() []model.MappingField {
+	return this.Fields
+}
+
+func (this *BLangMappingConstructorExpr) SetTypeCheckedType(ty BType) {
+	this.ExpectedType = ty
+}
+
 func createBLangUnaryExpr(location Location, operator model.OperatorKind, expr BLangExpression) *BLangUnaryExpr {
 	exprNode := &BLangUnaryExpr{}
 	exprNode.pos = location

ast/node_builder.go

@@ -1795,7 +1795,53 @@
 }
 
 func (n *NodeBuilder) TransformMappingConstructorExpression(mappingConstructorExpressionNode *tree.MappingConstructorExpressionNode) BLangNode {
-	panic("TransformMappingConstructorExpression unimplemented")
+	mappingConstructor := &BLangMappingConstructorExpr{
+		Fields: make([]model.MappingField, 0),
+	}
+	fields := mappingConstructorExpressionNode.FieldNodes()
+	for i := 0; i < fields.Size(); i += 2 {
+		field := fields.Get(i)
+		switch field.Kind() {
+		case common.SPREAD_FIELD:
+			panic("mapping constructor spread field not implemented")
+		case common.COMPUTED_NAME_FIELD:
+			computedNameField := field.(*tree.ComputedNameFieldNode)
+			keyExpr := n.createExpression(computedNameField.FieldNameExpr())
+			key := &BLangMappingKey{
+				Expr:        keyExpr,
+				ComputedKey: true,
+			}
+			key.SetPosition(getPosition(computedNameField.FieldNameExpr()))
+			keyValueField := &BLangMappingKeyValueField{
+				Key:       key,
+				ValueExpr: n.createExpression(computedNameField.ValueExpr()),
+			}
+			keyValueField.SetPosition(getPosition(computedNameField))
+			mappingConstructor.Fields = append(mappingConstructor.Fields, keyValueField)
+		case common.SPECIFIC_FIELD:
+			specificField := field.(*tree.SpecificFieldNode)
+			if specificField.ValueExpr() == nil {
+				panic("mapping constructor var-name field not implemented")
+			}
+			keyExpr := n.createExpression(specificField.FieldName())
+			key := &BLangMappingKey{
+				Expr:        keyExpr,
+				ComputedKey: false,
+			}
+			key.SetPosition(getPosition(specificField.FieldName()))
+			keyValueField := &BLangMappingKeyValueField{
+				Key:       key,
+				ValueExpr: n.createExpression(specificField.ValueExpr()),
+				Readonly:  specificField.ReadonlyKeyword() != nil,
+			}
+			keyValueField.SetPosition(getPosition(specificField))
+			mappingConstructor.Fields = append(mappingConstructor.Fields, keyValueField)
+		default:
+			panic(fmt.Sprintf("unexpected mapping field kind: %v", field.Kind()))
+		}
+	}
+	mappingConstructor.SetPosition(getPosition(mappingConstructorExpressionNode))
+	return mappingConstructor
 }
 
 func (n *NodeBuilder) TransformIndexedExpression(indexedExpressionNode *tree.IndexedExpressionNode) BLangNode {
@@ -2097,7 +2143,23 @@
 }
 
 func (n *NodeBuilder) TransformMapTypeDescriptor(mapTypeDescriptorNode *tree.MapTypeDescriptorNode) BLangNode {
-	panic("TransformMapTypeDescriptor unimplemented")
+	refType := &BLangBuiltInRefTypeNode{
+		TypeKind: model.TypeKind_MAP,
+	}
+	refType.SetPosition(getPosition(mapTypeDescriptorNode))
+
+	mapTypeParamsNode := mapTypeDescriptorNode.MapTypeParamsNode()
+	if mapTypeParamsNode == nil || mapTypeParamsNode.TypeNode() == nil {
+		panic("map type requires type parameter")
+	}
+	constraint := n.createTypeNode(mapTypeParamsNode.TypeNode())
+
+	constrainedType := &BLangConstrainedType{
+		Type:       model.TypeData{TypeDescriptor: refType},
+		Constraint: model.TypeData{TypeDescriptor: constraint},
+	}
+	constrainedType.SetPosition(refType.GetPosition())
+	return constrainedType
 }
 
 func (n *NodeBuilder) TransformNilLiteral(nilLiteralNode *tree.NilLiteralNode) BLangNode {

ast/pretty_printer.go

@@ -104,6 +104,8 @@ func (p *PrettyPrinter) PrintInner(node BLangNode) {
 		p.printUnionTypeNode(t)
 	case *BLangErrorTypeNode:
 		p.printErrorTypeNode(t)
+	case *BLangConstrainedType:
+		p.printConstrainedType(t)
 	case *BLangTypeDefinition:
 		p.printTypeDefinition(t)
 	case *BLangUserDefinedType:
@@ -112,6 +114,8 @@ func (p *PrettyPrinter) PrintInner(node BLangNode) {
 		p.printFiniteTypeNode(t)
 	case *BLangListConstructorExpr:
 		p.printListConstructorExpr(t)
+	case *BLangMappingConstructorExpr:
+		p.printMappingConstructor(t)
 	case *BLangTypeConversionExpr:
 		p.printTypeConversionExpr(t)
 	default:
@@ -647,6 +651,34 @@ func (p *PrettyPrinter) printListConstructorExpr(node *BLangListConstructorExpr)
 	p.endNode()
 }
 
+func (p *PrettyPrinter) printMappingConstructor(node *BLangMappingConstructorExpr) {
+	p.startNode()
+	p.printString("mapping-constructor-expr")
+	p.indentLevel++
+	for _, f := range node.Fields {
+		if kv, ok := f.(*BLangMappingKeyValueField); ok {
+			p.printMappingKeyValueField(kv)
+		}
+	}
+	p.indentLevel--
+	p.endNode()
+}
+
+// Mapping key-value field printer: prints as (key-value (key) (value))
+func (p *PrettyPrinter) printMappingKeyValueField(kv *BLangMappingKeyValueField) {
+	p.startNode()
+	p.printString("key-value")
+	p.indentLevel++
+	if kv.Key != nil && kv.Key.Expr != nil {
+		p.PrintInner(kv.Key.Expr.(BLangNode))
+	}
+	if kv.ValueExpr != nil {
+		p.PrintInner(kv.ValueExpr.(BLangNode))
+	}
+	p.indentLevel--
+	p.endNode()
+}
+
 // Wildcard binding pattern printer
 func (p *PrettyPrinter) printWildCardBindingPattern(node *BLangWildCardBindingPattern) {
 	p.startNode()
@@ -689,6 +721,20 @@ func (p *PrettyPrinter) printErrorTypeNode(node *BLangErrorTypeNode) {
 	p.endNode()
 }
 
+func (p *PrettyPrinter) printConstrainedType(node *BLangConstrainedType) {
+	p.startNode()
+	p.printString("constrained-type")
+	p.indentLevel++
+	if node.Type.TypeDescriptor != nil {
+		p.PrintInner(node.Type.TypeDescriptor.(BLangNode))
+	}
+	if node.Constraint.TypeDescriptor != nil {
+		p.PrintInner(node.Constraint.TypeDescriptor.(BLangNode))
+	}
+	p.indentLevel--
+	p.endNode()
+}
+
 // Type definition printer
 func (p *PrettyPrinter) printTypeDefinition(node *BLangTypeDefinition) {
 	p.startNode()

ast/types.go

@@ -131,6 +131,13 @@
 		BLangTypeBase
 		detailType model.TypeData
 	}
+
+	BLangConstrainedType struct {
+		BLangTypeBase
+		Type       model.TypeData
+		Constraint model.TypeData
+		Definition semtypes.Definition
+	}
 )
 
 var (
@@ -145,6 +152,7 @@
 	_ BNodeWithSymbol                = &BLangUserDefinedType{}
 	_ model.UnionTypeNode            = &BLangUnionTypeNode{}
 	_ model.ErrorTypeNode            = &BLangErrorTypeNode{}
+	_ model.ConstrainedTypeNode      = &BLangConstrainedType{}
 )
 
 var (
@@ -159,7 +167,9 @@
 	_ BLangNode            = &BLangArrayType{}
 	_ BLangNode            = &BLangUserDefinedType{}
 	_ BLangNode            = &BLangValueType{}
+	_ BLangNode            = &BLangConstrainedType{}
 	_ model.TypeDescriptor = &BLangValueType{}
+	_ model.TypeDescriptor = &BLangConstrainedType{}
 )
 
 func (this *BLangArrayType) GetKind() model.NodeKind {
@@ -430,3 +440,25 @@
 func (this *BLangErrorTypeNode) IsDistinct() bool {
 	return this.FlagSet.Contains(model.Flag_DISTINCT)
 }
+
+func (this *BLangConstrainedType) GetKind() model.NodeKind {
+	return model.NodeKind_CONSTRAINED_TYPE
+}
+
+func (this *BLangConstrainedType) GetType() model.TypeData {
+	return this.Type
+}
+
+func (this *BLangConstrainedType) GetConstraint() model.TypeData {
+	return this.Constraint
+}
+
+func (this *BLangConstrainedType) GetTypeKind() model.TypeKind {
+	if this.Type.TypeDescriptor == nil {
+		panic("base type is nil")
+	}
+	if builtIn, ok := this.Type.TypeDescriptor.(model.BuiltInReferenceTypeNode); ok {
+		return builtIn.GetTypeKind()
+	}
+	panic("BLangConstrainedType.Type does not implement BuiltInReferenceTypeNode")
+}

ast/walk.go

@@ -406,6 +406,17 @@ func Walk(v Visitor, node BLangNode) {
 		for _, expr := range node.Exprs {
 			Walk(v, expr.(BLangNode))
 		}
+	case *BLangMappingConstructorExpr:
+		for _, f := range node.Fields {
+			if kv, ok := f.(*BLangMappingKeyValueField); ok {
+				if kv.Key != nil && kv.Key.Expr != nil {
+					Walk(v, kv.Key.Expr.(BLangNode))
+				}
+				if kv.ValueExpr != nil {
+					Walk(v, kv.ValueExpr.(BLangNode))
+				}
+			}
+		}
 	case *BLangErrorConstructorExpr:
 		if node.ErrorTypeRef != nil {
 			Walk(v, node.ErrorTypeRef)
@@ -545,6 +556,10 @@ func Walk(v Visitor, node BLangNode) {
 	case *BLangErrorTypeNode:
 		WalkTypeData(v, &node.detailType)
 
+	case *BLangConstrainedType:
+		WalkTypeData(v, &node.Type)
+		WalkTypeData(v, &node.Constraint)
+
 	// Section 9: Binding Patterns
 	case *BLangCaptureBindingPattern:
 		Walk(v, &node.Identifier)

bir/bir_gen.go

@@ -524,11 +524,42 @@
 		return listConstructorExpression(ctx, curBB, expr)
 	case *ast.BLangTypeConversionExpr:
 		return typeConversionExpression(ctx, curBB, expr)
+	case *ast.BLangMappingConstructorExpr:
+		return mappingConstructorExpression(ctx, curBB, expr)
 	default:
 		panic("unexpected expression type")
 	}
 }
 
+func mappingConstructorExpression(ctx *stmtContext, curBB *BIRBasicBlock, expr *ast.BLangMappingConstructorExpr) expressionEffect {
+	var values []MappingConstructorEntry
+	for _, field := range expr.Fields {
+		switch f := field.(type) {
+		case *ast.BLangMappingKeyValueField:
+			keyEffect := handleExpression(ctx, curBB, f.Key.Expr)
+			curBB = keyEffect.block
+			valueEffect := handleExpression(ctx, curBB, f.ValueExpr)
+			curBB = valueEffect.block
+			values = append(values, &MappingConstructorKeyValueEntry{
+				keyOp:   keyEffect.result,
+				valueOp: valueEffect.result,
+			})
+		default:
+			ctx.birCx.CompilerContext.Unimplemented("non-key-value record field not implemented", expr.GetPosition())
+		}
+	}
+	resultOperand := ctx.addTempVar(expr.GetDeterminedType())
+	newMap := &NewMap{}
+	newMap.Type = expr.GetDeterminedType()
+	newMap.Values = values
+	newMap.LhsOp = resultOperand
+	curBB.Instructions = append(curBB.Instructions, newMap)
+	return expressionEffect{
+		result: resultOperand,
+		block:  curBB,
+	}
+}
+
 func typeConversionExpression(ctx *stmtContext, curBB *BIRBasicBlock, expr *ast.BLangTypeConversionExpr) expressionEffect {
 	exprEffect := handleExpression(ctx, curBB, expr.Expression)
 	curBB = exprEffect.block