diff --git a/src/js_class.hpp b/src/js_class.hpp
index 0e6eb112..39603897 100644
--- a/src/js_class.hpp
+++ b/src/js_class.hpp
@@ -68,27 +68,22 @@ using MethodMap = std::map<std::string, typename T::FunctionCallback>;
 template<typename T>
 using PropertyMap = std::map<std::string, PropertyType<T>>;
 
-template<typename T, typename U>
+template<typename T, typename U, typename V = void>
 struct ClassDefinition {
     using Internal = U;
+    using Parent = V;
     
-    // Every specialization *must* at least have a name.
-    std::string name;
-};
-
-template<typename T, typename U = void>
-struct BaseClassDefinition {
-    // This pointer does not need to be set.
-    ClassDefinition<T, U>* superclass;
+    // Every subclass *must* at least have a name.
+    // std::string const name;
 
     // ClassDefinition specializations should inherit from this class and override what's needed below.
-    ConstructorType<T>* constructor;
-    MethodMap<T> static_methods;
-    PropertyMap<T> static_properties;
-    MethodMap<T> methods;
-    PropertyMap<T> properties;
-    IndexPropertyType<T> index_accessor;
-    StringPropertyType<T> string_accessor;
+    ConstructorType<T>* const constructor = nullptr;
+    MethodMap<T> const static_methods = {};
+    PropertyMap<T> const static_properties = {};
+    MethodMap<T> const methods = {};
+    PropertyMap<T> const properties = {};
+    IndexPropertyType<T> const index_accessor = {};
+    StringPropertyType<T> const string_accessor = {};
 };
 
 template<typename T, typename ClassType>
diff --git a/src/js_collection.hpp b/src/js_collection.hpp
index 2ed53915..510333a7 100644
--- a/src/js_collection.hpp
+++ b/src/js_collection.hpp
@@ -27,7 +27,7 @@ namespace js {
 class Collection {};
 
 template<typename T>
-struct CollectionClass : ClassDefinition<T, Collection>, BaseClassDefinition<T> {
+struct CollectionClass : ClassDefinition<T, Collection> {
     std::string const name = "Collection";
 };
 
diff --git a/src/js_list.hpp b/src/js_list.hpp
index a1152915..b78883c7 100644
--- a/src/js_list.hpp
+++ b/src/js_list.hpp
@@ -58,7 +58,7 @@ struct List {
 };
 
 template<typename T>
-struct ListClass : ClassDefinition<T, realm::List>, BaseClassDefinition<T, CollectionClass<T>> {
+struct ListClass : ClassDefinition<T, realm::List, CollectionClass<T>> {
     using List = List<T>;
 
     std::string const name = "List";
diff --git a/src/js_object.hpp b/src/js_object.hpp
index f79ddbce..9872706b 100644
--- a/src/js_object.hpp
+++ b/src/js_object.hpp
@@ -48,7 +48,7 @@ struct RealmObject {
 };
 
 template<typename T>
-struct RealmObjectClass : ClassDefinition<T, realm::Object>, BaseClassDefinition<T> {
+struct RealmObjectClass : ClassDefinition<T, realm::Object> {
     using RealmObject = RealmObject<T>;
 
     const std::string name = "RealmObject";
diff --git a/src/js_realm.hpp b/src/js_realm.hpp
index 2ea8ebf3..b7609391 100644
--- a/src/js_realm.hpp
+++ b/src/js_realm.hpp
@@ -199,7 +199,7 @@ class Realm {
 };
 
 template<typename T>
-struct RealmClass : ClassDefinition<T, SharedRealm>, BaseClassDefinition<T> {
+struct RealmClass : ClassDefinition<T, SharedRealm> {
     using Realm = Realm<T>;
 
     std::string const name = "Realm";
diff --git a/src/js_results.hpp b/src/js_results.hpp
index a0577b3a..641293f9 100644
--- a/src/js_results.hpp
+++ b/src/js_results.hpp
@@ -58,7 +58,7 @@ struct Results {
 };
 
 template<typename T>
-struct ResultsClass : ClassDefinition<T, realm::Results>, BaseClassDefinition<T, CollectionClass<T>> {
+struct ResultsClass : ClassDefinition<T, realm::Results, CollectionClass<T>> {
     using Results = Results<T>;
 
     std::string const name = "Results";
diff --git a/src/jsc/jsc_class.hpp b/src/jsc/jsc_class.hpp
index 2aefe1cf..403f37bf 100644
--- a/src/jsc/jsc_class.hpp
+++ b/src/jsc/jsc_class.hpp
@@ -40,6 +40,7 @@ template<typename ClassType>
 class ObjectWrap {
 public:
     using Internal = typename ClassType::Internal;
+    using ParentClassType = typename ClassType::Parent;
 
     operator Internal*() const {
         return m_object.get();
@@ -186,11 +187,6 @@ private:
         }
     }
 
-    template<typename U>
-    static JSClassRef get_superclass(ClassDefinition<U>*) {
-        return ObjectWrap<U>::get_class();
-    }
-
     static std::vector<JSStaticFunction> get_methods(const MethodMap &methods) {
         std::vector<JSStaticFunction> functions;
         functions.reserve(methods.size() + 1);
@@ -227,7 +223,7 @@ private:
         std::vector<JSStaticFunction> methods;
         std::vector<JSStaticValue> properties;
 
-        definition.parentClass = get_superclass(s_class.superclass);
+        definition.parentClass = ObjectWrap<ParentClassType>::get_class();
         definition.className = s_class.name.c_str();
         definition.finalize = finalize;
 
diff --git a/src/node/node_class.hpp b/src/node/node_class.hpp
index 5319e011..3c9dbbc0 100644
--- a/src/node/node_class.hpp
+++ b/src/node/node_class.hpp
@@ -86,6 +86,7 @@ static inline void setup_property(v8::Local<TargetType> target, const std::strin
 template<typename ClassType>
 class ObjectWrap : public Nan::ObjectWrap {
     using Internal = typename ClassType::Internal;
+    using ParentClassType = typename ClassType::Parent;
 
     static ClassType s_class;
 
@@ -93,11 +94,6 @@ class ObjectWrap : public Nan::ObjectWrap {
 
     ObjectWrap(Internal* object = nullptr) : m_object(object) {}
 
-    template<typename U>
-    static v8::Local<v8::FunctionTemplate> get_superclass(ClassDefinition<U>*) {
-        return ObjectWrap<U>::get_template();
-    }
-
     static void get_nonexistent_property(v8::Local<v8::String> property, Nan::NAN_PROPERTY_GETTER_ARGS_TYPE info) {
         // Do nothing. This function exists only to prevent a crash where it is used.
     }
@@ -149,7 +145,7 @@ class ObjectWrap : public Nan::ObjectWrap {
         tpl->SetClassName(name);
         instance_tpl->SetInternalFieldCount(1);
 
-        v8::Local<v8::FunctionTemplate> super_tpl = get_superclass(s_class.superclass);
+        v8::Local<v8::FunctionTemplate> super_tpl = ObjectWrap<ParentClassType>::get_template();
         if (!super_tpl.IsEmpty()) {
             tpl->Inherit(super_tpl);
         }