diff options
Diffstat (limited to 'source/slang')
39 files changed, 1304 insertions, 1224 deletions
diff --git a/source/slang/slang-ast-base.h b/source/slang/slang-ast-base.h index ffa065323..9e99d008f 100644 --- a/source/slang/slang-ast-base.h +++ b/source/slang/slang-ast-base.h @@ -22,7 +22,10 @@ struct ReflectClassInfo; class NodeBase : public RefObject { SLANG_ABSTRACT_CLASS(NodeBase) - + + // By default AST types do *not* store the builder. This is called when constructed tho. + SLANG_FORCE_INLINE void setASTBuilder(ASTBuilder* astBuilder) { SLANG_UNUSED(astBuilder); } + SyntaxClass<NodeBase> getClass() { return SyntaxClass<NodeBase>(&getClassInfo()); } }; @@ -78,14 +81,14 @@ class Val : public NodeBase // construct a new value by applying a set of parameter // substitutions to this one - RefPtr<Val> substitute(SubstitutionSet subst); + RefPtr<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). - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff); + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff); virtual bool equalsVal(Val* val) = 0; virtual String toString() = 0; @@ -124,15 +127,20 @@ class Type: public Val void accept(ITypeVisitor* visitor, void* extra); -public: - Session* getSession() { return this->session; } - void setSession(Session* s) { this->session = s; } + /// Type derived types store the AST builder they were constructed on. The builder calls this function + /// after constructing + SLANG_FORCE_INLINE void setASTBuilder(ASTBuilder* astBuilder) { m_astBuilder = astBuilder; } + + /// Get the ASTBuilder that was used to construct this Type + SLANG_FORCE_INLINE ASTBuilder* getASTBuilder() const { return m_astBuilder; } + //Session* getSession() { return this->session; } + bool equals(Type* type); Type* getCanonicalType(); - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; virtual bool equalsVal(Val* val) override; @@ -145,7 +153,7 @@ protected: Type* canonicalType = nullptr; SLANG_UNREFLECTED - Session* session = nullptr; + ASTBuilder* m_astBuilder = nullptr; }; template <typename T> @@ -159,11 +167,14 @@ class Substitutions: public RefObject { SLANG_ABSTRACT_CLASS(Substitutions) + // By default AST types do *not* store the builder. This is called when constructed tho. + SLANG_FORCE_INLINE void setASTBuilder(ASTBuilder* astBuilder) { SLANG_UNUSED(astBuilder); } + // The next outer that this one refines. RefPtr<Substitutions> outer; // Apply a set of substitutions to the bindings in this substitution - virtual RefPtr<Substitutions> applySubstitutionsShallow(SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) = 0; + virtual RefPtr<Substitutions> applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) = 0; // Check if these are equivalent substitutions to another set virtual bool equals(Substitutions* subst) = 0; @@ -182,7 +193,7 @@ class GenericSubstitution : public Substitutions List<RefPtr<Val> > args; // Apply a set of substitutions to the bindings in this substitution - virtual RefPtr<Substitutions> applySubstitutionsShallow(SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) override; + virtual RefPtr<Substitutions> applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) override; // Check if these are equivalent substitutions to another set virtual bool equals(Substitutions* subst) override; @@ -212,7 +223,7 @@ class ThisTypeSubstitution : public Substitutions // The actual type that provides the lookup scope for an associated type // Apply a set of substitutions to the bindings in this substitution - virtual RefPtr<Substitutions> applySubstitutionsShallow(SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) override; + virtual RefPtr<Substitutions> applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) override; // Check if these are equivalent substitutions to another set virtual bool equals(Substitutions* subst) override; @@ -239,7 +250,7 @@ class GlobalGenericParamSubstitution : public Substitutions List<ConstraintArg> constraintArgs; // Apply a set of substitutions to the bindings in this substitution - virtual RefPtr<Substitutions> applySubstitutionsShallow(SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) override; + virtual RefPtr<Substitutions> applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) override; // Check if these are equivalent substitutions to another set virtual bool equals(Substitutions* subst) override; @@ -361,4 +372,5 @@ class Stmt : public ModifiableSyntaxNode void accept(IStmtVisitor* visitor, void* extra); }; + } // namespace Slang diff --git a/source/slang/slang-ast-builder.cpp b/source/slang/slang-ast-builder.cpp new file mode 100644 index 000000000..7e40e52ec --- /dev/null +++ b/source/slang/slang-ast-builder.cpp @@ -0,0 +1,225 @@ +// slang-ast-builder.cpp +#include "slang-ast-builder.h" +#include <assert.h> + +#include "slang-compiler.h" + +namespace Slang { + +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! SharedASTBuilder !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +SharedASTBuilder::SharedASTBuilder() +{ +} + + +void SharedASTBuilder::init(Session* session) +{ + m_namePool = session->getNamePool(); + + // Save the associated session + m_session = session; + + // We just want as a place to store allocations of shared types + RefPtr<ASTBuilder> astBuilder(new ASTBuilder); + + astBuilder->m_sharedASTBuilder = this; + + memset(m_builtinTypes, 0, sizeof(m_builtinTypes)); + + m_errorType = m_astBuilder->create<ErrorType>(); + m_initializerListType = m_astBuilder->create<InitializerListType>(); + m_overloadedType = m_astBuilder->create<OverloadGroupType>(); + + m_astBuilder = astBuilder.detach(); + + // We can just iterate over the class pointers. + // NOTE! That this adds the names of the abstract classes too(!) + for (Index i = 0; i < Index(ASTNodeType::CountOf); ++i) + { + const ReflectClassInfo* info = ReflectClassInfo::getInfo(ASTNodeType(i)); + if (info) + { + m_sliceToTypeMap.Add(UnownedStringSlice(info->m_name), info); + Name* name = m_namePool->getName(String(info->m_name)); + m_nameToTypeMap.Add(name, info); + } + } +} + +const ReflectClassInfo* SharedASTBuilder::findClassInfo(const UnownedStringSlice& slice) +{ + const ReflectClassInfo* typeInfo; + return m_sliceToTypeMap.TryGetValue(slice, typeInfo) ? typeInfo : nullptr; +} + +SyntaxClass<RefObject> SharedASTBuilder::findSyntaxClass(const UnownedStringSlice& slice) +{ + const ReflectClassInfo* typeInfo; + if (m_sliceToTypeMap.TryGetValue(slice, typeInfo)) + { + return SyntaxClass<RefObject>(typeInfo); + } + return SyntaxClass<RefObject>(); +} + +const ReflectClassInfo* SharedASTBuilder::findClassInfo(Name* name) +{ + const ReflectClassInfo* typeInfo; + return m_nameToTypeMap.TryGetValue(name, typeInfo) ? typeInfo : nullptr; +} + +SyntaxClass<RefObject> SharedASTBuilder::findSyntaxClass(Name* name) +{ + const ReflectClassInfo* typeInfo; + if (m_nameToTypeMap.TryGetValue(name, typeInfo)) + { + return SyntaxClass<RefObject>(typeInfo); + } + return SyntaxClass<RefObject>(); +} + +Type* SharedASTBuilder::getStringType() +{ + if (!m_stringType) + { + auto stringTypeDecl = findMagicDecl("StringType"); + m_stringType = DeclRefType::create(m_astBuilder, makeDeclRef<Decl>(stringTypeDecl)); + } + return m_stringType; +} + +Type* SharedASTBuilder::getEnumTypeType() +{ + if (!m_enumTypeType) + { + auto enumTypeTypeDecl = findMagicDecl("EnumTypeType"); + m_enumTypeType = DeclRefType::create(m_astBuilder, makeDeclRef<Decl>(enumTypeTypeDecl)); + } + return m_enumTypeType; +} + +SharedASTBuilder::~SharedASTBuilder() +{ + // Release built in types.. + for (Index i = 0; i < SLANG_COUNT_OF(m_builtinTypes); ++i) + { + m_builtinTypes[i].setNull(); + } + + if (m_astBuilder) + { + m_astBuilder->releaseReference(); + } +} + +void SharedASTBuilder::registerBuiltinDecl(RefPtr<Decl> decl, RefPtr<BuiltinTypeModifier> modifier) +{ + auto type = DeclRefType::create(m_astBuilder, DeclRef<Decl>(decl.Ptr(), nullptr)); + m_builtinTypes[Index(modifier->tag)] = type; +} + +void SharedASTBuilder::registerMagicDecl(RefPtr<Decl> decl, RefPtr<MagicTypeModifier> modifier) +{ + // In some cases the modifier will have been applied to the + // "inner" declaration of a `GenericDecl`, but what we + // actually want to register is the generic itself. + // + auto declToRegister = decl; + if (auto genericDecl = as<GenericDecl>(decl->parentDecl)) + declToRegister = genericDecl; + + m_magicDecls[modifier->name] = declToRegister.Ptr(); +} + +RefPtr<Decl> SharedASTBuilder::findMagicDecl(const String& name) +{ + return m_magicDecls[name].GetValue(); +} + +// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ASTBuilder !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +ASTBuilder::ASTBuilder(SharedASTBuilder* sharedASTBuilder): + m_sharedASTBuilder(sharedASTBuilder) +{ + SLANG_ASSERT(sharedASTBuilder); +} + +ASTBuilder::ASTBuilder(): + m_sharedASTBuilder(nullptr) +{ +} + +RefPtr<PtrType> ASTBuilder::getPtrType( RefPtr<Type> valueType) +{ + return getPtrType(valueType, "PtrType").dynamicCast<PtrType>(); +} + +// Construct the type `Out<valueType>` +RefPtr<OutType> ASTBuilder::getOutType(RefPtr<Type> valueType) +{ + return getPtrType(valueType, "OutType").dynamicCast<OutType>(); +} + +RefPtr<InOutType> ASTBuilder::getInOutType(RefPtr<Type> valueType) +{ + return getPtrType(valueType, "InOutType").dynamicCast<InOutType>(); +} + +RefPtr<RefType> ASTBuilder::getRefType(RefPtr<Type> valueType) +{ + return getPtrType(valueType, "RefType").dynamicCast<RefType>(); +} + +RefPtr<PtrTypeBase> ASTBuilder::getPtrType(RefPtr<Type> valueType, char const* ptrTypeName) +{ + auto genericDecl = m_sharedASTBuilder->findMagicDecl(ptrTypeName).dynamicCast<GenericDecl>(); + return getPtrType(valueType, genericDecl); +} + +RefPtr<PtrTypeBase> ASTBuilder::getPtrType(RefPtr<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 rsType = DeclRefType::create(this, declRef); + return as<PtrTypeBase>(rsType); +} + +RefPtr<ArrayExpressionType> ASTBuilder::getArrayType(Type* elementType, IntVal* elementCount) +{ + RefPtr<ArrayExpressionType> arrayType = create<ArrayExpressionType>(); + arrayType->baseType = elementType; + arrayType->arrayLength = elementCount; + return arrayType; +} + +RefPtr<VectorExpressionType> ASTBuilder::getVectorType( + RefPtr<Type> elementType, + RefPtr<IntVal> elementCount) +{ + auto vectorGenericDecl = m_sharedASTBuilder->findMagicDecl("Vector").as<GenericDecl>(); + + auto vectorTypeDecl = vectorGenericDecl->inner; + + auto substitutions = new GenericSubstitution(); + substitutions->genericDecl = vectorGenericDecl.Ptr(); + substitutions->args.add(elementType); + substitutions->args.add(elementCount); + + auto declRef = DeclRef<Decl>(vectorTypeDecl.Ptr(), substitutions); + + return DeclRefType::create(this, declRef).as<VectorExpressionType>(); +} + +RefPtr<TypeType> ASTBuilder::getTypeType(Type* type) +{ + return create<TypeType>(type); +} + + +} // namespace Slang diff --git a/source/slang/slang-ast-builder.h b/source/slang/slang-ast-builder.h new file mode 100644 index 000000000..0cb853424 --- /dev/null +++ b/source/slang/slang-ast-builder.h @@ -0,0 +1,174 @@ +// slang-ast-dump.h +#ifndef SLANG_AST_BUILDER_H +#define SLANG_AST_BUILDER_H + +#include "slang-ast-support-types.h" +#include "slang-ast-all.h" + +#include "../core/slang-type-traits.h" + +namespace Slang +{ + +class SharedASTBuilder : public RefObject +{ + friend class ASTBuilder; +public: + + void registerBuiltinDecl(RefPtr<Decl> decl, RefPtr<BuiltinTypeModifier> modifier); + void registerMagicDecl(RefPtr<Decl> decl, RefPtr<MagicTypeModifier> modifier); + + /// Get the string type + Type* getStringType(); + /// Get the enum type type + Type* getEnumTypeType(); + + const ReflectClassInfo* findClassInfo(Name* name); + SyntaxClass<RefObject> findSyntaxClass(Name* name); + + const ReflectClassInfo* findClassInfo(const UnownedStringSlice& slice); + SyntaxClass<RefObject> findSyntaxClass(const UnownedStringSlice& slice); + + // Look up a magic declaration by its name + RefPtr<Decl> findMagicDecl(String const& name); + + /// A name pool that can be used for lookup for findClassInfo etc. It is the same pool as the Session. + NamePool* getNamePool() { return m_namePool; } + + /// Must be called before used + void init(Session* session); + + SharedASTBuilder(); + + ~SharedASTBuilder(); + +protected: + // State shared between ASTBuilders + + RefPtr<Type> m_errorType; + RefPtr<Type> m_initializerListType; + RefPtr<Type> m_overloadedType; + + // The following types are created lazily, such that part of their definition + // can be in the standard library + // + // Note(tfoley): These logically belong to `Type`, + // but order-of-declaration stuff makes that tricky + // + // TODO(tfoley): These should really belong to the compilation context! + // + RefPtr<Type> m_stringType; + RefPtr<Type> m_enumTypeType; + + RefPtr<Type> m_builtinTypes[Index(BaseType::CountOf)]; + + Dictionary<String, Decl*> m_magicDecls; + + Dictionary<UnownedStringSlice, const ReflectClassInfo*> m_sliceToTypeMap; + Dictionary<Name*, const ReflectClassInfo*> m_nameToTypeMap; + + NamePool* m_namePool = nullptr; + + // This is a private builder used for these shared types + ASTBuilder* m_astBuilder = nullptr; + Session* m_session = nullptr; +}; + +class ASTBuilder : public RefObject +{ + friend class SharedASTBuilder; +public: + + // For compile time check to see if thing being constructed is an AST type + template <typename T> + struct IsValidType + { + enum + { + Value = IsBaseOf<NodeBase, T>::Value || IsBaseOf<Substitutions, T>::Value + }; + }; + + /// Create AST type. + template <typename T> + T* create() { SLANG_COMPILE_TIME_ASSERT(IsValidType<T>::Value); T* node = new T; node->setASTBuilder(this); return node; } + + template<typename T, typename P0> + T* create(const P0& p0) { SLANG_COMPILE_TIME_ASSERT(IsValidType<T>::Value); T* node = new T(p0); node->setASTBuilder(this); return node;} + + template<typename T, typename P0, typename P1> + T* create(const P0& p0, const P1& p1) { SLANG_COMPILE_TIME_ASSERT(IsValidType<T>::Value); T* node = new T(p0, p1); node->setASTBuilder(this); return node; } + + /// Get the built in types + SLANG_FORCE_INLINE Type* getBoolType() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::Bool)]; } + SLANG_FORCE_INLINE Type* getHalfType() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::Half)]; } + SLANG_FORCE_INLINE Type* getFloatType() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::Float)]; } + SLANG_FORCE_INLINE Type* getDoubleType() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::Double)]; } + SLANG_FORCE_INLINE Type* getIntType() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::Int)]; } + SLANG_FORCE_INLINE Type* getInt64Type() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::Int64)]; } + SLANG_FORCE_INLINE Type* getUIntType() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::UInt)]; } + SLANG_FORCE_INLINE Type* getUInt64Type() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::UInt64)]; } + SLANG_FORCE_INLINE Type* getVoidType() { return m_sharedASTBuilder->m_builtinTypes[Index(BaseType::Void)]; } + + /// Get a builtin type by the BaseType + SLANG_FORCE_INLINE Type* getBuiltinType(BaseType flavor) { return m_sharedASTBuilder->m_builtinTypes[Index(flavor)]; } + + Type* getInitializerListType() { return m_sharedASTBuilder->m_initializerListType; } + Type* getOverloadedType() { return m_sharedASTBuilder->m_overloadedType; } + Type* getErrorType() { return m_sharedASTBuilder->m_errorType; } + Type* getStringType() { return m_sharedASTBuilder->getStringType(); } + Type* getEnumTypeType() { return m_sharedASTBuilder->getEnumTypeType(); } + + // Construct the type `Ptr<valueType>`, where `Ptr` + // is looked up as a builtin type. + RefPtr<PtrType> getPtrType(RefPtr<Type> valueType); + + // Construct the type `Out<valueType>` + RefPtr<OutType> getOutType(RefPtr<Type> valueType); + + // Construct the type `InOut<valueType>` + RefPtr<InOutType> getInOutType(RefPtr<Type> valueType); + + // Construct the type `Ref<valueType>` + RefPtr<RefType> getRefType(RefPtr<Type> valueType); + + // Construct a pointer type like `Ptr<valueType>`, but where + // the actual type name for the pointer type is given by `ptrTypeName` + RefPtr<PtrTypeBase> getPtrType(RefPtr<Type> valueType, char const* ptrTypeName); + + // Construct a pointer type like `Ptr<valueType>`, but where + // the generic declaration for the pointer type is `genericDecl` + RefPtr<PtrTypeBase> getPtrType(RefPtr<Type> valueType, GenericDecl* genericDecl); + + RefPtr<ArrayExpressionType> getArrayType(Type* elementType, IntVal* elementCount); + + RefPtr<VectorExpressionType> getVectorType(RefPtr<Type> elementType, RefPtr<IntVal> elementCount); + + RefPtr<TypeType> getTypeType(Type* type); + + /// Helpers to get type info from the SharedASTBuilder + const ReflectClassInfo* findClassInfo(const UnownedStringSlice& slice) { return m_sharedASTBuilder->findClassInfo(slice); } + SyntaxClass<RefObject> findSyntaxClass(const UnownedStringSlice& slice) { return m_sharedASTBuilder->findSyntaxClass(slice); } + + const ReflectClassInfo* findClassInfo(Name* name) { return m_sharedASTBuilder->findClassInfo(name); } + SyntaxClass<RefObject> findSyntaxClass(Name* name) { return m_sharedASTBuilder->findSyntaxClass(name); } + + /// Get the shared AST builder + SharedASTBuilder* getSharedASTBuilder() { return m_sharedASTBuilder; } + + /// Get the global session + Session* getGlobalSession() { return m_sharedASTBuilder->m_session; } + + /// Ctor + ASTBuilder(SharedASTBuilder* sharedASTBuilder); + +protected: + // Special default Ctor that can only be used by SharedASTBuilder + ASTBuilder(); + + SharedASTBuilder* m_sharedASTBuilder; +}; + +} // namespace Slang + +#endif diff --git a/source/slang/slang-ast-reflect.cpp b/source/slang/slang-ast-reflect.cpp index eb511689d..7efccd3e4 100644 --- a/source/slang/slang-ast-reflect.cpp +++ b/source/slang/slang-ast-reflect.cpp @@ -44,11 +44,13 @@ bool ReflectClassInfo::isSubClassOfSlow(const ThisType& super) const // Now try and implement all of the classes // Macro generated is of the format - -template <typename T> -struct CreateImpl +struct ASTConstructAccess { - static void* create() { return new T; } + template <typename T> + struct CreateImpl + { + static void* create() { return new T; } + }; }; #define SLANG_GET_SUPER_BASE(SUPER) nullptr @@ -56,10 +58,10 @@ struct CreateImpl #define SLANG_GET_SUPER_LEAF(SUPER) &SUPER::kReflectClassInfo #define SLANG_GET_CREATE_FUNC_ABSTRACT(NAME) nullptr -#define SLANG_GET_CREATE_FUNC_NONE(NAME) &CreateImpl<NAME>::create +#define SLANG_GET_CREATE_FUNC_NONE(NAME) &ASTConstructAccess::CreateImpl<NAME>::create #define SLANG_GET_CREATE_FUNC_NON_VISITOR_ABSTRACT(NAME) nullptr -#define SLANG_GET_CREATE_FUNC_NON_VISITOR(NAME) &CreateImpl<NAME>::create +#define SLANG_GET_CREATE_FUNC_NON_VISITOR(NAME) &ASTConstructAccess::CreateImpl<NAME>::create #define SLANG_REFLECT_CLASS_INFO(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \ diff --git a/source/slang/slang-ast-reflect.h b/source/slang/slang-ast-reflect.h index 5384e4afd..a5875d34a 100644 --- a/source/slang/slang-ast-reflect.h +++ b/source/slang/slang-ast-reflect.h @@ -12,12 +12,17 @@ // Implementation for SLANG_ABSTRACT_CLASS(x) using reflection from C++ extractor in slang-ast-generated.h #define SLANG_CLASS_REFLECT_IMPL(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \ + protected: \ + NAME() = default; \ public: \ + typedef NAME This; \ typedef SUPER Super; \ static const ASTNodeType kType = ASTNodeType::NAME; \ static const ReflectClassInfo kReflectClassInfo; \ SLANG_FORCE_INLINE static bool isDerivedFrom(ASTNodeType type) { return int(type) >= int(kType) && int(type) <= int(ASTNodeType::LAST); } \ virtual const ReflectClassInfo& getClassInfo() const SLANG_AST_OVERRIDE_##TYPE { return kReflectClassInfo; } \ + friend class ASTBuilder; \ + friend struct ASTConstructAccess; // Macro definitions - use the SLANG_ASTNode_ definitions to invoke the IMPL to produce the code // injected into AST classes diff --git a/source/slang/slang-ast-stmt.h b/source/slang/slang-ast-stmt.h index 946106e78..9f7f8aa4d 100644 --- a/source/slang/slang-ast-stmt.h +++ b/source/slang/slang-ast-stmt.h @@ -177,7 +177,6 @@ class CompileTimeForStmt : public ScopeStmt class JumpStmt : public ChildStmt { SLANG_ABSTRACT_CLASS(JumpStmt) - }; class BreakStmt : public JumpStmt diff --git a/source/slang/slang-ast-support-types.h b/source/slang/slang-ast-support-types.h index af5689a5c..5cb7f3202 100644 --- a/source/slang/slang-ast-support-types.h +++ b/source/slang/slang-ast-support-types.h @@ -610,6 +610,8 @@ namespace Slang HashCode getHashCode() const; }; + class ASTBuilder; + template<typename T> struct DeclRef; @@ -644,15 +646,15 @@ namespace Slang {} // Apply substitutions to a type or declaration - RefPtr<Type> Substitute(RefPtr<Type> type) const; + RefPtr<Type> substitute(ASTBuilder* astBuilder, RefPtr<Type> type) const; - DeclRefBase Substitute(DeclRefBase declRef) const; + DeclRefBase substitute(ASTBuilder* astBuilder, DeclRefBase declRef) const; // Apply substitutions to an expression - RefPtr<Expr> Substitute(RefPtr<Expr> expr) const; + RefPtr<Expr> substitute(ASTBuilder* astBuilder, RefPtr<Expr> expr) const; // Apply substitutions to this declaration reference - DeclRefBase SubstituteImpl(SubstitutionSet subst, int* ioDiff); + DeclRefBase substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff); // Returns true if 'as' will return a valid cast template <typename T> @@ -719,26 +721,26 @@ namespace Slang return DeclRef<T>((T*) declRef.decl, declRef.substitutions); } - RefPtr<Type> Substitute(RefPtr<Type> type) const + RefPtr<Type> substitute(ASTBuilder* astBuilder, RefPtr<Type> type) const { - return DeclRefBase::Substitute(type); + return DeclRefBase::substitute(astBuilder, type); } - RefPtr<Expr> Substitute(RefPtr<Expr> expr) const + RefPtr<Expr> substitute(ASTBuilder* astBuilder, RefPtr<Expr> expr) const { - return DeclRefBase::Substitute(expr); + return DeclRefBase::substitute(astBuilder, expr); } // Apply substitutions to a type or declaration template<typename U> - DeclRef<U> Substitute(DeclRef<U> declRef) const + DeclRef<U> substitute(ASTBuilder* astBuilder, DeclRef<U> declRef) const { - return DeclRef<U>::unsafeInit(DeclRefBase::Substitute(declRef)); + return DeclRef<U>::unsafeInit(DeclRefBase::substitute(astBuilder, declRef)); } // Apply substitutions to this declaration reference - DeclRef<T> SubstituteImpl(SubstitutionSet subst, int* ioDiff) + DeclRef<T> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { - return DeclRef<T>::unsafeInit(DeclRefBase::SubstituteImpl(subst, ioDiff)); + return DeclRef<T>::unsafeInit(DeclRefBase::substituteImpl(astBuilder, subst, ioDiff)); } DeclRef<ContainerDecl> GetParent() const @@ -1284,7 +1286,7 @@ namespace Slang RefPtr<WitnessTable> getWitnessTable(); - RequirementWitness specialize(SubstitutionSet const& subst); + RequirementWitness specialize(ASTBuilder* astBuilder, SubstitutionSet const& subst); Flavor m_flavor; DeclRef<Decl> m_declRef; diff --git a/source/slang/slang-ast-type.h b/source/slang/slang-ast-type.h index a1ed29b8a..68935108c 100644 --- a/source/slang/slang-ast-type.h +++ b/source/slang/slang-ast-type.h @@ -13,12 +13,11 @@ class OverloadGroupType : public Type { SLANG_CLASS(OverloadGroupType) -public: virtual String toString() override; protected: - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; }; @@ -31,8 +30,8 @@ class InitializerListType : public Type virtual String toString() override; protected: - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; }; @@ -41,13 +40,12 @@ class ErrorType : public Type { SLANG_CLASS(ErrorType) -public: virtual String toString() override; protected: - virtual bool equalsImpl(Type * type) override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; virtual RefPtr<Type> createCanonicalType() override; + virtual bool equalsImpl(Type* type) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; virtual HashCode getHashCode() override; }; @@ -59,22 +57,18 @@ class DeclRefType : public Type DeclRef<Decl> declRef; virtual String toString() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; - static RefPtr<DeclRefType> Create( - Session* session, - DeclRef<Decl> declRef); + static RefPtr<DeclRefType> create(ASTBuilder* astBuilder, DeclRef<Decl> declRef); - DeclRefType() - {} - DeclRefType( - DeclRef<Decl> declRef) +protected: + DeclRefType( DeclRef<Decl> declRef) : declRef(declRef) {} -protected: + virtual HashCode getHashCode() override; - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; + virtual bool equalsImpl(Type* type) override; }; // Base class for types that can be used in arithmetic expressions @@ -90,18 +84,17 @@ class BasicExpressionType : public ArithmeticExpressionType { SLANG_CLASS(BasicExpressionType) - BaseType baseType; - BasicExpressionType() {} +protected: BasicExpressionType( Slang::BaseType baseType) : baseType(baseType) {} -protected: + virtual BasicExpressionType* GetScalarType() override; - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; + virtual bool equalsImpl(Type* type) override; }; @@ -111,7 +104,6 @@ protected: class BuiltinType : public DeclRefType { SLANG_ABSTRACT_CLASS(BuiltinType) - }; // Resources that contain "elements" that can be fetched @@ -139,14 +131,11 @@ class TextureTypeBase : public ResourceType { SLANG_ABSTRACT_CLASS(TextureTypeBase) - TextureTypeBase() - {} - TextureTypeBase( - TextureFlavor flavor, - RefPtr<Type> elementType) +protected: + TextureTypeBase(TextureFlavor inFlavor, RefPtr<Type> inElementType) { - this->elementType = elementType; - this->flavor = flavor; + elementType = inElementType; + flavor = inFlavor; } }; @@ -154,11 +143,8 @@ class TextureType : public TextureTypeBase { SLANG_CLASS(TextureType) - TextureType() - {} - TextureType( - TextureFlavor flavor, - RefPtr<Type> elementType) +protected: + TextureType(TextureFlavor flavor, RefPtr<Type> elementType) : TextureTypeBase(flavor, elementType) {} }; @@ -169,11 +155,8 @@ class TextureSamplerType : public TextureTypeBase { SLANG_CLASS(TextureSamplerType) - TextureSamplerType() - {} - TextureSamplerType( - TextureFlavor flavor, - RefPtr<Type> elementType) +protected: + TextureSamplerType(TextureFlavor flavor, RefPtr<Type> elementType) : TextureTypeBase(flavor, elementType) {} }; @@ -183,8 +166,7 @@ class GLSLImageType : public TextureTypeBase { SLANG_CLASS(GLSLImageType) - GLSLImageType() - {} +protected: GLSLImageType( TextureFlavor flavor, RefPtr<Type> elementType) @@ -396,9 +378,9 @@ class ArrayExpressionType : public Type virtual String toString() override; protected: - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual bool equalsImpl(Type* type) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; virtual HashCode getHashCode() override; }; @@ -412,18 +394,15 @@ class TypeType : public Type // The type that this is the type of... RefPtr<Type> type; -public: - TypeType() - {} + virtual String toString() override; + +protected: TypeType(RefPtr<Type> type) : type(type) {} - virtual String toString() override; - -protected: - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; }; @@ -527,20 +506,18 @@ class NamedExpressionType : public Type SLANG_CLASS(NamedExpressionType) DeclRef<TypeDefDecl> declRef; - RefPtr<Type> innerType; - NamedExpressionType() - {} + + virtual String toString() override; + +protected: NamedExpressionType( DeclRef<TypeDefDecl> declRef) : declRef(declRef) {} - virtual String toString() override; - -protected: - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; }; @@ -559,18 +536,16 @@ class FuncType : public Type List<RefPtr<Type>> paramTypes; RefPtr<Type> resultType; - FuncType() - {} - UInt getParamCount() { return paramTypes.getCount(); } Type* getParamType(UInt index) { return paramTypes[index]; } Type* getResultType() { return resultType; } virtual String toString() override; + protected: - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; - virtual bool equalsImpl(Type * type) override; virtual RefPtr<Type> createCanonicalType() override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; }; @@ -581,19 +556,17 @@ class GenericDeclRefType : public Type DeclRef<GenericDecl> declRef; - GenericDeclRefType() - {} - GenericDeclRefType( - DeclRef<GenericDecl> declRef) - : declRef(declRef) - {} - DeclRef<GenericDecl> const& getDeclRef() const { return declRef; } virtual String toString() override; protected: - virtual bool equalsImpl(Type * type) override; + GenericDeclRefType( + DeclRef<GenericDecl> declRef) + : declRef(declRef) + {} + + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; virtual RefPtr<Type> createCanonicalType() override; }; @@ -605,15 +578,12 @@ class NamespaceType : public Type DeclRef<NamespaceDeclBase> declRef; - NamespaceType() - {} - DeclRef<NamespaceDeclBase> const& getDeclRef() const { return declRef; } virtual String toString() override; protected: - virtual bool equalsImpl(Type * type) override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; virtual RefPtr<Type> createCanonicalType() override; }; @@ -627,10 +597,10 @@ class ExtractExistentialType : public Type DeclRef<VarDeclBase> declRef; virtual String toString() override; - virtual bool equalsImpl(Type * type) override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; virtual RefPtr<Type> createCanonicalType() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; /// A tagged union of zero or more other types. @@ -646,10 +616,10 @@ class TaggedUnionType : public Type List<RefPtr<Type>> caseTypes; virtual String toString() override; - virtual bool equalsImpl(Type * type) override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; virtual RefPtr<Type> createCanonicalType() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; class ExistentialSpecializedType : public Type @@ -660,10 +630,10 @@ class ExistentialSpecializedType : public Type ExpandedSpecializationArgs args; virtual String toString() override; - virtual bool equalsImpl(Type * type) override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; virtual RefPtr<Type> createCanonicalType() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; /// The type of `this` within a polymorphic declaration @@ -674,11 +644,10 @@ class ThisType : public Type DeclRef<InterfaceDecl> interfaceDeclRef; virtual String toString() override; - virtual bool equalsImpl(Type * type) override; + virtual bool equalsImpl(Type* type) override; virtual HashCode getHashCode() override; virtual RefPtr<Type> createCanonicalType() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; - + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; } // namespace Slang diff --git a/source/slang/slang-ast-val.h b/source/slang/slang-ast-val.h index a6425e060..5345a389f 100644 --- a/source/slang/slang-ast-val.h +++ b/source/slang/slang-ast-val.h @@ -21,10 +21,9 @@ class ConstantIntVal : public IntVal IntegerLiteralValue value; - ConstantIntVal() - {} - ConstantIntVal(IntegerLiteralValue value) - : value(value) +protected: + ConstantIntVal(IntegerLiteralValue inValue) + : value(inValue) {} virtual bool equalsVal(Val* val) override; @@ -32,23 +31,22 @@ class ConstantIntVal : public IntVal virtual HashCode getHashCode() override; }; -// The logical "value" of a rererence to a generic value parameter +// The logical "value" of a reference to a generic value parameter class GenericParamIntVal : public IntVal { SLANG_CLASS(GenericParamIntVal) DeclRef<VarDeclBase> declRef; - GenericParamIntVal() - {} - GenericParamIntVal(DeclRef<VarDeclBase> declRef) - : declRef(declRef) +protected: + GenericParamIntVal(DeclRef<VarDeclBase> inDeclRef) + : declRef(inDeclRef) {} virtual bool equalsVal(Val* val) override; virtual String toString() override; virtual HashCode getHashCode() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; /// An unknown integer value indicating an erroneous sub-expression @@ -60,13 +58,10 @@ class ErrorIntVal : public IntVal // and have all `Val`s that represent ordinary values hold their // `Type` so that we can have an `ErrorVal` of any type. - ErrorIntVal() - {} - virtual bool equalsVal(Val* val) override; virtual String toString() override; virtual HashCode getHashCode() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int* ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; // A witness to the fact that some proposition is true, encoded @@ -124,11 +119,10 @@ class TypeEqualityWitness : public SubtypeWitness { SLANG_CLASS(TypeEqualityWitness) - virtual bool equalsVal(Val* val) override; virtual String toString() override; virtual HashCode getHashCode() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int * ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; // A witness that one type is a subtype of another @@ -142,7 +136,7 @@ class DeclaredSubtypeWitness : public SubtypeWitness virtual bool equalsVal(Val* val) override; virtual String toString() override; virtual HashCode getHashCode() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int * ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; // A witness that `sub : sup` because `sub : mid` and `mid : sup` @@ -159,7 +153,7 @@ class TransitiveSubtypeWitness : public SubtypeWitness virtual bool equalsVal(Val* val) override; virtual String toString() override; virtual HashCode getHashCode() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int * ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; // A witness taht `sub : sup` because `sub` was wrapped into @@ -174,7 +168,7 @@ class ExtractExistentialSubtypeWitness : public SubtypeWitness virtual bool equalsVal(Val* val) override; virtual String toString() override; virtual HashCode getHashCode() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int * ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; // A witness that `sub : sup`, because `sub` is a tagged union @@ -193,7 +187,7 @@ class TaggedUnionSubtypeWitness : public SubtypeWitness virtual bool equalsVal(Val* val) override; virtual String toString() override; virtual HashCode getHashCode() override; - virtual RefPtr<Val> substituteImpl(SubstitutionSet subst, int * ioDiff) override; + virtual RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) override; }; } // namespace Slang diff --git a/source/slang/slang-check-conformance.cpp b/source/slang/slang-check-conformance.cpp index 639716ee5..4a149c10f 100644 --- a/source/slang/slang-check-conformance.cpp +++ b/source/slang/slang-check-conformance.cpp @@ -10,7 +10,7 @@ namespace Slang RefPtr<DeclaredSubtypeWitness> SemanticsVisitor::createSimpleSubtypeWitness( TypeWitnessBreadcrumb* breadcrumb) { - RefPtr<DeclaredSubtypeWitness> witness = new DeclaredSubtypeWitness(); + RefPtr<DeclaredSubtypeWitness> witness = m_astBuilder->create<DeclaredSubtypeWitness>(); witness->sub = breadcrumb->sub; witness->sup = breadcrumb->sup; witness->declRef = breadcrumb->declRef; @@ -79,7 +79,7 @@ namespace Slang // where `[...]` represents the "hole" we leave // open to fill in next. // - RefPtr<TransitiveSubtypeWitness> transitiveWitness = new TransitiveSubtypeWitness(); + RefPtr<TransitiveSubtypeWitness> transitiveWitness = m_astBuilder->create<TransitiveSubtypeWitness>(); transitiveWitness->sub = bb->sub; transitiveWitness->sup = bb->sup; transitiveWitness->midToSup = bb->declRef; @@ -190,7 +190,7 @@ namespace Slang // loops better). This would also help avoid checking multiply-inherited // conformances multiple times. - auto inheritedType = getBaseType(inheritanceDeclRef); + auto inheritedType = getBaseType(m_astBuilder, inheritanceDeclRef); // We need to ensure that the witness that gets created // is a composite one, reflecting lookup through @@ -211,7 +211,7 @@ namespace Slang for (auto genConstraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(aggTypeDeclRef)) { ensureDecl(genConstraintDeclRef, DeclCheckState::CanUseBaseOfInheritanceDecl); - auto inheritedType = GetSup(genConstraintDeclRef); + auto inheritedType = GetSup(m_astBuilder, genConstraintDeclRef); TypeWitnessBreadcrumb breadcrumb; breadcrumb.prev = inBreadcrumbs; breadcrumb.sub = type; @@ -233,8 +233,8 @@ namespace Slang for( auto constraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(genericDeclRef) ) { - auto sub = GetSub(constraintDeclRef); - auto sup = GetSup(constraintDeclRef); + auto sub = GetSub(m_astBuilder, constraintDeclRef); + auto sup = GetSup(m_astBuilder, constraintDeclRef); auto subDeclRef = as<DeclRefType>(sub); if(!subDeclRef) @@ -313,9 +313,9 @@ namespace Slang // if(outWitness) { - RefPtr<TaggedUnionSubtypeWitness> taggedUnionWitness = new TaggedUnionSubtypeWitness(); + RefPtr<TaggedUnionSubtypeWitness> taggedUnionWitness = m_astBuilder->create<TaggedUnionSubtypeWitness>(); taggedUnionWitness->sub = taggedUnionType; - taggedUnionWitness->sup = DeclRefType::Create(getSession(), interfaceDeclRef); + taggedUnionWitness->sup = DeclRefType::create(m_astBuilder, interfaceDeclRef); taggedUnionWitness->caseWitnesses.swapWith(caseWitnesses); *outWitness = taggedUnionWitness; @@ -346,7 +346,7 @@ namespace Slang RefPtr<Val> SemanticsVisitor::createTypeEqualityWitness( Type* type) { - RefPtr<TypeEqualityWitness> rs = new TypeEqualityWitness(); + RefPtr<TypeEqualityWitness> rs = m_astBuilder->create<TypeEqualityWitness>(); rs->sub = type; rs->sup = type; return rs; diff --git a/source/slang/slang-check-constraint.cpp b/source/slang/slang-check-constraint.cpp index a5a5620ae..315f9c5b1 100644 --- a/source/slang/slang-check-constraint.cpp +++ b/source/slang/slang-check-constraint.cpp @@ -114,7 +114,7 @@ namespace Slang continue; // Look up the type in our session. - auto candidateType = type->getSession()->getBuiltinType(BaseType(baseTypeFlavorIndex)); + auto candidateType = type->getASTBuilder()->getBuiltinType(BaseType(baseTypeFlavorIndex)); if(!candidateType) continue; @@ -286,7 +286,7 @@ namespace Slang // that `X<T>.IndexType == T`. for( auto constraintDeclRef : getMembersOfType<GenericTypeConstraintDecl>(genericDeclRef) ) { - if(!TryUnifyTypes(*system, GetSub(constraintDeclRef), GetSup(constraintDeclRef))) + if(!TryUnifyTypes(*system, GetSub(m_astBuilder, constraintDeclRef), GetSup(m_astBuilder, constraintDeclRef))) return SubstitutionSet(); } SubstitutionSet resultSubst = genericDeclRef.substitutions; @@ -391,7 +391,7 @@ namespace Slang // search for a conformance `Robin : ISidekick`, which involved // apply the substitutions we already know... - RefPtr<GenericSubstitution> solvedSubst = new GenericSubstitution(); + RefPtr<GenericSubstitution> solvedSubst = m_astBuilder->create<GenericSubstitution>(); solvedSubst->genericDecl = genericDeclRef.getDecl(); solvedSubst->outer = genericDeclRef.substitutions.substitutions; solvedSubst->args = args; @@ -404,8 +404,8 @@ namespace Slang solvedSubst); // Extract the (substituted) sub- and super-type from the constraint. - auto sub = GetSub(constraintDeclRef); - auto sup = GetSup(constraintDeclRef); + auto sub = GetSub(m_astBuilder, constraintDeclRef); + auto sup = GetSup(m_astBuilder, constraintDeclRef); // Search for a witness that shows the constraint is satisfied. auto subTypeWitness = tryGetSubtypeWitness(sub, sup); diff --git a/source/slang/slang-check-conversion.cpp b/source/slang/slang-check-conversion.cpp index e514caebf..dfcf7ece2 100644 --- a/source/slang/slang-check-conversion.cpp +++ b/source/slang/slang-check-conversion.cpp @@ -310,9 +310,8 @@ namespace Slang // We have a new type for the conversion, based on what // we learned. - toType = getSession()->getArrayType( - toElementType, - new ConstantIntVal(elementCount)); + toType = m_astBuilder->getArrayType(toElementType, + m_astBuilder->create<ConstantIntVal>(elementCount)); } } else if(auto toMatrixType = as<MatrixExpressionType>(toType)) @@ -383,7 +382,7 @@ namespace Slang { RefPtr<Expr> coercedArg; bool argResult = _readValueFromInitializerList( - GetType(fieldDeclRef), + GetType(m_astBuilder, fieldDeclRef), outToExpr ? &coercedArg : nullptr, fromInitializerListExpr, ioArgIndex); @@ -418,7 +417,7 @@ namespace Slang // if(outToExpr) { - auto toInitializerListExpr = new InitializerListExpr(); + auto toInitializerListExpr = m_astBuilder->create<InitializerListExpr>(); toInitializerListExpr->loc = fromInitializerListExpr->loc; toInitializerListExpr->type = QualType(toType); toInitializerListExpr->args = coercedArgs; @@ -575,7 +574,7 @@ namespace Slang RefPtr<DerefExpr> derefExpr; if(outToExpr) { - derefExpr = new DerefExpr(); + derefExpr = m_astBuilder->create<DerefExpr>(); derefExpr->base = fromExpr; derefExpr->type = QualType(fromElementType); } @@ -814,7 +813,7 @@ namespace Slang RefPtr<TypeCastExpr> SemanticsVisitor::createImplicitCastExpr() { - return new ImplicitCastExpr(); + return m_astBuilder->create<ImplicitCastExpr>(); } RefPtr<Expr> SemanticsVisitor::CreateImplicitCastExpr( @@ -823,9 +822,9 @@ namespace Slang { RefPtr<TypeCastExpr> castExpr = createImplicitCastExpr(); - auto typeType = getTypeType(toType); + auto typeType = m_astBuilder->getTypeType(toType); - auto typeExpr = new SharedTypeExpr(); + auto typeExpr = m_astBuilder->create<SharedTypeExpr>(); typeExpr->type.type = typeType; typeExpr->base.type = toType; @@ -841,7 +840,7 @@ namespace Slang RefPtr<Expr> fromExpr, RefPtr<Val> witness) { - RefPtr<CastToInterfaceExpr> expr = new CastToInterfaceExpr(); + RefPtr<CastToInterfaceExpr> expr = m_astBuilder->create<CastToInterfaceExpr>(); expr->loc = fromExpr->loc; expr->type = QualType(toType); expr->valueArg = fromExpr; @@ -866,7 +865,7 @@ namespace Slang // really shouldn't *change* the expression that is passed in, but should // introduce new AST nodes to coerce its value to a different type... return CreateImplicitCastExpr( - getSession()->getErrorType(), + m_astBuilder->getErrorType(), fromExpr); } return expr; diff --git a/source/slang/slang-check-decl.cpp b/source/slang/slang-check-decl.cpp index b69b3ad7d..b08baa42f 100644 --- a/source/slang/slang-check-decl.cpp +++ b/source/slang/slang-check-decl.cpp @@ -272,7 +272,7 @@ namespace Slang // Get the type to use when referencing a declaration QualType getTypeForDeclRef( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* sema, DiagnosticSink* sink, DeclRef<Decl> declRef, @@ -304,7 +304,7 @@ namespace Slang if(_isLocalVar(varDecl)) { sema->getSink()->diagnose(varDecl, Diagnostics::localVariableUsedBeforeDeclared, varDecl); - return QualType(session->getErrorType()); + return QualType(astBuilder->getErrorType()); } } } @@ -322,7 +322,7 @@ namespace Slang if (auto varDeclRef = declRef.as<VarDeclBase>()) { QualType qualType; - qualType.type = GetType(varDeclRef); + qualType.type = GetType(astBuilder, varDeclRef); bool isLValue = true; if(varDeclRef.getDecl()->findModifier<ConstModifier>()) @@ -368,37 +368,37 @@ namespace Slang else if( auto enumCaseDeclRef = declRef.as<EnumCaseDecl>() ) { QualType qualType; - qualType.type = getType(enumCaseDeclRef); + qualType.type = getType(astBuilder, enumCaseDeclRef); qualType.IsLeftValue = false; return qualType; } else if (auto typeAliasDeclRef = declRef.as<TypeDefDecl>()) { - auto type = getNamedType(session, typeAliasDeclRef); + auto type = getNamedType(astBuilder, typeAliasDeclRef); *outTypeResult = type; - return QualType(getTypeType(type)); + return QualType(astBuilder->getTypeType(type)); } else if (auto aggTypeDeclRef = declRef.as<AggTypeDecl>()) { - auto type = DeclRefType::Create(session, aggTypeDeclRef); + auto type = DeclRefType::create(astBuilder, aggTypeDeclRef); *outTypeResult = type; - return QualType(getTypeType(type)); + return QualType(astBuilder->getTypeType(type)); } else if (auto simpleTypeDeclRef = declRef.as<SimpleTypeDecl>()) { - auto type = DeclRefType::Create(session, simpleTypeDeclRef); + auto type = DeclRefType::create(astBuilder, simpleTypeDeclRef); *outTypeResult = type; - return QualType(getTypeType(type)); + return QualType(astBuilder->getTypeType(type)); } else if (auto genericDeclRef = declRef.as<GenericDecl>()) { - auto type = getGenericDeclRefType(session, genericDeclRef); + auto type = getGenericDeclRefType(astBuilder, genericDeclRef); *outTypeResult = type; - return QualType(getTypeType(type)); + return QualType(astBuilder->getTypeType(type)); } else if (auto funcDeclRef = declRef.as<CallableDecl>()) { - auto type = getFuncType(session, funcDeclRef); + auto type = getFuncType(astBuilder, funcDeclRef); return QualType(type); } else if (auto constraintDeclRef = declRef.as<TypeConstraintDecl>()) @@ -406,12 +406,12 @@ namespace Slang // When we access a constraint or an inheritance decl (as a member), // we are conceptually performing a "cast" to the given super-type, // with the declaration showing that such a cast is legal. - auto type = GetSup(constraintDeclRef); + auto type = GetSup(astBuilder, constraintDeclRef); return QualType(type); } else if( auto namespaceDeclRef = declRef.as<NamespaceDeclBase>()) { - auto type = getNamespaceType(session, namespaceDeclRef); + auto type = getNamespaceType(astBuilder, namespaceDeclRef); return QualType(type); } if( sink ) @@ -430,16 +430,16 @@ namespace Slang // sink->diagnose(loc, Diagnostics::undefinedIdentifier2, declRef.GetName()); } - return QualType(session->getErrorType()); + return QualType(astBuilder->getErrorType()); } QualType getTypeForDeclRef( - Session* session, + ASTBuilder* astBuilder, DeclRef<Decl> declRef, SourceLoc loc) { RefPtr<Type> typeResult; - return getTypeForDeclRef(session, nullptr, nullptr, declRef, &typeResult, loc); + return getTypeForDeclRef(astBuilder, nullptr, nullptr, declRef, &typeResult, loc); } DeclRef<ExtensionDecl> ApplyExtensionToType( @@ -453,12 +453,12 @@ namespace Slang return semantics->ApplyExtensionToType(extDecl, type); } - RefPtr<GenericSubstitution> createDefaultSubsitutionsForGeneric( - Session* session, + RefPtr<GenericSubstitution> createDefaultSubstitutionsForGeneric( + ASTBuilder* astBuilder, GenericDecl* genericDecl, RefPtr<Substitutions> outerSubst) { - RefPtr<GenericSubstitution> genericSubst = new GenericSubstitution(); + RefPtr<GenericSubstitution> genericSubst = astBuilder->create<GenericSubstitution>(); genericSubst->genericDecl = genericDecl; genericSubst->outer = outerSubst; @@ -466,11 +466,11 @@ namespace Slang { if( auto genericTypeParamDecl = as<GenericTypeParamDecl>(mm) ) { - genericSubst->args.add(DeclRefType::Create(session, DeclRef<Decl>(genericTypeParamDecl, outerSubst))); + genericSubst->args.add(DeclRefType::create(astBuilder, DeclRef<Decl>(genericTypeParamDecl, outerSubst))); } else if( auto genericValueParamDecl = as<GenericValueParamDecl>(mm) ) { - genericSubst->args.add(new GenericParamIntVal(DeclRef<GenericValueParamDecl>(genericValueParamDecl, outerSubst))); + genericSubst->args.add(astBuilder->create<GenericParamIntVal>(DeclRef<GenericValueParamDecl>(genericValueParamDecl, outerSubst))); } } @@ -479,7 +479,7 @@ namespace Slang { if (auto genericTypeConstraintDecl = as<GenericTypeConstraintDecl>(mm)) { - RefPtr<DeclaredSubtypeWitness> witness = new DeclaredSubtypeWitness(); + RefPtr<DeclaredSubtypeWitness> witness = astBuilder->create<DeclaredSubtypeWitness>(); witness->declRef = DeclRef<Decl>(genericTypeConstraintDecl, outerSubst); witness->sub = genericTypeConstraintDecl->sub.type; witness->sup = genericTypeConstraintDecl->sup.type; @@ -495,7 +495,7 @@ namespace Slang // using their archetypes). // SubstitutionSet createDefaultSubstitutions( - Session* session, + ASTBuilder* astBuilder, Decl* decl, SubstitutionSet outerSubstSet) { @@ -507,8 +507,8 @@ namespace Slang if(decl != genericDecl->inner) return outerSubstSet; - RefPtr<GenericSubstitution> genericSubst = createDefaultSubsitutionsForGeneric( - session, + RefPtr<GenericSubstitution> genericSubst = createDefaultSubstitutionsForGeneric( + astBuilder, genericDecl, outerSubstSet.substitutions); @@ -519,15 +519,15 @@ namespace Slang } SubstitutionSet createDefaultSubstitutions( - Session* session, + ASTBuilder* astBuilder, Decl* decl) { SubstitutionSet subst; if( auto parentDecl = decl->parentDecl ) { - subst = createDefaultSubstitutions(session, parentDecl); + subst = createDefaultSubstitutions(astBuilder, parentDecl); } - subst = createDefaultSubstitutions(session, decl, subst); + subst = createDefaultSubstitutions(astBuilder, decl, subst); return subst; } @@ -776,7 +776,7 @@ namespace Slang if(!initExpr) { getSink()->diagnose(varDecl, Diagnostics::varWithoutTypeMustHaveInitializer); - varDecl->type.type = getSession()->getErrorType(); + varDecl->type.type = m_astBuilder->getErrorType(); } else { @@ -803,7 +803,7 @@ namespace Slang TypeExp typeExp = CheckUsableType(varDecl->type); varDecl->type = typeExp; - if (varDecl->type.equals(getSession()->getVoidType())) + if (varDecl->type.equals(m_astBuilder->getVoidType())) { getSink()->diagnose(varDecl, Diagnostics::invalidTypeVoid); } @@ -921,7 +921,7 @@ namespace Slang { if (auto declRefType = as<DeclRefType>(sharedTypeExpr->base)) { - declRefType->declRef.substitutions = createDefaultSubstitutions(getSession(), declRefType->declRef.getDecl()); + declRefType->declRef.substitutions = createDefaultSubstitutions(m_astBuilder, declRefType->declRef.getDecl()); if (auto typetype = as<TypeType>(typeExp.exp->type)) typetype->type = declRefType; @@ -1041,13 +1041,15 @@ namespace Slang /// static void _registerBuiltinDeclsRec(Session* session, Decl* decl) { + SharedASTBuilder* sharedASTBuilder = session->m_sharedASTBuilder; + if (auto builtinMod = decl->findModifier<BuiltinTypeModifier>()) { - registerBuiltinDecl(session, decl, builtinMod); + sharedASTBuilder->registerBuiltinDecl(decl, builtinMod); } if (auto magicMod = decl->findModifier<MagicTypeModifier>()) { - registerMagicDecl(session, decl, magicMod); + sharedASTBuilder->registerMagicDecl(decl, magicMod); } if(auto containerDecl = as<ContainerDecl>(decl)) @@ -1283,7 +1285,7 @@ namespace Slang for (auto requiredConstraintDeclRef : getMembersOfType<TypeConstraintDecl>(requiredAssociatedTypeDeclRef)) { // Grab the type we expect to conform to from the constraint. - auto requiredSuperType = GetSup(requiredConstraintDeclRef); + auto requiredSuperType = GetSup(m_astBuilder, requiredConstraintDeclRef); // Perform a search for a witness to the subtype relationship. auto witness = tryGetSubtypeWitness(satisfyingType, requiredSuperType); @@ -1397,7 +1399,7 @@ namespace Slang { ensureDecl(subAggTypeDeclRef, DeclCheckState::CanUseAsType); - auto satisfyingType = DeclRefType::Create(getSession(), subAggTypeDeclRef); + auto satisfyingType = DeclRefType::create(m_astBuilder, subAggTypeDeclRef); return doesTypeSatisfyAssociatedTypeRequirement(satisfyingType, requiredTypeDeclRef, witnessTable); } } @@ -1409,7 +1411,7 @@ namespace Slang { ensureDecl(typedefDeclRef, DeclCheckState::CanUseAsType); - auto satisfyingType = getNamedType(getSession(), typedefDeclRef); + auto satisfyingType = getNamedType(m_astBuilder, typedefDeclRef); return doesTypeSatisfyAssociatedTypeRequirement(satisfyingType, requiredTypeDeclRef, witnessTable); } } @@ -1461,7 +1463,7 @@ namespace Slang context, type, requiredInheritanceDeclRef.getDecl(), - getBaseType(requiredInheritanceDeclRef)); + getBaseType(m_astBuilder, requiredInheritanceDeclRef)); if(!satisfyingWitnessTable) return false; @@ -1503,7 +1505,7 @@ namespace Slang // on subsequent checking in this function to // rule out inherited abstract members. // - auto lookupResult = lookUpMember(getSession(), this, name, type); + auto lookupResult = lookUpMember(m_astBuilder, this, name, type); // Iterate over the members and look for one that matches // the expected signature for the requirement. @@ -1607,9 +1609,7 @@ namespace Slang // // TODO: need to decide if a this-type substitution is needed here. // It probably it. - RefPtr<Type> targetType = DeclRefType::Create( - getSession(), - interfaceDeclRef); + RefPtr<Type> targetType = DeclRefType::create(m_astBuilder, interfaceDeclRef); auto extDeclRef = ApplyExtensionToType(candidateExt, targetType); if(!extDeclRef) continue; @@ -1713,8 +1713,8 @@ namespace Slang void SemanticsVisitor::checkExtensionConformance(ExtensionDecl* decl) { - auto declRef = createDefaultSubstitutionsIfNeeded(getSession(), makeDeclRef(decl)).as<ExtensionDecl>(); - auto targetType = GetTargetType(declRef); + auto declRef = createDefaultSubstitutionsIfNeeded(m_astBuilder, makeDeclRef(decl)).as<ExtensionDecl>(); + auto targetType = GetTargetType(m_astBuilder, declRef); for (auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>()) { @@ -1744,8 +1744,10 @@ namespace Slang // For non-interface types we need to check conformance. // - auto declRef = createDefaultSubstitutionsIfNeeded(getSession(), makeDeclRef(decl)).as<AggTypeDeclBase>(); - auto type = DeclRefType::Create(getSession(), declRef); + auto astBuilder = getASTBuilder(); + + auto declRef = createDefaultSubstitutionsIfNeeded(astBuilder, makeDeclRef(decl)).as<AggTypeDeclBase>(); + auto type = DeclRefType::create(astBuilder, declRef); // TODO: Need to figure out what this should do for // `abstract` types if we ever add them. Should they @@ -1845,7 +1847,7 @@ namespace Slang // type of their tag. if(!tagType) { - tagType = getSession()->getIntType(); + tagType = m_astBuilder->getIntType(); } else { @@ -1867,12 +1869,12 @@ namespace Slang // seems like the best place to do it. { // First, look up the type of the `__EnumType` interface. - RefPtr<Type> enumTypeType = getSession()->getEnumTypeType(); + RefPtr<Type> enumTypeType = getASTBuilder()->getEnumTypeType(); - RefPtr<InheritanceDecl> enumConformanceDecl = new InheritanceDecl(); + RefPtr<InheritanceDecl> enumConformanceDecl = m_astBuilder->create<InheritanceDecl>(); enumConformanceDecl->parentDecl = decl; enumConformanceDecl->loc = decl->loc; - enumConformanceDecl->base.type = getSession()->getEnumTypeType(); + enumConformanceDecl->base.type = getASTBuilder()->getEnumTypeType(); decl->members.add(enumConformanceDecl); // The `__EnumType` interface has one required member, the `__Tag` type. @@ -1921,9 +1923,7 @@ namespace Slang void SemanticsDeclBodyVisitor::visitEnumDecl(EnumDecl* decl) { - auto enumType = DeclRefType::Create( - getSession(), - makeDeclRef(decl)); + auto enumType = DeclRefType::create(m_astBuilder, makeDeclRef(decl)); auto tagType = decl->tagType; @@ -1979,7 +1979,7 @@ namespace Slang { // This tag has no initializer, so it should use // the default tag value we are tracking. - RefPtr<IntegerLiteralExpr> tagValExpr = new IntegerLiteralExpr(); + RefPtr<IntegerLiteralExpr> tagValExpr = m_astBuilder->create<IntegerLiteralExpr>(); tagValExpr->loc = caseDecl->loc; tagValExpr->type = QualType(tagType); tagValExpr->value = defaultTag; @@ -2297,12 +2297,12 @@ namespace Slang // and `sup` types are pairwise equivalent. // auto leftSub = leftConstraint->sub; - auto rightSub = GetSub(rightConstraint); + auto rightSub = GetSub(m_astBuilder, rightConstraint); if(!leftSub->equals(rightSub)) return false; auto leftSup = leftConstraint->sup; - auto rightSup = GetSup(rightConstraint); + auto rightSup = GetSup(m_astBuilder, rightConstraint); if(!leftSup->equals(rightSup)) return false; } @@ -2336,7 +2336,7 @@ namespace Slang auto sndParam = sndParams[ii]; // If a given parameter type doesn't match, then signatures don't match - if (!GetType(fstParam)->equals(GetType(sndParam))) + if (!GetType(m_astBuilder, fstParam)->equals(GetType(m_astBuilder, sndParam))) return false; // If one parameter is `out` and the other isn't, then they don't match @@ -2361,7 +2361,7 @@ namespace Slang RefPtr<GenericSubstitution> SemanticsVisitor::createDummySubstitutions( GenericDecl* genericDecl) { - RefPtr<GenericSubstitution> subst = new GenericSubstitution(); + RefPtr<GenericSubstitution> subst = m_astBuilder->create<GenericSubstitution>(); subst->genericDecl = genericDecl; for (auto dd : genericDecl->members) { @@ -2370,13 +2370,12 @@ namespace Slang if (auto typeParam = as<GenericTypeParamDecl>(dd)) { - auto type = DeclRefType::Create(getSession(), - makeDeclRef(typeParam)); + auto type = DeclRefType::create(m_astBuilder, makeDeclRef(typeParam)); subst->args.add(type); } else if (auto valueParam = as<GenericValueParamDecl>(dd)) { - auto val = new GenericParamIntVal( + auto val = m_astBuilder->create<GenericParamIntVal>( makeDeclRef(valueParam)); subst->args.add(val); } @@ -2544,8 +2543,8 @@ namespace Slang // consider result types earlier, as part of the signature // matching step. // - auto resultType = GetResultType(newDeclRef); - auto prevResultType = GetResultType(oldDeclRef); + auto resultType = GetResultType(m_astBuilder, newDeclRef); + auto prevResultType = GetResultType(m_astBuilder, oldDeclRef); if (!resultType->equals(prevResultType)) { // Bad redeclaration @@ -2779,7 +2778,7 @@ namespace Slang } else { - resultType = TypeExp(getSession()->getVoidType()); + resultType = TypeExp(m_astBuilder->getVoidType()); } funcDecl->returnType = resultType; @@ -2823,6 +2822,7 @@ namespace Slang // Create a new array type based on the size we found, // and install it into our type. varDecl->type.type = getArrayType( + m_astBuilder, arrayType->baseType, elementCount); } @@ -2879,8 +2879,7 @@ namespace Slang // conform to the interface and fill in its // requirements. // - RefPtr<ThisType> thisType = new ThisType(); - thisType->setSession(getSession()); + RefPtr<ThisType> thisType = m_astBuilder->create<ThisType>(); thisType->interfaceDeclRef = interfaceDeclRef; return thisType; } @@ -2895,9 +2894,7 @@ namespace Slang // would need to refer to the eventual concrete // type, much like the `interface` case above. // - return DeclRefType::Create( - getSession(), - aggTypeDeclRef); + return DeclRefType::create(m_astBuilder, aggTypeDeclRef); } else if (auto extDeclRef = declRef.as<ExtensionDecl>()) { @@ -2922,7 +2919,7 @@ namespace Slang // sooner or later. // ensureDecl(extDeclRef, DeclCheckState::CanUseExtensionTargetType); - auto targetType = GetTargetType(extDeclRef); + auto targetType = GetTargetType(m_astBuilder, extDeclRef); return calcThisType(targetType); } else @@ -2964,7 +2961,7 @@ namespace Slang if( !thisType ) { getSink()->diagnose(decl, Diagnostics::initializerNotInsideType); - thisType = getSession()->getErrorType(); + thisType = m_astBuilder->getErrorType(); } return thisType; } @@ -2997,7 +2994,7 @@ namespace Slang if(!anyAccessors) { - RefPtr<GetterDecl> getterDecl = new GetterDecl(); + RefPtr<GetterDecl> getterDecl = m_astBuilder->create<GetterDecl>(); getterDecl->loc = decl->loc; getterDecl->parentDecl = decl; @@ -3067,7 +3064,7 @@ namespace Slang } // Now extract the target type from our (possibly specialized) extension decl-ref. - RefPtr<Type> targetType = GetTargetType(extDeclRef); + RefPtr<Type> targetType = GetTargetType(m_astBuilder, extDeclRef); // As a bit of a kludge here, if the target type of the extension is // an interface, and the `type` we are trying to match up has a this-type @@ -3098,12 +3095,12 @@ namespace Slang SLANG_ASSERT(!targetInterfaceDeclRef.substitutions.substitutions.as<ThisTypeSubstitution>()); // We will create a new substitution to apply to the target type. - RefPtr<ThisTypeSubstitution> newTargetSubst = new ThisTypeSubstitution(); + RefPtr<ThisTypeSubstitution> newTargetSubst = m_astBuilder->create<ThisTypeSubstitution>(); newTargetSubst->interfaceDecl = appThisTypeSubst->interfaceDecl; newTargetSubst->witness = appThisTypeSubst->witness; newTargetSubst->outer = targetInterfaceDeclRef.substitutions.substitutions; - targetType = DeclRefType::Create(getSession(), + targetType = DeclRefType::create(m_astBuilder, DeclRef<InterfaceDecl>(targetInterfaceDeclRef.getDecl(), newTargetSubst)); // Note: we are constructing a this-type substitution that @@ -3113,7 +3110,7 @@ namespace Slang // references to the target type of the extension // declaration have a chance to resolve the way we want them to. - RefPtr<ThisTypeSubstitution> newExtSubst = new ThisTypeSubstitution(); + RefPtr<ThisTypeSubstitution> newExtSubst = m_astBuilder->create<ThisTypeSubstitution>(); newExtSubst->interfaceDecl = appThisTypeSubst->interfaceDecl; newExtSubst->witness = appThisTypeSubst->witness; newExtSubst->outer = extDeclRef.substitutions.substitutions; @@ -3155,7 +3152,7 @@ namespace Slang { RefPtr<Type> typeResult; return getTypeForDeclRef( - getSession(), + m_astBuilder, this, getSink(), declRef, diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp index 6bf096ae9..e0f439ab3 100644 --- a/source/slang/slang-check-expr.cpp +++ b/source/slang/slang-check-expr.cpp @@ -31,7 +31,7 @@ namespace Slang template<typename F> RefPtr<Expr> SemanticsVisitor::moveTemp(RefPtr<Expr> const& expr, F const& func) { - RefPtr<VarDecl> varDecl = new VarDecl(); + RefPtr<VarDecl> varDecl = m_astBuilder->create<VarDecl>(); varDecl->parentDecl = nullptr; // TODO: need to fill this in somehow! varDecl->checkState = DeclCheckState::Checked; varDecl->nameAndLoc.loc = expr->loc; @@ -40,7 +40,7 @@ namespace Slang auto varDeclRef = makeDeclRef(varDecl.Ptr()); - RefPtr<LetExpr> letExpr = new LetExpr(); + RefPtr<LetExpr> letExpr = m_astBuilder->create<LetExpr>(); letExpr->decl = varDecl; auto body = func(varDeclRef); @@ -102,23 +102,23 @@ namespace Slang auto interfaceDecl = interfaceDeclRef.getDecl(); return maybeMoveTemp(expr, [&](DeclRef<VarDeclBase> varDeclRef) { - RefPtr<ExtractExistentialType> openedType = new ExtractExistentialType(); + RefPtr<ExtractExistentialType> openedType = m_astBuilder->create<ExtractExistentialType>(); openedType->declRef = varDeclRef; - RefPtr<ExtractExistentialSubtypeWitness> openedWitness = new ExtractExistentialSubtypeWitness(); + RefPtr<ExtractExistentialSubtypeWitness> openedWitness = m_astBuilder->create<ExtractExistentialSubtypeWitness>(); openedWitness->sub = openedType; openedWitness->sup = expr->type.type; openedWitness->declRef = varDeclRef; - RefPtr<ThisTypeSubstitution> openedThisType = new ThisTypeSubstitution(); + RefPtr<ThisTypeSubstitution> openedThisType = m_astBuilder->create<ThisTypeSubstitution>(); openedThisType->outer = interfaceDeclRef.substitutions.substitutions; openedThisType->interfaceDecl = interfaceDecl; openedThisType->witness = openedWitness; DeclRef<InterfaceDecl> substDeclRef = DeclRef<InterfaceDecl>(interfaceDecl, openedThisType); - auto substDeclRefType = DeclRefType::Create(getSession(), substDeclRef); + auto substDeclRefType = DeclRefType::create(m_astBuilder, substDeclRef); - RefPtr<ExtractExistentialValueExpr> openedValue = new ExtractExistentialValueExpr(); + RefPtr<ExtractExistentialValueExpr> openedValue = m_astBuilder->create<ExtractExistentialValueExpr>(); openedValue->declRef = varDeclRef; openedValue->type = QualType(substDeclRefType); @@ -218,7 +218,7 @@ namespace Slang declRef.GetName()); } - auto expr = new StaticMemberExpr(); + auto expr = m_astBuilder->create<StaticMemberExpr>(); expr->loc = loc; expr->type = type; expr->baseExpression = baseExpr; @@ -230,11 +230,11 @@ namespace Slang { // Extract the type of the baseExpr auto baseExprType = baseExpr->type.type; - RefPtr<SharedTypeExpr> baseTypeExpr = new SharedTypeExpr(); + RefPtr<SharedTypeExpr> baseTypeExpr = m_astBuilder->create<SharedTypeExpr>(); baseTypeExpr->base.type = baseExprType; - baseTypeExpr->type.type = getTypeType(baseExprType); + baseTypeExpr->type.type = m_astBuilder->getTypeType(baseExprType); - auto expr = new StaticMemberExpr(); + auto expr = m_astBuilder->create<StaticMemberExpr>(); expr->loc = loc; expr->type = type; expr->baseExpression = baseTypeExpr; @@ -247,7 +247,7 @@ namespace Slang // If the base expression wasn't a type, then this // is a normal member expression. // - auto expr = new MemberExpr(); + auto expr = m_astBuilder->create<MemberExpr>(); expr->loc = loc; expr->type = type; expr->baseExpression = baseExpr; @@ -274,7 +274,7 @@ namespace Slang // If there is no base expression, then the result must // be an ordinary variable expression. // - auto expr = new VarExpr(); + auto expr = m_astBuilder->create<VarExpr>(); expr->loc = loc; expr->name = declRef.GetName(); expr->type = type; @@ -290,7 +290,7 @@ namespace Slang auto ptrLikeType = as<PointerLikeType>(base->type); SLANG_ASSERT(ptrLikeType); - auto derefExpr = new DerefExpr(); + auto derefExpr = m_astBuilder->create<DerefExpr>(); derefExpr->loc = loc; derefExpr->base = base; derefExpr->type = QualType(ptrLikeType->elementType); @@ -364,9 +364,9 @@ namespace Slang // will be `typeof(This)`, which conceptually // `typeof(typeof(this))` // - auto thisTypeType = getTypeType(thisType); + auto thisTypeType = m_astBuilder->getTypeType(thisType); - auto typeExpr = new SharedTypeExpr(); + auto typeExpr = m_astBuilder->create<SharedTypeExpr>(); typeExpr->type.type = thisTypeType; typeExpr->base.type = thisType; @@ -380,7 +380,7 @@ namespace Slang // refernece to `this.someStaticMember` will be translated // over to `This.someStaticMember`. // - RefPtr<ThisExpr> expr = new ThisExpr(); + RefPtr<ThisExpr> expr = m_astBuilder->create<ThisExpr>(); expr->type.type = thisType; expr->loc = loc; @@ -412,11 +412,11 @@ namespace Slang { if (lookupResult.isOverloaded()) { - auto overloadedExpr = new OverloadedExpr(); + auto overloadedExpr = m_astBuilder->create<OverloadedExpr>(); overloadedExpr->name = name; overloadedExpr->loc = loc; overloadedExpr->type = QualType( - getSession()->getOverloadedType()); + m_astBuilder->getOverloadedType()); overloadedExpr->base = baseExpr; overloadedExpr->lookupResult2 = lookupResult; return overloadedExpr; @@ -588,7 +588,7 @@ namespace Slang RefPtr<Expr> SemanticsVisitor::CreateErrorExpr(Expr* expr) { - expr->type = QualType(getSession()->getErrorType()); + expr->type = QualType(m_astBuilder->getErrorType()); return expr; } @@ -617,7 +617,7 @@ namespace Slang RefPtr<Expr> SemanticsExprVisitor::visitBoolLiteralExpr(BoolLiteralExpr* expr) { - expr->type = getSession()->getBoolType(); + expr->type = m_astBuilder->getBoolType(); return expr; } @@ -636,7 +636,7 @@ namespace Slang // if(!expr->type.type) { - expr->type = getSession()->getIntType(); + expr->type = m_astBuilder->getIntType(); } return expr; } @@ -645,21 +645,21 @@ namespace Slang { if(!expr->type.type) { - expr->type = getSession()->getFloatType(); + expr->type = m_astBuilder->getFloatType(); } return expr; } RefPtr<Expr> SemanticsExprVisitor::visitStringLiteralExpr(StringLiteralExpr* expr) { - expr->type = getSession()->getStringType(); + expr->type = m_astBuilder->getStringType(); return expr; } IntVal* SemanticsVisitor::GetIntVal(IntegerLiteralExpr* expr) { // TODO(tfoley): don't keep allocating here! - return new ConstantIntVal(expr->value); + return m_astBuilder->create<ConstantIntVal>(expr->value); } RefPtr<IntVal> SemanticsVisitor::TryConstantFoldExpr( @@ -784,7 +784,7 @@ namespace Slang return nullptr; } - RefPtr<IntVal> result = new ConstantIntVal(resultValue); + RefPtr<IntVal> result = m_astBuilder->create<ConstantIntVal>(resultValue); return result; } @@ -811,7 +811,7 @@ namespace Slang if (auto genericValParamRef = declRef.as<GenericValueParamDecl>()) { // TODO(tfoley): handle the case of non-`int` value parameters... - return new GenericParamIntVal(genericValParamRef); + return m_astBuilder->create<GenericParamIntVal>(genericValParamRef); } // We may also need to check for references to variables that @@ -826,7 +826,7 @@ namespace Slang if(auto constAttr = varDecl->findModifier<ConstModifier>()) { // HLSL `static const` can be used as a constant expression - if(auto initExpr = getInitExpr(varRef)) + if(auto initExpr = getInitExpr(m_astBuilder, varRef)) { return TryConstantFoldExpr(initExpr.Ptr()); } @@ -836,7 +836,7 @@ namespace Slang else if(auto enumRef = declRef.as<EnumCaseDecl>()) { // The cases in an `enum` declaration can also be used as constant expressions, - if(auto tagExpr = getTagExpr(enumRef)) + if(auto tagExpr = getTagExpr(m_astBuilder, enumRef)) { return TryConstantFoldExpr(tagExpr.Ptr()); } @@ -882,7 +882,7 @@ namespace Slang if(IsErrorExpr(inExpr)) return nullptr; // First coerce the expression to the expected type - auto expr = coerce(getSession()->getIntType(),inExpr); + auto expr = coerce(m_astBuilder->getIntType(),inExpr); // No need to issue further errors if the type coercion failed. if(IsErrorExpr(expr)) return nullptr; @@ -923,8 +923,8 @@ namespace Slang auto baseExpr = subscriptExpr->baseExpression; auto indexExpr = subscriptExpr->indexExpression; - if (!indexExpr->type->equals(getSession()->getIntType()) && - !indexExpr->type->equals(getSession()->getUIntType())) + if (!indexExpr->type->equals(m_astBuilder->getIntType()) && + !indexExpr->type->equals(m_astBuilder->getUIntType())) { getSink()->diagnose(indexExpr, Diagnostics::subscriptIndexNonInteger); return CreateErrorExpr(subscriptExpr.Ptr()); @@ -973,10 +973,11 @@ namespace Slang auto elementType = CoerceToUsableType(TypeExp(baseExpr, baseTypeType->type)); auto arrayType = getArrayType( + m_astBuilder, elementType, elementCount); - subscriptExpr->type = QualType(getTypeType(arrayType)); + subscriptExpr->type = QualType(m_astBuilder->getTypeType(arrayType)); return subscriptExpr; } else if (auto baseArrayType = as<ArrayExpressionType>(baseType)) @@ -1010,7 +1011,7 @@ namespace Slang { Name* name = getName("operator[]"); LookupResult lookupResult = lookUpMember( - getSession(), + m_astBuilder, this, name, baseType); @@ -1028,7 +1029,7 @@ namespace Slang RefPtr<Expr> subscriptFuncExpr = createLookupResultExpr( name, lookupResult, subscriptExpr->baseExpression, subscriptExpr->loc); - RefPtr<InvokeExpr> subscriptCallExpr = new InvokeExpr(); + RefPtr<InvokeExpr> subscriptCallExpr = m_astBuilder->create<InvokeExpr>(); subscriptCallExpr->loc = subscriptExpr->loc; subscriptCallExpr->functionExpr = subscriptFuncExpr; @@ -1223,9 +1224,9 @@ namespace Slang if (expr->declRef) return expr; - expr->type = QualType(getSession()->getErrorType()); + expr->type = QualType(m_astBuilder->getErrorType()); auto lookupResult = lookUp( - getSession(), + m_astBuilder, this, expr->name, expr->scope); if (lookupResult.isValid()) { @@ -1316,7 +1317,7 @@ namespace Slang // of explicit default initializers for `struct` fields to // make this a major concern (since they aren't supported in HLSL). // - RefPtr<InitializerListExpr> initListExpr = new InitializerListExpr(); + RefPtr<InitializerListExpr> initListExpr = m_astBuilder->create<InitializerListExpr>(); auto checkedInitListExpr = visitInitializerListExpr(initListExpr); return coerce(typeExp.type, initListExpr); } @@ -1342,7 +1343,7 @@ namespace Slang auto elementType = QualType(pointerLikeType->elementType); elementType.IsLeftValue = baseType.IsLeftValue; - auto derefExpr = new DerefExpr(); + auto derefExpr = m_astBuilder->create<DerefExpr>(); derefExpr->base = expr; derefExpr->type = elementType; @@ -1360,7 +1361,7 @@ namespace Slang RefPtr<Type> baseElementType, IntegerLiteralValue baseElementCount) { - RefPtr<SwizzleExpr> swizExpr = new SwizzleExpr(); + RefPtr<SwizzleExpr> swizExpr = m_astBuilder->create<SwizzleExpr>(); swizExpr->loc = memberRefExpr->loc; swizExpr->base = memberRefExpr->baseExpression; @@ -1439,7 +1440,7 @@ namespace Slang // here if the input type had a sugared name... swizExpr->type = QualType(createVectorType( baseElementType, - new ConstantIntVal(elementCount))); + m_astBuilder->create<ConstantIntVal>(elementCount))); } // A swizzle can be used as an l-value as long as there @@ -1484,7 +1485,7 @@ namespace Slang // we can reference the declaration here. // LookupResult lookupResult = lookUpDirectAndTransparentMembers( - getSession(), + m_astBuilder, this, expr->name, namespaceDeclRef); @@ -1515,7 +1516,7 @@ namespace Slang } LookupResult lookupResult = lookUpMember( - getSession(), + m_astBuilder, this, expr->name, type); @@ -1640,7 +1641,7 @@ namespace Slang SLANG_ASSERT(as<StaticMemberExpr>(expr) || as<MemberExpr>(expr)); getSink()->diagnose(expr, Diagnostics::noMemberOfNameInType, expr->name, baseType); - expr->type = QualType(getSession()->getErrorType()); + expr->type = QualType(m_astBuilder->getErrorType()); return expr; } @@ -1703,7 +1704,7 @@ namespace Slang else { LookupResult lookupResult = lookUpMember( - getSession(), + m_astBuilder, this, expr->name, baseType.Ptr()); @@ -1734,7 +1735,7 @@ namespace Slang arg = CheckTerm(arg); } - expr->type = getSession()->getInitializerListType(); + expr->type = m_astBuilder->getInitializerListType(); return expr; } @@ -1814,7 +1815,7 @@ namespace Slang if( auto typeOrExtensionDecl = as<AggTypeDeclBase>(containerDecl) ) { auto thisType = calcThisType(makeDeclRef(typeOrExtensionDecl)); - auto thisTypeType = getTypeType(thisType); + auto thisTypeType = m_astBuilder->getTypeType(thisType); expr->type.type = thisTypeType; return expr; diff --git a/source/slang/slang-check-impl.h b/source/slang/slang-check-impl.h index fb55e5bef..fba43adcb 100644 --- a/source/slang/slang-check-impl.h +++ b/source/slang/slang-check-impl.h @@ -11,9 +11,7 @@ namespace Slang { - RefPtr<TypeType> getTypeType( - Type* type); - + /// Should the given `decl` be treated as a static rather than instance declaration? bool isEffectivelyStatic( Decl* decl); @@ -229,18 +227,25 @@ namespace Slang return m_linkage->getSessionImpl(); } + Linkage* getLinkage() + { + return m_linkage; + } }; struct SemanticsVisitor { SemanticsVisitor( SharedSemanticsContext* shared) - : m_shared(shared) + : m_shared(shared), + m_astBuilder(shared->getLinkage()->getASTBuilder()) {} SharedSemanticsContext* m_shared = nullptr; + ASTBuilder* m_astBuilder = nullptr; SharedSemanticsContext* getShared() { return m_shared; } + ASTBuilder* getASTBuilder() { return m_astBuilder;} DiagnosticSink* getSink() { return m_shared->getSink(); } @@ -1304,7 +1309,7 @@ namespace Slang DeclRefExpr* expr, QualType const& baseType); - SharedSemanticsContext & operator = (const SharedSemanticsContext &) = delete; + SharedSemanticsContext& operator=(const SharedSemanticsContext &) = delete; // diff --git a/source/slang/slang-check-modifier.cpp b/source/slang/slang-check-modifier.cpp index b8b3846dc..42a9735af 100644 --- a/source/slang/slang-check-modifier.cpp +++ b/source/slang/slang-check-modifier.cpp @@ -80,15 +80,13 @@ namespace Slang AttributeDecl* SemanticsVisitor::lookUpAttributeDecl(Name* attributeName, Scope* scope) { - auto session = getSession(); - // We start by looking for an existing attribute matching // the name `attributeName`. // { // Look up the name and see what attributes we find. // - auto lookupResult = lookUp(session, this, attributeName, scope, LookupMask::Attribute); + auto lookupResult = lookUp(m_astBuilder, this, attributeName, scope, LookupMask::Attribute); // If the result was overloaded, then that means there // are multiple attributes matching the name, and we @@ -118,7 +116,7 @@ namespace Slang // If the attribute was `[Something(...)]` then we will // look for a `struct` named `SomethingAttribute`. // - LookupResult lookupResult = lookUp(session, this, session->getNameObj(attributeName->text + "Attribute"), scope, LookupMask::type); + LookupResult lookupResult = lookUp(m_astBuilder, this, m_astBuilder->getGlobalSession()->getNameObj(attributeName->text + "Attribute"), scope, LookupMask::type); // // If we didn't find a matching type name, then we give up. // @@ -140,12 +138,12 @@ namespace Slang // We will now synthesize a new `AttributeDecl` to mirror // what was declared on the `struct` type. // - RefPtr<AttributeDecl> attrDecl = new AttributeDecl(); + RefPtr<AttributeDecl> attrDecl = m_astBuilder->create<AttributeDecl>(); attrDecl->nameAndLoc.name = attributeName; attrDecl->nameAndLoc.loc = structDecl->nameAndLoc.loc; attrDecl->loc = structDecl->loc; - RefPtr<AttributeTargetModifier> targetModifier = new AttributeTargetModifier(); + RefPtr<AttributeTargetModifier> targetModifier = m_astBuilder->create<AttributeTargetModifier>(); targetModifier->syntaxClass = attrUsageAttr->targetSyntaxClass; targetModifier->loc = attrUsageAttr->loc; addModifier(attrDecl, targetModifier); @@ -155,8 +153,8 @@ namespace Slang // // User-defined attributes create instances of // `UserDefinedAttribute`. - // - attrDecl->syntaxClass = session->findSyntaxClass(session->getNameObj("UserDefinedAttribute")); + // + attrDecl->syntaxClass = m_astBuilder->findSyntaxClass(UnownedStringSlice::fromLiteral("UserDefinedAttribute")); // The fields of the user-defined `struct` type become // the parameters of the new attribute. @@ -169,7 +167,7 @@ namespace Slang { ensureDecl(varMember, DeclCheckState::CanUseTypeOfValueDecl); - RefPtr<ParamDecl> paramDecl = new ParamDecl(); + RefPtr<ParamDecl> paramDecl = m_astBuilder->create<ParamDecl>(); paramDecl->nameAndLoc = member->nameAndLoc; paramDecl->type = varMember->type; paramDecl->loc = member->loc; @@ -236,17 +234,17 @@ namespace Slang { if (typeFlags == (int)UserDefinedAttributeTargets::Struct) { - cls = getSession()->findSyntaxClass(getSession()->getNameObj("StructDecl")); + cls = m_astBuilder->findSyntaxClass(UnownedStringSlice::fromLiteral("StructDecl")); return true; } if (typeFlags == (int)UserDefinedAttributeTargets::Var) { - cls = getSession()->findSyntaxClass(getSession()->getNameObj("VarDecl")); + cls = m_astBuilder->findSyntaxClass(UnownedStringSlice::fromLiteral("VarDecl")); return true; } if (typeFlags == (int)UserDefinedAttributeTargets::Function) { - cls = getSession()->findSyntaxClass(getSession()->getNameObj("FuncDecl")); + cls = m_astBuilder->findSyntaxClass(UnownedStringSlice::fromLiteral("FuncDecl")); return true; } return false; diff --git a/source/slang/slang-check-overload.cpp b/source/slang/slang-check-overload.cpp index 745597a76..6af2eec58 100644 --- a/source/slang/slang-check-overload.cpp +++ b/source/slang/slang-check-overload.cpp @@ -165,9 +165,9 @@ namespace Slang // // Along the way we will build up a `GenericSubstitution` // to represent the arguments that have been coerced to - // appropriateforms. + // appropriate forms. // - auto genSubst = new GenericSubstitution(); + auto genSubst = m_astBuilder->create<GenericSubstitution>(); candidate.subst = genSubst; auto& checkedArgs = genSubst->args; @@ -228,7 +228,7 @@ namespace Slang // if( !typeArg.type ) { - typeArg.type = getSession()->getErrorType(); + typeArg.type = m_astBuilder->getErrorType(); success = false; } @@ -257,7 +257,7 @@ namespace Slang if (context.mode == OverloadResolveContext::Mode::JustTrying) { ConversionCost cost = kConversionCost_None; - if (!canCoerce(GetType(valParamRef), arg->type, &cost)) + if (!canCoerce(GetType(m_astBuilder, valParamRef), arg->type, &cost)) { success = false; } @@ -265,7 +265,7 @@ namespace Slang } else { - arg = coerce(GetType(valParamRef), arg); + arg = coerce(GetType(m_astBuilder, valParamRef), arg); } } @@ -288,7 +288,7 @@ namespace Slang // if( !val ) { - val = new ErrorIntVal(); + val = m_astBuilder->create<ErrorIntVal>(); } checkedArgs.add(val); } @@ -343,10 +343,10 @@ namespace Slang if( context.disallowNestedConversions ) { // We need an exact match in this case. - if(!GetType(param)->equals(argType)) + if(!GetType(m_astBuilder, param)->equals(argType)) return false; } - else if (!canCoerce(GetType(param), argType, &cost)) + else if (!canCoerce(GetType(m_astBuilder, param), argType, &cost)) { return false; } @@ -354,7 +354,7 @@ namespace Slang } else { - arg = coerce(GetType(param), arg); + arg = coerce(GetType(m_astBuilder, param), arg); } } return true; @@ -396,8 +396,8 @@ namespace Slang DeclRef<GenericTypeConstraintDecl> constraintDeclRef( constraintDecl, subset); - auto sub = GetSub(constraintDeclRef); - auto sup = GetSup(constraintDeclRef); + auto sub = GetSub(m_astBuilder, constraintDeclRef); + auto sup = GetSup(m_astBuilder, constraintDeclRef); auto subTypeWitness = tryGetSubtypeWitness(sub, sup); if(subTypeWitness) @@ -523,7 +523,7 @@ namespace Slang RefPtr<AppExprBase> callExpr = as<InvokeExpr>(context.originalExpr); if(!callExpr) { - callExpr = new InvokeExpr(); + callExpr = m_astBuilder->create<InvokeExpr>(); callExpr->loc = context.loc; for(Index aa = 0; aa < context.argCount; ++aa) @@ -940,7 +940,7 @@ namespace Slang OverloadCandidate candidate; candidate.flavor = OverloadCandidate::Flavor::Func; candidate.item = item; - candidate.resultType = GetResultType(funcDeclRef); + candidate.resultType = GetResultType(m_astBuilder, funcDeclRef); AddOverloadCandidate(context, candidate); } @@ -1037,7 +1037,7 @@ namespace Slang // So the question is then whether a mismatch during the // unification step should be taken as an immediate failure... - TryUnifyTypes(constraints, context.getArgType(aa), GetType(params[aa])); + TryUnifyTypes(constraints, context.getArgType(aa), GetType(m_astBuilder, params[aa])); #endif } } @@ -1086,7 +1086,7 @@ namespace Slang // some just to make code that does, e.g., `float(1.0f)` work. LookupResult initializers = lookUpMember( - getSession(), + m_astBuilder, this, getName("$init"), type); @@ -1106,9 +1106,7 @@ namespace Slang } else if (auto aggTypeDeclRef = item.declRef.as<AggTypeDecl>()) { - auto type = DeclRefType::Create( - getSession(), - aggTypeDeclRef); + auto type = DeclRefType::create(m_astBuilder, aggTypeDeclRef); AddTypeOverloadCandidates(type, context); } else if (auto genericDeclRef = item.declRef.as<GenericDecl>()) @@ -1142,14 +1140,12 @@ namespace Slang } else if( auto typeDefDeclRef = item.declRef.as<TypeDefDecl>() ) { - auto type = getNamedType(getSession(), typeDefDeclRef); + auto type = getNamedType(m_astBuilder, typeDefDeclRef); AddTypeOverloadCandidates(type, context); } else if( auto genericTypeParamDeclRef = item.declRef.as<GenericTypeParamDecl>() ) { - auto type = DeclRefType::Create( - getSession(), - genericTypeParamDeclRef); + auto type = DeclRefType::create(m_astBuilder, genericTypeParamDeclRef); AddTypeOverloadCandidates(type, context); } else @@ -1328,7 +1324,7 @@ namespace Slang { if (!first) sb << ", "; - formatType(sb, GetType(paramDeclRef)); + formatType(sb, GetType(m_astBuilder, paramDeclRef)); first = false; @@ -1356,7 +1352,7 @@ namespace Slang sb << getText(genericValParam.GetName()); sb << ":"; - formatType(sb, GetType(genericValParam)); + formatType(sb, GetType(m_astBuilder, genericValParam)); } else {} @@ -1395,7 +1391,7 @@ namespace Slang else if(auto callableDeclRef = declRef.as<CallableDecl>()) { sb << " -> "; - formatType(sb, GetResultType(callableDeclRef)); + formatType(sb, GetResultType(m_astBuilder, callableDeclRef)); } } @@ -1632,7 +1628,7 @@ namespace Slang { // Nothing at all was found that we could even consider invoking getSink()->diagnose(expr->functionExpr, Diagnostics::expectedFunction, funcExprType); - expr->type = QualType(getSession()->getErrorType()); + expr->type = QualType(m_astBuilder->getErrorType()); return expr; } } @@ -1748,7 +1744,7 @@ namespace Slang // There were multiple viable candidates, but that isn't an error: we just need // to complete all of them and create an overloaded expression as a result. - auto overloadedExpr = new OverloadedExpr2(); + auto overloadedExpr = m_astBuilder->create<OverloadedExpr2>(); overloadedExpr->base = context.baseExpr; for (auto candidate : context.bestCandidates) { diff --git a/source/slang/slang-check-shader.cpp b/source/slang/slang-check-shader.cpp index ec0c5137e..f68439f8a 100644 --- a/source/slang/slang-check-shader.cpp +++ b/source/slang/slang-check-shader.cpp @@ -46,11 +46,13 @@ namespace Slang /// Recursively walk `paramDeclRef` and add any existential/interface specialization parameters to `ioSpecializationParams`. static void _collectExistentialSpecializationParamsRec( + ASTBuilder* astBuilder, SpecializationParams& ioSpecializationParams, DeclRef<VarDeclBase> paramDeclRef); /// Recursively walk `type` and add any existential/interface specialization parameters to `ioSpecializationParams`. static void _collectExistentialSpecializationParamsRec( + ASTBuilder* astBuilder, SpecializationParams& ioSpecializationParams, Type* type, SourceLoc loc) @@ -66,6 +68,7 @@ namespace Slang if( auto parameterGroupType = as<ParameterGroupType>(type) ) { _collectExistentialSpecializationParamsRec( + astBuilder, ioSpecializationParams, parameterGroupType->getElementType(), loc); @@ -95,6 +98,7 @@ namespace Slang for( auto fieldDeclRef : GetFields(structDeclRef, MemberFilterStyle::Instance) ) { _collectExistentialSpecializationParamsRec( + astBuilder, ioSpecializationParams, fieldDeclRef); } @@ -107,24 +111,27 @@ namespace Slang } static void _collectExistentialSpecializationParamsRec( + ASTBuilder* astBuilder, SpecializationParams& ioSpecializationParams, DeclRef<VarDeclBase> paramDeclRef) { _collectExistentialSpecializationParamsRec( + astBuilder, ioSpecializationParams, - GetType(paramDeclRef), + GetType(astBuilder, paramDeclRef), paramDeclRef.getLoc()); } /// Collect any interface/existential specialization parameters for `paramDeclRef` into `ioParamInfo` and `ioSpecializationParams` static void _collectExistentialSpecializationParamsForShaderParam( + ASTBuilder* astBuilder, ShaderParamInfo& ioParamInfo, SpecializationParams& ioSpecializationParams, DeclRef<VarDeclBase> paramDeclRef) { Index beginParamIndex = ioSpecializationParams.getCount(); - _collectExistentialSpecializationParamsRec(ioSpecializationParams, paramDeclRef); + _collectExistentialSpecializationParamsRec(astBuilder, ioSpecializationParams, paramDeclRef); Index endParamIndex = ioSpecializationParams.getCount(); ioParamInfo.firstSpecializationParamIndex = beginParamIndex; @@ -199,6 +206,7 @@ namespace Slang shaderParamInfo.paramDeclRef = paramDeclRef; _collectExistentialSpecializationParamsForShaderParam( + getLinkage()->getASTBuilder(), shaderParamInfo, m_existentialSpecializationParams, paramDeclRef); @@ -617,6 +625,7 @@ namespace Slang // with the correct parameter. // _collectExistentialSpecializationParamsForShaderParam( + getLinkage()->getASTBuilder(), shaderParamInfo, m_specializationParams, makeDeclRef(globalVar.Ptr())); @@ -966,7 +975,7 @@ namespace Slang if(!argType) { sink->diagnose(param.loc, Diagnostics::expectedTypeForSpecializationArg, genericTypeParamDecl); - argType = getLinkage()->getSessionImpl()->getErrorType(); + argType = getLinkage()->getASTBuilder()->getErrorType(); } // TODO: There is a serious flaw to this checking logic if we ever have cases where @@ -1026,7 +1035,7 @@ namespace Slang for(auto constraintDecl : genericTypeParamDecl->getMembersOfType<GenericTypeConstraintDecl>()) { // Get the type that the constraint is enforcing conformance to - auto interfaceType = GetSup(DeclRef<GenericTypeConstraintDecl>(constraintDecl, nullptr)); + auto interfaceType = GetSup(getLinkage()->getASTBuilder(), DeclRef<GenericTypeConstraintDecl>(constraintDecl, nullptr)); // Use our semantic-checking logic to search for a witness to the required conformance auto witness = visitor.tryGetSubtypeWitness(argType, interfaceType); @@ -1058,7 +1067,7 @@ namespace Slang if(!argType) { sink->diagnose(param.loc, Diagnostics::expectedTypeForSpecializationArg, interfaceType); - argType = getLinkage()->getSessionImpl()->getErrorType(); + argType = getLinkage()->getASTBuilder()->getErrorType(); } auto witness = visitor.tryGetSubtypeWitness(argType, interfaceType); @@ -1092,7 +1101,7 @@ namespace Slang if(!intVal) { sink->diagnose(param.loc, Diagnostics::expectedValueOfTypeForSpecializationArg, paramDecl->getType(), paramDecl); - intVal = new ConstantIntVal(0); + intVal = getLinkage()->getASTBuilder()->create<ConstantIntVal>(0); } ModuleSpecializationInfo::GenericArgInfo expandedArg; @@ -1166,7 +1175,7 @@ namespace Slang auto genericDeclRef = m_funcDeclRef.GetParent().as<GenericDecl>(); SLANG_ASSERT(genericDeclRef); // otherwise we wouldn't have generic parameters - RefPtr<GenericSubstitution> genericSubst = new GenericSubstitution(); + RefPtr<GenericSubstitution> genericSubst = getLinkage()->getASTBuilder()->create<GenericSubstitution>(); genericSubst->outer = genericDeclRef.substitutions.substitutions; genericSubst->genericDecl = genericDeclRef.getDecl(); @@ -1184,8 +1193,10 @@ namespace Slang DeclRef<GenericTypeConstraintDecl> constraintDeclRef( constraintDecl, constraintSubst); - auto sub = GetSub(constraintDeclRef); - auto sup = GetSup(constraintDeclRef); + ASTBuilder* astBuilder = getLinkage()->getASTBuilder(); + + auto sub = GetSub(astBuilder, constraintDeclRef); + auto sup = GetSup(astBuilder, constraintDeclRef); auto subTypeWitness = visitor.tryGetSubtypeWitness(sub, sup); if(subTypeWitness) @@ -1360,7 +1371,7 @@ namespace Slang SemanticsVisitor visitor(&sharedSemanticsContext); SpecializationParams specializationParams; - _collectExistentialSpecializationParamsRec(specializationParams, unspecializedType, SourceLoc()); + _collectExistentialSpecializationParamsRec(getASTBuilder(), specializationParams, unspecializedType, SourceLoc()); assert(specializationParams.getCount() == argCount); @@ -1376,7 +1387,7 @@ namespace Slang specializationArgs.add(arg); } - RefPtr<ExistentialSpecializedType> specializedType = new ExistentialSpecializedType(); + RefPtr<ExistentialSpecializedType> specializedType = m_astBuilder->create<ExistentialSpecializedType>(); specializedType->baseType = unspecializedType; specializedType->args = specializationArgs; diff --git a/source/slang/slang-check-stmt.cpp b/source/slang/slang-check-stmt.cpp index fa2eb59a0..71cf97396 100644 --- a/source/slang/slang-check-stmt.cpp +++ b/source/slang/slang-check-stmt.cpp @@ -112,7 +112,7 @@ namespace Slang { RefPtr<Expr> e = expr; e = CheckTerm(e); - e = coerce(getSession()->getBoolType(), e); + e = coerce(m_astBuilder->getBoolType(), e); return e; } @@ -153,8 +153,8 @@ namespace Slang { WithOuterStmt subContext(this, stmt); - stmt->varDecl->type.type = getSession()->getIntType(); - addModifier(stmt->varDecl, new ConstModifier()); + stmt->varDecl->type.type = m_astBuilder->getIntType(); + addModifier(stmt->varDecl, m_astBuilder->create<ConstModifier>()); stmt->varDecl->setCheckState(DeclCheckState::Checked); RefPtr<IntVal> rangeBeginVal; @@ -166,7 +166,7 @@ namespace Slang } else { - RefPtr<ConstantIntVal> rangeBeginConst = new ConstantIntVal(); + RefPtr<ConstantIntVal> rangeBeginConst = m_astBuilder->create<ConstantIntVal>(); rangeBeginConst->value = 0; rangeBeginVal = rangeBeginConst; } @@ -250,7 +250,7 @@ namespace Slang auto function = getParentFunc(); if (!stmt->expression) { - if (function && !function->returnType.equals(getSession()->getVoidType())) + if (function && !function->returnType.equals(m_astBuilder->getVoidType())) { getSink()->diagnose(stmt, Diagnostics::returnNeedsExpression); } @@ -258,7 +258,7 @@ namespace Slang else { stmt->expression = CheckTerm(stmt->expression); - if (!stmt->expression->type->equals(getSession()->getErrorType())) + if (!stmt->expression->type->equals(m_astBuilder->getErrorType())) { if (function) { diff --git a/source/slang/slang-check-type.cpp b/source/slang/slang-check-type.cpp index e6c924be8..db5d555cd 100644 --- a/source/slang/slang-check-type.cpp +++ b/source/slang/slang-check-type.cpp @@ -37,7 +37,7 @@ namespace Slang { return typeType->type; } - return getSession()->getErrorType(); + return m_astBuilder->getErrorType(); } RefPtr<Type> SemanticsVisitor::TranslateTypeNode(const RefPtr<Expr> & node) @@ -97,7 +97,7 @@ namespace Slang { return typeType->type; } - return getSession()->getErrorType(); + return m_astBuilder->getErrorType(); } RefPtr<Type> SemanticsVisitor::ExtractGenericArgType(RefPtr<Expr> exp) @@ -114,7 +114,7 @@ namespace Slang // constant expression in context, then we will instead construct // a dummy "error" value to represent the result. // - val = new ErrorIntVal(); + val = m_astBuilder->create<ErrorIntVal>(); return val; } @@ -149,7 +149,7 @@ namespace Slang DeclRef<GenericDecl> genericDeclRef, List<RefPtr<Expr>> const& args) { - RefPtr<GenericSubstitution> subst = new GenericSubstitution(); + RefPtr<GenericSubstitution> subst = m_astBuilder->create<GenericSubstitution>(); subst->genericDecl = genericDeclRef.getDecl(); subst->outer = genericDeclRef.substitutions.substitutions; @@ -162,9 +162,7 @@ namespace Slang innerDeclRef.decl = GetInner(genericDeclRef); innerDeclRef.substitutions = SubstitutionSet(subst); - return DeclRefType::Create( - getSession(), - innerDeclRef); + return DeclRefType::create(m_astBuilder, innerDeclRef); } bool SemanticsVisitor::CoerceToProperTypeImpl( @@ -216,7 +214,7 @@ namespace Slang if (diagSink) { diagSink->diagnose(typeExp.exp.Ptr(), Diagnostics::genericTypeNeedsArgs, typeExp); - *outProperType = getSession()->getErrorType(); + *outProperType = m_astBuilder->getErrorType(); } return false; } @@ -232,7 +230,7 @@ namespace Slang if (diagSink) { diagSink->diagnose(typeExp.exp.Ptr(), Diagnostics::unimplemented, "can't fill in default for generic type parameter"); - *outProperType = getSession()->getErrorType(); + *outProperType = m_astBuilder->getErrorType(); } return false; } @@ -293,7 +291,7 @@ namespace Slang { // TODO(tfoley): pick the right diagnostic message getSink()->diagnose(result.exp.Ptr(), Diagnostics::invalidTypeVoid); - result.type = getSession()->getErrorType(); + result.type = m_astBuilder->getErrorType(); return result; } } @@ -334,21 +332,18 @@ namespace Slang RefPtr<Type> elementType, RefPtr<IntVal> elementCount) { - auto session = getSession(); - auto vectorGenericDecl = findMagicDecl( - session, "Vector").as<GenericDecl>(); + auto vectorGenericDecl = m_astBuilder->getSharedASTBuilder()->findMagicDecl("Vector").as<GenericDecl>(); + auto vectorTypeDecl = vectorGenericDecl->inner; - auto substitutions = new GenericSubstitution(); + auto substitutions = m_astBuilder->create<GenericSubstitution>(); substitutions->genericDecl = vectorGenericDecl.Ptr(); substitutions->args.add(elementType); substitutions->args.add(elementCount); auto declRef = DeclRef<Decl>(vectorTypeDecl.Ptr(), substitutions); - return DeclRefType::Create( - session, - declRef).as<VectorExpressionType>(); + return DeclRefType::create(m_astBuilder, declRef).as<VectorExpressionType>(); } RefPtr<Expr> SemanticsExprVisitor::visitSharedTypeExpr(SharedTypeExpr* expr) @@ -366,8 +361,8 @@ namespace Slang // We have an expression of the form `__TaggedUnion(A, B, ...)` // which will evaluate to a tagged-union type over `A`, `B`, etc. // - RefPtr<TaggedUnionType> type = new TaggedUnionType(); - expr->type = QualType(getTypeType(type)); + RefPtr<TaggedUnionType> type = m_astBuilder->create<TaggedUnionType>(); + expr->type = QualType(m_astBuilder->getTypeType(type)); for( auto& caseTypeExpr : expr->caseTypes ) { diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp index 83f362ec7..489808a44 100644 --- a/source/slang/slang-compiler.cpp +++ b/source/slang/slang-compiler.cpp @@ -188,7 +188,7 @@ namespace Slang funcDeclRef.GetName(), profile, funcDeclRef); - entryPoint->m_mangledName = getMangledName(funcDeclRef); + entryPoint->m_mangledName = getMangledName(linkage->getASTBuilder(), funcDeclRef); return entryPoint; } diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index 852898de6..2c23a89bc 100644 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -1228,7 +1228,7 @@ namespace Slang SlangMatrixLayoutMode mode); /// Create an initially-empty linkage - Linkage(Session* session); + Linkage(Session* session, ASTBuilder* astBuilder); /// Get the parent session for this linkage Session* getSessionImpl() { return m_session; } @@ -1256,6 +1256,10 @@ namespace Slang NamePool* getNamePool() { return &namePool; } + ASTBuilder* getASTBuilder() { return m_astBuilder; } + + RefPtr<ASTBuilder> m_astBuilder; + // Modules that have been dynamically loaded via `import` // // This is a list of unique modules loaded, in the order they were encountered. @@ -2043,6 +2047,12 @@ namespace Slang Name* tryGetNameObj(String name) { return namePool.tryGetName(name); } // + /// This AST Builder should only be used for creating AST nodes that are global across requests + /// not doing so could lead to memory being consumed but not used. + ASTBuilder* getGlobalASTBuilder() { return globalAstBuilder; } + + RefPtr<ASTBuilder> globalAstBuilder; + // Generated code for stdlib, etc. String stdlibPath; String coreLibraryCode; @@ -2054,72 +2064,8 @@ namespace Slang String getCoreLibraryCode(); String getHLSLLibraryCode(); - // Basic types that we don't want to re-create all the time - RefPtr<Type> errorType; - RefPtr<Type> initializerListType; - RefPtr<Type> overloadedType; - RefPtr<Type> constExprRate; - RefPtr<Type> irBasicBlockType; - - RefPtr<Type> stringType; - RefPtr<Type> enumTypeType; - - RefPtr<Type> builtinTypes[Index(BaseType::CountOf)]; - Dictionary<String, Decl*> magicDecls; - - void initializeTypes(); - - Type* getBoolType(); - Type* getHalfType(); - Type* getFloatType(); - Type* getDoubleType(); - Type* getIntType(); - Type* getInt64Type(); - Type* getUIntType(); - Type* getUInt64Type(); - Type* getVoidType(); - Type* getBuiltinType(BaseType flavor); - - Type* getInitializerListType(); - Type* getOverloadedType(); - Type* getErrorType(); - Type* getStringType(); - - Type* getEnumTypeType(); - - // Construct the type `Ptr<valueType>`, where `Ptr` - // is looked up as a builtin type. - RefPtr<PtrType> getPtrType(RefPtr<Type> valueType); - - // Construct the type `Out<valueType>` - RefPtr<OutType> getOutType(RefPtr<Type> valueType); - - // Construct the type `InOut<valueType>` - RefPtr<InOutType> getInOutType(RefPtr<Type> valueType); - - // Construct the type `Ref<valueType>` - RefPtr<RefType> getRefType(RefPtr<Type> valueType); - - // Construct a pointer type like `Ptr<valueType>`, but where - // the actual type name for the pointer type is given by `ptrTypeName` - RefPtr<PtrTypeBase> getPtrType(RefPtr<Type> valueType, char const* ptrTypeName); - - // Construct a pointer type like `Ptr<valueType>`, but where - // the generic declaration for the pointer type is `genericDecl` - RefPtr<PtrTypeBase> getPtrType(RefPtr<Type> valueType, GenericDecl* genericDecl); - - RefPtr<ArrayExpressionType> getArrayType( - Type* elementType, - IntVal* elementCount); - - RefPtr<VectorExpressionType> getVectorType( - RefPtr<Type> elementType, - RefPtr<IntVal> elementCount); - - SyntaxClass<RefObject> findSyntaxClass(Name* name); - - Dictionary<Name*, SyntaxClass<RefObject> > mapNameToSyntaxClass; + RefPtr<SharedASTBuilder> m_sharedASTBuilder; // cache used by type checking, implemented in check.cpp TypeCheckingCache* typeCheckingCache = nullptr; diff --git a/source/slang/slang-lookup.cpp b/source/slang/slang-lookup.cpp index 1a1d2e621..b174d068c 100644 --- a/source/slang/slang-lookup.cpp +++ b/source/slang/slang-lookup.cpp @@ -173,7 +173,7 @@ LookupResultItem CreateLookupResultItem( } static void _lookUpMembersInValue( - Session* session, + ASTBuilder* astBuilder, Name* name, DeclRef<Decl> valueDeclRef, LookupRequest const& request, @@ -187,7 +187,7 @@ static void _lookUpMembersInValue( /// inheritance clauses, etc. /// static void _lookUpDirectAndTransparentMembers( - Session* session, + ASTBuilder* astBuilder, Name* name, DeclRef<ContainerDecl> containerDeclRef, LookupRequest const& request, @@ -236,7 +236,7 @@ static void _lookUpDirectAndTransparentMembers( memberRefBreadcrumb.prev = inBreadcrumbs; _lookUpMembersInValue( - session, + astBuilder, name, transparentMemberDeclRef, request, @@ -247,7 +247,7 @@ static void _lookUpDirectAndTransparentMembers( /// Perform "direct" lookup in a container declaration LookupResult lookUpDirectAndTransparentMembers( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* semantics, Name* name, DeclRef<ContainerDecl> containerDeclRef, @@ -258,7 +258,7 @@ LookupResult lookUpDirectAndTransparentMembers( request.mask = mask; LookupResult result; _lookUpDirectAndTransparentMembers( - session, + astBuilder, name, containerDeclRef, request, @@ -269,6 +269,7 @@ LookupResult lookUpDirectAndTransparentMembers( static RefPtr<SubtypeWitness> _makeSubtypeWitness( + ASTBuilder* astBuilder, Type* subType, SubtypeWitness* subToMidWitness, Type* superType, @@ -276,7 +277,7 @@ static RefPtr<SubtypeWitness> _makeSubtypeWitness( { if(subToMidWitness) { - RefPtr<TransitiveSubtypeWitness> transitiveWitness = new TransitiveSubtypeWitness(); + RefPtr<TransitiveSubtypeWitness> transitiveWitness = astBuilder->create<TransitiveSubtypeWitness>(); transitiveWitness->subToMid = subToMidWitness; transitiveWitness->midToSup = midToSuperConstraint; transitiveWitness->sub = subType; @@ -285,7 +286,7 @@ static RefPtr<SubtypeWitness> _makeSubtypeWitness( } else { - RefPtr<DeclaredSubtypeWitness> declaredWitness = new DeclaredSubtypeWitness(); + RefPtr<DeclaredSubtypeWitness> declaredWitness = astBuilder->create<DeclaredSubtypeWitness>(); declaredWitness->declRef = midToSuperConstraint; declaredWitness->sub = subType; declaredWitness->sup = superType; @@ -295,7 +296,7 @@ static RefPtr<SubtypeWitness> _makeSubtypeWitness( // Same as the above, but we are specializing a type instead of a decl-ref static RefPtr<Type> _maybeSpecializeSuperType( - Session* session, + ASTBuilder* astBuilder, Type* superType, SubtypeWitness* subIsSuperWitness) { @@ -303,14 +304,14 @@ static RefPtr<Type> _maybeSpecializeSuperType( { if (auto superInterfaceDeclRef = superDeclRefType->declRef.as<InterfaceDecl>()) { - RefPtr<ThisTypeSubstitution> thisTypeSubst = new ThisTypeSubstitution(); + RefPtr<ThisTypeSubstitution> thisTypeSubst = astBuilder->create<ThisTypeSubstitution>(); thisTypeSubst->interfaceDecl = superInterfaceDeclRef.getDecl(); thisTypeSubst->witness = subIsSuperWitness; thisTypeSubst->outer = superInterfaceDeclRef.substitutions.substitutions; auto specializedInterfaceDeclRef = DeclRef<Decl>(superInterfaceDeclRef.getDecl(), thisTypeSubst); - auto specializedInterfaceType = DeclRefType::Create(session, specializedInterfaceDeclRef); + auto specializedInterfaceType = DeclRefType::create(astBuilder, specializedInterfaceDeclRef); return specializedInterfaceType; } } @@ -319,7 +320,7 @@ static RefPtr<Type> _maybeSpecializeSuperType( } static void _lookUpMembersInType( - Session* session, + ASTBuilder* astBuilder, Name* name, RefPtr<Type> type, LookupRequest const& request, @@ -327,7 +328,7 @@ static void _lookUpMembersInType( BreadcrumbInfo* breadcrumbs); static void _lookUpMembersInSuperTypeImpl( - Session* session, + ASTBuilder* astBuilder, Name* name, Type* leafType, Type* superType, @@ -338,7 +339,7 @@ static void _lookUpMembersInSuperTypeImpl( static void _lookUpMembersInSuperType( - Session* session, + ASTBuilder* astBuilder, Name* name, Type* leafType, SubtypeWitness* leafIsIntermediateWitness, @@ -355,12 +356,13 @@ static void _lookUpMembersInSuperType( // The super-type in the constraint (e.g., `Foo` in `T : Foo`) // will tell us a type we should use for lookup. // - auto superType = GetSup(intermediateIsSuperConstraint); + auto superType = GetSup(astBuilder, intermediateIsSuperConstraint); // // We will go ahead and perform lookup using `superType`, // after dealing with some details. auto leafIsSuperWitness = _makeSubtypeWitness( + astBuilder, leafType, leafIsIntermediateWitness, superType, @@ -372,7 +374,7 @@ static void _lookUpMembersInSuperType( // be applied to any members we look up. // superType = _maybeSpecializeSuperType( - session, + astBuilder, superType, leafIsSuperWitness); @@ -394,11 +396,11 @@ static void _lookUpMembersInSuperType( // we might end up seeing the same interface via different "paths" and // we wouldn't want that to lead to overload-resolution failure. // - _lookUpMembersInSuperTypeImpl(session, name, leafType, superType, leafIsSuperWitness, request, ioResult, &breadcrumb); + _lookUpMembersInSuperTypeImpl(astBuilder, name, leafType, superType, leafIsSuperWitness, request, ioResult, &breadcrumb); } static void _lookUpMembersInSuperTypeDeclImpl( - Session* session, + ASTBuilder* astBuilder, Name* name, Type* leafType, Type* superType, @@ -435,7 +437,7 @@ static void _lookUpMembersInSuperTypeDeclImpl( // We want constraints of the form `T : Foo` where `T` is the // generic parameter in question, and `Foo` is whatever we are // constraining it to. - auto subType = GetSub(constraintDeclRef); + auto subType = GetSub(astBuilder, constraintDeclRef); auto subDeclRefType = as<DeclRefType>(subType); if(!subDeclRefType) continue; @@ -443,7 +445,7 @@ static void _lookUpMembersInSuperTypeDeclImpl( continue; _lookUpMembersInSuperType( - session, + astBuilder, name, leafType, leafIsSuperWitness, @@ -458,7 +460,7 @@ static void _lookUpMembersInSuperTypeDeclImpl( for (auto constraintDeclRef : getMembersOfType<TypeConstraintDecl>(declRef.as<ContainerDecl>())) { _lookUpMembersInSuperType( - session, + astBuilder, name, leafType, leafIsSuperWitness, @@ -474,7 +476,7 @@ static void _lookUpMembersInSuperTypeDeclImpl( // type or an `extension`, so the first thing to do is to look for // matching members declared directly in the body of the type/`extension`. // - _lookUpDirectAndTransparentMembers(session, name, aggTypeDeclBaseRef, request, ioResult, inBreadcrumbs); + _lookUpDirectAndTransparentMembers(astBuilder, name, aggTypeDeclBaseRef, request, ioResult, inBreadcrumbs); // There are further lookup steps that we can only perform when a // semantic checking context is available to us. That means that @@ -506,7 +508,7 @@ static void _lookUpMembersInSuperTypeDeclImpl( // was found through an extension. // _lookUpMembersInSuperTypeDeclImpl( - session, + astBuilder, name, leafType, superType, @@ -525,14 +527,14 @@ static void _lookUpMembersInSuperTypeDeclImpl( for (auto inheritanceDeclRef : getMembersOfType<InheritanceDecl>(aggTypeDeclBaseRef)) { ensureDecl(semantics, inheritanceDeclRef.getDecl(), DeclCheckState::CanUseBaseOfInheritanceDecl); - _lookUpMembersInSuperType(session, name, leafType, leafIsSuperWitness, inheritanceDeclRef, request, ioResult, inBreadcrumbs); + _lookUpMembersInSuperType(astBuilder, name, leafType, leafIsSuperWitness, inheritanceDeclRef, request, ioResult, inBreadcrumbs); } } } } static void _lookUpMembersInSuperTypeImpl( - Session* session, + ASTBuilder* astBuilder, Name* name, Type* leafType, Type* superType, @@ -553,7 +555,7 @@ static void _lookUpMembersInSuperTypeImpl( // Recursively perform lookup on the result of deref _lookUpMembersInType( - session, + astBuilder, name, pointerLikeType->elementType, request, ioResult, &derefBreacrumb); return; } @@ -564,7 +566,7 @@ static void _lookUpMembersInSuperTypeImpl( { auto declRef = declRefType->declRef; - _lookUpMembersInSuperTypeDeclImpl(session, name, leafType, superType, leafIsSuperWitness, declRef, request, ioResult, inBreadcrumbs); + _lookUpMembersInSuperTypeDeclImpl(astBuilder, name, leafType, superType, leafIsSuperWitness, declRef, request, ioResult, inBreadcrumbs); } } @@ -580,7 +582,7 @@ static void _lookUpMembersInSuperTypeImpl( /// set of members visible on `type`. /// static void _lookUpMembersInType( - Session* session, + ASTBuilder* astBuilder, Name* name, RefPtr<Type> type, LookupRequest const& request, @@ -592,7 +594,7 @@ static void _lookUpMembersInType( return; } - _lookUpMembersInSuperTypeImpl(session, name, type, type, nullptr, request, ioResult, breadcrumbs); + _lookUpMembersInSuperTypeImpl(astBuilder, name, type, type, nullptr, request, ioResult, breadcrumbs); } /// Look up members by `name` in the given `valueDeclRef`. @@ -602,7 +604,7 @@ static void _lookUpMembersInType( /// kind of lookup we'd expect for `valueDeclRef.<name>`. /// static void _lookUpMembersInValue( - Session* session, + ASTBuilder* astBuilder, Name* name, DeclRef<Decl> valueDeclRef, LookupRequest const& request, @@ -613,17 +615,13 @@ static void _lookUpMembersInValue( // be reduced to the problem of looking up `name` // in the *type* of that value. // - auto valueType = getTypeForDeclRef( - session, - valueDeclRef, - SourceLoc()); - return _lookUpMembersInType( - session, - name, valueType, request, ioResult, breadcrumbs); + auto valueType = getTypeForDeclRef(astBuilder, valueDeclRef, SourceLoc()); + + return _lookUpMembersInType(astBuilder, name, valueType, request, ioResult, breadcrumbs); } static void _lookUpInScopes( - Session* session, + ASTBuilder* astBuilder, Name* name, LookupRequest const& request, LookupResult& result) @@ -656,7 +654,7 @@ static void _lookUpInScopes( // just a decl. // DeclRef<ContainerDecl> containerDeclRef = - DeclRef<Decl>(containerDecl, createDefaultSubstitutions(session, containerDecl)).as<ContainerDecl>(); + DeclRef<Decl>(containerDecl, createDefaultSubstitutions(astBuilder, containerDecl)).as<ContainerDecl>(); // If the container we are looking into represents a type // or an `extension` of a type, then we need to treat @@ -693,15 +691,15 @@ static void _lookUpInScopes( // declaration, then the `this` expression will have // a type that uses the "target type" of the `extension`. // - type = GetTargetType(extDeclRef); + type = GetTargetType(astBuilder, extDeclRef); } else { assert(aggTypeDeclBaseRef.as<AggTypeDecl>()); - type = DeclRefType::Create(session, aggTypeDeclBaseRef); + type = DeclRefType::create(astBuilder, aggTypeDeclBaseRef); } - _lookUpMembersInType(session, name, type, request, result, &breadcrumb); + _lookUpMembersInType(astBuilder, name, type, request, result, &breadcrumb); } else { @@ -709,7 +707,7 @@ static void _lookUpInScopes( // type or `extension` declaration, so we can look up members // in that scope much more simply. // - _lookUpDirectAndTransparentMembers(session, name, containerDeclRef, request, result, nullptr); + _lookUpDirectAndTransparentMembers(astBuilder, name, containerDeclRef, request, result, nullptr); } // Before we proceed up to the next outer scope to perform lookup @@ -779,7 +777,7 @@ static void _lookUpInScopes( } LookupResult lookUp( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* semantics, Name* name, RefPtr<Scope> scope, @@ -791,12 +789,12 @@ LookupResult lookUp( request.mask = mask; LookupResult result; - _lookUpInScopes(session, name, request, result); + _lookUpInScopes(astBuilder, name, request, result); return result; } void lookUpMemberImpl( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* semantics, Name* name, Type* type, @@ -805,7 +803,7 @@ void lookUpMemberImpl( LookupMask mask); LookupResult lookUpMember( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* semantics, Name* name, Type* type, @@ -816,7 +814,7 @@ LookupResult lookUpMember( request.mask = mask; LookupResult result; - _lookUpMembersInType(session, name, type, request, result, nullptr); + _lookUpMembersInType(astBuilder, name, type, request, result, nullptr); return result; } diff --git a/source/slang/slang-lookup.h b/source/slang/slang-lookup.h index 0f44121c6..253355d7b 100644 --- a/source/slang/slang-lookup.h +++ b/source/slang/slang-lookup.h @@ -18,7 +18,7 @@ void buildMemberDictionary(ContainerDecl* decl); // Look up a name in the given scope, proceeding up through // parent scopes as needed. LookupResult lookUp( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* semantics, Name* name, RefPtr<Scope> scope, @@ -26,7 +26,7 @@ LookupResult lookUp( // Perform member lookup in the context of a type LookupResult lookUpMember( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* semantics, Name* name, Type* type, @@ -34,7 +34,7 @@ LookupResult lookUpMember( /// Perform "direct" lookup in a container declaration LookupResult lookUpDirectAndTransparentMembers( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* semantics, Name* name, DeclRef<ContainerDecl> containerDeclRef, @@ -43,7 +43,7 @@ LookupResult lookUpDirectAndTransparentMembers( // TODO: this belongs somewhere else QualType getTypeForDeclRef( - Session* session, + ASTBuilder* astBuilder, SemanticsVisitor* sema, DiagnosticSink* sink, DeclRef<Decl> declRef, @@ -51,7 +51,7 @@ QualType getTypeForDeclRef( SourceLoc loc); QualType getTypeForDeclRef( - Session* session, + ASTBuilder* astBuilder, DeclRef<Decl> declRef, SourceLoc loc); diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp index 5b4694d36..f612e4ade 100644 --- a/source/slang/slang-lower-to-ir.cpp +++ b/source/slang/slang-lower-to-ir.cpp @@ -360,6 +360,8 @@ struct SharedIRGenContext struct IRGenContext { + ASTBuilder* astBuilder; + // Shared state for the IR generation process SharedIRGenContext* shared; @@ -378,8 +380,9 @@ struct IRGenContext // might be insufficient. LoweredValInfo thisVal; - explicit IRGenContext(SharedIRGenContext* inShared) + explicit IRGenContext(SharedIRGenContext* inShared, ASTBuilder* inAstBuilder) : shared(inShared) + , astBuilder(inAstBuilder) , env(&inShared->globalEnv) , irBuilder(nullptr) {} @@ -969,7 +972,7 @@ static void addLinkageDecoration( IRInst* inst, Decl* decl) { - String mangledName = getMangledName(decl); + String mangledName = getMangledName(context->astBuilder, decl); if (context->shared->m_obfuscateCode) { @@ -1025,7 +1028,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower LoweredValInfo visitGenericParamIntVal(GenericParamIntVal* val) { return emitDeclRef(context, val->declRef, - lowerType(context, GetType(val->declRef))); + lowerType(context, GetType(context->astBuilder, val->declRef))); } LoweredValInfo visitDeclaredSubtypeWitness(DeclaredSubtypeWitness* val) @@ -1176,14 +1179,14 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower // for emitting the signature of a `CallableDecl`, and we should // try to re-use that if at all possible. // - auto irParamType = lowerType(context, GetType(paramDeclRef)); + auto irParamType = lowerType(context, GetType(context->astBuilder, paramDeclRef)); auto irParam = subBuilder->emitParam(irParamType); irParams.add(irParam); irParamTypes.add(irParamType); } - auto irResultType = lowerType(context, GetResultType(callableDeclRef)); + auto irResultType = lowerType(context, GetResultType(context->astBuilder, callableDeclRef)); auto irFuncType = subBuilder->getFuncType( irParamTypes, @@ -1481,7 +1484,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower IRType* visitExtractExistentialType(ExtractExistentialType* type) { auto declRef = type->declRef; - auto existentialType = lowerType(context, GetType(declRef)); + auto existentialType = lowerType(context, GetType(context->astBuilder, declRef)); IRInst* existentialVal = getSimpleVal(context, emitDeclRef(context, declRef, existentialType)); return getBuilder()->emitExtractExistentialType(existentialVal); } @@ -1489,7 +1492,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower LoweredValInfo visitExtractExistentialSubtypeWitness(ExtractExistentialSubtypeWitness* witness) { auto declRef = witness->declRef; - auto existentialType = lowerType(context, GetType(declRef)); + auto existentialType = lowerType(context, GetType(context->astBuilder, declRef)); IRInst* existentialVal = getSimpleVal(context, emitDeclRef(context, declRef, existentialType)); return LoweredValInfo::simple(getBuilder()->emitExtractExistentialWitnessTable(existentialVal)); } @@ -1520,7 +1523,7 @@ struct ValLoweringVisitor : ValVisitor<ValLoweringVisitor, LoweredValInfo, Lower // getBuilder()->addExportDecoration( irType, - getMangledTypeName(type).getUnownedSlice()); + getMangledTypeName(context->astBuilder, type).getUnownedSlice()); } return LoweredValInfo::simple(irType); } @@ -1922,7 +1925,7 @@ DeclRef<Decl> createDefaultSpecializedDeclRefImpl(IRGenContext* context, Decl* d { DeclRef<Decl> declRef; declRef.decl = decl; - declRef.substitutions = createDefaultSubstitutions(context->getSession(), decl); + declRef.substitutions = createDefaultSubstitutions(context->astBuilder, decl); return declRef; } // @@ -1950,11 +1953,11 @@ RefPtr<Type> getThisParamTypeForContainer( { if( auto aggTypeDeclRef = parentDeclRef.as<AggTypeDecl>() ) { - return DeclRefType::Create(context->getSession(), aggTypeDeclRef); + return DeclRefType::create(context->astBuilder, aggTypeDeclRef); } else if( auto extensionDeclRef = parentDeclRef.as<ExtensionDecl>() ) { - return GetTargetType(extensionDeclRef); + return GetTargetType(context->astBuilder, extensionDeclRef); } return nullptr; @@ -1984,6 +1987,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> IRGenContext* context; IRBuilder* getBuilder() { return context->irBuilder; } + ASTBuilder* getASTBuilder() { return context->astBuilder; } // Lower an expression that should have the same l-value-ness // as the visitor itself. @@ -2514,7 +2518,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> for (auto paramDeclRef : getMembersOfType<ParamDecl>(funcDeclRef)) { auto paramDecl = paramDeclRef.getDecl(); - IRType* paramType = lowerType(context, GetType(paramDeclRef)); + IRType* paramType = lowerType(context, GetType(getASTBuilder(), paramDeclRef)); auto paramDirection = getParameterDirection(paramDecl); UInt argIndex = argCounter++; @@ -2529,7 +2533,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> // but there are still parameters remaining. This must mean // that these parameters have default argument expressions // associated with them. - argExpr = getInitExpr(paramDeclRef); + argExpr = getInitExpr(getASTBuilder(), paramDeclRef); // Assert that such an expression must have been present. SLANG_ASSERT(argExpr); @@ -2879,7 +2883,7 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> LoweredValInfo visitExtractExistentialValueExpr(ExtractExistentialValueExpr* expr) { - auto existentialType = lowerType(context, GetType(expr->declRef)); + auto existentialType = lowerType(context, GetType(getASTBuilder(), expr->declRef)); auto existentialVal = getSimpleVal(context, emitDeclRef(context, expr->declRef, existentialType)); auto openedType = lowerType(context, expr->type); @@ -4461,9 +4465,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo> } else { - subType = DeclRefType::Create( - context->getSession(), - makeDeclRef(parentDecl)); + subType = DeclRefType::create(context->astBuilder, makeDeclRef(parentDecl)); } // What is the super-type that we have declared we inherit from? @@ -4473,7 +4475,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo> // on the type that is conforming, and the type that it conforms to. // // TODO: This approach doesn't really make sense for generic `extension` conformances. - auto mangledName = getMangledNameForConformanceWitness(subType, superType); + auto mangledName = getMangledNameForConformanceWitness(context->astBuilder, subType, superType); // A witness table may need to be generic, if the outer // declaration (either a type declaration or an `extension`) @@ -6657,9 +6659,7 @@ static void lowerProgramEntryPointToIR( // First, lower the entry point like an ordinary function - - auto session = context->getSession(); - auto entryPointFuncType = lowerType(context, getFuncType(session, entryPointFuncDeclRef)); + auto entryPointFuncType = lowerType(context, getFuncType(context->astBuilder, entryPointFuncDeclRef)); auto builder = context->irBuilder; builder->setInsertInto(builder->getModule()->getModuleInst()); @@ -6669,7 +6669,7 @@ static void lowerProgramEntryPointToIR( if(!loweredEntryPointFunc->findDecoration<IRLinkageDecoration>()) { - builder->addExportDecoration(loweredEntryPointFunc, getMangledName(entryPointFuncDeclRef).getUnownedSlice()); + builder->addExportDecoration(loweredEntryPointFunc, getMangledName(context->astBuilder, entryPointFuncDeclRef).getUnownedSlice()); } // We may have shader parameters of interface/existential type, @@ -6725,6 +6725,7 @@ static void ensureAllDeclsRec( } IRModule* generateIRForTranslationUnit( + ASTBuilder* astBuilder, TranslationUnitRequest* translationUnit) { auto compileRequest = translationUnit->compileRequest; @@ -6736,7 +6737,7 @@ IRModule* generateIRForTranslationUnit( translationUnit->getModuleDecl()); SharedIRGenContext* sharedContext = &sharedContextStorage; - IRGenContext contextStorage(sharedContext); + IRGenContext contextStorage(sharedContext, astBuilder); IRGenContext* context = &contextStorage; SharedIRBuilder sharedBuilderStorage; @@ -6926,7 +6927,7 @@ struct SpecializedComponentTypeIRGenContext : ComponentTypeVisitor ); SharedIRGenContext* sharedContext = &sharedContextStorage; - IRGenContext contextStorage(sharedContext); + IRGenContext contextStorage(sharedContext, linkage->getASTBuilder()); context = &contextStorage; SharedIRBuilder sharedBuilderStorage; @@ -7034,8 +7035,8 @@ RefPtr<IRModule> TargetProgram::getOrCreateIRModuleForLayout(DiagnosticSink* sin /// Specialized IR generation context for when generating IR for layouts. struct IRLayoutGenContext : IRGenContext { - IRLayoutGenContext(SharedIRGenContext* shared) - : IRGenContext(shared) + IRLayoutGenContext(SharedIRGenContext* shared, ASTBuilder* astBuilder) + : IRGenContext(shared, astBuilder) {} /// Cache for custom key instructions used for entry-point parameter layout information. @@ -7325,7 +7326,9 @@ RefPtr<IRModule> TargetProgram::createIRModuleForLayout(DiagnosticSink* sink) linkage->m_obfuscateCode); auto sharedContext = &sharedContextStorage; - IRLayoutGenContext contextStorage(sharedContext); + ASTBuilder* astBuilder = linkage->getASTBuilder(); + + IRLayoutGenContext contextStorage(sharedContext, astBuilder); auto context = &contextStorage; SharedIRBuilder sharedBuilderStorage; @@ -7375,12 +7378,12 @@ RefPtr<IRModule> TargetProgram::createIRModuleForLayout(DiagnosticSink* sink) if(!funcDeclRef) continue; - auto irFuncType = lowerType(context, getFuncType(session, funcDeclRef)); + auto irFuncType = lowerType(context, getFuncType(astBuilder, funcDeclRef)); auto irFunc = getSimpleVal(context, emitDeclRef(context, funcDeclRef, irFuncType)); if( !irFunc->findDecoration<IRLinkageDecoration>() ) { - builder->addImportDecoration(irFunc, getMangledName(funcDeclRef).getUnownedSlice()); + builder->addImportDecoration(irFunc, getMangledName(astBuilder, funcDeclRef).getUnownedSlice()); } auto irEntryPointLayout = lowerEntryPointLayout(context, entryPointLayout); diff --git a/source/slang/slang-lower-to-ir.h b/source/slang/slang-lower-to-ir.h index 33dfd9d27..dbf2e550a 100644 --- a/source/slang/slang-lower-to-ir.h +++ b/source/slang/slang-lower-to-ir.h @@ -27,6 +27,7 @@ namespace Slang /// that are imported before code generation can be performed. /// IRModule* generateIRForTranslationUnit( + ASTBuilder* astBuilder, TranslationUnitRequest* translationUnit); /// Generate an IR module to represent the specializations applied by `componentType`. diff --git a/source/slang/slang-mangle.cpp b/source/slang/slang-mangle.cpp index 0ecc12b45..5e141228d 100644 --- a/source/slang/slang-mangle.cpp +++ b/source/slang/slang-mangle.cpp @@ -7,6 +7,11 @@ namespace Slang { struct ManglingContext { + ManglingContext(ASTBuilder* inAstBuilder): + astBuilder(inAstBuilder) + { + } + ASTBuilder* astBuilder; StringBuilder sb; }; @@ -130,7 +135,7 @@ namespace Slang } else if( auto namedType = dynamicCast<NamedExpressionType>(type) ) { - emitType(context, GetType(namedType->declRef)); + emitType(context, GetType(context->astBuilder, namedType->declRef)); } else if( auto declRefType = dynamicCast<DeclRefType>(type) ) { @@ -246,7 +251,7 @@ namespace Slang if(auto inheritanceDeclRef = declRef.as<InheritanceDecl>()) { emit(context, "I"); - emitType(context, GetSup(inheritanceDeclRef)); + emitType(context, GetSup(context->astBuilder, inheritanceDeclRef)); return; } @@ -259,7 +264,7 @@ namespace Slang // that is in the same module as the type it extends should // be treated as equivalent to the type itself. emit(context, "X"); - emitType(context, GetTargetType(extensionDeclRef)); + emitType(context, GetTargetType(context->astBuilder, extensionDeclRef)); return; } @@ -334,7 +339,7 @@ namespace Slang else if(auto genericValueParamDecl = mm.as<GenericValueParamDecl>()) { emitRaw(context, "v"); - emitType(context, GetType(genericValueParamDecl)); + emitType(context, GetType(context->astBuilder, genericValueParamDecl)); } else if(mm.as<GenericTypeConstraintDecl>()) { @@ -366,14 +371,14 @@ namespace Slang for(auto paramDeclRef : parameters) { - emitType(context, GetType(paramDeclRef)); + emitType(context, GetType(context->astBuilder, paramDeclRef)); } // Don't print result type for an initializer/constructor, // since it is implicit in the qualified name. if (!callableDeclRef.is<ConstructorDecl>()) { - emitType(context, GetResultType(callableDeclRef)); + emitType(context, GetResultType(context->astBuilder, callableDeclRef)); } } } @@ -419,29 +424,30 @@ namespace Slang emitQualifiedName(context, declRef); } - String getMangledName(DeclRef<Decl> const& declRef) + String getMangledName(ASTBuilder* astBuilder, DeclRef<Decl> const& declRef) { - ManglingContext context; + ManglingContext context(astBuilder); mangleName(&context, declRef); return context.sb.ProduceString(); } - String getMangledName(DeclRefBase const & declRef) + String getMangledName(ASTBuilder* astBuilder, DeclRefBase const & declRef) { - return getMangledName( + return getMangledName(astBuilder, DeclRef<Decl>(declRef.decl, declRef.substitutions)); } - String getMangledName(Decl* decl) + String getMangledName(ASTBuilder* astBuilder, Decl* decl) { - return getMangledName(makeDeclRef(decl)); + return getMangledName(astBuilder, makeDeclRef(decl)); } String getMangledNameForConformanceWitness( + ASTBuilder* astBuilder, DeclRef<Decl> sub, DeclRef<Decl> sup) { - ManglingContext context; + ManglingContext context(astBuilder); emitRaw(&context, "_SW"); emitQualifiedName(&context, sub); emitQualifiedName(&context, sup); @@ -449,6 +455,7 @@ namespace Slang } String getMangledNameForConformanceWitness( + ASTBuilder* astBuilder, DeclRef<Decl> sub, Type* sup) { @@ -457,7 +464,7 @@ namespace Slang // // {Conforms(sub,sup)} => _SW{sub}{sup} // - ManglingContext context; + ManglingContext context(astBuilder); emitRaw(&context, "_SW"); emitQualifiedName(&context, sub); emitType(&context, sup); @@ -465,6 +472,7 @@ namespace Slang } String getMangledNameForConformanceWitness( + ASTBuilder* astBuilder, Type* sub, Type* sup) { @@ -473,16 +481,16 @@ namespace Slang // // {Conforms(sub,sup)} => _SW{sub}{sup} // - ManglingContext context; + ManglingContext context(astBuilder); emitRaw(&context, "_SW"); emitType(&context, sub); emitType(&context, sup); return context.sb.ProduceString(); } - String getMangledTypeName(Type* type) + String getMangledTypeName(ASTBuilder* astBuilder, Type* type) { - ManglingContext context; + ManglingContext context(astBuilder); emitType(&context, type); return context.sb.ProduceString(); } diff --git a/source/slang/slang-mangle.h b/source/slang/slang-mangle.h index 186f8bae4..e579ebfda 100644 --- a/source/slang/slang-mangle.h +++ b/source/slang/slang-mangle.h @@ -10,22 +10,27 @@ namespace Slang { struct IRSpecialize; - String getMangledName(Decl* decl); - String getMangledName(DeclRef<Decl> const & declRef); - String getMangledName(DeclRefBase const & declRef); + String getMangledName(ASTBuilder* astBuilder, Decl* decl); + String getMangledName(ASTBuilder* astBuilder, DeclRef<Decl> const & declRef); + String getMangledName(ASTBuilder* astBuilder, DeclRefBase const & declRef); String getHashedName(const UnownedStringSlice& mangledName); String getMangledNameForConformanceWitness( + ASTBuilder* astBuilder, Type* sub, Type* sup); String getMangledNameForConformanceWitness( + ASTBuilder* astBuilder, DeclRef<Decl> sub, DeclRef<Decl> sup); String getMangledNameForConformanceWitness( + ASTBuilder* astBuilder, DeclRef<Decl> sub, Type* sup); - String getMangledTypeName(Type* type); + String getMangledTypeName( + ASTBuilder* astBuilder, + Type* type); } #endif diff --git a/source/slang/slang-parameter-binding.cpp b/source/slang/slang-parameter-binding.cpp index 39cf16229..c4f7dc9d5 100644 --- a/source/slang/slang-parameter-binding.cpp +++ b/source/slang/slang-parameter-binding.cpp @@ -407,6 +407,8 @@ struct ParameterBindingContext TargetRequest* getTargetRequest() { return shared->getTargetRequest(); } LayoutRulesFamilyImpl* getRulesFamily() { return layoutContext.getRulesFamily(); } + ASTBuilder* getASTBuilder() { return shared->getLinkage()->getASTBuilder(); } + Linkage* getLinkage() { return shared->getLinkage(); } }; @@ -700,10 +702,12 @@ static void collectGlobalScopeParameter( ShaderParamInfo const& shaderParamInfo, SubstitutionSet globalGenericSubst) { + auto astBuilder = context->getASTBuilder(); + auto varDeclRef = shaderParamInfo.paramDeclRef; // We apply any substitutions for global generic parameters here. - auto type = GetType(varDeclRef)->substitute(globalGenericSubst).as<Type>(); + auto type = GetType(astBuilder, varDeclRef)->substitute(astBuilder, globalGenericSubst).as<Type>(); // We use a single operation to both check whether the // variable represents a shader parameter, and to compute @@ -1922,7 +1926,7 @@ static RefPtr<TypeLayout> processEntryPointVaryingParameter( auto fieldTypeLayout = processEntryPointVaryingParameterDecl( context, field.getDecl(), - GetType(field), + GetType(context->getASTBuilder(), field), state, fieldVarLayout); @@ -2039,7 +2043,7 @@ static RefPtr<TypeLayout> computeEntryPointParameterTypeLayout( RefPtr<VarLayout> paramVarLayout, EntryPointParameterState& state) { - auto paramType = GetType(paramDeclRef); + auto paramType = GetType(context->getASTBuilder(), paramDeclRef); SLANG_ASSERT(paramType); if( paramDeclRef.getDecl()->hasModifier<HLSLUniformModifier>() ) @@ -2431,6 +2435,8 @@ static RefPtr<EntryPointLayout> collectEntryPointParameters( EntryPoint* entryPoint, EntryPoint::EntryPointSpecializationInfo* specializationInfo) { + auto astBuilder = context->getASTBuilder(); + // We will take responsibility for creating and filling in // the `EntryPointLayout` object here. // @@ -2471,7 +2477,7 @@ static RefPtr<EntryPointLayout> collectEntryPointParameters( if(specializationInfo) entryPointFuncDeclRef = specializationInfo->specializedFuncDeclRef; - auto entryPointType = DeclRefType::Create(context->getLinkage()->getSessionImpl(), entryPointFuncDeclRef); + auto entryPointType = DeclRefType::create(astBuilder, entryPointFuncDeclRef); entryPointLayout->entryPoint = entryPointFuncDeclRef; @@ -2575,10 +2581,10 @@ static RefPtr<EntryPointLayout> collectEntryPointParameters( // TODO: Ideally we should make the layout process more robust to empty/void // types and apply this logic unconditionally. // - auto resultType = GetResultType(entryPointFuncDeclRef); + auto resultType = GetResultType(astBuilder, entryPointFuncDeclRef); SLANG_ASSERT(resultType); - if( !resultType->equals(resultType->getSession()->getVoidType()) ) + if( !resultType->equals(astBuilder->getVoidType()) ) { state.loc = entryPointFuncDeclRef.getLoc(); state.directionMask = kEntryPointParameterDirection_Output; diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index f8622964f..fec7147b5 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -84,6 +84,7 @@ namespace Slang public: NamePool* namePool; SourceLanguage sourceLanguage; + ASTBuilder* astBuilder; NamePool* getNamePool() { return namePool; } SourceLanguage getSourceLanguage() { return sourceLanguage; } @@ -131,19 +132,18 @@ namespace Slang currentScope = currentScope->parent; } Parser( - Session* session, + ASTBuilder* inAstBuilder, TokenSpan const& _tokens, DiagnosticSink * sink, RefPtr<Scope> const& outerScope) : tokenReader(_tokens) + , astBuilder(inAstBuilder) , sink(sink) , outerScope(outerScope) - , m_session(session) {} Parser(const Parser & other) = default; - Session* m_session = nullptr; - Session* getSession() { return m_session; } + //Session* getSession() { return m_session; } Token ReadToken(); Token ReadToken(TokenType type); @@ -588,7 +588,7 @@ namespace Slang RefPtr<RefObject> ParseTypeDef(Parser* parser, void* /*userData*/) { - RefPtr<TypeDefDecl> typeDefDecl = new TypeDefDecl(); + RefPtr<TypeDefDecl> typeDefDecl = parser->astBuilder->create<TypeDefDecl>(); // TODO(tfoley): parse an actual declarator auto type = parser->ParseTypeExp(); @@ -725,7 +725,7 @@ namespace Slang Token nameToken = parseAttributeName(parser); - RefPtr<UncheckedAttribute> modifier = new UncheckedAttribute(); + RefPtr<UncheckedAttribute> modifier = parser->astBuilder->create<UncheckedAttribute>(); modifier->name = nameToken.getName(); modifier->loc = nameToken.getLoc(); modifier->scope = parser->currentScope; @@ -786,7 +786,7 @@ namespace Slang // Let's look up the name and see what we find. auto lookupResult = lookUp( - parser->getSession(), + parser->astBuilder, nullptr, // no semantics visitor available yet name, parser->currentScope); @@ -931,7 +931,7 @@ namespace Slang { parser->haveSeenAnyImportDecls = true; - auto decl = new ImportDecl(); + auto decl = parser->astBuilder->create<ImportDecl>(); decl->scope = parser->currentScope; if (peekTokenType(parser) == TokenType::StringLiteral) @@ -1099,7 +1099,7 @@ namespace Slang if (AdvanceIf(parser, "let")) { // default case is a type parameter - auto paramDecl = new GenericValueParamDecl(); + auto paramDecl = parser->astBuilder->create<GenericValueParamDecl>(); paramDecl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); if (AdvanceIf(parser, TokenType::Colon)) { @@ -1114,24 +1114,24 @@ namespace Slang else { // default case is a type parameter - RefPtr<GenericTypeParamDecl> paramDecl = new GenericTypeParamDecl(); + RefPtr<GenericTypeParamDecl> paramDecl = parser->astBuilder->create<GenericTypeParamDecl>(); parser->FillPosition(paramDecl); paramDecl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); if (AdvanceIf(parser, TokenType::Colon)) { // The user is apply a constraint to this type parameter... - auto paramConstraint = new GenericTypeConstraintDecl(); + auto paramConstraint = parser->astBuilder->create<GenericTypeConstraintDecl>(); parser->FillPosition(paramConstraint); - auto paramType = DeclRefType::Create( - parser->getSession(), + auto paramType = DeclRefType::create( + parser->astBuilder, DeclRef<Decl>(paramDecl, nullptr)); - auto paramTypeExpr = new SharedTypeExpr(); + auto paramTypeExpr = parser->astBuilder->create<SharedTypeExpr>(); paramTypeExpr->loc = paramDecl->loc; paramTypeExpr->base.type = paramType; - paramTypeExpr->type = QualType(getTypeType(paramType)); + paramTypeExpr->type = QualType(parser->astBuilder->getTypeType(paramType)); paramConstraint->sub = TypeExp(paramTypeExpr); paramConstraint->sup = parser->ParseTypeExp(); @@ -1184,7 +1184,7 @@ namespace Slang // TODO: may want more advanced disambiguation than this... if (parser->LookAheadToken(TokenType::OpLess)) { - RefPtr<GenericDecl> genericDecl = new GenericDecl(); + RefPtr<GenericDecl> genericDecl = parser->astBuilder->create<GenericDecl>(); parser->FillPosition(genericDecl); parser->PushScope(genericDecl); ParseGenericDeclImpl(parser, genericDecl, parseInner); @@ -1199,7 +1199,7 @@ namespace Slang static RefPtr<RefObject> ParseGenericDecl(Parser* parser, void*) { - RefPtr<GenericDecl> decl = new GenericDecl(); + RefPtr<GenericDecl> decl = parser->astBuilder->create<GenericDecl>(); parser->FillPosition(decl.Ptr()); parser->PushScope(decl.Ptr()); ParseGenericDeclImpl(parser, decl.Ptr(), [=](GenericDecl* genDecl) {return ParseSingleDecl(parser, genDecl); }); @@ -1288,7 +1288,7 @@ namespace Slang Parser* parser, DeclaratorInfo const& declaratorInfo) { - RefPtr<FuncDecl> decl = new FuncDecl(); + RefPtr<FuncDecl> decl = parser->astBuilder->create<FuncDecl>(); parser->FillPosition(decl.Ptr()); decl->loc = declaratorInfo.nameAndLoc.loc; decl->nameAndLoc = declaratorInfo.nameAndLoc; @@ -1325,19 +1325,20 @@ namespace Slang } static RefPtr<VarDeclBase> CreateVarDeclForContext( + ASTBuilder* astBuilder, ContainerDecl* containerDecl ) { if (as<CallableDecl>(containerDecl)) { // Function parameters always use their dedicated syntax class. // - return new ParamDecl(); + return astBuilder->create<ParamDecl>(); } else { // Globals, locals, and member variables all use the same syntax class. // - return new VarDecl(); + return astBuilder->create<VarDecl>(); } } @@ -1555,6 +1556,7 @@ namespace Slang } static void UnwrapDeclarator( + ASTBuilder* astBuilder, RefPtr<Declarator> declarator, DeclaratorInfo* ioInfo) { @@ -1586,7 +1588,7 @@ namespace Slang // TODO(tfoley): we don't support pointers for now auto arrayDeclarator = (ArrayDeclarator*) declarator.Ptr(); - auto arrayTypeExpr = new IndexExpr(); + auto arrayTypeExpr = astBuilder->create<IndexExpr>(); arrayTypeExpr->loc = arrayDeclarator->openBracketLoc; arrayTypeExpr->baseExpression = ioInfo->typeSpec; arrayTypeExpr->indexExpression = arrayDeclarator->elementCountExpr; @@ -1604,10 +1606,11 @@ namespace Slang } static void UnwrapDeclarator( + ASTBuilder* astBuilder, InitDeclarator const& initDeclarator, DeclaratorInfo* ioInfo) { - UnwrapDeclarator(initDeclarator.declarator, ioInfo); + UnwrapDeclarator(astBuilder, initDeclarator.declarator, ioInfo); ioInfo->semantics = initDeclarator.semantics; ioInfo->initializer = initDeclarator.initializer; } @@ -1618,6 +1621,7 @@ namespace Slang SourceLoc startPosition; RefPtr<Decl> decl; RefPtr<DeclGroup> group; + ASTBuilder* astBuilder = nullptr; // Add a new declaration to the potential group void addDecl( @@ -1627,7 +1631,7 @@ namespace Slang if( decl ) { - group = new DeclGroup(); + group = astBuilder->create<DeclGroup>(); group->loc = startPosition; group->decls.add(decl); decl = nullptr; @@ -1665,7 +1669,7 @@ namespace Slang // // TODO: do this better, e.g. by filling in the `declRef` field directly - auto expr = new VarExpr(); + auto expr = parser->astBuilder->create<VarExpr>(); expr->scope = parser->currentScope.Ptr(); expr->loc = decl->getNameLoc(); expr->name = decl->getName(); @@ -1687,7 +1691,7 @@ namespace Slang Parser* parser, RefPtr<Expr> base) { - RefPtr<GenericAppExpr> genericApp = new GenericAppExpr(); + RefPtr<GenericAppExpr> genericApp = parser->astBuilder->create<GenericAppExpr>(); parser->FillPosition(genericApp.Ptr()); // set up scope for lookup genericApp->functionExpr = base; @@ -1716,7 +1720,7 @@ namespace Slang static bool isGenericName(Parser* parser, Name* name) { auto lookupResult = lookUp( - parser->getSession(), + parser->astBuilder, nullptr, // no semantics visitor available yet name, parser->currentScope); @@ -1771,7 +1775,7 @@ namespace Slang { // When called the :: or . have been consumed, so don't need to consume here. - RefPtr<MemberExpr> memberExpr = new MemberExpr(); + RefPtr<MemberExpr> memberExpr = parser->astBuilder->create<MemberExpr>(); parser->FillPosition(memberExpr.Ptr()); memberExpr->baseExpression = base; @@ -1787,7 +1791,7 @@ namespace Slang auto typeExpr = inTypeExpr; while (parser->LookAheadToken(TokenType::LBracket)) { - RefPtr<IndexExpr> arrType = new IndexExpr(); + RefPtr<IndexExpr> arrType = parser->astBuilder->create<IndexExpr>(); arrType->loc = typeExpr->loc; arrType->baseExpression = typeExpr; parser->ReadToken(TokenType::LBracket); @@ -1803,7 +1807,7 @@ namespace Slang static RefPtr<Expr> parseTaggedUnionType(Parser* parser) { - RefPtr<TaggedUnionTypeExpr> taggedUnionType = new TaggedUnionTypeExpr(); + RefPtr<TaggedUnionTypeExpr> taggedUnionType = parser->astBuilder->create<TaggedUnionTypeExpr>(); parser->ReadToken(TokenType::LParent); while(!AdvanceIfMatch(parser, TokenType::RParent)) @@ -1828,7 +1832,7 @@ namespace Slang /// Parse a `This` type expression static RefPtr<Expr> parseThisTypeExpr(Parser* parser) { - RefPtr<ThisTypeExpr> expr = new ThisTypeExpr(); + RefPtr<ThisTypeExpr> expr = parser->astBuilder->create<ThisTypeExpr>(); expr->scope = parser->currentScope; return expr; } @@ -1900,7 +1904,7 @@ namespace Slang Token typeName = parser->ReadToken(TokenType::Identifier); - auto basicType = new VarExpr(); + auto basicType = parser->astBuilder->create<VarExpr>(); basicType->scope = parser->currentScope.Ptr(); basicType->loc = typeName.loc; basicType->name = typeName.getNameOrNull(); @@ -1945,6 +1949,7 @@ namespace Slang // declaration DeclGroupBuilder declGroupBuilder; declGroupBuilder.startPosition = startPosition; + declGroupBuilder.astBuilder = parser->astBuilder; // The type specifier may include a declaration. E.g., // it might declare a `struct` type. @@ -2030,7 +2035,7 @@ namespace Slang && !initDeclarator.semantics) { // Looks like a function, so parse it like one. - UnwrapDeclarator(initDeclarator, &declaratorInfo); + UnwrapDeclarator(parser->astBuilder, initDeclarator, &declaratorInfo); return parseTraditionalFuncDecl(parser, declaratorInfo); } @@ -2039,8 +2044,8 @@ namespace Slang if( AdvanceIf(parser, TokenType::Semicolon) ) { // easy case: we only had a single declaration! - UnwrapDeclarator(initDeclarator, &declaratorInfo); - RefPtr<VarDeclBase> firstDecl = CreateVarDeclForContext(containerDecl); + UnwrapDeclarator(parser->astBuilder, initDeclarator, &declaratorInfo); + RefPtr<VarDeclBase> firstDecl = CreateVarDeclForContext(parser->astBuilder, containerDecl); CompleteVarDecl(parser, firstDecl, declaratorInfo); declGroupBuilder.addDecl(firstDecl); @@ -2054,16 +2059,16 @@ namespace Slang // about it once, so we need to share structure rather than just // clone syntax. - auto sharedTypeSpec = new SharedTypeExpr(); + auto sharedTypeSpec = parser->astBuilder->create<SharedTypeExpr>(); sharedTypeSpec->loc = typeSpec.expr->loc; sharedTypeSpec->base = TypeExp(typeSpec.expr); for(;;) { declaratorInfo.typeSpec = sharedTypeSpec; - UnwrapDeclarator(initDeclarator, &declaratorInfo); + UnwrapDeclarator(parser->astBuilder, initDeclarator, &declaratorInfo); - RefPtr<VarDeclBase> varDecl = CreateVarDeclForContext(containerDecl); + RefPtr<VarDeclBase> varDecl = CreateVarDeclForContext(parser->astBuilder, containerDecl); CompleteVarDecl(parser, varDecl, declaratorInfo); declGroupBuilder.addDecl(varDecl); @@ -2182,21 +2187,21 @@ namespace Slang { if (parser->LookAheadToken("register")) { - RefPtr<HLSLRegisterSemantic> semantic = new HLSLRegisterSemantic(); + RefPtr<HLSLRegisterSemantic> semantic = parser->astBuilder->create<HLSLRegisterSemantic>(); parser->FillPosition(semantic); parseHLSLRegisterSemantic(parser, semantic.Ptr()); return semantic; } else if (parser->LookAheadToken("packoffset")) { - RefPtr<HLSLPackOffsetSemantic> semantic = new HLSLPackOffsetSemantic(); + RefPtr<HLSLPackOffsetSemantic> semantic = parser->astBuilder->create<HLSLPackOffsetSemantic>(); parser->FillPosition(semantic); parseHLSLPackOffsetSemantic(parser, semantic.Ptr()); return semantic; } else if (parser->LookAheadToken(TokenType::Identifier)) { - RefPtr<HLSLSimpleSemantic> semantic = new HLSLSimpleSemantic(); + RefPtr<HLSLSimpleSemantic> semantic = parser->astBuilder->create<HLSLSimpleSemantic>(); parser->FillPosition(semantic); semantic->name = parser->ReadToken(TokenType::Identifier); return semantic; @@ -2286,8 +2291,8 @@ namespace Slang // We are going to represent each buffer as a pair of declarations. // The first is a type declaration that holds all the members, while // the second is a variable declaration that uses the buffer type. - RefPtr<StructDecl> bufferDataTypeDecl = new StructDecl(); - RefPtr<VarDecl> bufferVarDecl = new VarDecl(); + RefPtr<StructDecl> bufferDataTypeDecl = parser->astBuilder->create<StructDecl>(); + RefPtr<VarDecl> bufferVarDecl = parser->astBuilder->create<VarDecl>(); // Both declarations will have a location that points to the name parser->FillPosition(bufferDataTypeDecl.Ptr()); @@ -2296,7 +2301,7 @@ namespace Slang auto reflectionNameToken = parser->ReadToken(TokenType::Identifier); // Attach the reflection name to the block so we can use it - auto reflectionNameModifier = new ParameterGroupReflectionName(); + auto reflectionNameModifier = parser->astBuilder->create<ParameterGroupReflectionName>(); reflectionNameModifier->nameAndLoc = NameLoc(reflectionNameToken); addModifier(bufferVarDecl, reflectionNameModifier); @@ -2304,8 +2309,8 @@ namespace Slang bufferVarDecl->nameAndLoc.name = generateName(parser, "parameterGroup_" + String(reflectionNameToken.getContent())); bufferDataTypeDecl->nameAndLoc.name = generateName(parser, "ParameterGroup_" + String(reflectionNameToken.getContent())); - addModifier(bufferDataTypeDecl, new ImplicitParameterGroupElementTypeModifier()); - addModifier(bufferVarDecl, new ImplicitParameterGroupVariableModifier()); + addModifier(bufferDataTypeDecl, parser->astBuilder->create<ImplicitParameterGroupElementTypeModifier>()); + addModifier(bufferVarDecl, parser->astBuilder->create<ImplicitParameterGroupVariableModifier>()); // TODO(tfoley): We end up constructing unchecked syntax here that // is expected to type check into the right form, but it might be @@ -2313,13 +2318,13 @@ namespace Slang // these constructs directly into the AST and *then* desugar them. // Construct a type expression to reference the buffer data type - auto bufferDataTypeExpr = new VarExpr(); + auto bufferDataTypeExpr = parser->astBuilder->create<VarExpr>(); bufferDataTypeExpr->loc = bufferDataTypeDecl->loc; bufferDataTypeExpr->name = bufferDataTypeDecl->nameAndLoc.name; bufferDataTypeExpr->scope = parser->currentScope.Ptr(); // Construct a type expression to reference the type constructor - auto bufferWrapperTypeExpr = new VarExpr(); + auto bufferWrapperTypeExpr = parser->astBuilder->create<VarExpr>(); bufferWrapperTypeExpr->loc = bufferWrapperTypeNamePos; bufferWrapperTypeExpr->name = getName(parser, bufferWrapperTypeName); @@ -2329,7 +2334,7 @@ namespace Slang // Construct a type expression that represents the type for the variable, // which is the wrapper type applied to the data type - auto bufferVarTypeExpr = new GenericAppExpr(); + auto bufferVarTypeExpr = parser->astBuilder->create<GenericAppExpr>(); bufferVarTypeExpr->loc = bufferVarDecl->loc; bufferVarTypeExpr->functionExpr = bufferWrapperTypeExpr; bufferVarTypeExpr->arguments.add(bufferDataTypeExpr); @@ -2346,7 +2351,7 @@ namespace Slang // All HLSL buffer declarations are "transparent" in that their // members are implicitly made visible in the parent scope. // We achieve this by applying the transparent modifier to the variable. - auto transparentModifier = new TransparentModifier(); + auto transparentModifier = parser->astBuilder->create<TransparentModifier>(); transparentModifier->next = bufferVarDecl->modifiers.first; bufferVarDecl->modifiers.first = transparentModifier; @@ -2385,7 +2390,7 @@ namespace Slang { auto base = parser->ParseTypeExp(); - auto inheritanceDecl = new InheritanceDecl(); + auto inheritanceDecl = parser->astBuilder->create<InheritanceDecl>(); inheritanceDecl->loc = base.exp->loc; inheritanceDecl->nameAndLoc.name = getName(parser, "$inheritance"); inheritanceDecl->base = base; @@ -2398,7 +2403,7 @@ namespace Slang static RefPtr<RefObject> ParseExtensionDecl(Parser* parser, void* /*userData*/) { - RefPtr<ExtensionDecl> decl = new ExtensionDecl(); + RefPtr<ExtensionDecl> decl = parser->astBuilder->create<ExtensionDecl>(); parser->FillPosition(decl.Ptr()); decl->targetType = parser->ParseTypeExp(); parseOptionalInheritanceClause(parser, decl); @@ -2408,24 +2413,22 @@ namespace Slang } - void parseOptionalGenericConstraints(Parser * parser, ContainerDecl* decl) + void parseOptionalGenericConstraints(Parser* parser, ContainerDecl* decl) { if (AdvanceIf(parser, TokenType::Colon)) { do { - RefPtr<GenericTypeConstraintDecl> paramConstraint = new GenericTypeConstraintDecl(); + RefPtr<GenericTypeConstraintDecl> paramConstraint = parser->astBuilder->create<GenericTypeConstraintDecl>(); parser->FillPosition(paramConstraint); // substitution needs to be filled during check - RefPtr<DeclRefType> paramType = DeclRefType::Create( - parser->getSession(), - DeclRef<Decl>(decl, nullptr)); + RefPtr<DeclRefType> paramType = DeclRefType::create(parser->astBuilder, DeclRef<Decl>(decl, nullptr)); - RefPtr<SharedTypeExpr> paramTypeExpr = new SharedTypeExpr(); + RefPtr<SharedTypeExpr> paramTypeExpr = parser->astBuilder->create<SharedTypeExpr>(); paramTypeExpr->loc = decl->loc; paramTypeExpr->base.type = paramType; - paramTypeExpr->type = QualType(getTypeType(paramType)); + paramTypeExpr->type = QualType(parser->astBuilder->getTypeType(paramType)); paramConstraint->sub = TypeExp(paramTypeExpr); paramConstraint->sup = parser->ParseTypeExp(); @@ -2435,9 +2438,9 @@ namespace Slang } } - RefPtr<RefObject> parseAssocType(Parser * parser, void *) + RefPtr<RefObject> parseAssocType(Parser* parser, void *) { - RefPtr<AssocTypeDecl> assocTypeDecl = new AssocTypeDecl(); + RefPtr<AssocTypeDecl> assocTypeDecl = parser->astBuilder->create<AssocTypeDecl>(); auto nameToken = parser->ReadToken(TokenType::Identifier); assocTypeDecl->nameAndLoc = NameLoc(nameToken); @@ -2449,7 +2452,7 @@ namespace Slang RefPtr<RefObject> parseGlobalGenericTypeParamDecl(Parser * parser, void *) { - RefPtr<GlobalGenericParamDecl> genParamDecl = new GlobalGenericParamDecl(); + RefPtr<GlobalGenericParamDecl> genParamDecl = parser->astBuilder->create<GlobalGenericParamDecl>(); auto nameToken = parser->ReadToken(TokenType::Identifier); genParamDecl->nameAndLoc = NameLoc(nameToken); genParamDecl->loc = nameToken.loc; @@ -2460,7 +2463,7 @@ namespace Slang RefPtr<RefObject> parseGlobalGenericValueParamDecl(Parser * parser, void *) { - RefPtr<GlobalGenericValueParamDecl> genericParamDecl = new GlobalGenericValueParamDecl(); + RefPtr<GlobalGenericValueParamDecl> genericParamDecl = parser->astBuilder->create<GlobalGenericValueParamDecl>(); auto nameToken = parser->ReadToken(TokenType::Identifier); genericParamDecl->nameAndLoc = NameLoc(nameToken); genericParamDecl->loc = nameToken.loc; @@ -2481,7 +2484,7 @@ namespace Slang static RefPtr<RefObject> parseInterfaceDecl(Parser* parser, void* /*userData*/) { - RefPtr<InterfaceDecl> decl = new InterfaceDecl(); + RefPtr<InterfaceDecl> decl = parser->astBuilder->create<InterfaceDecl>(); parser->FillPosition(decl.Ptr()); decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); @@ -2588,7 +2591,7 @@ namespace Slang // if( !namespaceDecl ) { - namespaceDecl = new NamespaceDecl(); + namespaceDecl = parser->astBuilder->create<NamespaceDecl>(); namespaceDecl->nameAndLoc = nameAndLoc; // In the case where we are creating the first @@ -2613,7 +2616,7 @@ namespace Slang static RefPtr<RefObject> parseConstructorDecl(Parser* parser, void* /*userData*/) { - RefPtr<ConstructorDecl> decl = new ConstructorDecl(); + RefPtr<ConstructorDecl> decl = parser->astBuilder->create<ConstructorDecl>(); parser->FillPosition(decl.Ptr()); parser->PushScope(decl); @@ -2642,15 +2645,15 @@ namespace Slang RefPtr<AccessorDecl> decl; if( AdvanceIf(parser, "get") ) { - decl = new GetterDecl(); + decl = parser->astBuilder->create<GetterDecl>(); } else if( AdvanceIf(parser, "set") ) { - decl = new SetterDecl(); + decl = parser->astBuilder->create<SetterDecl>(); } else if( AdvanceIf(parser, "ref") ) { - decl = new RefAccessorDecl(); + decl = parser->astBuilder->create<RefAccessorDecl>(); } else { @@ -2674,7 +2677,7 @@ namespace Slang static RefPtr<RefObject> ParseSubscriptDecl(Parser* parser, void* /*userData*/) { - RefPtr<SubscriptDecl> decl = new SubscriptDecl(); + RefPtr<SubscriptDecl> decl = parser->astBuilder->create<SubscriptDecl>(); parser->FillPosition(decl.Ptr()); parser->PushScope(decl); @@ -2742,7 +2745,7 @@ namespace Slang static RefPtr<RefObject> parseLetDecl( Parser* parser, void* /*userData*/) { - RefPtr<LetDecl> decl = new LetDecl(); + RefPtr<LetDecl> decl = parser->astBuilder->create<LetDecl>(); parseModernVarDeclCommon(parser, decl); return decl; } @@ -2750,7 +2753,7 @@ namespace Slang static RefPtr<RefObject> parseVarDecl( Parser* parser, void* /*userData*/) { - RefPtr<VarDecl> decl = new VarDecl(); + RefPtr<VarDecl> decl = parser->astBuilder->create<VarDecl>(); parseModernVarDeclCommon(parser, decl); return decl; } @@ -2758,7 +2761,7 @@ namespace Slang static RefPtr<ParamDecl> parseModernParamDecl( Parser* parser) { - RefPtr<ParamDecl> decl = new ParamDecl(); + RefPtr<ParamDecl> decl = parser->astBuilder->create<ParamDecl>(); // TODO: "modern" parameters should not accept keyword-based // modifiers and should only accept `[attribute]` syntax for @@ -2790,7 +2793,7 @@ namespace Slang static RefPtr<RefObject> parseFuncDecl( Parser* parser, void* /*userData*/) { - RefPtr<FuncDecl> decl = new FuncDecl(); + RefPtr<FuncDecl> decl = parser->astBuilder->create<FuncDecl>(); parser->FillPosition(decl.Ptr()); decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); @@ -2812,7 +2815,7 @@ namespace Slang static RefPtr<RefObject> parseTypeAliasDecl( Parser* parser, void* /*userData*/) { - RefPtr<TypeAliasDecl> decl = new TypeAliasDecl(); + RefPtr<TypeAliasDecl> decl = parser->astBuilder->create<TypeAliasDecl>(); parser->FillPosition(decl.Ptr()); decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); @@ -2860,7 +2863,7 @@ namespace Slang // User is specifying the class that should be construted auto classNameAndLoc = expectIdentifier(parser); - syntaxClass = parser->getSession()->findSyntaxClass(classNameAndLoc.name); + syntaxClass = parser->astBuilder->findSyntaxClass(classNameAndLoc.name); } // If the user specified a syntax class, then we will default @@ -2911,7 +2914,7 @@ namespace Slang // TODO: skip creating the declaration if anything failed, just to not screw things // up for downstream code? - RefPtr<SyntaxDecl> syntaxDecl = new SyntaxDecl(); + RefPtr<SyntaxDecl> syntaxDecl = parser->astBuilder->create<SyntaxDecl>(); syntaxDecl->nameAndLoc = nameAndLoc; syntaxDecl->loc = nameAndLoc.loc; syntaxDecl->syntaxClass = syntaxClass; @@ -2929,7 +2932,7 @@ namespace Slang { auto nameAndLoc = expectIdentifier(parser); - RefPtr<ParamDecl> paramDecl = new ParamDecl(); + RefPtr<ParamDecl> paramDecl = parser->astBuilder->create<ParamDecl>(); paramDecl->nameAndLoc = nameAndLoc; if(AdvanceIf(parser, TokenType::Colon)) @@ -2971,7 +2974,7 @@ namespace Slang // First we parse the attribute name. auto nameAndLoc = expectIdentifier(parser); - RefPtr<AttributeDecl> attrDecl = new AttributeDecl(); + RefPtr<AttributeDecl> attrDecl = parser->astBuilder->create<AttributeDecl>(); if(AdvanceIf(parser, TokenType::LParent)) { while(!AdvanceIfMatch(parser, TokenType::RParent)) @@ -2999,7 +3002,7 @@ namespace Slang // User is specifying the class that should be construted auto classNameAndLoc = expectIdentifier(parser); - syntaxClass = parser->getSession()->findSyntaxClass(classNameAndLoc.name); + syntaxClass = parser->astBuilder->findSyntaxClass(classNameAndLoc.name); } else { @@ -3090,7 +3093,7 @@ namespace Slang { advanceToken(parser); - decl = new EmptyDecl(); + decl = parser->astBuilder->create<EmptyDecl>(); decl->loc = loc; } break; @@ -3113,7 +3116,7 @@ namespace Slang // so we want to give later passes a way to detect which modifiers // were shared, vs. which ones are specific to a single declaration. - auto sharedModifiers = new SharedModifiers(); + auto sharedModifiers = parser->astBuilder->create<SharedModifiers>(); sharedModifiers->next = modifiers.first; modifiers.first = sharedModifiers; @@ -3217,7 +3220,7 @@ namespace Slang RefPtr<Decl> Parser::ParseStruct() { - RefPtr<StructDecl> rs = new StructDecl(); + RefPtr<StructDecl> rs = astBuilder->create<StructDecl>(); FillPosition(rs.Ptr()); ReadToken("struct"); @@ -3236,7 +3239,7 @@ namespace Slang RefPtr<ClassDecl> Parser::ParseClass() { - RefPtr<ClassDecl> rs = new ClassDecl(); + RefPtr<ClassDecl> rs = astBuilder->create<ClassDecl>(); FillPosition(rs.Ptr()); ReadToken("class"); rs->nameAndLoc = expectIdentifier(this); @@ -3249,7 +3252,7 @@ namespace Slang static RefPtr<EnumCaseDecl> parseEnumCaseDecl(Parser* parser) { - RefPtr<EnumCaseDecl> decl = new EnumCaseDecl(); + RefPtr<EnumCaseDecl> decl = parser->astBuilder->create<EnumCaseDecl>(); decl->nameAndLoc = expectIdentifier(parser); if(AdvanceIf(parser, TokenType::OpAssign)) @@ -3262,7 +3265,7 @@ namespace Slang static RefPtr<Decl> parseEnumDecl(Parser* parser) { - RefPtr<EnumDecl> decl = new EnumDecl(); + RefPtr<EnumDecl> decl = parser->astBuilder->create<EnumDecl>(); parser->FillPosition(decl); parser->ReadToken("enum"); @@ -3299,7 +3302,7 @@ namespace Slang static RefPtr<Stmt> ParseSwitchStmt(Parser* parser) { - RefPtr<SwitchStmt> stmt = new SwitchStmt(); + RefPtr<SwitchStmt> stmt = parser->astBuilder->create<SwitchStmt>(); parser->FillPosition(stmt.Ptr()); parser->ReadToken("switch"); parser->ReadToken(TokenType::LParent); @@ -3311,7 +3314,7 @@ namespace Slang static RefPtr<Stmt> ParseCaseStmt(Parser* parser) { - RefPtr<CaseStmt> stmt = new CaseStmt(); + RefPtr<CaseStmt> stmt = parser->astBuilder->create<CaseStmt>(); parser->FillPosition(stmt.Ptr()); parser->ReadToken("case"); stmt->expr = parser->ParseExpression(); @@ -3321,7 +3324,7 @@ namespace Slang static RefPtr<Stmt> ParseDefaultStmt(Parser* parser) { - RefPtr<DefaultStmt> stmt = new DefaultStmt(); + RefPtr<DefaultStmt> stmt = parser->astBuilder->create<DefaultStmt>(); parser->FillPosition(stmt.Ptr()); parser->ReadToken("default"); parser->ReadToken(TokenType::Colon); @@ -3331,7 +3334,7 @@ namespace Slang static bool isTypeName(Parser* parser, Name* name) { auto lookupResult = lookUp( - parser->getSession(), + parser->astBuilder, nullptr, // no semantics visitor available yet name, parser->currentScope); @@ -3365,8 +3368,8 @@ namespace Slang RefPtr<Stmt> parseCompileTimeForStmt( Parser* parser) { - RefPtr<ScopeDecl> scopeDecl = new ScopeDecl(); - RefPtr<CompileTimeForStmt> stmt = new CompileTimeForStmt(); + RefPtr<ScopeDecl> scopeDecl = parser->astBuilder->create<ScopeDecl>(); + RefPtr<CompileTimeForStmt> stmt = parser->astBuilder->create<CompileTimeForStmt>(); stmt->scopeDecl = scopeDecl; @@ -3374,7 +3377,7 @@ namespace Slang parser->ReadToken(TokenType::LParent); NameLoc varNameAndLoc = expectIdentifier(parser); - RefPtr<VarDecl> varDecl = new VarDecl(); + RefPtr<VarDecl> varDecl = parser->astBuilder->create<VarDecl>(); varDecl->nameAndLoc = varNameAndLoc; varDecl->loc = varNameAndLoc.loc; @@ -3446,7 +3449,7 @@ namespace Slang statement = ParseReturnStatement(); else if (LookAheadToken("discard")) { - statement = new DiscardStmt(); + statement = astBuilder->create<DiscardStmt>(); FillPosition(statement.Ptr()); ReadToken("discard"); ReadToken(TokenType::Semicolon); @@ -3543,7 +3546,7 @@ namespace Slang } else if (LookAheadToken(TokenType::Semicolon)) { - statement = new EmptyStmt(); + statement = astBuilder->create<EmptyStmt>(); FillPosition(statement.Ptr()); ReadToken(TokenType::Semicolon); } @@ -3568,8 +3571,8 @@ namespace Slang RefPtr<Stmt> Parser::parseBlockStatement() { - RefPtr<ScopeDecl> scopeDecl = new ScopeDecl(); - RefPtr<BlockStmt> blockStatement = new BlockStmt(); + RefPtr<ScopeDecl> scopeDecl = astBuilder->create<ScopeDecl>(); + RefPtr<BlockStmt> blockStatement = astBuilder->create<BlockStmt>(); blockStatement->scopeDecl = scopeDecl; pushScopeAndSetParent(scopeDecl.Ptr()); ReadToken(TokenType::LBrace); @@ -3595,7 +3598,7 @@ namespace Slang } else { - RefPtr<SeqStmt> newBody = new SeqStmt(); + RefPtr<SeqStmt> newBody = astBuilder->create<SeqStmt>(); newBody->loc = blockStatement->loc; newBody->stmts.add(body); newBody->stmts.add(stmt); @@ -3609,7 +3612,7 @@ namespace Slang if(!body) { - body = new EmptyStmt(); + body = astBuilder->create<EmptyStmt>(); body->loc = blockStatement->loc; } @@ -3620,7 +3623,7 @@ namespace Slang RefPtr<DeclStmt> Parser::parseVarDeclrStatement( Modifiers modifiers) { - RefPtr<DeclStmt>varDeclrStatement = new DeclStmt(); + RefPtr<DeclStmt>varDeclrStatement = astBuilder->create<DeclStmt>(); FillPosition(varDeclrStatement.Ptr()); auto decl = ParseDeclWithModifiers(this, currentScope->containerDecl, modifiers); @@ -3630,7 +3633,7 @@ namespace Slang RefPtr<IfStmt> Parser::parseIfStatement() { - RefPtr<IfStmt> ifStatement = new IfStmt(); + RefPtr<IfStmt> ifStatement = astBuilder->create<IfStmt>(); FillPosition(ifStatement.Ptr()); ReadToken("if"); ReadToken(TokenType::LParent); @@ -3647,7 +3650,7 @@ namespace Slang RefPtr<ForStmt> Parser::ParseForStatement() { - RefPtr<ScopeDecl> scopeDecl = new ScopeDecl(); + RefPtr<ScopeDecl> scopeDecl = astBuilder->create<ScopeDecl>(); // HLSL implements the bad approach to scoping a `for` loop // variable, and we want to respect that, but *only* when @@ -3663,11 +3666,11 @@ namespace Slang RefPtr<ForStmt> stmt; if (brokenScoping) { - stmt = new UnscopedForStmt(); + stmt = astBuilder->create<UnscopedForStmt>(); } else { - stmt = new ForStmt(); + stmt = astBuilder->create<ForStmt>(); } stmt->scopeDecl = scopeDecl; @@ -3708,7 +3711,7 @@ namespace Slang RefPtr<WhileStmt> Parser::ParseWhileStatement() { - RefPtr<WhileStmt> whileStatement = new WhileStmt(); + RefPtr<WhileStmt> whileStatement = astBuilder->create<WhileStmt>(); FillPosition(whileStatement.Ptr()); ReadToken("while"); ReadToken(TokenType::LParent); @@ -3720,7 +3723,7 @@ namespace Slang RefPtr<DoWhileStmt> Parser::ParseDoWhileStatement() { - RefPtr<DoWhileStmt> doWhileStatement = new DoWhileStmt(); + RefPtr<DoWhileStmt> doWhileStatement = astBuilder->create<DoWhileStmt>(); FillPosition(doWhileStatement.Ptr()); ReadToken("do"); doWhileStatement->statement = ParseStatement(); @@ -3734,7 +3737,7 @@ namespace Slang RefPtr<BreakStmt> Parser::ParseBreakStatement() { - RefPtr<BreakStmt> breakStatement = new BreakStmt(); + RefPtr<BreakStmt> breakStatement = astBuilder->create<BreakStmt>(); FillPosition(breakStatement.Ptr()); ReadToken("break"); ReadToken(TokenType::Semicolon); @@ -3743,7 +3746,7 @@ namespace Slang RefPtr<ContinueStmt> Parser::ParseContinueStatement() { - RefPtr<ContinueStmt> continueStatement = new ContinueStmt(); + RefPtr<ContinueStmt> continueStatement = astBuilder->create<ContinueStmt>(); FillPosition(continueStatement.Ptr()); ReadToken("continue"); ReadToken(TokenType::Semicolon); @@ -3752,7 +3755,7 @@ namespace Slang RefPtr<ReturnStmt> Parser::ParseReturnStatement() { - RefPtr<ReturnStmt> returnStatement = new ReturnStmt(); + RefPtr<ReturnStmt> returnStatement = astBuilder->create<ReturnStmt>(); FillPosition(returnStatement.Ptr()); ReadToken("return"); if (!LookAheadToken(TokenType::Semicolon)) @@ -3763,7 +3766,7 @@ namespace Slang RefPtr<ExpressionStmt> Parser::ParseExpressionStatement() { - RefPtr<ExpressionStmt> statement = new ExpressionStmt(); + RefPtr<ExpressionStmt> statement = astBuilder->create<ExpressionStmt>(); FillPosition(statement.Ptr()); statement->expression = ParseExpression(); @@ -3774,14 +3777,14 @@ namespace Slang RefPtr<ParamDecl> Parser::ParseParameter() { - RefPtr<ParamDecl> parameter = new ParamDecl(); + RefPtr<ParamDecl> parameter = astBuilder->create<ParamDecl>(); parameter->modifiers = ParseModifiers(this); DeclaratorInfo declaratorInfo; declaratorInfo.typeSpec = ParseType(); InitDeclarator initDeclarator = parseInitDeclarator(this, kDeclaratorParseOption_AllowEmpty); - UnwrapDeclarator(initDeclarator, &declaratorInfo); + UnwrapDeclarator(astBuilder, initDeclarator, &declaratorInfo); // Assume it is a variable-like declarator CompleteVarDecl(this, parameter, declaratorInfo); @@ -3901,7 +3904,7 @@ namespace Slang break; } - auto opExpr = new VarExpr(); + auto opExpr = parser->astBuilder->create<VarExpr>(); opExpr->name = getName(parser, opToken.getContent()); opExpr->scope = parser->currentScope; opExpr->loc = opToken.loc; @@ -3911,12 +3914,12 @@ namespace Slang } static RefPtr<Expr> createInfixExpr( - Parser* /*parser*/, + Parser* parser, RefPtr<Expr> left, RefPtr<Expr> op, RefPtr<Expr> right) { - RefPtr<InfixExpr> expr = new InfixExpr(); + RefPtr<InfixExpr> expr = parser->astBuilder->create<InfixExpr>(); expr->loc = op->loc; expr->functionExpr = op; expr->arguments.add(left); @@ -3943,7 +3946,7 @@ namespace Slang // one non-binary case we need to deal with. if(opTokenType == TokenType::QuestionMark) { - RefPtr<SelectExpr> select = new SelectExpr(); + RefPtr<SelectExpr> select = parser->astBuilder->create<SelectExpr>(); select->loc = op->loc; select->functionExpr = op; @@ -3971,7 +3974,7 @@ namespace Slang if (opTokenType == TokenType::OpAssign) { - RefPtr<AssignExpr> assignExpr = new AssignExpr(); + RefPtr<AssignExpr> assignExpr = parser->astBuilder->create<AssignExpr>(); assignExpr->loc = op->loc; assignExpr->left = expr; assignExpr->right = right; @@ -4069,14 +4072,14 @@ namespace Slang // Parse OOP `this` expression syntax static RefPtr<RefObject> parseThisExpr(Parser* parser, void* /*userData*/) { - RefPtr<ThisExpr> expr = new ThisExpr(); + RefPtr<ThisExpr> expr = parser->astBuilder->create<ThisExpr>(); expr->scope = parser->currentScope; return expr; } - static RefPtr<Expr> parseBoolLitExpr(Parser* /*parser*/, bool value) + static RefPtr<Expr> parseBoolLitExpr(Parser* parser, bool value) { - RefPtr<BoolLiteralExpr> expr = new BoolLiteralExpr(); + RefPtr<BoolLiteralExpr> expr = parser->astBuilder->create<BoolLiteralExpr>(); expr->value = value; return expr; } @@ -4280,7 +4283,7 @@ namespace Slang if (peekTypeName(parser) && parser->LookAheadToken(TokenType::RParent, 1)) { - RefPtr<TypeCastExpr> tcexpr = new ExplicitCastExpr(); + RefPtr<TypeCastExpr> tcexpr = parser->astBuilder->create<ExplicitCastExpr>(); parser->FillPosition(tcexpr.Ptr()); tcexpr->functionExpr = parser->ParseType(); parser->ReadToken(TokenType::RParent); @@ -4295,7 +4298,7 @@ namespace Slang RefPtr<Expr> base = parser->ParseExpression(); parser->ReadToken(TokenType::RParent); - RefPtr<ParenExpr> parenExpr = new ParenExpr(); + RefPtr<ParenExpr> parenExpr = parser->astBuilder->create<ParenExpr>(); parenExpr->loc = openParen.loc; parenExpr->base = base; return parenExpr; @@ -4305,7 +4308,7 @@ namespace Slang // An initializer list `{ expr, ... }` case TokenType::LBrace: { - RefPtr<InitializerListExpr> initExpr = new InitializerListExpr(); + RefPtr<InitializerListExpr> initExpr = parser->astBuilder->create<InitializerListExpr>(); parser->FillPosition(initExpr.Ptr()); // Initializer list @@ -4335,7 +4338,7 @@ namespace Slang case TokenType::IntegerLiteral: { - RefPtr<IntegerLiteralExpr> constExpr = new IntegerLiteralExpr(); + RefPtr<IntegerLiteralExpr> constExpr = parser->astBuilder->create<IntegerLiteralExpr>(); parser->FillPosition(constExpr.Ptr()); auto token = parser->tokenReader.advanceToken(); @@ -4411,9 +4414,9 @@ namespace Slang } value = _fixIntegerLiteral(suffixBaseType, value, &token, parser->sink); - - auto session = parser->getSession(); - Type* suffixType = (suffixBaseType == BaseType::Void) ? session->getErrorType() : session->getBuiltinType(suffixBaseType); + + ASTBuilder* astBuilder = parser->astBuilder; + Type* suffixType = (suffixBaseType == BaseType::Void) ? astBuilder->getErrorType() : astBuilder->getBuiltinType(suffixBaseType); constExpr->value = value; constExpr->type = QualType(suffixType); @@ -4424,7 +4427,7 @@ namespace Slang case TokenType::FloatingPointLiteral: { - RefPtr<FloatingPointLiteralExpr> constExpr = new FloatingPointLiteralExpr(); + RefPtr<FloatingPointLiteralExpr> constExpr = parser->astBuilder->create<FloatingPointLiteralExpr>(); parser->FillPosition(constExpr.Ptr()); auto token = parser->tokenReader.advanceToken(); @@ -4526,9 +4529,9 @@ namespace Slang } } - Session* session = parser->getSession(); + ASTBuilder* astBuilder = parser->astBuilder; - Type* suffixType = (suffixBaseType == BaseType::Void) ? session->getErrorType() : session->getBuiltinType(suffixBaseType); + Type* suffixType = (suffixBaseType == BaseType::Void) ? astBuilder->getErrorType() : astBuilder->getBuiltinType(suffixBaseType); constExpr->value = fixedValue; constExpr->type = QualType(suffixType); @@ -4538,7 +4541,7 @@ namespace Slang case TokenType::StringLiteral: { - RefPtr<StringLiteralExpr> constExpr = new StringLiteralExpr(); + RefPtr<StringLiteralExpr> constExpr = parser->astBuilder->create<StringLiteralExpr>(); auto token = parser->tokenReader.advanceToken(); constExpr->token = token; parser->FillPosition(constExpr.Ptr()); @@ -4580,7 +4583,7 @@ namespace Slang } // Default behavior is just to create a name expression - RefPtr<VarExpr> varExpr = new VarExpr(); + RefPtr<VarExpr> varExpr = parser->astBuilder->create<VarExpr>(); varExpr->scope = parser->currentScope.Ptr(); parser->FillPosition(varExpr.Ptr()); @@ -4611,7 +4614,7 @@ namespace Slang case TokenType::OpInc: case TokenType::OpDec: { - RefPtr<OperatorExpr> postfixExpr = new PostfixExpr(); + RefPtr<OperatorExpr> postfixExpr = parser->astBuilder->create<PostfixExpr>(); parser->FillPosition(postfixExpr.Ptr()); postfixExpr->functionExpr = parseOperator(parser); postfixExpr->arguments.add(expr); @@ -4623,7 +4626,7 @@ namespace Slang // Subscript operation `a[i]` case TokenType::LBracket: { - RefPtr<IndexExpr> indexExpr = new IndexExpr(); + RefPtr<IndexExpr> indexExpr = parser->astBuilder->create<IndexExpr>(); indexExpr->baseExpression = expr; parser->FillPosition(indexExpr.Ptr()); parser->ReadToken(TokenType::LBracket); @@ -4641,7 +4644,7 @@ namespace Slang // Call oepration `f(x)` case TokenType::LParent: { - RefPtr<InvokeExpr> invokeExpr = new InvokeExpr(); + RefPtr<InvokeExpr> invokeExpr = parser->astBuilder->create<InvokeExpr>(); invokeExpr->functionExpr = expr; parser->FillPosition(invokeExpr.Ptr()); parser->ReadToken(TokenType::LParent); @@ -4666,7 +4669,7 @@ namespace Slang // Scope access `x::m` case TokenType::Scope: { - RefPtr<StaticMemberExpr> staticMemberExpr = new StaticMemberExpr(); + RefPtr<StaticMemberExpr> staticMemberExpr = parser->astBuilder->create<StaticMemberExpr>(); // TODO(tfoley): why would a member expression need this? staticMemberExpr->scope = parser->currentScope.Ptr(); @@ -4686,7 +4689,7 @@ namespace Slang // Member access `x.m` case TokenType::Dot: { - RefPtr<MemberExpr> memberExpr = new MemberExpr(); + RefPtr<MemberExpr> memberExpr = parser->astBuilder->create<MemberExpr>(); // TODO(tfoley): why would a member expression need this? memberExpr->scope = parser->currentScope.Ptr(); @@ -4747,7 +4750,7 @@ namespace Slang case TokenType::OpInc: case TokenType::OpDec: { - RefPtr<PrefixExpr> prefixExpr = new PrefixExpr(); + RefPtr<PrefixExpr> prefixExpr = parser->astBuilder->create<PrefixExpr>(); parser->FillPosition(prefixExpr.Ptr()); prefixExpr->functionExpr = parseOperator(parser); @@ -4760,7 +4763,7 @@ namespace Slang case TokenType::OpAdd: case TokenType::OpSub: { - RefPtr<PrefixExpr> prefixExpr = new PrefixExpr(); + RefPtr<PrefixExpr> prefixExpr = parser->astBuilder->create<PrefixExpr>(); parser->FillPosition(prefixExpr.Ptr()); prefixExpr->functionExpr = parseOperator(parser); @@ -4768,7 +4771,7 @@ namespace Slang if (auto intLit = as<IntegerLiteralExpr>(arg)) { - RefPtr<IntegerLiteralExpr> newLiteral = new IntegerLiteralExpr(*intLit); + RefPtr<IntegerLiteralExpr> newLiteral = parser->astBuilder->create<IntegerLiteralExpr>(*intLit); IRIntegerValue value = _foldIntegerPrefixOp(tokenType, newLiteral->value); @@ -4783,7 +4786,7 @@ namespace Slang } else if (auto floatLit = as<FloatingPointLiteralExpr>(arg)) { - RefPtr<FloatingPointLiteralExpr> newLiteral = new FloatingPointLiteralExpr(*floatLit); + RefPtr<FloatingPointLiteralExpr> newLiteral = parser->astBuilder->create<FloatingPointLiteralExpr>(*floatLit); newLiteral->value = _foldFloatPrefixOp(tokenType, floatLit->value); return newLiteral; } @@ -4802,14 +4805,14 @@ namespace Slang } RefPtr<Expr> parseTermFromSourceFile( - Session* session, + ASTBuilder* astBuilder, TokenSpan const& tokens, DiagnosticSink* sink, RefPtr<Scope> const& outerScope, NamePool* namePool, SourceLanguage sourceLanguage) { - Parser parser(session, tokens, sink, outerScope); + Parser parser(astBuilder, tokens, sink, outerScope); parser.currentScope = outerScope; parser.namePool = namePool; parser.sourceLanguage = sourceLanguage; @@ -4818,12 +4821,13 @@ namespace Slang // Parse a source file into an existing translation unit void parseSourceFile( + ASTBuilder* astBuilder, TranslationUnitRequest* translationUnit, TokenSpan const& tokens, DiagnosticSink* sink, RefPtr<Scope> const& outerScope) { - Parser parser(translationUnit->getSession(), tokens, sink, outerScope); + Parser parser(astBuilder, tokens, sink, outerScope); parser.namePool = translationUnit->getNamePool(); parser.sourceLanguage = translationUnit->sourceLanguage; @@ -4840,7 +4844,9 @@ namespace Slang { Name* name = session->getNamePool()->getName(nameText); - RefPtr<SyntaxDecl> syntaxDecl = new SyntaxDecl(); + ASTBuilder* globalASTBuilder = session->getGlobalASTBuilder(); + + RefPtr<SyntaxDecl> syntaxDecl = globalASTBuilder->create<SyntaxDecl>(); syntaxDecl->nameAndLoc = NameLoc(name); syntaxDecl->syntaxClass = syntaxClass; syntaxDecl->parseCallback = callback; @@ -4872,7 +4878,7 @@ namespace Slang static RefPtr<RefObject> parseIntrinsicOpModifier(Parser* parser, void* /*userData*/) { - RefPtr<IntrinsicOpModifier> modifier = new IntrinsicOpModifier(); + RefPtr<IntrinsicOpModifier> modifier = parser->astBuilder->create<IntrinsicOpModifier>(); // We allow a few difference forms here: // @@ -4920,7 +4926,7 @@ namespace Slang static RefPtr<RefObject> parseTargetIntrinsicModifier(Parser* parser, void* /*userData*/) { - auto modifier = new TargetIntrinsicModifier(); + auto modifier = parser->astBuilder->create<TargetIntrinsicModifier>(); if (AdvanceIf(parser, TokenType::LParent)) { @@ -4946,7 +4952,7 @@ namespace Slang static RefPtr<RefObject> parseSpecializedForTargetModifier(Parser* parser, void* /*userData*/) { - auto modifier = new SpecializedForTargetModifier(); + auto modifier = parser->astBuilder->create<SpecializedForTargetModifier>(); if (AdvanceIf(parser, TokenType::LParent)) { modifier->targetToken = parser->ReadToken(TokenType::Identifier); @@ -4957,7 +4963,7 @@ namespace Slang static RefPtr<RefObject> parseGLSLExtensionModifier(Parser* parser, void* /*userData*/) { - auto modifier = new RequiredGLSLExtensionModifier(); + auto modifier = parser->astBuilder->create<RequiredGLSLExtensionModifier>(); parser->ReadToken(TokenType::LParent); modifier->extensionNameToken = parser->ReadToken(TokenType::Identifier); @@ -4968,7 +4974,7 @@ namespace Slang static RefPtr<RefObject> parseGLSLVersionModifier(Parser* parser, void* /*userData*/) { - auto modifier = new RequiredGLSLVersionModifier(); + auto modifier = parser->astBuilder->create<RequiredGLSLVersionModifier>(); parser->ReadToken(TokenType::LParent); modifier->versionNumberToken = parser->ReadToken(TokenType::IntegerLiteral); @@ -5013,7 +5019,7 @@ namespace Slang SemanticVersion version; if (SLANG_SUCCEEDED(parseSemanticVersion(parser, token, version))) { - auto modifier = new RequiredSPIRVVersionModifier(); + auto modifier = parser->astBuilder->create<RequiredSPIRVVersionModifier>(); modifier->version = version; return modifier; } @@ -5027,7 +5033,7 @@ namespace Slang SemanticVersion version; if (SLANG_SUCCEEDED(parseSemanticVersion(parser, token, version))) { - auto modifier = new RequiredCUDASMVersionModifier(); + auto modifier = parser->astBuilder->create<RequiredCUDASMVersionModifier>(); modifier->version = version; return modifier; } @@ -5041,7 +5047,7 @@ namespace Slang RefPtr<UncheckedAttribute> numThreadsAttrib; - listBuilder.add(new GLSLLayoutModifierGroupBegin()); + listBuilder.add(parser->astBuilder->create<GLSLLayoutModifierGroupBegin>()); parser->ReadToken(TokenType::LParent); while (!AdvanceIfMatch(parser, TokenType::RParent)) @@ -5062,7 +5068,7 @@ namespace Slang { if (!numThreadsAttrib) { - numThreadsAttrib = new UncheckedAttribute; + numThreadsAttrib = parser->astBuilder->create<UncheckedAttribute>(); numThreadsAttrib->args.setCount(3); // Just mark the loc and name from the first in the list @@ -5089,7 +5095,7 @@ namespace Slang GLSLBindingAttribute* attr = listBuilder.find<GLSLBindingAttribute>(); if (!attr) { - attr = new GLSLBindingAttribute(); + attr = parser->astBuilder->create<GLSLBindingAttribute>(); listBuilder.add(attr); } @@ -5117,13 +5123,13 @@ namespace Slang { RefPtr<Modifier> modifier; -#define CASE(key, type) if (nameText == #key) { modifier = new type; } else +#define CASE(key, type) if (nameText == #key) { modifier = parser->astBuilder->create<type>(); } else CASE(push_constant, PushConstantAttribute) CASE(shaderRecordNV, ShaderRecordAttribute) CASE(constant_id, GLSLConstantIDLayoutModifier) CASE(location, GLSLLocationLayoutModifier) { - modifier = new GLSLUnparsedLayoutModifier(); + modifier = parser->astBuilder->create<GLSLUnparsedLayoutModifier>(); } SLANG_ASSERT(modifier); #undef CASE @@ -5153,14 +5159,14 @@ namespace Slang listBuilder.add(numThreadsAttrib); } - listBuilder.add(new GLSLLayoutModifierGroupEnd()); + listBuilder.add(parser->astBuilder->create<GLSLLayoutModifierGroupEnd>()); return listBuilder.getFirst(); } static RefPtr<RefObject> parseBuiltinTypeModifier(Parser* parser, void* /*userData*/) { - RefPtr<BuiltinTypeModifier> modifier = new BuiltinTypeModifier(); + RefPtr<BuiltinTypeModifier> modifier = parser->astBuilder->create<BuiltinTypeModifier>(); parser->ReadToken(TokenType::LParent); modifier->tag = BaseType(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).getContent())); parser->ReadToken(TokenType::RParent); @@ -5170,7 +5176,7 @@ namespace Slang static RefPtr<RefObject> parseMagicTypeModifier(Parser* parser, void* /*userData*/) { - RefPtr<MagicTypeModifier> modifier = new MagicTypeModifier(); + RefPtr<MagicTypeModifier> modifier = parser->astBuilder->create<MagicTypeModifier>(); parser->ReadToken(TokenType::LParent); modifier->name = parser->ReadToken(TokenType::Identifier).getContent(); if (AdvanceIf(parser, TokenType::Comma)) @@ -5184,7 +5190,7 @@ namespace Slang static RefPtr<RefObject> parseIntrinsicTypeModifier(Parser* parser, void* /*userData*/) { - RefPtr<IntrinsicTypeModifier> modifier = new IntrinsicTypeModifier(); + RefPtr<IntrinsicTypeModifier> modifier = parser->astBuilder->create<IntrinsicTypeModifier>(); parser->ReadToken(TokenType::LParent); modifier->irOp = uint32_t(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).getContent())); while( AdvanceIf(parser, TokenType::Comma) ) @@ -5198,7 +5204,7 @@ namespace Slang } static RefPtr<RefObject> parseImplicitConversionModifier(Parser* parser, void* /*userData*/) { - RefPtr<ImplicitConversionModifier> modifier = new ImplicitConversionModifier(); + RefPtr<ImplicitConversionModifier> modifier = parser->astBuilder->create<ImplicitConversionModifier>(); ConversionCost cost = kConversionCost_Default; if( AdvanceIf(parser, TokenType::LParent) ) @@ -5216,19 +5222,21 @@ namespace Slang auto syntaxClassNameAndLoc = expectIdentifier(parser); expect(parser, TokenType::RParent); - auto syntaxClass = parser->getSession()->findSyntaxClass(syntaxClassNameAndLoc.name); + auto syntaxClass = parser->astBuilder->findSyntaxClass(syntaxClassNameAndLoc.name); - RefPtr<AttributeTargetModifier> modifier = new AttributeTargetModifier(); + RefPtr<AttributeTargetModifier> modifier = parser->astBuilder->create<AttributeTargetModifier>(); modifier->syntaxClass = syntaxClass; return modifier; } RefPtr<ModuleDecl> populateBaseLanguageModule( - Session* session, + ASTBuilder* astBuilder, RefPtr<Scope> scope) { - RefPtr<ModuleDecl> moduleDecl = new ModuleDecl(); + Session* session = astBuilder->getGlobalSession(); + + RefPtr<ModuleDecl> moduleDecl = astBuilder->create<ModuleDecl>(); scope->containerDecl = moduleDecl; // Add syntax for declaration keywords diff --git a/source/slang/slang-parser.h b/source/slang/slang-parser.h index 1c21b9474..f3587793e 100644 --- a/source/slang/slang-parser.h +++ b/source/slang/slang-parser.h @@ -9,13 +9,14 @@ namespace Slang { // Parse a source file into an existing translation unit void parseSourceFile( + ASTBuilder* astBuilder, TranslationUnitRequest* translationUnit, TokenSpan const& tokens, DiagnosticSink* sink, RefPtr<Scope> const& outerScope); RefPtr<Expr> parseTermFromSourceFile( - Session* session, + ASTBuilder* astBuilder, TokenSpan const& tokens, DiagnosticSink* sink, RefPtr<Scope> const& outerScope, @@ -23,7 +24,7 @@ namespace Slang SourceLanguage sourceLanguage); RefPtr<ModuleDecl> populateBaseLanguageModule( - Session* session, + ASTBuilder* astBuilder, RefPtr<Scope> scope); } diff --git a/source/slang/slang-reflection.cpp b/source/slang/slang-reflection.cpp index 1316efa5d..23d006b3f 100644 --- a/source/slang/slang-reflection.cpp +++ b/source/slang/slang-reflection.cpp @@ -489,7 +489,10 @@ SLANG_API SlangReflectionUserAttribute* spReflectionType_FindUserAttributeByName if (!type) return 0; if (auto declRefType = as<DeclRefType>(type)) { - return findUserAttributeByName(declRefType->getSession(), declRefType->declRef.getDecl(), name); + ASTBuilder* astBuilder = declRefType->getASTBuilder(); + auto globalSession = astBuilder->getGlobalSession(); + + return findUserAttributeByName(globalSession, declRefType->declRef.getDecl(), name); } return 0; } diff --git a/source/slang/slang-syntax.cpp b/source/slang/slang-syntax.cpp index 70b8a4239..54d27bd57 100644 --- a/source/slang/slang-syntax.cpp +++ b/source/slang/slang-syntax.cpp @@ -244,10 +244,10 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return false; } - RefPtr<Val> Type::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> Type::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; - auto canSubst = getCanonicalType()->substituteImpl(subst, &diff); + auto canSubst = getCanonicalType()->substituteImpl(astBuilder, subst, &diff); // If nothing changed, then don't drop any sugar that is applied if (!diff) @@ -279,168 +279,6 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return et->canonicalType; } - void Session::initializeTypes() - { - errorType = new ErrorType(); - errorType->setSession(this); - - initializerListType = new InitializerListType(); - initializerListType->setSession(this); - - overloadedType = new OverloadGroupType(); - overloadedType->setSession(this); - } - - Type* Session::getBoolType() - { - return getBuiltinType(BaseType::Bool); - } - - Type* Session::getHalfType() - { - return getBuiltinType(BaseType::Half); - } - - Type* Session::getFloatType() - { - return getBuiltinType(BaseType::Float); - } - - Type* Session::getDoubleType() - { - return getBuiltinType(BaseType::Double); - } - - Type* Session::getIntType() - { - return getBuiltinType(BaseType::Int); - } - - Type* Session::getInt64Type() - { - return getBuiltinType(BaseType::Int64); - } - - Type* Session::getUIntType() - { - return getBuiltinType(BaseType::UInt); - } - - Type* Session::getUInt64Type() - { - return getBuiltinType(BaseType::UInt64); - } - - Type* Session::getVoidType() - { - return getBuiltinType(BaseType::Void); - } - - Type* Session::getBuiltinType(BaseType flavor) - { - return builtinTypes[int(flavor)]; - } - - Type* Session::getInitializerListType() - { - return initializerListType; - } - - Type* Session::getOverloadedType() - { - return overloadedType; - } - - Type* Session::getErrorType() - { - return errorType; - } - - Type* Session::getStringType() - { - if (stringType == nullptr) - { - auto stringTypeDecl = findMagicDecl(this, "StringType"); - stringType = DeclRefType::Create(this, makeDeclRef<Decl>(stringTypeDecl)); - } - return stringType; - } - - Type* Session::getEnumTypeType() - { - if (enumTypeType == nullptr) - { - auto enumTypeTypeDecl = findMagicDecl(this, "EnumTypeType"); - enumTypeType = DeclRefType::Create(this, makeDeclRef<Decl>(enumTypeTypeDecl)); - } - return enumTypeType; - } - - RefPtr<PtrType> Session::getPtrType( - RefPtr<Type> valueType) - { - return getPtrType(valueType, "PtrType").dynamicCast<PtrType>(); - } - - // Construct the type `Out<valueType>` - RefPtr<OutType> Session::getOutType(RefPtr<Type> valueType) - { - return getPtrType(valueType, "OutType").dynamicCast<OutType>(); - } - - RefPtr<InOutType> Session::getInOutType(RefPtr<Type> valueType) - { - return getPtrType(valueType, "InOutType").dynamicCast<InOutType>(); - } - - RefPtr<RefType> Session::getRefType(RefPtr<Type> valueType) - { - return getPtrType(valueType, "RefType").dynamicCast<RefType>(); - } - - RefPtr<PtrTypeBase> Session::getPtrType(RefPtr<Type> valueType, char const* ptrTypeName) - { - auto genericDecl = findMagicDecl(this, ptrTypeName).dynamicCast<GenericDecl>(); - return getPtrType(valueType, genericDecl); - } - - RefPtr<PtrTypeBase> Session::getPtrType(RefPtr<Type> valueType, GenericDecl* genericDecl) - { - auto typeDecl = genericDecl->inner; - - auto substitutions = new GenericSubstitution(); - substitutions->genericDecl = genericDecl; - substitutions->args.add(valueType); - - auto declRef = DeclRef<Decl>(typeDecl.Ptr(), substitutions); - auto rsType = DeclRefType::Create( - this, - declRef); - return as<PtrTypeBase>( rsType); - } - - RefPtr<ArrayExpressionType> Session::getArrayType( - Type* elementType, - IntVal* elementCount) - { - RefPtr<ArrayExpressionType> arrayType = new ArrayExpressionType(); - arrayType->setSession(this); - arrayType->baseType = elementType; - arrayType->arrayLength = elementCount; - return arrayType; - } - - SyntaxClass<RefObject> Session::findSyntaxClass(Name* name) - { - SyntaxClass<RefObject> syntaxClass; - if (mapNameToSyntaxClass.TryGetValue(name, syntaxClass)) - return syntaxClass; - - return SyntaxClass<RefObject>(); - } - - - bool ArrayExpressionType::equalsImpl(Type* type) { auto arrType = as<ArrayExpressionType>(type); @@ -449,16 +287,17 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return (areValsEqual(arrayLength, arrType->arrayLength) && baseType->equals(arrType->baseType.Ptr())); } - RefPtr<Val> ArrayExpressionType::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> ArrayExpressionType::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; - auto elementType = baseType->substituteImpl(subst, &diff).as<Type>(); - auto arrlen = arrayLength->substituteImpl(subst, &diff).as<IntVal>(); + auto elementType = baseType->substituteImpl(astBuilder, subst, &diff).as<Type>(); + auto arrlen = arrayLength->substituteImpl(astBuilder, subst, &diff).as<IntVal>(); SLANG_ASSERT(arrlen); if (diff) { *ioDiff = 1; auto rsType = getArrayType( + astBuilder, elementType, arrlen); return rsType; @@ -469,11 +308,12 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt RefPtr<Type> ArrayExpressionType::createCanonicalType() { auto canonicalElementType = baseType->getCanonicalType(); - auto canonicalArrayType = getArrayType( + auto canonicalArrayType = getASTBuilder()->getArrayType( canonicalElementType, arrayLength); return canonicalArrayType; } + HashCode ArrayExpressionType::getHashCode() { if (arrayLength) @@ -538,7 +378,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt } - RequirementWitness RequirementWitness::specialize(SubstitutionSet const& subst) + RequirementWitness RequirementWitness::specialize(ASTBuilder* astBuilder, SubstitutionSet const& subst) { switch(getFlavor()) { @@ -551,7 +391,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt { int diff = 0; return RequirementWitness( - getDeclRef().SubstituteImpl(subst, &diff)); + getDeclRef().substituteImpl(astBuilder, subst, &diff)); } case RequirementWitness::Flavor::val: @@ -560,12 +400,13 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt SLANG_ASSERT(val); return RequirementWitness( - val->substitute(subst)); + val->substitute(astBuilder, subst)); } } } RequirementWitness tryLookUpRequirementWitness( + ASTBuilder* astBuilder, SubtypeWitness* subtypeWitness, Decl* requirementKey) { @@ -625,7 +466,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // So, in order to get the *right* end result, we need to apply // the substitutions from the inheritance decl-ref to the witness. // - requirementWitness = requirementWitness.specialize(inheritanceDeclRef.substitutions); + requirementWitness = requirementWitness.specialize(astBuilder, inheritanceDeclRef.substitutions); return requirementWitness; } @@ -637,7 +478,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return RequirementWitness(); } - RefPtr<Val> DeclRefType::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> DeclRefType::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { if (!subst) return this; @@ -698,7 +539,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt } } int diff = 0; - DeclRef<Decl> substDeclRef = declRef.SubstituteImpl(subst, &diff); + DeclRef<Decl> substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff); if (!diff) return this; @@ -726,7 +567,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // We need to look up the declaration that satisfies // the requirement named by the associated type. Decl* requirementKey = substAssocTypeDecl; - RequirementWitness requirementWitness = tryLookUpRequirementWitness(thisSubst->witness, requirementKey); + RequirementWitness requirementWitness = tryLookUpRequirementWitness(astBuilder, thisSubst->witness, requirementKey); switch(requirementWitness.getFlavor()) { default: @@ -746,7 +587,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt } // Re-construct the type in case we are using a specialized sub-class - return DeclRefType::Create(getSession(), substDeclRef); + return DeclRefType::create(astBuilder, substDeclRef); } static RefPtr<Type> ExtractGenericArgType(RefPtr<Val> val) @@ -764,7 +605,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt } DeclRef<Decl> createDefaultSubstitutionsIfNeeded( - Session* session, + ASTBuilder* astBuilder, DeclRef<Decl> declRef) { // It is possible that `declRef` refers to a generic type, @@ -822,8 +663,8 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt if(!foundSubst) { - RefPtr<Substitutions> newSubst = createDefaultSubsitutionsForGeneric( - session, + RefPtr<Substitutions> newSubst = createDefaultSubstitutionsForGeneric( + astBuilder, genericParentDecl, nullptr); @@ -837,21 +678,20 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return declRef; int diff = 0; - return declRef.SubstituteImpl(substsToApply, &diff); + return declRef.substituteImpl(astBuilder, substsToApply, &diff); } // TODO: need to figure out how to unify this with the logic // in the generic case... - RefPtr<DeclRefType> DeclRefType::Create( - Session* session, + RefPtr<DeclRefType> DeclRefType::create( + ASTBuilder* astBuilder, DeclRef<Decl> declRef) { - declRef = createDefaultSubstitutionsIfNeeded(session, declRef); + declRef = createDefaultSubstitutionsIfNeeded(astBuilder, declRef); if (auto builtinMod = declRef.getDecl()->findModifier<BuiltinTypeModifier>()) { - auto type = new BasicExpressionType(builtinMod->tag); - type->setSession(session); + auto type = astBuilder->create<BasicExpressionType>(builtinMod->tag); type->declRef = declRef; return type; } @@ -869,8 +709,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt if (magicMod->name == "SamplerState") { - auto type = new SamplerStateType(); - type->setSession(session); + auto type = astBuilder->create<SamplerStateType>(); type->declRef = declRef; type->flavor = SamplerStateFlavor(magicMod->tag); return type; @@ -878,8 +717,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt else if (magicMod->name == "Vector") { SLANG_ASSERT(subst && subst->args.getCount() == 2); - auto vecType = new VectorExpressionType(); - vecType->setSession(session); + auto vecType = astBuilder->create<VectorExpressionType>(); vecType->declRef = declRef; vecType->elementType = ExtractGenericArgType(subst->args[0]); vecType->elementCount = ExtractGenericArgInteger(subst->args[1]); @@ -888,38 +726,34 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt else if (magicMod->name == "Matrix") { SLANG_ASSERT(subst && subst->args.getCount() == 3); - auto matType = new MatrixExpressionType(); - matType->setSession(session); + auto matType = astBuilder->create<MatrixExpressionType>(); matType->declRef = declRef; return matType; } else if (magicMod->name == "Texture") { SLANG_ASSERT(subst && subst->args.getCount() >= 1); - auto textureType = new TextureType( + auto textureType = astBuilder->create<TextureType>( TextureFlavor(magicMod->tag), ExtractGenericArgType(subst->args[0])); - textureType->setSession(session); textureType->declRef = declRef; return textureType; } else if (magicMod->name == "TextureSampler") { SLANG_ASSERT(subst && subst->args.getCount() >= 1); - auto textureType = new TextureSamplerType( + auto textureType = astBuilder->create<TextureSamplerType>( TextureFlavor(magicMod->tag), ExtractGenericArgType(subst->args[0])); - textureType->setSession(session); textureType->declRef = declRef; return textureType; } else if (magicMod->name == "GLSLImageType") { SLANG_ASSERT(subst && subst->args.getCount() >= 1); - auto textureType = new GLSLImageType( + auto textureType = astBuilder->create<GLSLImageType>( TextureFlavor(magicMod->tag), ExtractGenericArgType(subst->args[0])); - textureType->setSession(session); textureType->declRef = declRef; return textureType; } @@ -930,8 +764,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt #define CASE(n,T) \ else if(magicMod->name == #n) { \ - auto type = new T(); \ - type->setSession(session); \ + auto type = astBuilder->create<T>(); \ type->declRef = declRef; \ return type; \ } @@ -944,8 +777,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt #define CASE(n,T) \ else if(magicMod->name == #n) { \ SLANG_ASSERT(subst && subst->args.getCount() == 1); \ - auto type = new T(); \ - type->setSession(session); \ + auto type = astBuilder->create<T>(); \ type->elementType = ExtractGenericArgType(subst->args[0]); \ type->declRef = declRef; \ return type; \ @@ -973,8 +805,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // "magic" builtin types which have no generic parameters #define CASE(n,T) \ else if(magicMod->name == #n) { \ - auto type = new T(); \ - type->setSession(session); \ + auto type = astBuilder->create<T>(); \ type->declRef = declRef; \ return type; \ } @@ -990,8 +821,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt else { - auto classInfo = session->findSyntaxClass( - session->getNamePool()->getName(magicMod->name)); + auto classInfo = astBuilder->findSyntaxClass(magicMod->name.getUnownedSlice()); if (!classInfo.classInfo) { SLANG_UNEXPECTED("unhandled type"); @@ -1008,16 +838,13 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt { SLANG_UNEXPECTED("expected a declaration reference type"); } - declRefType->session = session; declRefType->declRef = declRef; return declRefType; } } else { - auto type = new DeclRefType(declRef); - type->setSession(session); - return type; + return astBuilder->create<DeclRefType>(declRef); } } @@ -1084,7 +911,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return this; } - RefPtr<Val> ErrorType::substituteImpl(SubstitutionSet /*subst*/, int* /*ioDiff*/) + RefPtr<Val> ErrorType::substituteImpl(ASTBuilder* /* astBuilder */, SubstitutionSet /*subst*/, int* /*ioDiff*/) { return this; } @@ -1111,7 +938,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt RefPtr<Type> NamedExpressionType::createCanonicalType() { if (!innerType) - innerType = GetType(declRef); + innerType = GetType(m_astBuilder, declRef); return innerType->getCanonicalType(); } @@ -1174,18 +1001,18 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return false; } - RefPtr<Val> FuncType::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> FuncType::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; // result type - RefPtr<Type> substResultType = resultType->substituteImpl(subst, &diff).as<Type>(); + RefPtr<Type> substResultType = resultType->substituteImpl(astBuilder, subst, &diff).as<Type>(); // parameter types List<RefPtr<Type>> substParamTypes; for( auto pp : paramTypes ) { - substParamTypes.add(pp->substituteImpl(subst, &diff).as<Type>()); + substParamTypes.add(pp->substituteImpl(astBuilder, subst, &diff).as<Type>()); } // early exit for no change... @@ -1193,8 +1020,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return this; (*ioDiff)++; - RefPtr<FuncType> substType = new FuncType(); - substType->session = session; + RefPtr<FuncType> substType = astBuilder->create<FuncType>(); substType->resultType = substResultType; substType->paramTypes = substParamTypes; return substType; @@ -1212,8 +1038,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt canParamTypes.add(pp->getCanonicalType()); } - RefPtr<FuncType> canType = new FuncType(); - canType->session = session; + RefPtr<FuncType> canType = getASTBuilder()->create<FuncType>(); canType->resultType = resultType; canType->paramTypes = canParamTypes; @@ -1254,8 +1079,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt RefPtr<Type> TypeType::createCanonicalType() { - auto canType = getTypeType(type->getCanonicalType()); - return canType; + return getASTBuilder()->getTypeType(type->getCanonicalType()); } HashCode TypeType::getHashCode() @@ -1381,30 +1205,12 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt { if( !rowType ) { - rowType = getSession()->getVectorType(getElementType(), getColumnCount()); + rowType = m_astBuilder->getVectorType(getElementType(), getColumnCount()); } return rowType; } - RefPtr<VectorExpressionType> Session::getVectorType( - RefPtr<Type> elementType, - RefPtr<IntVal> elementCount) - { - auto vectorGenericDecl = findMagicDecl( - this, "Vector").as<GenericDecl>(); - auto vectorTypeDecl = vectorGenericDecl->inner; - - auto substitutions = new GenericSubstitution(); - substitutions->genericDecl = vectorGenericDecl.Ptr(); - substitutions->args.add(elementType); - substitutions->args.add(elementCount); - - auto declRef = DeclRef<Decl>(vectorTypeDecl.Ptr(), substitutions); - - return DeclRefType::Create( - this, - declRef).as<VectorExpressionType>(); - } + // PtrTypeBase @@ -1435,7 +1241,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return declRef.getHashCode() ^ HashCode(0xFFFF); } - RefPtr<Val> GenericParamIntVal::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> GenericParamIntVal::substituteImpl(ASTBuilder* /* astBuilder */, SubstitutionSet subst, int* ioDiff) { // search for a substitution that might apply to us for(auto s = subst.substitutions; s; s = s->outer) @@ -1498,8 +1304,9 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return HashCode(typeid(this).hash_code()); } - RefPtr<Val> ErrorIntVal::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> ErrorIntVal::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { + SLANG_UNUSED(astBuilder); SLANG_UNUSED(subst); SLANG_UNUSED(ioDiff); return this; @@ -1507,7 +1314,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // Substitutions - RefPtr<Substitutions> GenericSubstitution::applySubstitutionsShallow(SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) + RefPtr<Substitutions> GenericSubstitution::applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) { int diff = 0; @@ -1516,13 +1323,13 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt List<RefPtr<Val>> substArgs; for (auto a : args) { - substArgs.add(a->substituteImpl(substSet, &diff)); + substArgs.add(a->substituteImpl(astBuilder, substSet, &diff)); } if (!diff) return this; (*ioDiff)++; - auto substSubst = new GenericSubstitution(); + auto substSubst = astBuilder->create<GenericSubstitution>(); substSubst->genericDecl = genericDecl; substSubst->args = substArgs; substSubst->outer = substOuter; @@ -1560,19 +1367,19 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return true; } - RefPtr<Substitutions> ThisTypeSubstitution::applySubstitutionsShallow(SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) + RefPtr<Substitutions> ThisTypeSubstitution::applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) { int diff = 0; if(substOuter != outer) diff++; // NOTE: Must use .as because we must have a smart pointer here to keep in scope. - auto substWitness = witness->substituteImpl(substSet, &diff).as<SubtypeWitness>(); + auto substWitness = witness->substituteImpl(astBuilder, substSet, &diff).as<SubtypeWitness>(); if (!diff) return this; (*ioDiff)++; - auto substSubst = new ThisTypeSubstitution(); + auto substSubst = astBuilder->create<ThisTypeSubstitution>(); substSubst->interfaceDecl = interfaceDecl; substSubst->witness = substWitness; substSubst->outer = substOuter; @@ -1609,7 +1416,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return witness->getHashCode(); } - RefPtr<Substitutions> GlobalGenericParamSubstitution::applySubstitutionsShallow(SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) + RefPtr<Substitutions> GlobalGenericParamSubstitution::applySubstitutionsShallow(ASTBuilder* astBuilder, SubstitutionSet substSet, RefPtr<Substitutions> substOuter, int* ioDiff) { // if we find a GlobalGenericParamSubstitution in subst that references the same type_param decl // return a copy of that GlobalGenericParamSubstitution @@ -1617,14 +1424,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt if(substOuter != outer) diff++; - auto substActualType = actualType->substituteImpl(substSet, &diff).as<Type>(); + auto substActualType = actualType->substituteImpl(astBuilder, substSet, &diff).as<Type>(); List<ConstraintArg> substConstraintArgs; for(auto constraintArg : constraintArgs) { ConstraintArg substConstraintArg; substConstraintArg.decl = constraintArg.decl; - substConstraintArg.val = constraintArg.val->substituteImpl(substSet, &diff); + substConstraintArg.val = constraintArg.val->substituteImpl(astBuilder, substSet, &diff); substConstraintArgs.add(substConstraintArg); } @@ -1634,7 +1441,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt (*ioDiff)++; - RefPtr<GlobalGenericParamSubstitution> substSubst = new GlobalGenericParamSubstitution(); + RefPtr<GlobalGenericParamSubstitution> substSubst = astBuilder->create<GlobalGenericParamSubstitution>(); substSubst->paramDecl = paramDecl; substSubst->actualType = substActualType; substSubst->constraintArgs = substConstraintArgs; @@ -1670,7 +1477,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // DeclRefBase - RefPtr<Type> DeclRefBase::Substitute(RefPtr<Type> type) const + RefPtr<Type> DeclRefBase::substitute(ASTBuilder* astBuilder, RefPtr<Type> type) const { // Note that type can be nullptr, and so this function can return nullptr (although only correctly when no substitutions) @@ -1682,19 +1489,19 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // Otherwise we need to recurse on the type structure // and apply substitutions where it makes sense - return type->substitute(substitutions).as<Type>(); + return type->substitute(astBuilder, substitutions).as<Type>(); } - DeclRefBase DeclRefBase::Substitute(DeclRefBase declRef) const + DeclRefBase DeclRefBase::substitute(ASTBuilder* astBuilder, DeclRefBase declRef) const { if(!substitutions) return declRef; int diff = 0; - return declRef.SubstituteImpl(substitutions, &diff); + return declRef.substituteImpl(astBuilder, substitutions, &diff); } - RefPtr<Expr> DeclRefBase::Substitute(RefPtr<Expr> expr) const + RefPtr<Expr> DeclRefBase::substitute(ASTBuilder* /* astBuilder*/, RefPtr<Expr> expr) const { // No substitutions? Easy. if (!substitutions) @@ -1740,16 +1547,18 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt } RefPtr<Substitutions> specializeSubstitutionsShallow( + ASTBuilder* astBuilder, RefPtr<Substitutions> substToSpecialize, RefPtr<Substitutions> substsToApply, RefPtr<Substitutions> restSubst, int* ioDiff) { SLANG_ASSERT(substToSpecialize); - return substToSpecialize->applySubstitutionsShallow(substsToApply, restSubst, ioDiff); + return substToSpecialize->applySubstitutionsShallow(astBuilder, substsToApply, restSubst, ioDiff); } RefPtr<Substitutions> specializeGlobalGenericSubstitutions( + ASTBuilder* astBuilder, Decl* declToSpecialize, RefPtr<Substitutions> substsToSpecialize, RefPtr<Substitutions> substsToApply, @@ -1768,6 +1577,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt int diff = 0; auto restSubst = specializeGlobalGenericSubstitutions( + astBuilder, declToSpecialize, specSubst->outer, substsToApply, @@ -1775,6 +1585,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt ioParametersFound); auto firstSubst = specializeSubstitutionsShallow( + astBuilder, specGlobalGenericSubst, substsToApply, restSubst, @@ -1819,7 +1630,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt if(ioParametersFound.Contains(appGlobalGenericSubst->paramDecl)) continue; - RefPtr<GlobalGenericParamSubstitution> newSubst = new GlobalGenericParamSubstitution(); + RefPtr<GlobalGenericParamSubstitution> newSubst = astBuilder->create<GlobalGenericParamSubstitution>(); newSubst->paramDecl = appGlobalGenericSubst->paramDecl; newSubst->actualType = appGlobalGenericSubst->actualType; newSubst->constraintArgs = appGlobalGenericSubst->constraintArgs; @@ -1832,6 +1643,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt } RefPtr<Substitutions> specializeGlobalGenericSubstitutions( + ASTBuilder* astBuilder, Decl* declToSpecialize, RefPtr<Substitutions> substsToSpecialize, RefPtr<Substitutions> substsToApply, @@ -1840,13 +1652,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // Keep track of any parameters already present in the // existing substitution. HashSet<GlobalGenericParamDecl*> parametersFound; - return specializeGlobalGenericSubstitutions(declToSpecialize, substsToSpecialize, substsToApply, ioDiff, parametersFound); + return specializeGlobalGenericSubstitutions(astBuilder, declToSpecialize, substsToSpecialize, substsToApply, ioDiff, parametersFound); } // Construct new substitutions to apply to a declaration, // based on a provided substitution set to be applied RefPtr<Substitutions> specializeSubstitutions( + ASTBuilder* astBuilder, Decl* declToSpecialize, RefPtr<Substitutions> substsToSpecialize, RefPtr<Substitutions> substsToApply, @@ -1880,12 +1693,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // keep one matching it in place. int diff = 0; auto restSubst = specializeSubstitutions( + astBuilder, ancestorGenericDecl->parentDecl, specGenericSubst->outer, substsToApply, &diff); auto firstSubst = specializeSubstitutionsShallow( + astBuilder, specGenericSubst, substsToApply, restSubst, @@ -1920,12 +1735,13 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt int diff = 0; auto restSubst = specializeSubstitutions( + astBuilder, ancestorGenericDecl->parentDecl, substsToSpecialize, substsToApply, &diff); - RefPtr<GenericSubstitution> firstSubst = new GenericSubstitution(); + RefPtr<GenericSubstitution> firstSubst = astBuilder->create<GenericSubstitution>(); firstSubst->genericDecl = ancestorGenericDecl; firstSubst->args = appGenericSubst->args; firstSubst->outer = restSubst; @@ -1950,12 +1766,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // keep one matching it in place. int diff = 0; auto restSubst = specializeSubstitutions( + astBuilder, ancestorInterfaceDecl->parentDecl, specThisTypeSubst->outer, substsToApply, &diff); auto firstSubst = specializeSubstitutionsShallow( + astBuilder, specThisTypeSubst, substsToApply, restSubst, @@ -1980,12 +1798,13 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt int diff = 0; auto restSubst = specializeSubstitutions( + astBuilder, ancestorInterfaceDecl->parentDecl, substsToSpecialize, substsToApply, &diff); - RefPtr<ThisTypeSubstitution> firstSubst = new ThisTypeSubstitution(); + RefPtr<ThisTypeSubstitution> firstSubst = astBuilder->create<ThisTypeSubstitution>(); firstSubst->interfaceDecl = ancestorInterfaceDecl; firstSubst->witness = appThisTypeSubst->witness; firstSubst->outer = restSubst; @@ -2016,13 +1835,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // of them were applicable. // return specializeGlobalGenericSubstitutions( + astBuilder, declToSpecialize, substsToSpecialize, substsToApply, ioDiff); } - DeclRefBase DeclRefBase::SubstituteImpl(SubstitutionSet substSet, int* ioDiff) + DeclRefBase DeclRefBase::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet substSet, int* ioDiff) { // Nothing to do when we have no declaration. if(!decl) @@ -2033,6 +1853,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt int diff = 0; auto substSubst = specializeSubstitutions( + astBuilder, decl, substitutions.substitutions, substSet.substitutions, @@ -2138,14 +1959,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // Val - RefPtr<Val> Val::substitute(SubstitutionSet subst) + RefPtr<Val> Val::substitute(ASTBuilder* astBuilder, SubstitutionSet subst) { if (!subst) return this; int diff = 0; - return substituteImpl(subst, &diff); + return substituteImpl(astBuilder, subst, &diff); } - RefPtr<Val> Val::substituteImpl(SubstitutionSet /*subst*/, int* /*ioDiff*/) + RefPtr<Val> Val::substituteImpl(ASTBuilder* /* astBuilder */, SubstitutionSet /*subst*/, int* /*ioDiff*/) { // Default behavior is to not substitute at all return this; @@ -2182,64 +2003,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return (HashCode) value; } - // - - void registerBuiltinDecl( - Session* session, - RefPtr<Decl> decl, - RefPtr<BuiltinTypeModifier> modifier) - { - auto type = DeclRefType::Create( - session, - DeclRef<Decl>(decl.Ptr(), nullptr)); - session->builtinTypes[(int)modifier->tag] = type; - } - - void registerMagicDecl( - Session* session, - RefPtr<Decl> decl, - RefPtr<MagicTypeModifier> modifier) - { - // In some cases the modifier will have been applied to the - // "inner" declaration of a `GenericDecl`, but what we - // actually want to register is the generic itself. - // - auto declToRegister = decl; - if(auto genericDecl = as<GenericDecl>(decl->parentDecl)) - declToRegister = genericDecl; - - session->magicDecls[modifier->name] = declToRegister.Ptr(); - } - - RefPtr<Decl> findMagicDecl( - Session* session, - String const& name) - { - return session->magicDecls[name].GetValue(); - } - - // - - SyntaxNodeBase* createInstanceOfSyntaxClassByName( - String const& name) - { - if(0) {} - #define CASE(NAME) \ - else if(name == #NAME) return new NAME() - - CASE(GLSLBufferModifier); - CASE(GLSLWriteOnlyModifier); - CASE(GLSLReadOnlyModifier); - CASE(GLSLPatchModifier); - CASE(SimpleModifier); - - #undef CASE - else - { - SLANG_UNEXPECTED("unhandled syntax class name"); - UNREACHABLE_RETURN(nullptr); - } - } + // @@ -2258,72 +2022,59 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // Constructors for types RefPtr<ArrayExpressionType> getArrayType( + ASTBuilder* astBuilder, Type* elementType, IntVal* elementCount) { - auto session = elementType->getSession(); - auto arrayType = new ArrayExpressionType(); - arrayType->setSession(session); + auto arrayType = astBuilder->create<ArrayExpressionType>(); arrayType->baseType = elementType; arrayType->arrayLength = elementCount; return arrayType; } RefPtr<ArrayExpressionType> getArrayType( + ASTBuilder* astBuilder, Type* elementType) { - auto session = elementType->getSession(); - auto arrayType = new ArrayExpressionType(); - arrayType->setSession(session); + auto arrayType = astBuilder->create<ArrayExpressionType>(); arrayType->baseType = elementType; return arrayType; } RefPtr<NamedExpressionType> getNamedType( - Session* session, + ASTBuilder* astBuilder, DeclRef<TypeDefDecl> const& declRef) { - DeclRef<TypeDefDecl> specializedDeclRef = createDefaultSubstitutionsIfNeeded(session, declRef).as<TypeDefDecl>(); + DeclRef<TypeDefDecl> specializedDeclRef = createDefaultSubstitutionsIfNeeded(astBuilder, declRef).as<TypeDefDecl>(); - auto namedType = new NamedExpressionType(specializedDeclRef); - namedType->setSession(session); - return namedType; - } - - RefPtr<TypeType> getTypeType( - Type* type) - { - auto session = type->getSession(); - auto typeType = new TypeType(type); - typeType->setSession(session); - return typeType; + return astBuilder->create<NamedExpressionType>(specializedDeclRef); } + RefPtr<FuncType> getFuncType( - Session* session, + ASTBuilder* astBuilder, DeclRef<CallableDecl> const& declRef) { - RefPtr<FuncType> funcType = new FuncType(); - funcType->setSession(session); + RefPtr<FuncType> funcType = astBuilder->create<FuncType>(); - funcType->resultType = GetResultType(declRef); + funcType->resultType = GetResultType(astBuilder, declRef); for (auto paramDeclRef : GetParameters(declRef)) { auto paramDecl = paramDeclRef.getDecl(); - auto paramType = GetType(paramDeclRef); + auto paramType = GetType(astBuilder, paramDeclRef); if( paramDecl->findModifier<RefModifier>() ) { - paramType = session->getRefType(paramType); + paramType = astBuilder->getRefType(paramType); } else if( paramDecl->findModifier<OutModifier>() ) { if(paramDecl->findModifier<InOutModifier>() || paramDecl->findModifier<InModifier>()) { - paramType = session->getInOutType(paramType); + paramType = astBuilder->getInOutType(paramType); } else { - paramType = session->getOutType(paramType); + paramType = astBuilder->getOutType(paramType); } } funcType->paramTypes.add(paramType); @@ -2333,30 +2084,25 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt } RefPtr<GenericDeclRefType> getGenericDeclRefType( - Session* session, + ASTBuilder* astBuilder, DeclRef<GenericDecl> const& declRef) { - auto genericDeclRefType = new GenericDeclRefType(declRef); - genericDeclRefType->setSession(session); - return genericDeclRefType; + return astBuilder->create<GenericDeclRefType>(declRef); } RefPtr<NamespaceType> getNamespaceType( - Session* session, + ASTBuilder* astBuilder, DeclRef<NamespaceDeclBase> const& declRef) { - auto type = new NamespaceType; - type->setSession(session); + auto type = astBuilder->create<NamespaceType>(); type->declRef = declRef; return type; } RefPtr<SamplerStateType> getSamplerStateType( - Session* session) + ASTBuilder* astBuilder) { - auto samplerStateType = new SamplerStateType(); - samplerStateType->setSession(session); - return samplerStateType; + return astBuilder->create<SamplerStateType>(); } // TODO: should really have a `type.cpp` and a `witness.cpp` @@ -2369,11 +2115,11 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return sub->equals(otherWitness->sub); } - RefPtr<Val> TypeEqualityWitness::substituteImpl(SubstitutionSet subst, int * ioDiff) + RefPtr<Val> TypeEqualityWitness::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int * ioDiff) { - RefPtr<TypeEqualityWitness> rs = new TypeEqualityWitness(); - rs->sub = sub->substituteImpl(subst, ioDiff).as<Type>(); - rs->sup = sup->substituteImpl(subst, ioDiff).as<Type>(); + RefPtr<TypeEqualityWitness> rs = astBuilder->create<TypeEqualityWitness>(); + rs->sub = sub->substituteImpl(astBuilder, subst, ioDiff).as<Type>(); + rs->sup = sup->substituteImpl(astBuilder, subst, ioDiff).as<Type>(); return rs; } @@ -2417,7 +2163,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return nullptr; } - RefPtr<Val> DeclaredSubtypeWitness::substituteImpl(SubstitutionSet subst, int * ioDiff) + RefPtr<Val> DeclaredSubtypeWitness::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int * ioDiff) { if (auto genConstraintDeclRef = declRef.as<GenericTypeConstraintDecl>()) { @@ -2477,9 +2223,9 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // Perform substitution on the constituent elements. int diff = 0; - auto substSub = sub->substituteImpl(subst, &diff).as<Type>(); - auto substSup = sup->substituteImpl(subst, &diff).as<Type>(); - auto substDeclRef = declRef.SubstituteImpl(subst, &diff); + auto substSub = sub->substituteImpl(astBuilder, subst, &diff).as<Type>(); + auto substSup = sup->substituteImpl(astBuilder, subst, &diff).as<Type>(); + auto substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff); if (!diff) return this; @@ -2509,7 +2255,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // We need to look up the declaration that satisfies // the requirement named by the associated type. Decl* requirementKey = substTypeConstraintDecl; - RequirementWitness requirementWitness = tryLookUpRequirementWitness(thisTypeSubst->witness, requirementKey); + RequirementWitness requirementWitness = tryLookUpRequirementWitness(astBuilder, thisTypeSubst->witness, requirementKey); switch(requirementWitness.getFlavor()) { default: @@ -2529,7 +2275,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt - RefPtr<DeclaredSubtypeWitness> rs = new DeclaredSubtypeWitness(); + RefPtr<DeclaredSubtypeWitness> rs = astBuilder->create<DeclaredSubtypeWitness>(); rs->sub = substSub; rs->sup = substSup; rs->declRef = substDeclRef; @@ -2568,14 +2314,14 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt && midToSup.equals(otherWitness->midToSup); } - RefPtr<Val> TransitiveSubtypeWitness::substituteImpl(SubstitutionSet subst, int * ioDiff) + RefPtr<Val> TransitiveSubtypeWitness::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int * ioDiff) { int diff = 0; - RefPtr<Type> substSub = sub->substituteImpl(subst, &diff).as<Type>(); - RefPtr<Type> substSup = sup->substituteImpl(subst, &diff).as<Type>(); - RefPtr<SubtypeWitness> substSubToMid = subToMid->substituteImpl(subst, &diff).as<SubtypeWitness>(); - DeclRef<Decl> substMidToSup = midToSup.SubstituteImpl(subst, &diff); + RefPtr<Type> substSub = sub->substituteImpl(astBuilder, subst, &diff).as<Type>(); + RefPtr<Type> substSup = sup->substituteImpl(astBuilder, subst, &diff).as<Type>(); + RefPtr<SubtypeWitness> substSubToMid = subToMid->substituteImpl(astBuilder, subst, &diff).as<SubtypeWitness>(); + DeclRef<Decl> substMidToSup = midToSup.substituteImpl(astBuilder, subst, &diff); // If nothing changed, then we can bail out early. if (!diff) @@ -2601,7 +2347,7 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt // In the simple case, we just construct a new transitive subtype // witness, and we move on with life. - RefPtr<TransitiveSubtypeWitness> result = new TransitiveSubtypeWitness(); + RefPtr<TransitiveSubtypeWitness> result = astBuilder->create<TransitiveSubtypeWitness>(); result->sub = substSub; result->sup = substSup; result->subToMid = substSubToMid; @@ -2695,16 +2441,16 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return this; } - RefPtr<Val> ExtractExistentialType::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> ExtractExistentialType::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; - auto substDeclRef = declRef.SubstituteImpl(subst, &diff); + auto substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff); if(!diff) return this; (*ioDiff)++; - RefPtr<ExtractExistentialType> substValue = new ExtractExistentialType(); + RefPtr<ExtractExistentialType> substValue = astBuilder->create<ExtractExistentialType>(); substValue->declRef = declRef; return substValue; } @@ -2734,20 +2480,20 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return declRef.getHashCode(); } - RefPtr<Val> ExtractExistentialSubtypeWitness::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> ExtractExistentialSubtypeWitness::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; - auto substDeclRef = declRef.SubstituteImpl(subst, &diff); - auto substSub = sub->substituteImpl(subst, &diff).as<Type>(); - auto substSup = sup->substituteImpl(subst, &diff).as<Type>(); + auto substDeclRef = declRef.substituteImpl(astBuilder, subst, &diff); + auto substSub = sub->substituteImpl(astBuilder, subst, &diff).as<Type>(); + auto substSup = sup->substituteImpl(astBuilder, subst, &diff).as<Type>(); if(!diff) return this; (*ioDiff)++; - RefPtr<ExtractExistentialSubtypeWitness> substValue = new ExtractExistentialSubtypeWitness(); + RefPtr<ExtractExistentialSubtypeWitness> substValue = astBuilder->create<ExtractExistentialSubtypeWitness>(); substValue->declRef = declRef; substValue->sub = substSub; substValue->sup = substSup; @@ -2804,9 +2550,8 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt RefPtr<Type> TaggedUnionType::createCanonicalType() { - RefPtr<TaggedUnionType> canType = new TaggedUnionType(); - canType->setSession(getSession()); - + RefPtr<TaggedUnionType> canType = m_astBuilder->create<TaggedUnionType>(); + for( auto caseType : caseTypes ) { auto canCaseType = caseType->getCanonicalType(); @@ -2816,22 +2561,21 @@ Index getFilterCountImpl(const ReflectClassInfo& clsInfo, MemberFilterStyle filt return canType; } - RefPtr<Val> TaggedUnionType::substituteImpl(SubstitutionSet subst, int* ioDiff) + RefPtr<Val> TaggedUnionType::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; List<RefPtr<Type>> substCaseTypes; for( auto caseType : caseTypes ) { - substCaseTypes.add(caseType->substituteImpl(subst, &diff).as<Type>()); + substCaseTypes.add(caseType->substituteImpl(astBuilder, subst, &diff).as<Type>()); } if(!diff) return this; (*ioDiff)++; - RefPtr<TaggedUnionType> substType = new TaggedUnionType(); - substType->setSession(getSession()); + RefPtr<TaggedUnionType> substType = astBuilder->create<TaggedUnionType>(); substType->caseTypes.swapWith(substCaseTypes); return substType; } @@ -2885,17 +2629,17 @@ HashCode TaggedUnionSubtypeWitness::getHashCode() return hash; } -RefPtr<Val> TaggedUnionSubtypeWitness::substituteImpl(SubstitutionSet subst, int* ioDiff) +RefPtr<Val> TaggedUnionSubtypeWitness::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; - auto substSub = sub->substituteImpl(subst, &diff).as<Type>(); - auto substSup = sup->substituteImpl(subst, &diff).as<Type>(); + auto substSub = sub->substituteImpl(astBuilder, subst, &diff).as<Type>(); + auto substSup = sup->substituteImpl(astBuilder, subst, &diff).as<Type>(); List<RefPtr<Val>> substCaseWitnesses; for( auto caseWitness : caseWitnesses ) { - substCaseWitnesses.add(caseWitness->substituteImpl(subst, &diff)); + substCaseWitnesses.add(caseWitness->substituteImpl(astBuilder, subst, &diff)); } if(!diff) @@ -2903,7 +2647,7 @@ RefPtr<Val> TaggedUnionSubtypeWitness::substituteImpl(SubstitutionSet subst, int (*ioDiff)++; - RefPtr<TaggedUnionSubtypeWitness> substWitness = new TaggedUnionSubtypeWitness(); + RefPtr<TaggedUnionSubtypeWitness> substWitness = astBuilder->create<TaggedUnionSubtypeWitness>(); substWitness->sub = substSub; substWitness->sup = substSup; substWitness->caseWitnesses.swapWith(substCaseWitnesses); @@ -3027,9 +2771,8 @@ RefPtr<Val> getCanonicalValue(Val* val) RefPtr<Type> ExistentialSpecializedType::createCanonicalType() { - RefPtr<ExistentialSpecializedType> canType = new ExistentialSpecializedType(); - canType->setSession(getSession()); - + RefPtr<ExistentialSpecializedType> canType = m_astBuilder->create<ExistentialSpecializedType>(); + canType->baseType = baseType->getCanonicalType(); for( auto arg : args ) { @@ -3041,24 +2784,24 @@ RefPtr<Type> ExistentialSpecializedType::createCanonicalType() return canType; } -RefPtr<Val> substituteImpl(Val* val, SubstitutionSet subst, int* ioDiff) +RefPtr<Val> substituteImpl(ASTBuilder* astBuilder, Val* val, SubstitutionSet subst, int* ioDiff) { if(!val) return nullptr; - return val->substituteImpl(subst, ioDiff); + return val->substituteImpl(astBuilder, subst, ioDiff); } -RefPtr<Val> ExistentialSpecializedType::substituteImpl(SubstitutionSet subst, int* ioDiff) +RefPtr<Val> ExistentialSpecializedType::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; - auto substBaseType = baseType->substituteImpl(subst, &diff).as<Type>(); + auto substBaseType = baseType->substituteImpl(astBuilder, subst, &diff).as<Type>(); ExpandedSpecializationArgs substArgs; for( auto arg : args ) { ExpandedSpecializationArg substArg; - substArg.val = Slang::substituteImpl(arg.val, subst, &diff); - substArg.witness = Slang::substituteImpl(arg.witness, subst, &diff); + substArg.val = Slang::substituteImpl(astBuilder, arg.val, subst, &diff); + substArg.witness = Slang::substituteImpl(astBuilder, arg.witness, subst, &diff); substArgs.add(substArg); } @@ -3067,8 +2810,7 @@ RefPtr<Val> ExistentialSpecializedType::substituteImpl(SubstitutionSet subst, in (*ioDiff)++; - RefPtr<ExistentialSpecializedType> substType = new ExistentialSpecializedType(); - substType->setSession(getSession()); + RefPtr<ExistentialSpecializedType> substType = astBuilder->create<ExistentialSpecializedType>(); substType->baseType = substBaseType; substType->args = substArgs; return substType; @@ -3107,19 +2849,18 @@ HashCode ThisType::getHashCode() RefPtr<Type> ThisType::createCanonicalType() { - RefPtr<ThisType> canType = new ThisType(); - canType->setSession(getSession()); - + RefPtr<ThisType> canType = m_astBuilder->create<ThisType>(); + // TODO: need to canonicalize the decl-ref canType->interfaceDeclRef = interfaceDeclRef; return canType; } -RefPtr<Val> ThisType::substituteImpl(SubstitutionSet subst, int* ioDiff) +RefPtr<Val> ThisType::substituteImpl(ASTBuilder* astBuilder, SubstitutionSet subst, int* ioDiff) { int diff = 0; - auto substInterfaceDeclRef = interfaceDeclRef.SubstituteImpl(subst, &diff); + auto substInterfaceDeclRef = interfaceDeclRef.substituteImpl(astBuilder, subst, &diff); auto thisTypeSubst = findThisTypeSubstitution(subst.substitutions, substInterfaceDeclRef.getDecl()); if( thisTypeSubst ) @@ -3132,8 +2873,7 @@ RefPtr<Val> ThisType::substituteImpl(SubstitutionSet subst, int* ioDiff) (*ioDiff)++; - RefPtr<ThisType> substType = new ThisType(); - substType->setSession(getSession()); + RefPtr<ThisType> substType = m_astBuilder->create<ThisType>(); substType->interfaceDeclRef = substInterfaceDeclRef; return substType; } diff --git a/source/slang/slang-syntax.h b/source/slang/slang-syntax.h index d1e626f25..266f27599 100644 --- a/source/slang/slang-syntax.h +++ b/source/slang/slang-syntax.h @@ -1,45 +1,21 @@ #ifndef SLANG_SYNTAX_H #define SLANG_SYNTAX_H -#include "slang-ast-support-types.h" - -#include "slang-ast-all.h" +#include "slang-ast-builder.h" namespace Slang { - inline RefPtr<Type> GetSub(DeclRef<GenericTypeConstraintDecl> const& declRef) + inline RefPtr<Type> GetSub(ASTBuilder* astBuilder, DeclRef<GenericTypeConstraintDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->sub.Ptr()); + return declRef.substitute(astBuilder, declRef.getDecl()->sub.Ptr()); } - inline RefPtr<Type> GetSup(DeclRef<TypeConstraintDecl> const& declRef) + inline RefPtr<Type> GetSup(ASTBuilder* astBuilder, DeclRef<TypeConstraintDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->getSup().type); + return declRef.substitute(astBuilder, declRef.getDecl()->getSup().type); } - // Note(tfoley): These logically belong to `Type`, - // but order-of-declaration stuff makes that tricky - // - // TODO(tfoley): These should really belong to the compilation context! - // - void registerBuiltinDecl( - Session* session, - RefPtr<Decl> decl, - RefPtr<BuiltinTypeModifier> modifier); - void registerMagicDecl( - Session* session, - RefPtr<Decl> decl, - RefPtr<MagicTypeModifier> modifier); - - // Look up a magic declaration by its name - RefPtr<Decl> findMagicDecl( - Session* session, - String const& name); - - // Create an instance of a syntax class by name - SyntaxNodeBase* createInstanceOfSyntaxClassByName( - String const& name); // `Val` @@ -119,29 +95,29 @@ namespace Slang /// Name* getReflectionName(VarDeclBase* varDecl); - inline RefPtr<Type> GetType(DeclRef<VarDeclBase> const& declRef) + inline RefPtr<Type> GetType(ASTBuilder* astBuilder, DeclRef<VarDeclBase> const& declRef) { - return declRef.Substitute(declRef.getDecl()->type.Ptr()); + return declRef.substitute(astBuilder, declRef.getDecl()->type.Ptr()); } - inline RefPtr<Expr> getInitExpr(DeclRef<VarDeclBase> const& declRef) + inline RefPtr<Expr> getInitExpr(ASTBuilder* astBuilder, DeclRef<VarDeclBase> const& declRef) { - return declRef.Substitute(declRef.getDecl()->initExpr); + return declRef.substitute(astBuilder, declRef.getDecl()->initExpr); } - inline RefPtr<Type> getType(DeclRef<EnumCaseDecl> const& declRef) + inline RefPtr<Type> getType(ASTBuilder* astBuilder, DeclRef<EnumCaseDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->type.Ptr()); + return declRef.substitute(astBuilder, declRef.getDecl()->type.Ptr()); } - inline RefPtr<Expr> getTagExpr(DeclRef<EnumCaseDecl> const& declRef) + inline RefPtr<Expr> getTagExpr(ASTBuilder* astBuilder, DeclRef<EnumCaseDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->tagExpr); + return declRef.substitute(astBuilder, declRef.getDecl()->tagExpr); } - inline RefPtr<Type> GetTargetType(DeclRef<ExtensionDecl> const& declRef) + inline RefPtr<Type> GetTargetType(ASTBuilder* astBuilder, DeclRef<ExtensionDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->targetType.Ptr()); + return declRef.substitute(astBuilder, declRef.getDecl()->targetType.Ptr()); } inline FilteredMemberRefList<VarDecl> GetFields(DeclRef<StructDecl> const& declRef, MemberFilterStyle filterStyle) @@ -151,19 +127,19 @@ namespace Slang - inline RefPtr<Type> getBaseType(DeclRef<InheritanceDecl> const& declRef) + inline RefPtr<Type> getBaseType(ASTBuilder* astBuilder, DeclRef<InheritanceDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->base.type); + return declRef.substitute(astBuilder, declRef.getDecl()->base.type); } - inline RefPtr<Type> GetType(DeclRef<TypeDefDecl> const& declRef) + inline RefPtr<Type> GetType(ASTBuilder* astBuilder, DeclRef<TypeDefDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->type.Ptr()); + return declRef.substitute(astBuilder, declRef.getDecl()->type.Ptr()); } - inline RefPtr<Type> GetResultType(DeclRef<CallableDecl> const& declRef) + inline RefPtr<Type> GetResultType(ASTBuilder* astBuilder, DeclRef<CallableDecl> const& declRef) { - return declRef.Substitute(declRef.getDecl()->returnType.type.Ptr()); + return declRef.substitute(astBuilder, declRef.getDecl()->returnType.type.Ptr()); } inline FilteredMemberRefList<ParamDecl> GetParameters(DeclRef<CallableDecl> const& declRef) @@ -182,33 +158,32 @@ namespace Slang // RefPtr<ArrayExpressionType> getArrayType( + ASTBuilder* astBuilder, Type* elementType, IntVal* elementCount); RefPtr<ArrayExpressionType> getArrayType( + ASTBuilder* astBuilder, Type* elementType); RefPtr<NamedExpressionType> getNamedType( - Session* session, + ASTBuilder* astBuilder, DeclRef<TypeDefDecl> const& declRef); - RefPtr<TypeType> getTypeType( - Type* type); - RefPtr<FuncType> getFuncType( - Session* session, + ASTBuilder* astBuilder, DeclRef<CallableDecl> const& declRef); RefPtr<GenericDeclRefType> getGenericDeclRefType( - Session* session, + ASTBuilder* astBuilder, DeclRef<GenericDecl> const& declRef); RefPtr<NamespaceType> getNamespaceType( - Session* session, + ASTBuilder* astBuilder, DeclRef<NamespaceDeclBase> const& declRef); RefPtr<SamplerStateType> getSamplerStateType( - Session* session); + ASTBuilder* astBuilder); // Definitions that can't come earlier despite @@ -237,20 +212,20 @@ namespace Slang // TODO: where should this live? SubstitutionSet createDefaultSubstitutions( - Session* session, + ASTBuilder* astBuilder, Decl* decl, SubstitutionSet parentSubst); SubstitutionSet createDefaultSubstitutions( - Session* session, + ASTBuilder* astBuilder, Decl* decl); DeclRef<Decl> createDefaultSubstitutionsIfNeeded( - Session* session, + ASTBuilder* astBuilder, DeclRef<Decl> declRef); - RefPtr<GenericSubstitution> createDefaultSubsitutionsForGeneric( - Session* session, + RefPtr<GenericSubstitution> createDefaultSubstitutionsForGeneric( + ASTBuilder* astBuilder, GenericDecl* genericDecl, RefPtr<Substitutions> outerSubst); diff --git a/source/slang/slang-type-layout.cpp b/source/slang/slang-type-layout.cpp index 29d6c66d4..3f005f18e 100644 --- a/source/slang/slang-type-layout.cpp +++ b/source/slang/slang-type-layout.cpp @@ -1298,9 +1298,12 @@ LayoutRulesFamilyImpl* getDefaultLayoutRulesFamilyForTarget(TargetRequest* targe TypeLayoutContext getInitialLayoutContextForTarget(TargetRequest* targetReq, ProgramLayout* programLayout) { + auto astBuilder = targetReq->getLinkage()->getASTBuilder(); + LayoutRulesFamilyImpl* rulesFamily = getDefaultLayoutRulesFamilyForTarget(targetReq); TypeLayoutContext context; + context.astBuilder = astBuilder; context.targetReq = targetReq; context.programLayout = programLayout; context.rules = nullptr; @@ -3460,7 +3463,7 @@ static TypeLayoutResult _createTypeLayout( TypeLayoutResult fieldResult = _createTypeLayout( fieldLayoutContext, - GetType(field).Ptr(), + GetType(context.astBuilder, field).Ptr(), field.getDecl()); auto fieldTypeLayout = fieldResult.layout; diff --git a/source/slang/slang-type-layout.h b/source/slang/slang-type-layout.h index fdf980fa9..fbe95608e 100644 --- a/source/slang/slang-type-layout.h +++ b/source/slang/slang-type-layout.h @@ -912,6 +912,8 @@ struct LayoutRulesFamilyImpl struct TypeLayoutContext { + ASTBuilder* astBuilder; + // The layout rules to use (e.g., we compute // layout differently in a `cbuffer` vs. the // parameter list of a fragment shader). diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index 2c698eeaf..486034876 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -118,26 +118,18 @@ void Session::init() // Set all the shared library function pointers to nullptr ::memset(m_sharedLibraryFunctions, 0, sizeof(m_sharedLibraryFunctions)); - - // Initialize the lookup table of syntax classes: - - // We can just iterate over the class pointers. - // NOTE! That this adds the names of the abstract classes too(!) - { - for (Index i = 0; i < Index(ASTNodeType::CountOf); ++i) - { - const ReflectClassInfo* info = ReflectClassInfo::getInfo(ASTNodeType(i)); - if (info) - { - mapNameToSyntaxClass.Add(getNamePool()->getName(info->m_name), SyntaxClass<Slang::RefObject>(info)); - } - } - } + // Set up shared AST builder + m_sharedASTBuilder = new SharedASTBuilder; + m_sharedASTBuilder->init(this); + // Use to create a ASTBuilder + RefPtr<ASTBuilder> builtinAstBuilder(new ASTBuilder(m_sharedASTBuilder)); + // Make sure our source manager is initialized builtinSourceManager.initialize(nullptr, nullptr); - m_builtinLinkage = new Linkage(this); + + m_builtinLinkage = new Linkage(this, builtinAstBuilder); // Because the `Session` retains the builtin `Linkage`, // we need to make sure that the parent pointer inside @@ -149,9 +141,7 @@ void Session::init() // m_builtinLinkage->_stopRetainingParentSession(); - // Initialize representations of some very basic types: - initializeTypes(); - + // Create scopes for various language builtins. // // TODO: load these on-demand to avoid parsing @@ -160,7 +150,7 @@ void Session::init() baseLanguageScope = new Scope(); auto baseModuleDecl = populateBaseLanguageModule( - this, + m_builtinLinkage->getASTBuilder(), baseLanguageScope); loadedModuleCode.add(baseModuleDecl); @@ -198,7 +188,8 @@ SLANG_NO_THROW SlangResult SLANG_MCALL Session::createSession( slang::SessionDesc const& desc, slang::ISession** outSession) { - RefPtr<Linkage> linkage = new Linkage(this); + RefPtr<ASTBuilder> astBuilder(new ASTBuilder(m_sharedASTBuilder)); + RefPtr<Linkage> linkage = new Linkage(this, astBuilder); Int targetCount = desc.targetCount; for(Int ii = 0; ii < targetCount; ++ii) @@ -507,10 +498,11 @@ Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) // -Linkage::Linkage(Session* session) +Linkage::Linkage(Session* session, ASTBuilder* astBuilder) : m_session(session) , m_retainedSession(session) , m_sourceManager(&m_defaultSourceManager) + , m_astBuilder(astBuilder) { getNamePool()->setRootNamePool(session->getRootNamePool()); @@ -868,7 +860,7 @@ RefPtr<Expr> Linkage::parseTermString(String typeStr, RefPtr<Scope> scope) nullptr); return parseTermFromSourceFile( - getSessionImpl(), + getASTBuilder(), tokens, &sink, scope, getNamePool(), SourceLanguage::Slang); } @@ -960,7 +952,7 @@ void FrontEndCompileRequest::parseTranslationUnit( combinedPreprocessorDefinitions.Add(def.Key, def.Value); auto module = translationUnit->getModule(); - RefPtr<ModuleDecl> translationUnitSyntax = new ModuleDecl(); + RefPtr<ModuleDecl> translationUnitSyntax = linkage->getASTBuilder()->create<ModuleDecl>(); translationUnitSyntax->nameAndLoc.name = translationUnit->moduleName; translationUnitSyntax->module = module; module->setModuleDecl(translationUnitSyntax); @@ -980,7 +972,7 @@ void FrontEndCompileRequest::parseTranslationUnit( // if( m_isStandardLibraryCode ) { - translationUnitSyntax->modifiers.first = new FromStdLibModifier(); + translationUnitSyntax->modifiers.first = linkage->getASTBuilder()->create<FromStdLibModifier>(); } for (auto sourceFile : translationUnit->getSourceFiles()) @@ -994,6 +986,7 @@ void FrontEndCompileRequest::parseTranslationUnit( module); parseSourceFile( + linkage->getASTBuilder(), translationUnit, tokens, getSink(), @@ -1062,7 +1055,7 @@ void FrontEndCompileRequest::generateIR() // * it can generate diagnostics /// Generate IR for translation unit - RefPtr<IRModule> irModule(generateIRForTranslationUnit(translationUnit)); + RefPtr<IRModule> irModule(generateIRForTranslationUnit(getLinkage()->getASTBuilder(), translationUnit)); if (verifyDebugSerialization) { @@ -1212,7 +1205,8 @@ EndToEndCompileRequest::EndToEndCompileRequest( : m_session(session) , m_sink(nullptr) { - m_linkage = new Linkage(session); + RefPtr<ASTBuilder> astBuilder(new ASTBuilder(session->m_sharedASTBuilder)); + m_linkage = new Linkage(session, astBuilder); init(); } @@ -1534,7 +1528,7 @@ void Linkage::loadParsedModule( // If we didn't run into any errors, then try to generate // IR code for the imported module. SLANG_ASSERT(errorCountAfter == 0); - loadedModule->setIRModule(generateIRForTranslationUnit(translationUnit)); + loadedModule->setIRModule(generateIRForTranslationUnit(getASTBuilder(), translationUnit)); } loadedModulesList.add(loadedModule); } @@ -2337,7 +2331,7 @@ SpecializedComponentType::SpecializedComponentType( if(specializationInfo) funcDeclRef = specializationInfo->specializedFuncDeclRef; - (*mangledEntryPointNames).add(getMangledName(funcDeclRef)); + (*mangledEntryPointNames).add(getMangledName(m_astBuilder, funcDeclRef)); } void visitModule(Module*, Module::ModuleSpecializationInfo*) SLANG_OVERRIDE @@ -2346,12 +2340,18 @@ SpecializedComponentType::SpecializedComponentType( { visitChildren(composite, specializationInfo); } void visitSpecialized(SpecializedComponentType* specialized) SLANG_OVERRIDE { visitChildren(specialized); } + + EntryPointMangledNameCollector(ASTBuilder* astBuilder): + m_astBuilder(astBuilder) + { + } + ASTBuilder* m_astBuilder; }; // With the visitor defined, we apply it to ourself to compute // and collect the mangled entry point names. // - EntryPointMangledNameCollector collector; + EntryPointMangledNameCollector collector(getLinkage()->getASTBuilder()); collector.mangledEntryPointNames = &m_entryPointMangledNames; collector.visitSpecialized(this); } @@ -2605,19 +2605,8 @@ void Session::addBuiltinSource( Session::~Session() { - // free all built-in types first - errorType = nullptr; - initializerListType = nullptr; - overloadedType = nullptr; - irBasicBlockType = nullptr; - constExprRate = nullptr; - destroyTypeCheckingCache(); - for (Index i = 0; i < SLANG_COUNT_OF(builtinTypes); ++i) - { - builtinTypes[i].setNull(); - } // destroy modules next loadedModuleCode = decltype(loadedModuleCode)(); } diff --git a/source/slang/slang.vcxproj b/source/slang/slang.vcxproj index 8c815e1e1..c3e936f8a 100644 --- a/source/slang/slang.vcxproj +++ b/source/slang/slang.vcxproj @@ -191,6 +191,7 @@ <ClInclude Include="hlsl.meta.slang.h" /> <ClInclude Include="slang-ast-all.h" /> <ClInclude Include="slang-ast-base.h" /> + <ClInclude Include="slang-ast-builder.h" /> <ClInclude Include="slang-ast-decl.h" /> <ClInclude Include="slang-ast-dump.h" /> <ClInclude Include="slang-ast-expr.h" /> @@ -273,6 +274,7 @@ <ClInclude Include="slang-visitor.h" /> </ItemGroup> <ItemGroup> + <ClCompile Include="slang-ast-builder.cpp" /> <ClCompile Include="slang-ast-dump.cpp" /> <ClCompile Include="slang-ast-reflect.cpp" /> <ClCompile Include="slang-check-conformance.cpp" /> diff --git a/source/slang/slang.vcxproj.filters b/source/slang/slang.vcxproj.filters index 31e03d73d..bec8547e1 100644 --- a/source/slang/slang.vcxproj.filters +++ b/source/slang/slang.vcxproj.filters @@ -24,6 +24,9 @@ <ClInclude Include="slang-ast-base.h"> <Filter>Header Files</Filter> </ClInclude> + <ClInclude Include="slang-ast-builder.h"> + <Filter>Header Files</Filter> + </ClInclude> <ClInclude Include="slang-ast-decl.h"> <Filter>Header Files</Filter> </ClInclude> @@ -266,6 +269,9 @@ </ClInclude> </ItemGroup> <ItemGroup> + <ClCompile Include="slang-ast-builder.cpp"> + <Filter>Source Files</Filter> + </ClCompile> <ClCompile Include="slang-ast-dump.cpp"> <Filter>Source Files</Filter> </ClCompile> |