Use TypeKind instead of Ptr to deduce Value types

3 files changed, 54 insertions, 41 deletions

diff --git a/pkg/lang/vm/exec.go b/pkg/lang/vm/exec.go
index 353d8ac..eeb8710 100644
--- a/pkg/lang/vm/exec.go
+++ b/pkg/lang/vm/exec.go
@@ -490,14 +490,16 @@ func (vm *VM) execAnchorType() error {
 		}
 	}
 
-	if !o.TypePtr().IsNull() {
+	obj := o.Data().(value.ObjectData)
+	typeRef := t.Data().(value.TypeRefData)
+
+	if obj.Type() != mem.NullPtr {
 		return ErrCantReanchorType{
 			Type: o.Type(),
 		}
 	}
 
-	o = o.WithType(t.Data().(value.TypeRefData).TypeRef())
-
+	o = o.WithData(obj.WithType(typeRef.TypeRef()))
 	vm.stack.Push(o)
 	return nil
 }
diff --git a/pkg/lang/vm/value/data.go b/pkg/lang/vm/value/data.go
index 6ec7be9..39193d5 100644
--- a/pkg/lang/vm/value/data.go
+++ b/pkg/lang/vm/value/data.go
@@ -207,6 +207,7 @@ func (t TypeRefData) AddMethod(m mem.Mem, name string, method FunctionData) erro
 }
 
 type ObjectData struct {
+	t   mem.Ptr
 	obj mem.Ptr
 }
 
