Implemented Value interface

src/core/ArrayElementToRegister.go

@@ -24,7 +24,7 @@ func (f *Function) ArrayElementToRegister(node *expression.Expression, register
 	index := node.Children[1]
 
 	memory := asm.Memory{
-		Base:           array.Register,
+		Base:           array.Value.Register,
 		Offset:         0,
 		OffsetRegister: math.MaxUint8,
 		Length:         byte(1),
@@ -50,11 +50,11 @@ func (f *Function) ArrayElementToRegister(node *expression.Expression, register
 
 		defer f.UseVariable(indexVariable)
 
-		if !types.Is(indexVariable.Type, types.AnyInt) {
+		if !types.Is(indexVariable.Value.Typ, types.AnyInt) {
-			return nil, errors.New(&errors.TypeMismatch{Encountered: indexVariable.Type.Name(), Expected: types.AnyInt.Name()}, f.File, index.Token.Position)
+			return nil, errors.New(&errors.TypeMismatch{Encountered: indexVariable.Value.Typ.Name(), Expected: types.AnyInt.Name()}, f.File, index.Token.Position)
 		}
 
-		memory.OffsetRegister = indexVariable.Register
+		memory.OffsetRegister = indexVariable.Value.Register
 
 	default:
 		typ, err := f.ExpressionToRegister(index, register)

src/core/Compare.go

@@ -21,7 +21,7 @@ func (f *Function) Compare(comparison *expression.Expression) error {
 		}
 
 		defer f.UseVariable(variable)
-		return f.Execute(comparison.Token, variable.Register, right)
+		return f.Execute(comparison.Token, variable.Value.Register, right)
 	}
 
 	if ast.IsFunctionCall(left) && right.IsLeaf() {

src/core/CompileAssign.go

@@ -20,7 +20,7 @@ func (f *Function) CompileAssign(node *ast.Assign) error {
 		}
 
 		defer f.UseVariable(variable)
-		return f.Execute(node.Expression.Token, variable.Register, right)
+		return f.Execute(node.Expression.Token, variable.Value.Register, right)
 	}
 
 	if left.Token.Kind == token.Dot {

src/core/CompileAssignArray.go

@@ -25,7 +25,7 @@ func (f *Function) CompileAssignArray(node *ast.Assign) error {
 	defer f.UseVariable(variable)
 
 	memory := asm.Memory{
-		Base:           variable.Register,
+		Base:           variable.Value.Register,
 		Offset:         0,
 		OffsetRegister: math.MaxUint8,
 		Length:         byte(1),
@@ -38,18 +38,18 @@ func (f *Function) CompileAssignArray(node *ast.Assign) error {
 		return err
 	}
 
-	if !types.Is(index.Type, types.AnyInt) {
+	if !types.Is(index.Type(), types.AnyInt) {
-		return errors.New(&errors.TypeMismatch{Encountered: index.Type.Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position)
+		return errors.New(&errors.TypeMismatch{Encountered: index.Type().Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position)
 	}
 
-	switch index.Kind {
+	switch index := index.(type) {
 	case eval.Number:
 		memory.Offset = int8(index.Number)
 	case eval.Register:
 		memory.OffsetRegister = index.Register
 		defer f.FreeRegister(index.Register)
 	default:
-		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, index.Kind))
+		panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, index))
 	}
 
 	_, err = f.ExpressionToMemory(right, memory)

src/core/CompileAssignDivision.go

@@ -36,8 +36,8 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error {
 			return err
 		}
 
-		quotientVariable.Type = types.Int
+		quotientVariable.Value.Typ = types.Int
-		remainderVariable.Type = types.Int
+		remainderVariable.Value.Typ = types.Int
 		f.AddVariable(quotientVariable)
 		f.AddVariable(remainderVariable)
 	} else {
@@ -68,13 +68,13 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error {
 		return err
 	}
 
-	if !types.Is(dividend.Type, types.AnyInt) {
+	if !types.Is(dividend.Type(), types.AnyInt) {
-		return errors.New(&errors.TypeMismatch{Encountered: dividend.Type.Name(), Expected: types.AnyInt.Name()}, f.File, dividendExpr.Token.Position)
+		return errors.New(&errors.TypeMismatch{Encountered: dividend.Type().Name(), Expected: types.AnyInt.Name()}, f.File, dividendExpr.Token.Position)
 	}
 
 	divisor := division.Children[1]
 
-	switch dividend.Kind {
+	switch dividend := dividend.(type) {
 	case eval.Number:
 		f.SaveRegister(x86.RAX)
 		f.RegisterNumber(asm.MOVE, x86.RAX, dividend.Number)
@@ -83,10 +83,10 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error {
 		err = f.Execute(division.Token, dividend.Register, divisor)
 		defer f.FreeRegister(dividend.Register)
 	default:
-		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, dividend.Kind))
+		panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, dividend))
 	}
 
-	f.RegisterRegister(asm.MOVE, quotientVariable.Register, x86.RAX)
+	f.RegisterRegister(asm.MOVE, quotientVariable.Value.Register, x86.RAX)
-	f.RegisterRegister(asm.MOVE, remainderVariable.Register, x86.RDX)
+	f.RegisterRegister(asm.MOVE, remainderVariable.Value.Register, x86.RDX)
 	return err
 }

src/core/CompileAssignField.go

@@ -22,7 +22,7 @@ func (f *Function) CompileAssignField(node *ast.Assign) error {
 	}
 
 	defer f.UseVariable(variable)
-	pointer := variable.Type.(*types.Pointer)
+	pointer := variable.Value.Typ.(*types.Pointer)
 	structure := pointer.To.(*types.Struct)
 	field := structure.FieldByName(fieldName)
 
@@ -31,7 +31,7 @@ func (f *Function) CompileAssignField(node *ast.Assign) error {
 	}
 
 	memory := asm.Memory{
-		Base:           variable.Register,
+		Base:           variable.Value.Register,
 		Offset:         int8(field.Offset),
 		OffsetRegister: math.MaxUint8,
 		Length:         byte(field.Type.Size()),

src/core/CompileCondition.go

@@ -75,11 +75,11 @@ func (f *Function) CompileCondition(condition *expression.Expression, successLab
 			return err
 		}
 
-		if !types.Is(value.Type, types.Bool) {
+		if !types.Is(value.Type(), types.Bool) {
-			return errors.New(&errors.TypeMismatch{Encountered: value.Type.Name(), Expected: types.Bool.Name()}, f.File, condition.Token.Position)
+			return errors.New(&errors.TypeMismatch{Encountered: value.Type().Name(), Expected: types.Bool.Name()}, f.File, condition.Token.Position)
 		}
 
-		switch value.Kind {
+		switch value := value.(type) {
 		case eval.Number:
 			if value.Number == 0 {
 				f.Jump(asm.JUMP, failLabel)
@@ -89,7 +89,7 @@ func (f *Function) CompileCondition(condition *expression.Expression, successLab
 			f.FreeRegister(value.Register)
 			f.Jump(asm.JE, failLabel)
 		default:
-			panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind))
+			panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value))
 		}
 
 		return nil

src/core/CompileDefinition.go

@@ -21,7 +21,7 @@ func (f *Function) CompileDefinition(node *ast.Define) error {
 			return err
 		}
 
-		typ, err := f.ExpressionToRegister(right, variable.Register)
+		typ, err := f.ExpressionToRegister(right, variable.Value.Register)
 
 		if err != nil {
 			return err
@@ -35,7 +35,7 @@ func (f *Function) CompileDefinition(node *ast.Define) error {
 			typ = types.Int
 		}
 
-		variable.Type = typ
+		variable.Value.Typ = typ
 		f.AddVariable(variable)
 		return nil
 	}
@@ -63,10 +63,10 @@ func (f *Function) CompileDefinition(node *ast.Define) error {
 		}
 
 		if count < len(types) {
-			variable.Type = types[count]
+			variable.Value.Typ = types[count]
 		}
 
-		f.RegisterRegister(asm.MOVE, variable.Register, f.CPU.Output[count])
+		f.RegisterRegister(asm.MOVE, variable.Value.Register, f.CPU.Output[count])
 		f.AddVariable(variable)
 		count++
 		return nil

src/core/CompileDelete.go

@@ -20,8 +20,8 @@ func (f *Function) CompileDelete(root *expression.Expression) error {
 	defer f.UseVariable(variable)
 	f.SaveRegister(f.CPU.Input[0])
 	f.SaveRegister(f.CPU.Input[1])
-	f.RegisterRegister(asm.MOVE, f.CPU.Input[0], variable.Register)
+	f.RegisterRegister(asm.MOVE, f.CPU.Input[0], variable.Value.Register)
-	f.RegisterNumber(asm.MOVE, f.CPU.Input[1], variable.Type.(*types.Pointer).To.Size())
+	f.RegisterNumber(asm.MOVE, f.CPU.Input[1], variable.Value.Typ.(*types.Pointer).To.Size())
 	f.CallSafe(f.All.Functions["mem.free"], f.CPU.Input[:2])
 	return nil
 }

src/core/CompileFor.go

@@ -40,7 +40,7 @@ func (f *Function) CompileFor(loop *ast.For) error {
 			return err
 		}
 
-		counter = variable.Register
+		counter = variable.Value.Register
 		from = loop.Head.Children[1].Children[0]
 		to = loop.Head.Children[1].Children[1]
 		f.AddVariable(variable)
@@ -67,20 +67,20 @@ func (f *Function) CompileFor(loop *ast.For) error {
 		return err
 	}
 
-	if !types.Is(value.Type, types.AnyInt) {
+	if !types.Is(value.Type(), types.AnyInt) {
-		return errors.New(&errors.TypeMismatch{Encountered: value.Type.Name(), Expected: types.AnyInt.Name()}, f.File, to.Token.Position)
+		return errors.New(&errors.TypeMismatch{Encountered: value.Type().Name(), Expected: types.AnyInt.Name()}, f.File, to.Token.Position)
 	}
 
 	f.AddLabel(label)
 
-	switch value.Kind {
+	switch value := value.(type) {
 	case eval.Number:
 		f.RegisterNumber(asm.COMPARE, counter, value.Number)
 	case eval.Register:
 		f.RegisterRegister(asm.COMPARE, counter, value.Register)
 		defer f.FreeRegister(value.Register)
 	default:
-		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind))
+		panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value))
 	}
 
 	f.Jump(asm.JGE, labelEnd)

src/core/CompileLen.go

@@ -21,8 +21,8 @@ func (f *Function) CompileLen(root *expression.Expression) error {
 		return err
 	}
 
-	if !types.Is(value.Type, types.AnyArray) {
+	if !types.Is(value.Type(), types.AnyArray) {
-		return errors.New(&errors.TypeMismatch{Encountered: value.Type.Name(), Expected: types.AnyArray.Name(), ParameterName: "array"}, f.File, root.Children[1].Token.Position)
+		return errors.New(&errors.TypeMismatch{Encountered: value.Type().Name(), Expected: types.AnyArray.Name(), ParameterName: "array"}, f.File, root.Children[1].Token.Position)
 	}
 
 	memory := asm.Memory{
@@ -34,17 +34,17 @@ func (f *Function) CompileLen(root *expression.Expression) error {
 	output := f.CPU.Output[0]
 	f.SaveRegister(output)
 
-	switch value.Kind {
+	switch value := value.(type) {
 	case eval.Register:
 		memory.Base = value.Register
+		defer f.FreeRegister(value.Register)
 	case eval.Label:
 		f.RegisterLabel(asm.MOVE, output, value.Label)
 		memory.Base = output
 	default:
-		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind))
+		panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value))
 	}
 
 	f.MemoryRegister(asm.LOAD, memory, output)
-	f.FreeRegister(value.Register)
 	return nil
 }

src/core/CompileMemoryStore.go

@@ -28,7 +28,7 @@ func (f *Function) CompileMemoryStore(root *expression.Expression) error {
 	defer f.UseVariable(variable)
 
 	memory := asm.Memory{
-		Base:           variable.Register,
+		Base:           variable.Value.Register,
 		OffsetRegister: math.MaxUint8,
 		Length:         byte(numBytes),
 	}

src/core/Define.go

@@ -25,8 +25,7 @@ func (f *Function) Define(leaf *expression.Expression) (*scope.Variable, error)
 
 	variable = &scope.Variable{
 		Name: name,
-		Value: eval.Value{
+		Value: eval.Register{
-			Kind:     eval.Register,
 			Register: f.NewRegister(),
 			Alive:    uses,
 		},

src/core/DotToRegister.go

@@ -20,10 +20,10 @@ func (f *Function) DotToRegister(node *expression.Expression, register cpu.Regis
 	variable := f.VariableByName(leftText)
 
 	if variable != nil {
-		field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(rightText)
+		field := variable.Value.Typ.(*types.Pointer).To.(*types.Struct).FieldByName(rightText)
 
 		memory := asm.Memory{
-			Base:           variable.Register,
+			Base:           variable.Value.Register,
 			Offset:         int8(field.Offset),
 			OffsetRegister: math.MaxUint8,
 			Length:         byte(field.Type.Size()),

src/core/Evaluate.go

@@ -10,9 +10,8 @@ import (
 // Evaluate evaluates an expression and returns a value.
 func (f *Function) Evaluate(expr *expression.Expression) (eval.Value, error) {
 	if expr.IsFolded {
-		value := eval.Value{
+		value := eval.Number{
-			Kind:   eval.Number,
+			Typ:    types.AnyInt,
-			Type:   types.AnyInt,
 			Number: expr.Value,
 		}
 
@@ -37,9 +36,8 @@ func (f *Function) Evaluate(expr *expression.Expression) (eval.Value, error) {
 	tmp := f.NewRegister()
 	typ, err := f.ExpressionToRegister(expr, tmp)
 
-	value := eval.Value{
+	value := eval.Register{
-		Kind:     eval.Register,
+		Typ:      typ,
-		Type:     typ,
 		Register: tmp,
 	}
 

src/core/EvaluateArray.go

@@ -17,13 +17,13 @@ func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Value, error
 	array := f.VariableByName(name)
 
 	if array == nil {
-		return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Children[0].Token.Position)
+		return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Children[0].Token.Position)
 	}
 
 	defer f.UseVariable(array)
 
 	memory := asm.Memory{
-		Base:           array.Register,
+		Base:           array.Value.Register,
 		Offset:         0,
 		OffsetRegister: math.MaxUint8,
 		Length:         byte(1),
@@ -33,26 +33,25 @@ func (f *Function) EvaluateArray(expr *expression.Expression) (eval.Value, error
 	index, err := f.Evaluate(indexExpr)
 
 	if err != nil {
-		return eval.Value{}, err
+		return nil, err
 	}
 
-	if !types.Is(index.Type, types.AnyInt) {
+	if !types.Is(index.Type(), types.AnyInt) {
-		return eval.Value{}, errors.New(&errors.TypeMismatch{Encountered: index.Type.Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position)
+		return nil, errors.New(&errors.TypeMismatch{Encountered: index.Type().Name(), Expected: types.AnyInt.Name()}, f.File, indexExpr.Token.Position)
 	}
 
-	switch index.Kind {
+	switch index := index.(type) {
 	case eval.Number:
 		memory.Offset = int8(index.Number)
 	case eval.Register:
 		memory.OffsetRegister = index.Register
 		defer f.FreeRegister(index.Register)
 	default:
-		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, index.Kind))
+		panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, index))
 	}
 
-	value := eval.Value{
+	value := eval.Memory{
-		Kind:   eval.Memory,
+		Typ:    array.Value.Typ.(*types.Array).Of,
-		Type:   array.Type.(*types.Array).Of,
 		Memory: memory,
 	}
 

src/core/EvaluateCall.go

@@ -11,16 +11,15 @@ func (f *Function) EvaluateCall(expr *expression.Expression) (eval.Value, error)
 	types, err := f.CompileCall(expr)
 
 	if err != nil {
-		return eval.Value{}, err
+		return nil, err
 	}
 
 	if len(types) == 0 {
-		return eval.Value{}, errors.New(errors.UntypedExpression, f.File, expr.Token.Position)
+		return nil, errors.New(errors.UntypedExpression, f.File, expr.Token.Position)
 	}
 
-	value := eval.Value{
+	value := eval.Register{
-		Kind:     eval.Register,
+		Typ:      types[0],
-		Type:     types[0],
 		Register: f.CPU.Output[0],
 	}
 

src/core/EvaluateDot.go

@@ -20,13 +20,12 @@ func (f *Function) EvaluateDot(expr *expression.Expression) (eval.Value, error)
 	variable := f.VariableByName(leftText)
 
 	if variable != nil {
-		field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(rightText)
+		field := variable.Value.Typ.(*types.Pointer).To.(*types.Struct).FieldByName(rightText)
 
-		value := eval.Value{
+		value := eval.Memory{
-			Kind: eval.Memory,
+			Typ: field.Type,
-			Type: field.Type,
 			Memory: asm.Memory{
-				Base:           variable.Register,
+				Base:           variable.Value.Register,
 				Offset:         int8(field.Offset),
 				OffsetRegister: math.MaxUint8,
 				Length:         byte(field.Type.Size()),
@@ -42,12 +41,11 @@ func (f *Function) EvaluateDot(expr *expression.Expression) (eval.Value, error)
 		number, err := ToNumber(constant.Token, constant.File)
 
 		if err != nil {
-			return eval.Value{}, err
+			return nil, err
 		}
 
-		value := eval.Value{
+		value := eval.Number{
-			Kind:   eval.Number,
+			Typ:    types.AnyInt,
-			Type:   types.AnyInt,
 			Number: number,
 		}
 
@@ -60,14 +58,13 @@ func (f *Function) EvaluateDot(expr *expression.Expression) (eval.Value, error)
 	if exists {
 		f.File.Imports[leftText].Used = true
 
-		value := eval.Value{
+		value := eval.Label{
-			Kind:  eval.Label,
+			Typ:   types.AnyPointer,
-			Type:  types.AnyPointer,
 			Label: function.UniqueName,
 		}
 
 		return value, nil
 	}
 
-	return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: uniqueName}, f.File, left.Token.Position)
+	return nil, errors.New(&errors.UnknownIdentifier{Name: uniqueName}, f.File, left.Token.Position)
 }

src/core/EvaluateLeaf.go

@@ -18,9 +18,8 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
 		name := expr.Token.Text(f.File.Bytes)
 
 		if name == "true" {
-			value := eval.Value{
+			value := eval.Number{
-				Kind:   eval.Number,
+				Typ:    types.Bool,
-				Type:   types.Bool,
 				Number: 1,
 			}
 
@@ -28,9 +27,8 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
 		}
 
 		if name == "false" {
-			value := eval.Value{
+			value := eval.Number{
-				Kind:   eval.Number,
+				Typ:    types.Bool,
-				Type:   types.Bool,
 				Number: 0,
 			}
 
@@ -42,16 +40,15 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
 		if variable != nil {
 			f.UseVariable(variable)
 
-			if variable.Alive == 0 {
+			if variable.Value.Alive == 0 {
 				return variable.Value, nil
 			}
 
 			tmp := f.NewRegister()
-			f.RegisterRegister(asm.MOVE, tmp, variable.Register)
+			f.RegisterRegister(asm.MOVE, tmp, variable.Value.Register)
 
-			value := eval.Value{
+			value := eval.Register{
-				Kind:     eval.Register,
+				Typ:      variable.Value.Typ,
-				Type:     variable.Type,
 				Register: tmp,
 			}
 
@@ -59,27 +56,25 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
 		}
 
 		if function != nil {
-			value := eval.Value{
+			value := eval.Label{
-				Kind:  eval.Label,
+				Typ:   types.AnyPointer,
-				Type:  types.AnyPointer,
 				Label: function.UniqueName,
 			}
 
 			return value, nil
 		}
 
-		return eval.Value{}, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Token.Position)
+		return nil, errors.New(&errors.UnknownIdentifier{Name: name}, f.File, expr.Token.Position)
 
 	case token.Number, token.Rune:
 		number, err := f.ToNumber(expr.Token)
 
 		if err != nil {
-			return eval.Value{}, err
+			return nil, err
 		}
 
-		value := eval.Value{
+		value := eval.Number{
-			Kind:   eval.Number,
+			Typ:    types.AnyInt,
-			Type:   types.AnyInt,
 			Number: number,
 		}
 
@@ -94,14 +89,13 @@ func (f *Function) EvaluateLeaf(expr *expression.Expression) (eval.Value, error)
 		copy(slice[8:], data)
 		label := f.AddBytes(slice)
 
-		value := eval.Value{
+		value := eval.Label{
-			Kind:  eval.Label,
+			Typ:   types.String,
-			Type:  types.String,
 			Label: label,
 		}
 
 		return value, nil
 	}
 
-	return eval.Value{}, errors.New(errors.InvalidExpression, f.File, expr.Token.Position)
+	return nil, errors.New(errors.InvalidExpression, f.File, expr.Token.Position)
 }

src/core/ExecuteLeaf.go

@@ -18,7 +18,7 @@ func (f *Function) ExecuteLeaf(operation token.Token, register cpu.Register, ope
 		}
 
 		defer f.UseVariable(variable)
-		return f.ExecuteRegisterRegister(operation, register, variable.Register)
+		return f.ExecuteRegisterRegister(operation, register, variable.Value.Register)
 
 	case token.Number, token.Rune:
 		number, err := f.ToNumber(operand)

src/core/ExpressionToMemory.go

@@ -17,7 +17,7 @@ func (f *Function) ExpressionToMemory(node *expression.Expression, memory asm.Me
 		return nil, err
 	}
 
-	switch value.Kind {
+	switch value := value.(type) {
 	case eval.Number:
 		f.MemoryNumber(asm.STORE, memory, value.Number)
 	case eval.Register:
@@ -31,8 +31,8 @@ func (f *Function) ExpressionToMemory(node *expression.Expression, memory asm.Me
 	case eval.Label:
 		f.MemoryLabel(asm.STORE, memory, value.Label)
 	default:
-		panic(fmt.Errorf("%s: not implemented: %d", f.UniqueName, value.Kind))
+		panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, value))
 	}
 
-	return value.Type, err
+	return value.Type(), err
 }

src/core/ExpressionToRegister.go

@@ -71,7 +71,7 @@ func (f *Function) ExpressionToRegister(node *expression.Expression, register cp
 	} else if right.Token.Kind == token.Identifier {
 		rightVariable := f.VariableByName(right.Token.Text(f.File.Bytes))
 		leftPointer, leftIsPointer := typ.(*types.Pointer)
-		rightPointer, rightIsPointer := rightVariable.Type.(*types.Pointer)
+		rightPointer, rightIsPointer := rightVariable.Value.Typ.(*types.Pointer)
 
 		if leftIsPointer && rightIsPointer && leftPointer.To == rightPointer.To {
 			typ = types.Int

src/core/MultiAssign.go

@@ -23,7 +23,7 @@ func (f *Function) MultiAssign(left *expression.Expression, right *expression.Ex
 			return errors.New(&errors.UnknownIdentifier{Name: name}, f.File, left.Token.Position)
 		}
 
-		f.RegisterRegister(asm.MOVE, variable.Register, f.CPU.Output[count])
+		f.RegisterRegister(asm.MOVE, variable.Value.Register, f.CPU.Output[count])
 		f.UseVariable(variable)
 		count++
 		return nil

src/core/ResolveTypes.go

@@ -32,9 +32,8 @@ func (f *Function) ResolveTypes() error {
 
 		f.AddVariable(&scope.Variable{
 			Name: param.name,
-			Value: eval.Value{
+			Value: eval.Register{
-				Kind:     eval.Register,
+				Typ:      param.typ,
-				Type:     param.typ,
 				Register: x86.InputRegisters[i],
 				Alive:    uses,
 			},

src/core/TokenToRegister.go

@@ -32,8 +32,8 @@ func (f *Function) TokenToRegister(t token.Token, register cpu.Register) (types.
 		if variable != nil {
 			f.UseVariable(variable)
 			f.SaveRegister(register)
-			f.RegisterRegister(asm.MOVE, register, variable.Register)
+			f.RegisterRegister(asm.MOVE, register, variable.Value.Register)
-			return variable.Type, nil
+			return variable.Value.Typ, nil
 		}
 
 		if function != nil {

src/core/UsesRegister.go

@@ -16,7 +16,7 @@ func (f *Function) UsesRegister(expr *expression.Expression, register cpu.Regist
 
 		variable := f.VariableByName(expr.Token.Text(f.File.Bytes))
 
-		if variable == nil || variable.Register != register {
+		if variable == nil || variable.Value.Register != register {
 			return false
 		}
 

src/eval/Kind.go

@@ -1,11 +0,0 @@
-package eval
-
-type Kind uint8
-
-const (
-	Invalid  Kind = iota // Invalid is an invalid value.
-	Number               // Number is an immediately encoded value stored together with the instruction.
-	Register             // Register is a CPU register.
-	Memory               // Memory is an area in the RAM.
-	Label                // Label is a reference to a name that can only be resolved once the program is fully compiled.
-)

src/eval/Label.go

@@ -0,0 +1,17 @@
+package eval
+
+import "git.urbach.dev/cli/q/src/types"
+
+// Label is a named pointer to a code or data section.
+type Label struct {
+	Typ   types.Type
+	Label string
+}
+
+func (v Label) String() string {
+	return "Label"
+}
+
+func (v Label) Type() types.Type {
+	return v.Typ
+}

src/eval/Memory.go

@@ -0,0 +1,20 @@
+package eval
+
+import (
+	"git.urbach.dev/cli/q/src/asm"
+	"git.urbach.dev/cli/q/src/types"
+)
+
+// Memory is a region in memory that can be addressed by an instruction.
+type Memory struct {
+	Typ    types.Type
+	Memory asm.Memory
+}
+
+func (v Memory) String() string {
+	return "Memory"
+}
+
+func (v Memory) Type() types.Type {
+	return v.Typ
+}

src/eval/Number.go

@@ -0,0 +1,17 @@
+package eval
+
+import "git.urbach.dev/cli/q/src/types"
+
+// Number is an immediate value that is stored next to the instruction.
+type Number struct {
+	Typ    types.Type
+	Number int
+}
+
+func (v Number) String() string {
+	return "Number"
+}
+
+func (v Number) Type() types.Type {
+	return v.Typ
+}

src/eval/Register.go

@@ -0,0 +1,21 @@
+package eval
+
+import (
+	"git.urbach.dev/cli/q/src/cpu"
+	"git.urbach.dev/cli/q/src/types"
+)
+
+// Register is a value that is stored inside a CPU register.
+type Register struct {
+	Typ      types.Type
+	Alive    uint8
+	Register cpu.Register
+}
+
+func (v Register) String() string {
+	return "Register"
+}
+
+func (v Register) Type() types.Type {
+	return v.Typ
+}

src/eval/Value.go

@@ -1,29 +1,22 @@
 package eval
 
 import (
-	"git.urbach.dev/cli/q/src/asm"
-	"git.urbach.dev/cli/q/src/cpu"
 	"git.urbach.dev/cli/q/src/types"
 )
 
-// Value combines a register with its data type.
+// Value abstracts all data storage types like immediates, registers and memory.
-type Value struct {
+type Value interface {
-	Type     types.Type
+	String() string
-	Label    string
+	Type() types.Type
-	Number   int
-	Memory   asm.Memory
-	Register cpu.Register
-	Alive    uint8
-	Kind     Kind
 }
 
-// IsAlive returns true if the Value is still alive.
+// IsAlive returns true if the register value is still alive.
-func (v *Value) IsAlive() bool {
+func (v *Register) IsAlive() bool {
 	return v.Alive > 0
 }
 
 // Use reduces the lifetime counter by one.
-func (v *Value) Use() {
+func (v *Register) Use() {
 	if v.Alive == 0 {
 		panic("incorrect number of value use calls")
 	}

src/register/SaveRegister.go

@@ -19,12 +19,12 @@ func (f *Machine) SaveRegister(register cpu.Register) {
 
 	variable := f.VariableByRegister(register)
 
-	if variable == nil || variable.Alive == 0 {
+	if variable == nil || variable.Value.Alive == 0 {
 		return
 	}
 
 	newRegister := f.NewRegister()
 	f.RegisterRegister(asm.MOVE, newRegister, register)
-	variable.Register = newRegister
+	variable.Value.Register = newRegister
 	f.FreeRegister(register)
 }

src/scope/Scope.go

@@ -15,7 +15,7 @@ type Scope struct {
 // AddVariable adds a new variable to the current scope.
 func (s *Scope) AddVariable(variable *Variable) {
 	s.Variables = append(s.Variables, variable)
-	s.Use(variable.Register)
+	s.Use(variable.Value.Register)
 }
 
 // VariableByName returns the variable with the given name or `nil` if it doesn't exist.

src/scope/Stack.go

@@ -46,11 +46,10 @@ func (stack *Stack) PushScope(body ast.AST, buffer []byte) *Scope {
 
 			s.Variables = append(s.Variables, &Variable{
 				Name: v.Name,
-				Value: eval.Value{
+				Value: eval.Register{
-					Kind:     eval.Register,
+					Typ:      v.Value.Typ,
-					Register: v.Register,
 					Alive:    count,
-					Type:     v.Type,
+					Register: v.Value.Register,
 				},
 			})
 		}
@@ -73,10 +72,10 @@ func (stack *Stack) UseVariable(variable *Variable) {
 			continue
 		}
 
-		local.Use()
+		local.Value.Use()
 
-		if !local.IsAlive() {
+		if !local.Value.IsAlive() {
-			scope.Free(local.Register)
+			scope.Free(local.Value.Register)
 		}
 	}
 }
@@ -89,7 +88,7 @@ func (stack *Stack) VariableByName(name string) *Variable {
 // VariableByRegister returns the variable that occupies the given register or `nil` if none occupy the register.
 func (stack *Stack) VariableByRegister(register cpu.Register) *Variable {
 	for _, v := range stack.CurrentScope().Variables {
-		if v.Register == register {
+		if v.Value.Register == register {
 			return v
 		}
 	}

src/scope/Variable.go

@@ -5,5 +5,5 @@ import "git.urbach.dev/cli/q/src/eval"
 // Variable is a named value.
 type Variable struct {
 	Name  string
-	eval.Value
+	Value eval.Register
 }