CastFromBool: support untyped bool

ast.go

@@ -779,6 +779,13 @@ func matchRcast(pkg *Package, fn *internal.Elem, m types.Object, typ types.Type,
 // CastFromBool tries to cast a bool expression into integer. typ must be an integer type.
 func CastFromBool(cb *CodeBuilder, typ types.Type, v *Element) (ret *Element, ok bool) {
 	if ok = isBool(cb, v); ok {
+		if v.CVal != nil { // untyped bool
+			var val int
+			if constant.BoolVal(v.CVal) {
+				val = 1
+			}
+			return toExpr(nil, val, v.Src), true
+		}
 		pkg := cb.pkg
 		results := types.NewTuple(types.NewParam(token.NoPos, pkg.Types, "", typ))
 		ret = cb.NewClosure(nil, results, false).BodyStart(pkg).

builtin_test.go

@@ -950,4 +950,21 @@ func TestTypeAST(t *testing.T) {
 	}
 }
 
+func TestCastFromBool(t *testing.T) {
+	ret, ok := CastFromBool(nil, types.Typ[types.Uint], &Element{
+		Type: types.Typ[types.UntypedBool],
+		CVal: constant.MakeBool(true),
+	})
+	if !ok || constant.Val(ret.CVal).(int64) != 1 {
+		t.Fatal("CastFromBool failed:", ret.CVal, ok)
+	}
+	ret, ok = CastFromBool(nil, types.Typ[types.Uint], &Element{
+		Type: types.Typ[types.Bool],
+		CVal: constant.MakeBool(false),
+	})
+	if !ok || constant.Val(ret.CVal).(int64) != 0 {
+		t.Fatal("CastFromBool failed:", ret.CVal, ok)
+	}
+}
+
 // ----------------------------------------------------------------------------

package_test.go

@@ -608,8 +608,17 @@ func TestDeleteType(t *testing.T) {
 	pkg := newMainPackage()
 	typ := types.NewStruct(nil, nil)
 	decl := pkg.NewType("foo")
+	if decl.State() != gox.TyStateUninited {
+		t.Fatal("TypeDecl.State failed")
+	}
 	decl.InitType(pkg, typ)
+	if decl.State() != gox.TyStateInited {
+		t.Fatal("TypeDecl.State failed")
+	}
 	decl.Delete()
+	if decl.State() != gox.TyStateDeleted {
+		t.Fatal("TypeDecl.State failed")
+	}
 	domTest(t, pkg, `package main
 
 

type_var_and_const.go

@@ -38,6 +38,14 @@ func (p *CodeBuilder) EndConst() *Element {
 
 // ----------------------------------------------------------------------------
 
+type TyState int
+
+const (
+	TyStateUninited TyState = iota
+	TyStateInited
+	TyStateDeleted
+)
+
 // TypeDecl type
 type TypeDecl struct {
 	typ   *types.Named
@@ -56,13 +64,28 @@ func (p *TypeDecl) Type() *types.Named {
 	return p.typ
 }
 
+// State checkes state of this type.
+// If Delete is called, it returns TyStateDeleted.
+// If InitType is called (but not deleted), it returns TyStateInited.
+// Otherwise it returns TyStateUninited.
+func (p *TypeDecl) State() TyState {
+	if spec := p.decl.Specs; len(spec) > 0 {
+		if spec[0].(*ast.TypeSpec).Type != nil {
+			return TyStateInited
+		}
+		return TyStateUninited
+	}
+	return TyStateDeleted
+}
+
 // Delete deletes this type.
 // NOTE: It panics if you call InitType after Delete.
 func (p *TypeDecl) Delete() {
 	p.decl.Specs = p.decl.Specs[:0]
 }
 
-// Inited checkes if `InitType` is called or not.
+// Inited checkes if InitType is called or not.
+// Will panic if this type is deleted (please use State to check).
 func (p *TypeDecl) Inited() bool {
 	return p.decl.Specs[0].(*ast.TypeSpec).Type != nil
 }