Updated analyzer

analyzer/assignment.go

@@ -381,54 +381,54 @@ func (this *Tree) isLocationExpression (expression entity.Expression) error {
 	case *entity.Declaration:
 		return nil
 	case *entity.Call:
-		return cannot(expression.Position, "function call")
+		return cannot(expression.Position(), "function call")
 	case *entity.MethodCall:
-		return cannot(expression.Position, "method call")
+		return cannot(expression.Position(), "method call")
 	case *entity.Subscript:
 		return this.isLocationExpression(expression.Slice)
 	case *entity.Slice:
-		return cannot(expression.Position, "slice operation")
+		return cannot(expression.Position(), "slice operation")
 	case *entity.Dereference:
 		return this.isLocationExpression(expression.Pointer)
 	case *entity.Reference:
-		return cannot(expression.Position, "reference operation")
+		return cannot(expression.Position(), "reference operation")
 	case *entity.ValueCast:
-		return cannot(expression.Position, "value cast")
+		return cannot(expression.Position(), "value cast")
 	case *entity.BitCast:
-		return cannot(expression.Position, "bit cast")
+		return cannot(expression.Position(), "bit cast")
 	case *entity.Operation:
-		return cannot(expression.Position, fmt.Sprintf (
+		return cannot(expression.Position(), fmt.Sprintf (
 			"cannot assign to %v operation",
 			expression.Operator))
 	case *entity.Block:
-		return cannot(expression.Position, "block")
+		return cannot(expression.Position(), "block")
 	case *entity.MemberAccess:
 		return this.isLocationExpression (
 			expression.Source)
 	case *entity.IfElse:
-		return cannot(expression.Position, "if/else")
+		return cannot(expression.Position(), "if/else")
 	case *entity.Match:
-		return cannot(expression.Position, "match")
+		return cannot(expression.Position(), "match")
 	case *entity.Loop:
-		return cannot(expression.Position, "loop")
+		return cannot(expression.Position(), "loop")
 	case *entity.Break:
-		return cannot(expression.Position, "break statement")
+		return cannot(expression.Position(), "break statement")
 	case *entity.Return:
-		return cannot(expression.Position, "return statement")
+		return cannot(expression.Position(), "return statement")
 	case *entity.LiteralInt:
-		return cannot(expression.Position, "integer literal")
+		return cannot(expression.Position(), "integer literal")
 	case *entity.LiteralFloat:
-		return cannot(expression.Position, "float literal")
+		return cannot(expression.Position(), "float literal")
 	case *entity.LiteralString:
-		return cannot(expression.Position, "string literal")
+		return cannot(expression.Position(), "string literal")
 	case *entity.LiteralArray:
-		return cannot(expression.Position, "array literal")
+		return cannot(expression.Position(), "array literal")
 	case *entity.LiteralStruct:
-		return cannot(expression.Position, "struct literal")
+		return cannot(expression.Position(), "struct literal")
 	case *entity.LiteralBoolean:
-		return cannot(expression.Position, "boolean literal")
+		return cannot(expression.Position(), "boolean literal")
 	case *entity.LiteralNil:
-		return cannot(expression.Position, "nil literal")
+		return cannot(expression.Position(), "nil literal")
 	default:
 		panic(fmt.Sprint (
 			"BUG: analyzer doesnt know about expression",

analyzer/expression.go

@@ -43,11 +43,11 @@ func (this *Tree) analyzeVariable (
 	declaration := this.variable(variable.Name)
 	if declaration == nil {
 		return nil, errors.Errorf (
-			variable.Position, "no variable named %s",
+			variable.Position(), "no variable named %s",
 			variable.Name)
 	}
 
-	err := this.canAssign(variable.Position, into, mode, declaration.Type())
+	err := this.canAssign(variable.Position(), into, mode, declaration.Type())
 	if err != nil { return nil, err }
 
 	variable.Declaration = declaration
@@ -66,16 +66,16 @@ func (this *Tree) analyzeDeclaration (
 	existing := scope.Variable(declaration.Name)
 	if existing != nil {
 		return nil, errors.Errorf (
-			declaration.Position,
+			declaration.Position(),
 			"%s already declared in block at %v",
-			declaration.Name, existing.Position)
+			declaration.Name, existing.Position())
 	}
 
 	ty, err := this.analyzeType(declaration.Ty, false)
 	declaration.Ty = ty
 	if err != nil { return nil, err }
 
-	err = this.canAssign(declaration.Position, into, mode, declaration.Type())
+	err = this.canAssign(declaration.Position(), into, mode, declaration.Type())
 	if err != nil { return nil, err }
 
 	this.addVariable(declaration)
@@ -91,35 +91,35 @@ func (this *Tree) analyzeCall (
 	error,
 ) {
 	// get function
-	unit, err := this.resolveNickname(call.Position, call.UnitNickname)
+	unit, err := this.resolveNickname(call.Position(), call.UnitNickname)
 	if err != nil { return nil, err }
-	function, err := this.analyzeFunction(call.Position, entity.Key {
+	function, err := this.analyzeFunction(call.Position(), entity.Key {
 		Unit: unit,
 		Name: call.Name,
 	})
 	if err != nil { return nil, err }
 	call.Function = function
-	call.Unit     = function.Unit
+	call.Unit     = function.Unit()
 	
 	// check access permissions
-	if function.Acc == entity.AccessPrivate && function.Unit != this.unit {
+	if function.Acc == entity.AccessPrivate && function.Unit() != this.unit {
 		return nil, errors.Errorf (
-			call.Position, "function %v::[%v] is private",
+			call.Position(), "function %v::[%v] is private",
 			call.UnitNickname, call.Name)
 	}
 	
 	// check return result
-	err = this.canAssign(call.Position, into, mode, function.Signature.Return)
+	err = this.canAssign(call.Position(), into, mode, function.Signature.Return)
 	if err != nil { return nil, err }
 
 	// check arg count
 	if len(call.Arguments) > len(function.Signature.Arguments) {
 		return nil, errors.Errorf (
-			call.Position, "too many arguments in call to %s",
+			call.Position(), "too many arguments in call to %s",
 			call.Name)
 	} else if len(call.Arguments) < len(function.Signature.Arguments) {
 		return nil, errors.Errorf (
-			call.Position, "too few arguments in call to %s",
+			call.Position(), "too few arguments in call to %s",
 			call.Name)
 	}
 
@@ -147,7 +147,7 @@ func (this *Tree) analyzeMethodCall (
 	source, err := this.analyzeExpression(nil, strict, call.Source)
 	if err != nil { return nil, err }
 	method, err := this.analyzeMethodOrBehavior (
-		call.Position, source.Type(), call.Name)
+		call.Position(), source.Type(), call.Name)
 	if err != nil { return nil, err }
 
 	// extract signature
@@ -159,7 +159,7 @@ func (this *Tree) analyzeMethodCall (
 
 		// since this is a behavior, check access permissions of the
 		// interface
-		err = this.typeOpaque(call.Position, source.Type())
+		err = this.typeOpaque(call.Position(), source.Type())
 		if err != nil { return nil, err }
 		
 	case *entity.Method:
@@ -168,9 +168,9 @@ func (this *Tree) analyzeMethodCall (
 		
 		// since this is a method, check access permissions of the
 		// method
-		if method.Acc == entity.AccessPrivate && method.Unit != this.unit {
+		if method.Acc == entity.AccessPrivate && method.Unit() != this.unit {
 			return nil, errors.Errorf (
-				call.Position, "method %v.[%v] is private",
+				call.Position(), "method %v.[%v] is private",
 				method.TypeName, method.Signature.Name)
 		}
 		
@@ -181,17 +181,17 @@ func (this *Tree) analyzeMethodCall (
 	}
 
 	// check return result
-	err = this.canAssign(call.Position, into, mode, signature.Return)
+	err = this.canAssign(call.Position(), into, mode, signature.Return)
 	if err != nil { return nil, err }
 
 	// check arg count
 	if len(call.Arguments) > len(signature.Arguments) {
 		return nil, errors.Errorf (
-			call.Position, "too many arguments in call to %s",
+			call.Position(), "too many arguments in call to %s",
 			call.Name)
 	} else if len(call.Arguments) < len(signature.Arguments) {
 		return nil, errors.Errorf (
-			call.Position, "too few arguments in call to %s",
+			call.Position(), "too few arguments in call to %s",
 			call.Name)
 	}
 
@@ -216,7 +216,7 @@ func (this *Tree) analyzeSubscript (
 ) {
 	slice, err := this.analyzeExpression (
 		&entity.TypeSlice {
-			Pos:     subscript.Position,
+			Pos:     subscript.Position(),
 			Element: into,
 		}, weak,
 		subscript.Slice)
@@ -225,7 +225,7 @@ func (this *Tree) analyzeSubscript (
 	subscript.Ty    = into
 	
 	// check permissions
-	err = this.typeOpaque(subscript.Position, slice.Type())
+	err = this.typeOpaque(subscript.Position(), slice.Type())
 	if err != nil { return nil, err }
 
 	offset, err := this.analyzeExpression (
@@ -264,7 +264,7 @@ func (this *Tree) analyzeSlice (
 	slice.Slice = value
 	
 	// check permissions
-	err = this.typeOpaque(slice.Position, value.Type())
+	err = this.typeOpaque(slice.Position(), value.Type())
 	if err != nil { return nil, err }
 
 	if slice.Start != nil {
@@ -312,7 +312,7 @@ func (this *Tree) analyzeDereference (
 ) {
 	pointer, err := this.analyzeExpression (
 		&entity.TypePointer {
-			Pos:        dereference.Position,
+			Pos:        dereference.Position(),
 			Referenced: into,
 		}, weak,
 		dereference.Pointer)
@@ -346,7 +346,7 @@ func (this *Tree) analyzeReference (
 ) {
 	referenced, ok := into.(*entity.TypePointer)
 	if !ok {
-		return nil, errors.Errorf(reference.Position, "expected %v", into)
+		return nil, errors.Errorf(reference.Position(), "expected %v", into)
 	}
 	
 	value, err := this.analyzeExpression (
@@ -373,7 +373,7 @@ func (this *Tree) analyzeValueCast (
 	if err != nil { return nil, err }
 	cast.Ty = ty
 
-	err = this.canAssign(cast.Position, into, mode, cast.Type())
+	err = this.canAssign(cast.Position(), into, mode, cast.Type())
 	if err != nil { return nil, err }
 	
 	value, err := this.analyzeExpression(cast.Ty, coerce, cast.Value)
@@ -395,7 +395,7 @@ func (this *Tree) analyzeBitCast (
 	if err != nil { return nil, err }
 	cast.Ty = ty
 
-	err = this.canAssign(cast.Position, into, mode, cast.Type())
+	err = this.canAssign(cast.Position(), into, mode, cast.Type())
 	if err != nil { return nil, err }
 	
 	value, err := this.analyzeExpression(cast.Ty, force, cast.Value)
@@ -414,26 +414,26 @@ func (this *Tree) analyzeOperation (
 	error,
 ) {
 	// check permissions
-	err := this.typeOpaque(operation.Position, into)
+	err := this.typeOpaque(operation.Position(), into)
 	if err != nil { return nil, err }
 
 	intoUntrustworthy := into == nil || mode == force || mode == coerce
 
 	undefined := func (ty entity.Type) (entity.Expression, error) {
 		return nil, errors.Errorf (
-			operation.Position, "operator %v undefined for %v",
+			operation.Position(), "operator %v undefined for %v",
 			operation.Operator, entity.FormatType(ty))
 	}
 
 	wrongInto := func () (entity.Expression, error) {
 		return nil, errors.Errorf (
-			operation.Position, "expected %v",
+			operation.Position(), "expected %v",
 			entity.FormatType(into))
 	}
 
 	wrongArgCount := func () (entity.Expression, error) {
 		return nil, errors.Errorf (
-			operation.Position, "wrong argument count for %v",
+			operation.Position(), "wrong argument count for %v",
 			operation.Operator)
 	}
 
@@ -453,7 +453,7 @@ func (this *Tree) analyzeOperation (
 		}
 		if argumentType == nil {
 			return nil, -1, errors.Errorf (
-				operation.Position,
+				operation.Position(),
 				"operation arguments have ambiguous type")
 		}
 		return argumentType, boss, err
@@ -594,7 +594,7 @@ func (this *Tree) analyzeBlock (
 
 	if len(block.Steps) == 0 && into != nil {
 		return nil, errors.Errorf (
-			block.Position, "block must have at least one statement")
+			block.Position(), "block must have at least one statement")
 	}
 
 	final := len(block.Steps) - 1
@@ -603,7 +603,7 @@ func (this *Tree) analyzeBlock (
 			expression, ok := step.(entity.Expression)
 			if !ok {
 				return nil, errors.Errorf (
-					block.Position, "expected expression")
+					block.Position(), "expected expression")
 			}
 			
 			step, err := this.analyzeExpression(into, strict, expression)
@@ -642,30 +642,30 @@ func (this *Tree) analyzeMemberAccess (
 		referenced, ok := ReduceToBase(sourceTypeAny.Referenced).(*entity.TypeStruct)
 		if !ok {
 			return nil, errors.Errorf (
-				access.Position, "cannot access members of %v",
+				access.Position(), "cannot access members of %v",
 				source)
 		}
 		sourceType          = referenced
 		qualifiedSourceType = sourceTypeAny.Referenced
 	default:
 		return nil, errors.Errorf (
-			access.Position, "cannot access members of %v",
+			access.Position(), "cannot access members of %v",
 			source)
 	}
 
 	// check permissions
-	err = this.typeOpaque(access.Position, qualifiedSourceType)
+	err = this.typeOpaque(access.Position(), qualifiedSourceType)
 	if err != nil { return nil, err }
 
 	// get member
 	member, ok := sourceType.MemberMap[access.Member]
 	if !ok {
 		return nil, errors.Errorf (
-			access.Position, "no member %v",
+			access.Position(), "no member %v",
 			access)
 	}
 	
-	err = this.canAssign(access.Position, into, mode, member.Type())
+	err = this.canAssign(access.Position(), into, mode, member.Type())
 	if err != nil { return nil, err }
 	access.Ty = member.Type()
 
@@ -696,7 +696,7 @@ func (this *Tree) analyzeIfElse (
 	if ifelse.False == nil {
 		if into != nil {
 			return nil, errors.Errorf (
-				ifelse.Position,
+				ifelse.Position(),
 				"else case required when using value of if")
 		}
 	} else {
@@ -726,7 +726,7 @@ func (this *Tree) analyzeMatch (
 		// FIXME: add Position() method to Expression, then change this
 		// error message (and others) #53
 		return nil, errors.Errorf (
-			match.Position, "type %v is not a union",
+			match.Position(), "type %v is not a union",
 			value.Type())
 	}
 	
@@ -761,7 +761,7 @@ func (this *Tree) analyzeMatch (
 
 	if into != nil && len(match.Cases) < len(rawUnion.Allowed) {
 		return nil, errors.Errorf (
-			match.Position,
+			match.Position(),
 			"match does not cover all types within %v",
 			value.Type())
 	}
@@ -819,14 +819,14 @@ func (this *Tree) analyzeBreak (
 	loop, ok := this.topLoop()
 	if !ok {
 		return nil, errors.Errorf (
-			brk.Position,
+			brk.Position(),
 			"break statement must be within loop")
 	}
 	brk.Loop = loop
 
 	if loop.Type() != nil && brk.Value == nil {
 		return nil, errors.Errorf (
-			brk.Position,
+			brk.Position(),
 			"break statement must have value")
 	}
 
@@ -858,7 +858,7 @@ func (this *Tree) analyzeReturn (
 
 	if ty != nil && ret.Value == nil {
 		return nil, errors.Errorf (
-			ret.Position,
+			ret.Position(),
 			"break statement must have value")
 	}
 

analyzer/function.go

@@ -24,7 +24,7 @@ func (this *Tree) analyzeFunction (
 	}
 	
 	// set unit
-	function.Unit = key.Unit
+	function.Unt = key.Unit
 
 	// functions cannot be marked as opaque
 	if function.Acc == entity.AccessOpaque {

analyzer/literal.go

@@ -12,18 +12,18 @@ func (this *Tree) analyzeLiteralInt (
 	entity.Expression,
 	error,
 ) {
-	err := this.typeOpaque(literal.Position, into)
+	err := this.typeOpaque(literal.Position(), into)
 	if err != nil { return nil, err }
 
 	if !isNumeric(into) {
 		return nil, errors.Errorf (
-			literal.Position, "cannot use integer literal as %v",
+			literal.Position(), "cannot use integer literal as %v",
 			entity.FormatType(into))
 	}
 
 	if isInteger(into) && !inRange(into, int64(literal.Value)) {
 		return nil, errors.Errorf (
-			literal.Position, "integer literal out of range for type %v",
+			literal.Position(), "integer literal out of range for type %v",
 			entity.FormatType(into))
 	}
 
@@ -39,12 +39,12 @@ func (this *Tree) analyzeLiteralFloat (
 	entity.Expression,
 	error,
 ) {
-	err := this.typeOpaque(literal.Position, into)
+	err := this.typeOpaque(literal.Position(), into)
 	if err != nil { return nil, err }
 
 	if !isFloat(into) {
 		return nil, errors.Errorf (
-			literal.Position, "cannot use float literal as %v",
+			literal.Position(), "cannot use float literal as %v",
 			entity.FormatType(into))
 	}
 
@@ -60,14 +60,14 @@ func (this *Tree) analyzeLiteralString (
 	entity.Expression,
 	error,
 ) {
-	err := this.typeOpaque(literal.Position, into)
+	err := this.typeOpaque(literal.Position(), into)
 	if err != nil { return nil, err }
 
 	base := ReduceToBase(into)
 
 	errCantUse := func () error {
 		return errors.Errorf (
-			literal.Position, "cannot use string literal as %v",
+			literal.Position(), "cannot use string literal as %v",
 			entity.FormatType(into))
 	}
 
@@ -92,13 +92,13 @@ func (this *Tree) analyzeLiteralString (
 		}
 		if length > 1 {
 			return nil, errors.Errorf (
-				literal.Position,
+				literal.Position(),
 				"cannot fit string literal of length " +
 				"%v into %v",
 				length, entity.FormatType(into))
 		} else if length < 1 {
 			return nil, errors.Errorf (
-				literal.Position,
+				literal.Position(),
 				"string literal must have data when " +
 				"assigning to %v",
 				entity.FormatType(into))
@@ -118,7 +118,7 @@ func (this *Tree) analyzeLiteralString (
 			}
 			if length > base.Length {
 				return nil, errors.Errorf (
-					literal.Position,
+					literal.Position(),
 					"cannot fit string literal of length " +
 					"%v into array of length %v",
 					length, base.Length)
@@ -163,7 +163,7 @@ func (this *Tree) analyzeLiteralArray (
 	entity.Expression,
 	error,
 ) {
-	err := this.typeOpaque(literal.Position, into)
+	err := this.typeOpaque(literal.Position(), into)
 	if err != nil { return nil, err }
 
 	base := ReduceToBase(into)
@@ -173,7 +173,7 @@ func (this *Tree) analyzeLiteralArray (
 		base := base.(*entity.TypeArray)
 		if base.Length < len(literal.Elements) {
 			return nil, errors.Errorf (
-				literal.Position, "expected %v elements or less",
+				literal.Position(), "expected %v elements or less",
 				base.Length)
 		}
 		elementType = base.Element
@@ -187,7 +187,7 @@ func (this *Tree) analyzeLiteralArray (
 		elementType = base.Referenced
 	default:
 		return nil, errors.Errorf (
-			literal.Position, "cannot use array literal as %v",
+			literal.Position(), "cannot use array literal as %v",
 			entity.FormatType(into))
 	}
 
@@ -209,13 +209,13 @@ func (this *Tree) analyzeLiteralStruct (
 	entity.Expression,
 	error,
 ) {
-	err := this.typeOpaque(literal.Position, into)
+	err := this.typeOpaque(literal.Position(), into)
 	if err != nil { return nil, err }
 
 	base, ok := ReduceToBase(into).(*entity.TypeStruct)
 	if !ok {
 		return nil, errors.Errorf (
-			literal.Position, "cannot use struct literal as %v",
+			literal.Position(), "cannot use struct literal as %v",
 			entity.FormatType(into))
 	}
 
@@ -226,7 +226,7 @@ func (this *Tree) analyzeLiteralStruct (
 		correct, ok := base.MemberMap[name]
 		if !ok {
 		return nil, errors.Errorf (
-			literal.Position, "no member %v.%s",
+			literal.Position(), "no member %v.%s",
 			into, name)
 		}
 
@@ -247,12 +247,12 @@ func (this *Tree) analyzeLiteralBoolean (
 	entity.Expression,
 	error,
 ) {
-	err := this.typeOpaque(literal.Position, into)
+	err := this.typeOpaque(literal.Position(), into)
 	if err != nil { return nil, err }
 
 	if !isBoolean(into) {
 		return nil, errors.Errorf (
-			literal.Position, "cannot use boolean literal as %v",
+			literal.Position(), "cannot use boolean literal as %v",
 			entity.FormatType(into))
 	}
 
@@ -268,7 +268,7 @@ func (this *Tree) analyzeLiteralNil (
 	entity.Expression,
 	error,
 ) {
-	err := this.typeOpaque(literal.Position, into)
+	err := this.typeOpaque(literal.Position(), into)
 	if err != nil { return nil, err }
 
 	literal.Ty = into
@@ -286,8 +286,8 @@ func (this *Tree) assembleStructLiteralMap (
 	for index, member := range literal.Members {
 		if previous, exists := literal.MemberMap[member.Name]; exists {
 			return literal, errors.Errorf (
-				member.Position, "%s already listed in struct literal at %v",
+				member.Position(), "%s already listed in struct literal at %v",
-				member.Name, previous.Position)
+				member.Name, previous.Position())
 		}
 		literal.MemberMap  [member.Name] = member
 		literal.MemberOrder[index]       = member.Name

analyzer/method.go

@@ -30,7 +30,7 @@ func (this *Tree) analyzeMethod (
 	}
 
 	// set method's unit, very important information yes
-	method.Unit = owner.Unit
+	method.Unt = owner.Unit()
 
 	// methods cannot be marked as opaque
 	if method.Acc == entity.AccessOpaque {
@@ -58,12 +58,12 @@ func (this *Tree) analyzeMethod (
 
 	// add owner to method
 	method.This = &entity.Declaration {
-		Position: method.Position,
+		Pos:  method.Position(),
-		Name:     "this",
+		Name: "this",
 		Ty: &entity.TypePointer {
-			Pos: method.Position,
+			Pos: method.Position(),
 			Referenced: &entity.TypeNamed {
-				Pos:  method.Position,
+				Pos:  method.Position(),
 				Unt:  key.Unit,
 				Name: key.Name,
 				Type: owner.Type,

analyzer/misc.go

@@ -9,8 +9,8 @@ func (this *Tree) assembleSignatureMap (signature *entity.Signature) (*entity.Si
 	for index, member := range signature.Arguments {
 		if previous, exists := signature.ArgumentMap[member.Name]; exists {
 			return signature, errors.Errorf (
-				member.Position, "%s already listed as argument at %v",
+				member.Position(), "%s already listed as argument at %v",
-				member.Name,     previous.Position)
+				member.Name, previous.Position())
 		}
 		signature.ArgumentMap  [member.Name] = member
 		signature.ArgumentOrder[index]       = member.Name

analyzer/tree.go

@@ -47,7 +47,7 @@ func (this *Tree) assembleRawMaps () error {
 				Unit: this.unit,
 				Name: declaration.Name,
 			}
-			err := this.topLevelNameAvailable(declaration.Position, key)
+			err := this.topLevelNameAvailable(declaration.Position(), key)
 			if err != nil { return err }
 			declaration.Methods = make(map[string] *entity.Method)
 			this.rawTypes[key] = declaration
@@ -57,7 +57,7 @@ func (this *Tree) assembleRawMaps () error {
 				Unit: this.unit,
 				Name: declaration.Signature.Name,
 			}
-			err := this.topLevelNameAvailable(declaration.Position, key)
+			err := this.topLevelNameAvailable(declaration.Position(), key)
 			if err != nil { return err }
 			this.rawFunctions[key] = declaration
 			
@@ -67,7 +67,7 @@ func (this *Tree) assembleRawMaps () error {
 				Name:   declaration.TypeName,
 				Method: declaration.Signature.Name,
 			}
-			err := this.topLevelNameAvailable(declaration.Position, key)
+			err := this.topLevelNameAvailable(declaration.Position(), key)
 			if err != nil { return err }
 			this.rawMethods[key] = declaration
 		}
@@ -89,34 +89,34 @@ func (this *Tree) topLevelNameAvailable (currentPos errors.Position, key entity.
 	if ty, isType := this.rawTypes[key]; isType {
 		return errors.Errorf (
 			currentPos, "%s already declared at %v",
-			key.Name, ty.Position)
+			key.Name, ty.Position())
 	}
 	if function, isFunction := this.rawFunctions[key]; isFunction {
 		return errors.Errorf (
 			currentPos, "%s already declared at %v",
-			key.Name, function.Position)
+			key.Name, function.Position())
 	}
 	if method, isMethod := this.rawMethods[key]; isMethod {
 		return errors.Errorf (
 			currentPos, "%s.%s already declared at %v",
-			key.Name, key.Method, method.Position)
+			key.Name, key.Method, method.Position())
 	}
 	return nil
 }
 
 func (this *Tree) analyzeDeclarations () error {
 	for key, rawType := range this.rawTypes {
-		ty, err := this.analyzeTypedef(rawType.Position, key, false)
+		ty, err := this.analyzeTypedef(rawType.Position(), key, false)
 		if err != nil { return err }
 		this.Types[key] = ty
 	}
 	for key, rawFunction := range this.rawFunctions {
-		_, err := this.analyzeFunction(rawFunction.Position, key)
+		_, err := this.analyzeFunction(rawFunction.Position(), key)
 		if err != nil { return err }
 	}
 	for _, rawMethod := range this.rawMethods {
 		_, err := this.analyzeMethod (
-			rawMethod.Position,
+			rawMethod.Position(),
 			entity.Key {
 				Unit:   this.unit,
 				Name:   rawMethod.TypeName,

analyzer/type.go

@@ -36,7 +36,7 @@ func (this *Tree) analyzeTypedef (
 	// analyze if it still needs to be analyzed
 	if definition, exists := this.rawTypes[key]; exists {
 		// update unit
-		definition.Unit = key.Unit
+		definition.Unt = key.Unit
 
 		// analyze
 		var err error
@@ -246,8 +246,8 @@ func (this *Tree) assembleStructMap (ty *entity.TypeStruct) (*entity.TypeStruct,
 	for index, member := range ty.Members {
 		if previous, exists := ty.MemberMap[member.Name]; exists {
 			return ty, errors.Errorf (
-				member.Position, "%s already listed in struct at %v",
+				member.Position(), "%s already listed in struct at %v",
-				member.Name, previous.Position)
+				member.Name, previous.Position())
 		}
 		ty.MemberMap  [member.Name] = member
 		ty.MemberOrder[index]       = member.Name