typeAssert: bool float string

ssa/expr.go

@@ -24,6 +24,7 @@ import (
 	"go/types"
 	"log"
 
+	"github.com/goplus/llgo/internal/abi"
 	"github.com/goplus/llvm"
 )
 
@@ -1051,7 +1052,7 @@ func (b Builder) MakeInterface(tinter Type, x Expr) (ret Expr) {
 	case *types.Basic:
 		kind := tx.Kind()
 		switch {
-		case kind >= types.Int && kind <= types.Uintptr:
+		case kind >= types.Bool && kind <= types.Uintptr:
 			t := b.InlineCall(pkg.rtFunc("Basic"), prog.Val(int(kind)))
 			tptr := prog.Uintptr()
 			vptr := Expr{llvm.CreateIntCast(b.impl, x.impl, tptr.ll), tptr}
@@ -1118,7 +1119,7 @@ func (b Builder) TypeAssert(x Expr, assertedTyp Type, commaOk bool) (ret Expr) {
 		log.Printf("TypeAssert %v, %v, %v\n", x.impl, assertedTyp.raw.Type, commaOk)
 	}
 	switch assertedTyp.kind {
-	case vkSigned, vkUnsigned:
+	case vkSigned, vkUnsigned, vkFloat, vkBool:
 		pkg := b.Func.Pkg
 		fnName := "I2Int"
 		if commaOk {
@@ -1133,25 +1134,44 @@ func (b Builder) TypeAssert(x Expr, assertedTyp Type, commaOk bool) (ret Expr) {
 			panic("todo")
 		}
 		typ := b.InlineCall(pkg.rtFunc("Basic"), b.Prog.Val(int(kind)))
-		return b.InlineCall(fn, x, typ)
-	case vkFloat:
-		var fnName string
-		kind := assertedTyp.raw.Underlying().(*types.Basic).Kind()
-		switch kind {
-		case types.Float32:
-			fnName = "I2Float32"
-			if commaOk {
-				fnName = "CheckI2Float32"
+		ret = b.InlineCall(fn, x, typ)
+		if kind != types.Uintptr {
+			conv := func(v llvm.Value) llvm.Value {
+				switch kind {
+				case types.Float32:
+					v = castInt(b.impl, v, b.Prog.tyInt32())
+					v = b.impl.CreateBitCast(v, assertedTyp.ll, "")
+				case types.Float64:
+					v = b.impl.CreateBitCast(v, assertedTyp.ll, "")
+				default:
+					v = castInt(b.impl, v, assertedTyp.ll)
+				}
+				return v
 			}
-		case types.Float64:
-			fnName = "I2Float64"
-			if commaOk {
-				fnName = "CheckI2Float64"
+			if !commaOk {
+				ret.Type = assertedTyp
+				ret.impl = conv(ret.impl)
+			} else {
+				ret.Type = b.Prog.toTuple(
+					types.NewTuple(
+						types.NewVar(token.NoPos, nil, "", assertedTyp.RawType()),
+						ret.Type.RawType().(*types.Tuple).At(1),
+					),
+				)
+				val0 := conv(b.impl.CreateExtractValue(ret.impl, 0, ""))
+				val1 := b.impl.CreateExtractValue(ret.impl, 1, "")
+				ret.impl = llvm.ConstStruct([]llvm.Value{val0, val1}, false)
 			}
 		}
+		return
+	case vkString:
 		pkg := b.Func.Pkg
+		fnName := "I2String"
+		if commaOk {
+			fnName = "CheckI2String"
+		}
 		fn := pkg.rtFunc(fnName)
-		typ := b.InlineCall(pkg.rtFunc("Basic"), b.Prog.Val(int(kind)))
+		typ := b.InlineCall(pkg.rtFunc("Basic"), b.Prog.Val(int(abi.String)))
 		return b.InlineCall(fn, x, typ)
 	}
 	panic("todo")
@@ -1262,11 +1282,4 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) {
 	panic("todo")
 }
 
-// BitCast bit cast expr to type
-func (b Builder) BitCast(val Expr, typ Type) (ret Expr) {
-	ret.Type = typ
-	ret.impl = b.impl.CreateBitCast(val.impl, typ.ll, "")
-	return
-}
-
 // -----------------------------------------------------------------------------