Use Reflection for (Serial)RefObject Serialization (#1567)

* First pass at generalizing serializer.

* Split out ReflectClassInfo

* Use the general ReflectClassInfo

* Fix some typos in debug generalized serialization.

* Add calculation of classIds.
Make distinct addCopy/add on SerialClasses.

* Write up of more generalized serialization

* WIP to transition from ASTSerialReader/Writer etc to generalized SerialReader/Writer and associated types.

* Improvements to SerialExtraObjects.
Keep RefObjects in scope in factory

* Compiles with Serial refactor - doesn't quite work yet.

* First pass serialization appears to work with refector.

* Split out type info for general slang types.

* Split out slang-serialize-misc-type-info.h

* DebugSerialData -> SerialSourecLocData
DebugSerialReader -> SerialSourceLocReader
DebugSerialWriter -> SerialSourceLocWriter

* Remove unused template that only compiles on VS.

* Fix warning around unused function on non-VS.

* Improve output of type names that are in scopes in C++ extractor.
Update premake5.lua to run generation for RefObject derived types.

* C++ extractor working on RefObject type.

* Split out serialization functionality that spans different types into slang-serialization-factory.cpp/.h
Put AST type info into header.
Removed RefObjectSerialSubType - use RefObjectType
Add filtering for RefObject derived types
Remove construction and filteringhacks.

* Set up field serialization for SerialRefObject derived types.

* Fix template problem compiling on Clang/Gcc

* Work in progress to make Value types work.

* Added slang-value-reflect.cpp

1 files changed, 19 insertions, 22 deletions

diff --git a/source/slang/slang-serialize.cpp b/source/slang/slang-serialize.cpp
index 06ddbdde0..46aae18b2 100644
--- a/source/slang/slang-serialize.cpp
+++ b/source/slang/slang-serialize.cpp
@@ -156,24 +156,6 @@ SerialClasses::SerialClasses():
 {
 }
 
-// For now just use an extern so we don't need to include AST serialize
-extern void addASTTypes(SerialClasses* serialClasses);
-extern RefObjectSerialSubType getRefObjectSubType(const RefObject* obj);
-
-/* static */SlangResult SerialClasses::create(RefPtr<SerialClasses>& out)
-{
-    RefPtr<SerialClasses> classes(new SerialClasses);
-    addASTTypes(classes);
-
-    out = classes;
-    return SLANG_OK;
-}
-
-/* static */RefObjectSerialSubType SerialClasses::getSubType(const RefObject* obj)
-{
-    return getRefObjectSubType(obj);
-}
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! SerialWriter  !!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 SerialWriter::SerialWriter(SerialClasses* classes, SerialFilter* filter) :
@@ -238,14 +220,17 @@ SerialIndex SerialWriter::writeObject(const NodeBase* node)
 
 SerialIndex SerialWriter::writeObject(const RefObject* obj)
 {
-    const RefObjectSerialSubType subType = SerialClasses::getSubType(obj);
-    if (subType == RefObjectSerialSubType::Invalid)
+    const SerialRefObject* serialObj = as<const SerialRefObject>(obj);
+    if (!serialObj)
     {
         SLANG_ASSERT(!"Unhandled type");
         return SerialIndex(0);
     }
 
-    const SerialClass* serialClass = m_classes->getSerialClass(SerialTypeKind::RefObject, SerialSubType(subType));
+    const ReflectClassInfo* classInfo = serialObj->getClassInfo();
+    SLANG_ASSERT(classInfo);
+
+    const SerialClass* serialClass = m_classes->getSerialClass(SerialTypeKind::RefObject, SerialSubType(classInfo->m_classId));
     return writeObject(serialClass, (const void*)obj);
 }
 
@@ -254,6 +239,11 @@ void SerialWriter::setPointerIndex(const NodeBase* ptr, SerialIndex index)
     m_ptrMap.Add(ptr, Index(index));
 }
 
+void SerialWriter::setPointerIndex(const RefObject* ptr, SerialIndex index)
+{
+    m_ptrMap.Add(ptr, Index(index));
+}
+
 SerialIndex SerialWriter::addPointer(const NodeBase* node)
 {
     // Null is always 0
@@ -307,7 +297,14 @@ SerialIndex SerialWriter::addPointer(const RefObject* obj)
         return addName(name);
     }
 
-    return writeObject(obj);
+    if (m_filter)
+    {
+        return m_filter->writePointer(this, obj);
+    }
+    else
+    {
+        return writeObject(obj);
+    }
 }
 
 SerialIndex SerialWriter::addString(const UnownedStringSlice& slice)