Add front end support for type test expressions

ast/expressions.go

@@ -282,6 +282,13 @@
 		// TODO: Add support for NamedArgs
 	}
 
+	BLangTypeTestExpr struct {
+		BLangExpressionBase
+		Expr       BLangExpression
+		Type       model.TypeData
+		isNegation bool
+	}
+
 	BLangMappingKey struct {
 		BLangNodeBase
 		Expr        BLangExpression
@@ -335,6 +342,8 @@
 	_ BLangExpression                                              = &BLangTypeConversionExpr{}
 	_ BLangExpression                                              = &BLangErrorConstructorExpr{}
 	_ BLangNode                                                    = &BLangErrorConstructorExpr{}
+	_ BLangExpression                                              = &BLangTypeTestExpr{}
+	_ model.TypeTestExpressionNode                                 = &BLangTypeTestExpr{}
 	_ model.MappingConstructor                                     = &BLangMappingConstructorExpr{}
 	_ model.MappingKeyValueFieldNode                               = &BLangMappingKeyValueField{}
 	_ BLangExpression                                              = &BLangMappingConstructorExpr{}
@@ -982,6 +991,26 @@
 	panic("not implemented")
 }
 
+func (this *BLangTypeTestExpr) GetKind() model.NodeKind {
+	return model.NodeKind_TYPE_TEST_EXPR
+}
+
+func (this *BLangTypeTestExpr) IsNegation() bool {
+	return this.isNegation
+}
+
+func (this *BLangTypeTestExpr) GetExpression() model.ExpressionNode {
+	return this.Expr
+}
+
+func (this *BLangTypeTestExpr) GetType() model.TypeData {
+	return this.Type
+}
+
+func (this *BLangTypeTestExpr) SetTypeCheckedType(ty BType) {
+	panic("not implemented")
+}
+
 func (this *BLangMappingKey) GetKind() model.NodeKind {
 	panic("BLangMappingKey has no NodeKind")
 }

ast/node_builder.go

@@ -2135,7 +2135,14 @@
 }
 
 func (n *NodeBuilder) TransformTypeTestExpression(typeTestExpressionNode *tree.TypeTestExpressionNode) BLangNode {
-	panic("TransformTypeTestExpression unimplemented")
+	typeTestExpr := &BLangTypeTestExpr{}
+	if typeTestExpressionNode.IsKeyword().Kind() == common.NOT_IS_KEYWORD {
+		typeTestExpr.isNegation = true
+	}
+	typeTestExpr.Expr = n.createExpression(typeTestExpressionNode.Expression())
+	typeTestExpr.Type = model.TypeData{TypeDescriptor: n.createTypeNode(typeTestExpressionNode.TypeDescriptor())}
+	typeTestExpr.SetPosition(getPosition(typeTestExpressionNode))
+	return typeTestExpr
 }
 
 func (n *NodeBuilder) TransformRemoteMethodCallAction(remoteMethodCallActionNode *tree.RemoteMethodCallActionNode) BLangNode {

ast/pretty_printer.go

@@ -118,6 +118,8 @@
 		p.printMappingConstructor(t)
 	case *BLangTypeConversionExpr:
 		p.printTypeConversionExpr(t)
+	case *BLangTypeTestExpr:
+		p.printTypeTestExpr(t)
 	default:
 		fmt.Println(p.buffer.String())
 		panic("Unsupported node type: " + reflect.TypeOf(t).String())
@@ -529,6 +531,22 @@
 	p.endNode()
 }
 
