     public let body: [Expression]
     public let importPaths: [StringLiteralExpression]
     public let within: TypeIdentifierExpression?
-    
-    public let hashValue: Int = nextHashValue()
-    
-    public func absolutise(absoluteName: String) {
-        name.value = absoluteName
+    public var absolutised: Bool = false
+    
+    public let hashValue: Int = nextHashValue()
+    
+    public mutating func absolutise(absoluteName: String) {
+        self.name.value = absoluteName
+        self.absolutised = true
     }
 }
 

        pairs.enumerated().forEach { order[$0.element.name.value] = $0.offset }
        
        let defaultConstructorName = IdentifierExpression(value: "__init__", grouped: false)
        let defaultConstructorSignature = StaticSignatureExpression(name: defaultConstructorName, receiverType: name, parameters: pairs, returnType: name, genericConstraints: nil)
        
        // TODO - Optional parameters, default parameters
        
        return TypeDefExpression(name: name, properties: pairs, propertyOrder: order, constructorSignatures: [defaultConstructorSignature])
    }
    
    /// A pair consists of an identifier followed by a type identifier, e.g. i Int

        let ret = try parseTypeIdentifierList()
        
        guard ret.count > 0 else {
            return StaticSignatureExpression(name: name, receiverType: receiver[0], parameters: args, returnType: nil, genericConstraints: gen, absolutised: false)
        }
        
        // TODO - Multiple return types should be sugar for returning a tuple of those types (saves typing an extra pair of parens)
        guard ret.count == 1 else { throw OrbitError.multipleReturns(token: try peek()) }
        
        return StaticSignatureExpression(name: name, receiverType: receiver[0], parameters: args, returnType: ret[0], genericConstraints: gen, absolutised: false)
    }
    
    func parseInstanceSignature() throws -> StaticSignatureExpression {
