Implemented reading from struct fields

examples/point/point.q

@@ -1,3 +1,6 @@
+import mem
+import sys
+
 struct Point {
 	x Int
 	y Int
@@ -5,7 +8,20 @@ struct Point {
 
 main() {
 	p := new(Point)
-	p.x = 4
+	p.x = 1
 	p.y = 2
+
+	out := mem.alloc(8)
+	out[0] = 'x'
+	out[1] = ' '
+	out[2] = '0' + p.x
+	out[3] = '\n'
+	out[4] = 'y'
+	out[5] = ' '
+	out[6] = '0' + p.y
+	out[7] = '\n'
+	sys.write(1, out, 8)
+	mem.free(out)
+
 	delete(p)
 }

src/core/CompileAssignField.go

@@ -24,21 +24,19 @@ func (f *Function) CompileAssignField(node *ast.Assign) error {
 	defer f.UseVariable(variable)
 	pointer := variable.Type.(*types.Pointer)
 	structure := pointer.To.(*types.Struct)
+	field := structure.FieldByName(fieldName)
 
-	for _, field := range structure.Fields {
-		if field.Name == fieldName {
-			memory := asm.Memory{
-				Base:           variable.Register,
-				Offset:         field.Offset,
-				OffsetRegister: math.MaxUint8,
-				Length:         field.Type.TotalSize(),
-			}
-
-			_, err := f.ExpressionToMemory(value, memory)
-			return err
-		}
+	if field == nil {
+		return errors.New(&errors.UnknownStructField{StructName: structure.Name, FieldName: fieldName}, f.File, destination.Children[1].Token.Position)
 	}
 
-	// TODO: unknown field error
-	return nil
+	memory := asm.Memory{
+		Base:           variable.Register,
+		Offset:         field.Offset,
+		OffsetRegister: math.MaxUint8,
+		Length:         field.Type.TotalSize(),
+	}
+
+	_, err := f.ExpressionToMemory(value, memory)
+	return err
 }

src/core/ExpressionToRegister.go

@@ -44,6 +44,17 @@ func (f *Function) ExpressionToRegister(node *expression.Expression, register cp
 		return types.Int, err
 	}
 
+	if node.Token.Kind == token.Period {
+		left := node.Children[0]
+		name := left.Token.Text(f.File.Bytes)
+		variable := f.VariableByName(name)
+		right := node.Children[1]
+		name = right.Token.Text(f.File.Bytes)
+		field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(name)
+		f.MemoryRegister(asm.LOAD, asm.Memory{Base: variable.Register, Offset: field.Offset, Length: field.Type.TotalSize()}, register)
+		return field.Type, nil
+	}
+
 	if len(node.Children) == 1 {
 		if !node.Token.IsUnaryOperator() {
 			return nil, errors.New(errors.MissingOperand, f.File, node.Token.End())

src/errors/UnknownStructField.go

@@ -0,0 +1,19 @@
+package errors
+
+import "fmt"
+
+// UnknownStructField represents unknown struct fields.
+type UnknownStructField struct {
+	StructName       string
+	FieldName        string
+	CorrectFieldName string
+}
+
+// Error generates the string representation.
+func (err *UnknownStructField) Error() string {
+	if err.CorrectFieldName != "" {
+		return fmt.Sprintf("Unknown struct field '%s' in '%s', did you mean '%s'?", err.FieldName, err.StructName, err.CorrectFieldName)
+	}
+
+	return fmt.Sprintf("Unknown struct field '%s' in '%s'", err.FieldName, err.StructName)
+}

src/types/Struct.go

@@ -14,3 +14,13 @@ func (s *Struct) UniqueName() string {
 func (s *Struct) TotalSize() uint8 {
 	return s.Size
 }
+
+func (s *Struct) FieldByName(name string) *Field {
+	for _, field := range s.Fields {
+		if field.Name == name {
+			return field
+		}
+	}
+
+	return nil
+}

tests/errors/UnknownStructField.q

@@ -0,0 +1,6 @@
+struct A {}
+
+main() {
+	a := new(A)
+	a.x = 1
+}

tests/errors_test.go

@@ -48,6 +48,7 @@ var errs = []struct {
 	{"UnknownIdentifier2.q", &errors.UnknownIdentifier{Name: "x"}},
 	{"UnknownIdentifier3.q", &errors.UnknownIdentifier{Name: "x"}},
 	{"UnknownPackage.q", &errors.UnknownPackage{Name: "sys"}},
+	{"UnknownStructField.q", &errors.UnknownStructField{StructName: "A", FieldName: "x"}},
 	{"UnusedImport.q", &errors.UnusedImport{Package: "sys"}},
 	{"UnusedVariable.q", &errors.UnusedVariable{Name: "x"}},
 	{"VariableAlreadyExists.q", &errors.VariableAlreadyExists{Name: "x"}},

tests/examples_test.go

@@ -24,6 +24,7 @@ var examples = []struct {
 	{"itoa", "", "9223372036854775807", 0},
 	{"collatz", "", "6 3 10 5 16 8 4 2 1", 0},
 	{"fizzbuzz", "", "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz", 0},
+	{"point", "", "x 1\ny 2\n", 0},
 	{"prime", "", "2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97", 0},
 }
 

tests/programs/struct.q

@@ -0,0 +1,34 @@
+struct Point {
+	x Int
+	y Int
+}
+
+main() {
+	p := new(Point)
+	assert p.x == 0
+	assert p.y == 0
+	assert p.x == p.y
+
+	p.x = 1
+	p.y = 2
+	assert p.x == 1
+	assert p.y == 2
+	assert p.x != p.y
+
+	p.x = p.y
+	assert p.x == 2
+	assert p.y == 2
+	assert p.x == p.y
+
+	p.x = p.y + 1
+	assert p.x == 3
+	assert p.y == 2
+	assert p.x != p.y
+
+	p.y = p.x
+	assert p.x == 3
+	assert p.y == 3
+	assert p.x == p.y
+
+	delete(p)
+}

tests/programs_test.go

@@ -60,6 +60,7 @@ var programs = []struct {
 	{"loop", "", "", 0},
 	{"loop-lifetime", "", "", 0},
 	{"out-of-memory", "", "", 0},
+	{"struct", "", "", 0},
 }
 
 func TestPrograms(t *testing.T) {