+func (p *PrettyPrinter) printTypeTestExpr(node *BLangTypeTestExpr) {
+	p.startNode()
+	if node.isNegation {
+		p.printString("type-test-expr !is")
+	} else {
+		p.printString("type-test-expr is")
+	}
+	p.indentLevel++
+	p.PrintInner(node.Expr.(BLangNode))
+	if node.Type.TypeDescriptor != nil {
+		p.PrintInner(node.Type.TypeDescriptor.(BLangNode))
+	}
+	p.indentLevel--
+	p.endNode()
+}
+
 // While loop printer
 func (p *PrettyPrinter) printWhile(node *BLangWhile) {
 	p.startNode()

ast/walk.go

@@ -477,6 +477,12 @@ func Walk(v Visitor, node BLangNode) {
 			Walk(v, node.TypeDescriptor.(BLangNode))
 		}
 
+	case *BLangTypeTestExpr:
+		if node.Expr != nil {
+			Walk(v, node.Expr.(BLangNode))
+		}
+		WalkTypeData(v, &node.Type)
+
 	case *BLangCommitExpr:
 		panic("unimplemented")
 

bir/bir_gen.go

@@ -524,6 +524,8 @@ func handleExpression(ctx *stmtContext, curBB *BIRBasicBlock, expr ast.BLangExpr
 		return listConstructorExpression(ctx, curBB, expr)
 	case *ast.BLangTypeConversionExpr:
 		return typeConversionExpression(ctx, curBB, expr)
+	case *ast.BLangTypeTestExpr:
+		return typeTestExpression(ctx, curBB, expr)
 	case *ast.BLangMappingConstructorExpr:
 		return mappingConstructorExpression(ctx, curBB, expr)
 	default:
@@ -575,6 +577,22 @@ func typeConversionExpression(ctx *stmtContext, curBB *BIRBasicBlock, expr *ast.
 	}
 }
 
+func typeTestExpression(ctx *stmtContext, curBB *BIRBasicBlock, expr *ast.BLangTypeTestExpr) expressionEffect {
+	exprEffect := handleExpression(ctx, curBB, expr.Expr)
+	curBB = exprEffect.block
+	resultOperand := ctx.addTempVar(expr.GetDeterminedType())
+	typeTest := &TypeTest{}
+	typeTest.LhsOp = resultOperand
+	typeTest.RhsOp = exprEffect.result
+	typeTest.Type = expr.Type.Type
+	typeTest.IsNegation = expr.IsNegation()
+	curBB.Instructions = append(curBB.Instructions, typeTest)
+	return expressionEffect{
+		result: resultOperand,
+		block:  curBB,
+	}
+}
+
 func listConstructorExpression(ctx *stmtContext, bb *BIRBasicBlock, expr *ast.BLangListConstructorExpr) expressionEffect {
 	initValues := make([]*BIROperand, len(expr.Exprs))
 	for i, expr := range expr.Exprs {

bir/non_terminator.go

@@ -89,6 +89,13 @@
 		// numeric conversions, which can be done with pure types
 		Type semtypes.SemType
 	}
+
+	TypeTest struct {
+		BIRInstructionBase
+		RhsOp      *BIROperand
+		Type       semtypes.SemType
+		IsNegation bool
+	}
 )
 
 type (
@@ -106,6 +113,7 @@
 	_ BIRInstruction          = &FieldAccess{}
 	_ BIRInstruction          = &NewArray{}
 	_ BIRInstruction          = &TypeCast{}
+	_ BIRAssignInstruction    = &TypeTest{}
 	_ BIRInstruction          = &NewMap{}
 	_ MappingConstructorEntry = &MappingConstructorKeyValueEntry{}
 )
@@ -206,6 +214,14 @@
 	return INSTRUCTION_KIND_TYPE_CAST
 }
 
+func (t *TypeTest) GetLhsOperand() *BIROperand {
+	return t.LhsOp
+}
+
+func (t *TypeTest) GetKind() InstructionKind {
+	return INSTRUCTION_KIND_TYPE_TEST
+}
+
 func (n *NewMap) GetKind() InstructionKind {
 	return INSTRUCTION_KIND_NEW_STRUCTURE
 }

bir/pretty_print.go

@@ -141,6 +141,8 @@
 		return p.PrintNewMap(instruction.(*NewMap))
 	case *TypeCast:
 		return p.PrintTypeCast(instruction.(*TypeCast))
+	case *TypeTest:
+		return p.PrintTypeTest(instruction.(*TypeTest))
 	default:
 		panic(fmt.Sprintf("unknown instruction type: %T", instruction))
 	}
@@ -150,6 +152,14 @@
 	return fmt.Sprintf("%s = <%s>(%s)", p.PrintOperand(*cast.LhsOp), cast.Type.String(), p.PrintOperand(*cast.RhsOp))
 }
 
+func (p *PrettyPrinter) PrintTypeTest(test *TypeTest) string {
+	op := "is"
+	if test.IsNegation {
+		op = "!is"
+	}
+	return fmt.Sprintf("%s = %s %s %s", p.PrintOperand(*test.LhsOp), p.PrintOperand(*test.RhsOp), op, test.Type.String())
+}
+
 func (p *PrettyPrinter) PrintNewArray(array *NewArray) string {
 	values := strings.Builder{}
 	for i, v := range array.Values {