Standard library save/loadable (#1592)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Fix handling of access modifiers inside type definition.

* Fix access problem for AST node.
Make dumping produce a single function with switch, to potentially make available without Dump specific access.

* WIP on serialization design doc.

* Remove project references to previously generated files.

* More docs on serialization design.

* Improve serialization documentation.
Remove unused function from IRSerialReader.

* Small fixes around naming. Remove long comment from slang-serialize.h - as covered in serialization.md

* Remove long comment in slang-serialize.h as covered in serialization.md

* More information about doing replacements on read for AST and problems surrounding.

* Typo fix.

* Spelling fixes.

* Value serialize.

* Value types with inheritence.

* Use value reflection serial conversion for more AST types

* Use automatic serialization on more of AST.

* Get the types via decltype, simplifies what the extractor has to do.

* Update the serialization.md for the value serialization.

* Small doc improvements.

* Update project.

* Remove ImportExternalDecl type
Added addImportSymbol and ImportSymbol type
Fixed bug in container which meant it wouldn't read back AST module

* Because of change of how imports and handled, store objects as SerialPointers.

* First pass symbol lookup from mangled names.

* Cache current module looked up from mangled name.

* Fix SourceLoc bug.
Improve comments.

* Added diagnostic on mangled symbol not being found

* Fix typo.

* WIP serializing stdlib.

* WIP serializing stdlib in.

* Fix problem serializing arrays that hold data that is already serialized.

* Remove clash of names in MagicTypeModifier.

* Make conversion from char to String explicit.
Fix reference count issue with SerialReader.

* Add code to save/load stdlib.

* Use return code to avoid warning -                 SerialContainerUtil::write(module, options, &stream))

* Make all String numeric ctors explicit.
Added isChar to UnownedStringSlice.
Added operator== for UnownedStringSlice to String to avoid need to convert to String and allocate.

* Add error check to readAllText.

* tabs -> spaces on String.h

* tab -> spaces String.cpp

* Remove msg for StringBuilder, just build inplace for exceptions.

* Check SerialClasses - for name clashes.
Renamed Modifier::name as Modifier::keywordName

* Handling of extensions when deserializing AST - updating the moduleDecl->mapTypeToCandidateExtensions

Co-authored-by: Tim Foley <tim.foley.is@gmail.com>

1 files changed, 64 insertions, 5 deletions

diff --git a/source/slang/slang-serialize.cpp b/source/slang/slang-serialize.cpp
index 34680d860..4f8fdc546 100644
--- a/source/slang/slang-serialize.cpp
+++ b/source/slang/slang-serialize.cpp
@@ -151,6 +151,58 @@ SerialClass* SerialClasses::_createSerialClass(const SerialClass* cls)
     return dst;
 }
 
+bool SerialClasses::isOk() const
+{
+    StringSlicePool pool(StringSlicePool::Style::Default);
+
+    for (const auto& classes : m_classesByTypeKind)
+    {
+        for (const SerialClass* cls : classes)
+        {
+            // It is possible potentially to have gaps
+            if (cls == nullptr)
+            {
+                continue;
+            }
+
+            if (cls->super && cls->super->typeKind != cls->typeKind)
+            {
+                // If has a super type, must be the same typeKind
+                return false;
+            }
+
+            // Make sure the fields are uniquely named
+
+            pool.clear();
+
+            {
+                const SerialClass* curCls = cls;
+
+                do
+                {
+                    for (Index i = 0; i < curCls->fieldsCount; ++i)
+                    {
+                        const SerialField& field = curCls->fields[i];
+
+                        StringSlicePool::Handle handle;
+                        if (pool.findOrAdd(UnownedStringSlice(field.name), handle))
+                        {
+                            return false;
+                        }
+                    }
+
+                    // Add the fields of the parent
+                    curCls = curCls->super;
+                }
+                while (curCls);
+            }
+        }
+    }
+
+    return true;
+}
+
+
 SerialClasses::SerialClasses():
     m_arena(2048)
 {
@@ -375,7 +427,7 @@ SerialIndex SerialWriter::addName(const Name* name)
     return index;
 }
 
-SerialIndex SerialWriter::_addArray(size_t elementSize, size_t alignment, const void* elements, Index elementCount)
+SerialIndex SerialWriter::addSerialArray(size_t elementSize, size_t alignment, const void* elements, Index elementCount)
 {
     typedef SerialInfo::ArrayEntry Entry;
 
@@ -699,12 +751,19 @@ String SerialReader::getString(SerialIndex index)
 
     // Okay we need to construct as a string
     UnownedStringSlice slice = getStringSlice(index);
-    String string(slice);
-    StringRepresentation* stringRep = string.getStringRepresentation();
 
-    m_scope.add(stringRep);
+    StringRepresentation* stringRep = nullptr;
+
+    const Index length = slice.getLength();
+    if (length)
+    {
+        stringRep = StringRepresentation::createWithCapacityAndLength(length, length);
+        memcpy(stringRep->getData(), slice.begin(), length * sizeof(char));
+        addScope(stringRep);
+    }
+
     m_objects[Index(index)] = stringRep;
-    return string;
+    return String(stringRep);
 }
 
 Name* SerialReader::getName(SerialIndex index)