ASTNodes use MemoryArena (shader-slang#1376)

* Add a ASTBuilder to a Module
Only construct on valid ASTBuilder (was being called on nullptr on occassion)

* Add nodes to ASTBuilder.

* Compiles with RefPtr removed from AST node types.

* Initialize all AST node pointer variables in headers to nullptr;

* Initialize AST node variables as nullptr.
Make ASTBuilder keep a ref on node types.
Make SyntaxParseCallback returns a NodeBase

* Don't release canonicalType on dtor (managed by ASTBuilder).

* Give ASTBuilders a name and id, to help in debugging.
For now destroy the session TypeCache, to stop it holding things released when the compile request destroys ASTBuilders.

* Moved the TypeCheckingCache over to Linkage from Session.

* NodeBase no longer derived from RefObject.

* Only add/dtor nodes that need destruction.
First pass compile on linux.

Author: jsmall-zzz

source/slang/slang-ast-base.h

@@ -14,14 +14,12 @@
 namespace Slang
 {
 
-// Signals to C++ extractor that RefObject is a base class, that isn't reflected to C++ extractor
-SLANG_REFLECT_BASE_CLASS(RefObject)
-
 struct ReflectClassInfo;
 
-class NodeBase : public RefObject
+class NodeBase 
 {
     SLANG_ABSTRACT_CLASS(NodeBase)
+    SLANG_CLASS_ROOT
 
         // MUST be called before used. Called automatically via the ASTBuilder.
         // Note that the astBuilder is not stored in the NodeBase derived types by default.
@@ -91,14 +89,14 @@ class Val : public NodeBase
 
     // construct a new value by applying a set of parameter
     // substitutions to this one
-    RefPtr<Val> substitute(ASTBuilder* astBuilder, SubstitutionSet subst);
+    Val* substitute(ASTBuilder* astBuilder, SubstitutionSet subst);
 
     // Lower-level interface for substitution. Like the basic
     // `Substitute` above, but also takes a by-reference
     // integer parameter that should be incremented when
     // returning a modified value (this can help the caller
     // decide whether they need to do anything).
-    RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
 
     bool equalsVal(Val* val);
     String toString();
@@ -109,7 +107,7 @@ class Val : public NodeBase
     }
 
     // Overrides should be public so base classes can access
-    RefPtr<Val> _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
     bool _equalsValOverride(Val* val);
     String _toStringOverride();
     HashCode _getHashCodeOverride();
@@ -154,17 +152,15 @@ class Type: public Val
 
     Type* getCanonicalType();
 
-    ~Type();
-
     // Overrides should be public so base classes can access
-    RefPtr<Val> _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
+    Val* _substituteImplOverride(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff);
     bool _equalsValOverride(Val* val);
     bool _equalsImplOverride(Type* type);
-    RefPtr<Type> _createCanonicalTypeOverride();
+    Type* _createCanonicalTypeOverride();
 
 protected:
     bool equalsImpl(Type* type);
-    RefPtr<Type> createCanonicalType();
+    Type* createCanonicalType();
 
     Type* canonicalType = nullptr;
 
@@ -184,17 +180,17 @@ class Substitutions: public NodeBase
     SLANG_ABSTRACT_CLASS(Substitutions)
 
     // The next outer that this one refines.
-    RefPtr<Substitutions> outer;
+    Substitutions* outer = nullptr;
 
     // Apply a set of substitutions to the bindings in this substitution
-    RefPtr<Substitutions> applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff);
+    Substitutions* applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
 
     // Check if these are equivalent substitutions to another set
     bool equals(Substitutions* subst);
     HashCode getHashCode() const;
 
     // Overrides should be public so base classes can access
-    RefPtr<Substitutions> _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff);
+    Substitutions* _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
     bool _equalsOverride(Substitutions* subst);
     HashCode _getHashCodeOverride() const;
 };
@@ -205,13 +201,13 @@ class GenericSubstitution : public Substitutions
 
     // The generic declaration that defines the
     // parameters we are binding to arguments
-    GenericDecl* genericDecl;
+    GenericDecl* genericDecl = nullptr;
 
     // The actual values of the arguments
-    List<RefPtr<Val> > args;
+    List<Val* > args;
 
     // Overrides should be public so base classes can access
