Gather properties from superclasses

Author: bradhilton

Sources/Reflection/Metadata+Class.swift

@@ -12,6 +12,11 @@ extension Metadata {
             guard let superclass = pointer.pointee.superclass else { return nil }
             return Metadata.Class(type: superclass)
         }
+        
+        func properties() throws -> [Property.Description] {
+            guard let superclass = superclass else { return [] }
+            return try superclass.properties() + fetchAndSaveProperties(nominalType: self, hashedType: HashedType(pointer))
+        }
 
     }
 }

Sources/Reflection/Properties.swift

@@ -1,11 +1,14 @@
-private struct HashedType : Hashable {
+struct HashedType : Hashable {
     let hashValue: Int
     init(_ type: Any.Type) {
         hashValue = unsafeBitCast(type, to: Int.self)
     }
+    init<T>(_ pointer: UnsafePointer<T>) {
+        hashValue = pointer.hashValue
+    }
 }
 
-private func == (lhs: HashedType, rhs: HashedType) -> Bool {
+func == (lhs: HashedType, rhs: HashedType) -> Bool {
     return lhs.hashValue == rhs.hashValue
 }
 
@@ -50,13 +53,13 @@ public func properties(_ type: Any.Type) throws -> [Property.Description] {
     } else if let nominalType = Metadata.Struct(type: type) {
         return try fetchAndSaveProperties(nominalType: nominalType, hashedType: hashedType)
     } else if let nominalType = Metadata.Class(type: type) {
-        return try fetchAndSaveProperties(nominalType: nominalType, hashedType: hashedType)
+        return try nominalType.properties()
     } else {
         throw ReflectionError.notStruct(type: type)
     }
 }
 
-private func fetchAndSaveProperties<T : NominalType>(nominalType: T, hashedType: HashedType) throws -> [Property.Description] {
+func fetchAndSaveProperties<T : NominalType>(nominalType: T, hashedType: HashedType) throws -> [Property.Description] {
     let properties = try propertiesForNominalType(nominalType)
     cachedProperties[hashedType] = properties
     return properties

Tests/ReflectionTests/PublicTests.swift

@@ -35,7 +35,20 @@ class ReferencePerson : Equatable {
     }
 }
 
-class SubclassedPerson : ReferencePerson {}
+class SubclassedPerson : ReferencePerson {
+    var hobby: String
+    
+    required init() {
+        self.hobby = ""
+        super.init()
+    }
+    
+    init(firstName: String, lastName: String, age: Int, hobby: String) {
+        self.hobby = hobby
+        super.init(firstName: firstName, lastName: lastName, age: age)
+    }
+    
+}
 
 func == (lhs: ReferencePerson, rhs: ReferencePerson) -> Bool {
     return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName && lhs.age == rhs.age
@@ -116,6 +129,22 @@ public class PublicTests : XCTestCase {
         XCTAssert(person.lastName == lastName)
         XCTAssert(person.age == age)
     }
+    
+    func testPropertiesForSubclass() throws {
+        var props: [Property] = []
+        let person = SubclassedPerson(firstName: "Brad", lastName: "Hilton", age: 27, hobby: "Golf")
+        props = try properties(person)
+        guard props.count == 4 else {
+            return XCTFail("Unexpected number of properties")
+        }
+        guard let firstName = props[0].value as? String, let lastName = props[1].value as? String, let age = props[2].value as? Int, let hobby = props[3].value as? String else {
+            return XCTFail("Unexpected properties")
+        }
+        XCTAssert(person.firstName == firstName)
+        XCTAssert(person.lastName == lastName)
+        XCTAssert(person.age == age)
+        XCTAssert(person.hobby == hobby)
+    }
 
     func testSetValueForKeyOfInstance() throws {
         var person = Person(firstName: "Brad", lastName: "Hilton", age: 27)