@@ -217,3 +218,11 @@ func (o ObjectData) String(_ mem.Mem) (string, error) {
 func (o ObjectData) Ptr() mem.Ptr {
 	return o.obj
 }
+
+func (o ObjectData) Type() mem.Ptr {
+	return o.t
+}
+
+func (o ObjectData) WithType(t mem.Ptr) ObjectData {
+	return ObjectData{t: t, obj: o.obj}
+}
diff --git a/pkg/lang/vm/value/value.go b/pkg/lang/vm/value/value.go
index b051f04..5ef3f07 100644
--- a/pkg/lang/vm/value/value.go
+++ b/pkg/lang/vm/value/value.go
@@ -6,17 +6,17 @@ import (
 )
 
 type Value struct {
-	t      mem.Ptr
+	t      TypeKind
 	d      Data
 	outlet mem.Ptr
 }
 
 func NewInt(x int64) Value {
-	return Value{t: CORE_TYPE_INT, d: IntData(x)}
+	return Value{t: IntType, d: IntData(x)}
 }
 
 func NewFloat(x float64) Value {
-	return Value{t: CORE_TYPE_FLOAT, d: FloatData(x)}
+	return Value{t: FloatType, d: FloatData(x)}
 }
 
 func NewString(m mem.Mem, str string) (Value, error) {
@@ -29,11 +29,11 @@ func NewString(m mem.Mem, str string) (Value, error) {
 		return Value{}, err
 	}
 
-	return Value{t: CORE_TYPE_STRING, d: StringData{data: ptr}}, nil
+	return Value{t: StringType, d: StringData{data: ptr}}, nil
 }
 
 func NewBool(b bool) Value {
-	return Value{t: CORE_TYPE_BOOL, d: BoolData(b)}
+	return Value{t: BoolType, d: BoolData(b)}
 }
 
 func NewArray(m mem.Mem, arr []Value) (Value, error) {
@@ -46,19 +46,19 @@ func NewArray(m mem.Mem, arr []Value) (Value, error) {
 		return Value{}, err
 	}
 
-	return Value{t: CORE_TYPE_ARRAY, d: ArrayData{data: ptr}}, nil
+	return Value{t: ArrayType, d: ArrayData{data: ptr}}, nil
 }
 
 func NewNull() Value {
-	return Value{t: CORE_TYPE_NULL, d: NullData{}}
+	return Value{t: NullType, d: NullData{}}
 }
 
 func NewFunction(pos code.Pos, args uint) Value {
-	return Value{t: CORE_TYPE_FUNCTION, d: FunctionData{pos: pos, args: args}}
+	return Value{t: FunctionType, d: FunctionData{pos: pos, args: args}}
 }
 
 func NewNativeFunction(f NativeFunc, args uint) Value {
-	return Value{t: CORE_TYPE_FUNCTION, d: FunctionData{native: f, args: args}}
+	return Value{t: FunctionType, d: FunctionData{native: f, args: args}}
 }
 
 func NewObject(m mem.Mem, t mem.Ptr) (Value, error) {
@@ -71,7 +71,7 @@ func NewObject(m mem.Mem, t mem.Ptr) (Value, error) {
 		return Value{}, err
 	}
 
-	return Value{t: t, d: ObjectData{obj: ptr}}, nil
+	return Value{t: ObjectType, d: ObjectData{t: t, obj: ptr}}, nil
 }
 
 func NewType(m mem.Mem, name string) (Value, error) {
@@ -86,37 +86,39 @@ func NewType(m mem.Mem, name string) (Value, error) {
 		return Value{}, err
 	}
 
-	return Value{t: CORE_TYPE_TYPE_REF, d: TypeRefData{typeRef: ptr}}, nil
+	return Value{t: TypeRefType, d: TypeRefData{typeRef: ptr}}, nil
 }
 
-func (v Value) TypePtr() mem.Ptr {
+func (v Value) Type() TypeKind {
 	return v.t
 }
 
-func (v Value) Type() TypeKind {
+func (v Value) TypePtr() mem.Ptr {
 	switch v.t {
-	case CORE_TYPE_NULL:
-		return NullType
-	case CORE_TYPE_INT:
-		return IntType
-	case CORE_TYPE_FLOAT:
-		return FloatType
-	case CORE_TYPE_STRING:
-		return StringType
-	case CORE_TYPE_BOOL:
-		return BoolType
-	case CORE_TYPE_ARRAY:
-		return ArrayType
-	case CORE_TYPE_FUNCTION:
-		return FunctionType
-	case CORE_TYPE_TYPE_REF:
-		return TypeRefType
+	case IntType:
+		return CORE_TYPE_INT
+	case FloatType:
+		return CORE_TYPE_FLOAT
+	case StringType:
+		return CORE_TYPE_STRING
+	case BoolType:
+		return CORE_TYPE_BOOL
+	case ArrayType:
+		return CORE_TYPE_ARRAY
+	case NullType:
+		return CORE_TYPE_NULL
+	case FunctionType:
+		return CORE_TYPE_FUNCTION
+	case TypeRefType:
+		return CORE_TYPE_TYPE_REF
+	case ObjectType:
+		return v.d.(ObjectData).t
 	default:
-		return ObjectType
+		return mem.NullPtr
 	}
 }
 
-func (v Value) WithType(t mem.Ptr) Value {
+func (v Value) WithType(t TypeKind) Value {
 	return Value{t: t, d: v.d, outlet: v.outlet}
 }
 
@@ -137,21 +139,21 @@ func (v Value) WithOutlet(outlet mem.Ptr) Value {
 }
 
 func (v Value) IsEmpty() bool {
-	return v.t == mem.NullPtr
+	return v == Value{}
 }
 
 func (v Value) Clone(m mem.Mem) Value {
-	if v.t == CORE_TYPE_STRING {
+	if v.t == StringType {
 		str := v.d.(StringData)
 		m.Retain(str.data)
 	}
 
-	if v.t == CORE_TYPE_ARRAY {
+	if v.t == ArrayType {
 		arr := v.d.(ArrayData)
 		m.Retain(arr.data)
 	}
 
-	if v.t == CORE_TYPE_FUNCTION {
+	if v.t == FunctionType {
 		fn := v.d.(FunctionData)
 		m.Retain(fn.env)
 	}
@@ -171,17 +173,17 @@ func (v Value) Drop(m mem.Mem) {
 		return
 	}
 
-	if v.t == CORE_TYPE_STRING {
+	if v.t == StringType {
 		str := v.d.(StringData)
 		m.Release(str.data)
 	}
 
-	if v.t == CORE_TYPE_ARRAY {
+	if v.t == ArrayType {
 		arr := v.d.(ArrayData)
 		m.Release(arr.data)
 	}
 
-	if v.t == CORE_TYPE_FUNCTION {
+	if v.t == FunctionType {
 		f := v.d.(FunctionData)
 		m.Release(f.env)
 	}