-    RefPtr<Substitutions> _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff);
+    Substitutions* _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
     bool _equalsOverride(Substitutions* subst);
     HashCode _getHashCodeOverride() const;
 };
@@ -225,11 +221,11 @@ class ThisTypeSubstitution : public Substitutions
 
     // A witness that shows that the concrete type used to
     // specialize the interface conforms to the interface.
-    RefPtr<SubtypeWitness> witness;
+    SubtypeWitness* witness = nullptr;
 
     // Overrides should be public so base classes can access
     // The actual type that provides the lookup scope for an associated type
-    RefPtr<Substitutions> _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff);
+    Substitutions* _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
     bool _equalsOverride(Substitutions* subst);
     HashCode _getHashCodeOverride() const;
 };
@@ -238,22 +234,22 @@ class GlobalGenericParamSubstitution : public Substitutions
 {
     SLANG_CLASS(GlobalGenericParamSubstitution)
     // the type_param decl to be substituted
-    GlobalGenericParamDecl* paramDecl;
+    GlobalGenericParamDecl* paramDecl = nullptr;
 
     // the actual type to substitute in
-    RefPtr<Type> actualType;
+    Type* actualType = nullptr;
 
     struct ConstraintArg
     {
-        RefPtr<Decl>    decl;
-        RefPtr<Val>     val;
+        Decl*    decl = nullptr;
+        Val*     val = nullptr;
     };
 
     // the values that satisfy any constraints on the type parameter
     List<ConstraintArg> constraintArgs;
 
     // Overrides should be public so base classes can access
-    RefPtr<Substitutions> _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff);
+    Substitutions* _applySubstitutionsShallowOverride(ASTBuilder* astBuilder, SubstitutionSet substSet, Substitutions* substOuter, int* ioDiff);
     bool _equalsOverride(Substitutions* subst);
     HashCode _getHashCodeOverride() const;
 };
@@ -276,7 +272,7 @@ class Modifier : public SyntaxNode
     void accept(IModifierVisitor* visitor, void* extra);
 
     // Next modifier in linked list of modifiers on same piece of syntax
-    RefPtr<Modifier> next;
+    Modifier* next = nullptr;
 
     // The keyword that was used to introduce t that was used to name this modifier.
     Name* name;
@@ -293,7 +289,7 @@ class ModifiableSyntaxNode : public SyntaxNode
     Modifiers modifiers;
 
     template<typename T>
-    FilteredModifierList<T> getModifiersOfType() { return FilteredModifierList<T>(modifiers.first.Ptr()); }
+    FilteredModifierList<T> getModifiersOfType() { return FilteredModifierList<T>(modifiers.first); }
 
     // Find the first modifier of a given type, or return `nullptr` if none is found.
     template<typename T>

source/slang/slang-ast-builder.cpp

@@ -12,7 +12,6 @@ SharedASTBuilder::SharedASTBuilder()
 {    
 }
 
-
 void SharedASTBuilder::init(Session* session)
 {
     m_namePool = session->getNamePool();
@@ -55,14 +54,14 @@ const ReflectClassInfo* SharedASTBuilder::findClassInfo(const UnownedStringSlice
     return m_sliceToTypeMap.TryGetValue(slice, typeInfo) ? typeInfo : nullptr;
 }
 
-SyntaxClass<RefObject> SharedASTBuilder::findSyntaxClass(const UnownedStringSlice& slice)
+SyntaxClass<NodeBase> SharedASTBuilder::findSyntaxClass(const UnownedStringSlice& slice)
 {
     const ReflectClassInfo* typeInfo;
     if (m_sliceToTypeMap.TryGetValue(slice, typeInfo))
     {
-        return SyntaxClass<RefObject>(typeInfo);
+        return SyntaxClass<NodeBase>(typeInfo);
     }
-    return SyntaxClass<RefObject>();
+    return SyntaxClass<NodeBase>();
 }
 
 const ReflectClassInfo* SharedASTBuilder::findClassInfo(Name* name)
@@ -71,14 +70,14 @@ const ReflectClassInfo* SharedASTBuilder::findClassInfo(Name* name)
     return m_nameToTypeMap.TryGetValue(name, typeInfo) ? typeInfo : nullptr;
 }
 
-SyntaxClass<RefObject> SharedASTBuilder::findSyntaxClass(Name* name)
+SyntaxClass<NodeBase> SharedASTBuilder::findSyntaxClass(Name* name)
 {
     const ReflectClassInfo* typeInfo;
     if (m_nameToTypeMap.TryGetValue(name, typeInfo))
     {
-        return SyntaxClass<RefObject>(typeInfo);
+        return SyntaxClass<NodeBase>(typeInfo);
     }
-    return SyntaxClass<RefObject>();
+    return SyntaxClass<NodeBase>();
 }
 
 Type* SharedASTBuilder::getStringType()
@@ -106,7 +105,7 @@ SharedASTBuilder::~SharedASTBuilder()
     // Release built in types..
     for (Index i = 0; i < SLANG_COUNT_OF(m_builtinTypes); ++i)
     {
-        m_builtinTypes[i].setNull();
+        m_builtinTypes[i] = nullptr;
     }
 
     if (m_astBuilder)
@@ -115,13 +114,13 @@ SharedASTBuilder::~SharedASTBuilder()
     }
 }
 
-void SharedASTBuilder::registerBuiltinDecl(RefPtr<Decl> decl, RefPtr<BuiltinTypeModifier> modifier)
+void SharedASTBuilder::registerBuiltinDecl(Decl* decl, BuiltinTypeModifier* modifier)
 {
-    auto type = DeclRefType::create(m_astBuilder, DeclRef<Decl>(decl.Ptr(), nullptr));
+    auto type = DeclRefType::create(m_astBuilder, DeclRef<Decl>(decl, nullptr));
     m_builtinTypes[Index(modifier->tag)] = type;
 }
 
-void SharedASTBuilder::registerMagicDecl(RefPtr<Decl> decl, RefPtr<MagicTypeModifier> modifier)
+void SharedASTBuilder::registerMagicDecl(Decl* decl, MagicTypeModifier* modifier)
 {
     // In some cases the modifier will have been applied to the
     // "inner" declaration of a `GenericDecl`, but what we
@@ -131,94 +130,110 @@ void SharedASTBuilder::registerMagicDecl(RefPtr<Decl> decl, RefPtr<MagicTypeModi
     if (auto genericDecl = as<GenericDecl>(decl->parentDecl))
         declToRegister = genericDecl;
 
-    m_magicDecls[modifier->name] = declToRegister.Ptr();
+    m_magicDecls[modifier->name] = declToRegister;
 }
 
-RefPtr<Decl> SharedASTBuilder::findMagicDecl(const String& name)
+Decl* SharedASTBuilder::findMagicDecl(const String& name)
 {
     return m_magicDecls[name].GetValue();
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ASTBuilder !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-ASTBuilder::ASTBuilder(SharedASTBuilder* sharedASTBuilder):
-    m_sharedASTBuilder(sharedASTBuilder)
+ASTBuilder::ASTBuilder(SharedASTBuilder* sharedASTBuilder, const String& name):
+    m_sharedASTBuilder(sharedASTBuilder),
+    m_name(name),
+    m_id(sharedASTBuilder->m_id++),
+    m_arena(2048)
 {
     SLANG_ASSERT(sharedASTBuilder);
 }
 
 ASTBuilder::ASTBuilder():
-    m_sharedASTBuilder(nullptr)
+    m_sharedASTBuilder(nullptr),
+    m_id(-1),
+    m_arena(2048)
+{
+    m_name = "ShadedASTBuilder::m_astBuilder";
+}
+
+ASTBuilder::~ASTBuilder()
 {
+    for (NodeBase* node : m_nodes)
+    {
+        const ReflectClassInfo* info = ReflectClassInfo::getInfo(node->astNodeType);
+        SLANG_ASSERT(info->m_destroyFunc);
+        info->m_destroyFunc(node);
+    }
 }
 
-RefPtr<PtrType> ASTBuilder::getPtrType(RefPtr<Type> valueType)
+PtrType* ASTBuilder::getPtrType(Type* valueType)
 {
-    return getPtrType(valueType, "PtrType").dynamicCast<PtrType>();
+    return dynamicCast<PtrType>(getPtrType(valueType, "PtrType"));
 }
 
 // Construct the type `Out<valueType>`
-RefPtr<OutType> ASTBuilder::getOutType(RefPtr<Type> valueType)
+OutType* ASTBuilder::getOutType(Type* valueType)
 {
-    return getPtrType(valueType, "OutType").dynamicCast<OutType>();
+    return dynamicCast<OutType>(getPtrType(valueType, "OutType"));
 }
 
-RefPtr<InOutType> ASTBuilder::getInOutType(RefPtr<Type> valueType)
+InOutType* ASTBuilder::getInOutType(Type* valueType)
 {
-    return getPtrType(valueType, "InOutType").dynamicCast<InOutType>();
+    return dynamicCast<InOutType>(getPtrType(valueType, "InOutType"));
 }
 
-RefPtr<RefType> ASTBuilder::getRefType(RefPtr<Type> valueType)
+RefType* ASTBuilder::getRefType(Type* valueType)
 {
-    return getPtrType(valueType, "RefType").dynamicCast<RefType>();
+    return dynamicCast<RefType>(getPtrType(valueType, "RefType"));
 }
 
-RefPtr<PtrTypeBase> ASTBuilder::getPtrType(RefPtr<Type> valueType, char const* ptrTypeName)
+PtrTypeBase* ASTBuilder::getPtrType(Type* valueType, char const* ptrTypeName)
 {
-    auto genericDecl = m_sharedASTBuilder->findMagicDecl(ptrTypeName).dynamicCast<GenericDecl>();
+    auto genericDecl = dynamicCast<GenericDecl>(m_sharedASTBuilder->findMagicDecl(ptrTypeName));
     return getPtrType(valueType, genericDecl);
 }
 
-RefPtr<PtrTypeBase> ASTBuilder::getPtrType(RefPtr<Type> valueType, GenericDecl* genericDecl)
+PtrTypeBase* ASTBuilder::getPtrType(Type* valueType, GenericDecl* genericDecl)
 {
     auto typeDecl = genericDecl->inner;
 
     auto substitutions = create<GenericSubstitution>();
     substitutions->genericDecl = genericDecl;
     substitutions->args.add(valueType);
 
-    auto declRef = DeclRef<Decl>(typeDecl.Ptr(), substitutions);
+    auto declRef = DeclRef<Decl>(typeDecl, substitutions);
     auto rsType = DeclRefType::create(this, declRef);
     return as<PtrTypeBase>(rsType);
 }
 
-RefPtr<ArrayExpressionType> ASTBuilder::getArrayType(Type* elementType, IntVal* elementCount)
+ArrayExpressionType* ASTBuilder::getArrayType(Type* elementType, IntVal* elementCount)
 {
-    RefPtr<ArrayExpressionType> arrayType = create<ArrayExpressionType>();
+    ArrayExpressionType* arrayType = create<ArrayExpressionType>();
     arrayType->baseType = elementType;
     arrayType->arrayLength = elementCount;
     return arrayType;
 }
 
-RefPtr<VectorExpressionType> ASTBuilder::getVectorType(
-    RefPtr<Type>    elementType,
-    RefPtr<IntVal>  elementCount)
+VectorExpressionType* ASTBuilder::getVectorType(
+    Type*    elementType,
+    IntVal*  elementCount)
 {
-    auto vectorGenericDecl = m_sharedASTBuilder->findMagicDecl("Vector").as<GenericDecl>();
+    auto vectorGenericDecl = as<GenericDecl>(m_sharedASTBuilder->findMagicDecl("Vector"));
 
     auto vectorTypeDecl = vectorGenericDecl->inner;
 
     auto substitutions = create<GenericSubstitution>();
-    substitutions->genericDecl = vectorGenericDecl.Ptr();
+    substitutions->genericDecl = vectorGenericDecl;
     substitutions->args.add(elementType);
     substitutions->args.add(elementCount);
 
-    auto declRef = DeclRef<Decl>(vectorTypeDecl.Ptr(), substitutions);
+    auto declRef = DeclRef<Decl>(vectorTypeDecl, substitutions);
 
-    return DeclRefType::create(this, declRef).as<VectorExpressionType>();
+    return as<VectorExpressionType>(DeclRefType::create(this, declRef));
 }
 
-RefPtr<TypeType> ASTBuilder::getTypeType(Type* type)
+TypeType* ASTBuilder::getTypeType(Type* type)
 {
     return create<TypeType>(type);
 }