From 43c146794aab638924d2ab838d10f8af2ebf02a7 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Fri, 5 Jun 2020 18:20:09 -0400 Subject: ASTNodes use MemoryArena (#1376) * Add a ASTBuilder to a Module Only construct on valid ASTBuilder (was being called on nullptr on occassion) * Add nodes to ASTBuilder. * Compiles with RefPtr removed from AST node types. * Initialize all AST node pointer variables in headers to nullptr; * Initialize AST node variables as nullptr. Make ASTBuilder keep a ref on node types. Make SyntaxParseCallback returns a NodeBase * Don't release canonicalType on dtor (managed by ASTBuilder). * Give ASTBuilders a name and id, to help in debugging. For now destroy the session TypeCache, to stop it holding things released when the compile request destroys ASTBuilders. * Moved the TypeCheckingCache over to Linkage from Session. * NodeBase no longer derived from RefObject. * Only add/dtor nodes that need destruction. First pass compile on linux. --- source/slang/slang-check-type.cpp | 68 +++++++++++++++++++-------------------- 1 file changed, 34 insertions(+), 34 deletions(-) (limited to 'source/slang/slang-check-type.cpp') diff --git a/source/slang/slang-check-type.cpp b/source/slang/slang-check-type.cpp index bdb043413..98b376a69 100644 --- a/source/slang/slang-check-type.cpp +++ b/source/slang/slang-check-type.cpp @@ -6,7 +6,7 @@ namespace Slang { - RefPtr checkProperType( + Type* checkProperType( Linkage* linkage, TypeExp typeExp, DiagnosticSink* sink) @@ -21,7 +21,7 @@ namespace Slang return typeOut.type; } - RefPtr SemanticsVisitor::TranslateTypeNodeImpl(const RefPtr & node) + Expr* SemanticsVisitor::TranslateTypeNodeImpl(Expr* node) { if (!node) return nullptr; @@ -30,7 +30,7 @@ namespace Slang return expr; } - RefPtr SemanticsVisitor::ExtractTypeFromTypeRepr(const RefPtr& typeRepr) + Type* SemanticsVisitor::ExtractTypeFromTypeRepr(Expr* typeRepr) { if (!typeRepr) return nullptr; if (auto typeType = as(typeRepr->type)) @@ -40,7 +40,7 @@ namespace Slang return m_astBuilder->getErrorType(); } - RefPtr SemanticsVisitor::TranslateTypeNode(const RefPtr & node) + Type* SemanticsVisitor::TranslateTypeNode(Expr* node) { if (!node) return nullptr; auto typeRepr = TranslateTypeNodeImpl(node); @@ -70,7 +70,7 @@ namespace Slang return TranslateTypeNodeForced(typeExp); } - RefPtr SemanticsVisitor::ExpectATypeRepr(RefPtr expr) + Expr* SemanticsVisitor::ExpectATypeRepr(Expr* expr) { if (auto overloadedExpr = as(expr)) { @@ -90,7 +90,7 @@ namespace Slang return CreateErrorExpr(expr); } - RefPtr SemanticsVisitor::ExpectAType(RefPtr expr) + Type* SemanticsVisitor::ExpectAType(Expr* expr) { auto typeRepr = ExpectATypeRepr(expr); if (auto typeType = as(typeRepr->type)) @@ -100,14 +100,14 @@ namespace Slang return m_astBuilder->getErrorType(); } - RefPtr SemanticsVisitor::ExtractGenericArgType(RefPtr exp) + Type* SemanticsVisitor::ExtractGenericArgType(Expr* exp) { return ExpectAType(exp); } - RefPtr SemanticsVisitor::ExtractGenericArgInteger(RefPtr exp, DiagnosticSink* sink) + IntVal* SemanticsVisitor::ExtractGenericArgInteger(Expr* exp, DiagnosticSink* sink) { - RefPtr val = CheckIntegerConstantExpression(exp.Ptr(), sink); + IntVal* val = CheckIntegerConstantExpression(exp, sink); if(val) return val; // If the argument expression could not be coerced to an integer @@ -118,12 +118,12 @@ namespace Slang return val; } - RefPtr SemanticsVisitor::ExtractGenericArgInteger(RefPtr exp) + IntVal* SemanticsVisitor::ExtractGenericArgInteger(Expr* exp) { return ExtractGenericArgInteger(exp, getSink()); } - RefPtr SemanticsVisitor::ExtractGenericArgVal(RefPtr exp) + Val* SemanticsVisitor::ExtractGenericArgVal(Expr* exp) { if (auto overloadedExpr = as(exp)) { @@ -145,11 +145,11 @@ namespace Slang } } - RefPtr SemanticsVisitor::InstantiateGenericType( + Type* SemanticsVisitor::InstantiateGenericType( DeclRef genericDeclRef, - List> const& args) + List const& args) { - RefPtr subst = m_astBuilder->create(); + GenericSubstitution* subst = m_astBuilder->create(); subst->genericDecl = genericDeclRef.getDecl(); subst->outer = genericDeclRef.substitutions.substitutions; @@ -167,10 +167,10 @@ namespace Slang bool SemanticsVisitor::CoerceToProperTypeImpl( TypeExp const& typeExp, - RefPtr* outProperType, + Type** outProperType, DiagnosticSink* diagSink) { - Type* type = typeExp.type.Ptr(); + Type* type = typeExp.type; if(!type && typeExp.exp) { auto expr = typeExp.exp; @@ -204,8 +204,8 @@ namespace Slang auto genericDeclRef = genericDeclRefType->getDeclRef(); ensureDecl(genericDeclRef, DeclCheckState::CanSpecializeGeneric); - List> args; - for (RefPtr member : genericDeclRef.getDecl()->members) + List args; + for (Decl* member : genericDeclRef.getDecl()->members) { if (auto typeParam = as(member)) { @@ -213,7 +213,7 @@ namespace Slang { if (diagSink) { - diagSink->diagnose(typeExp.exp.Ptr(), Diagnostics::genericTypeNeedsArgs, typeExp); + diagSink->diagnose(typeExp.exp, Diagnostics::genericTypeNeedsArgs, typeExp); *outProperType = m_astBuilder->getErrorType(); } return false; @@ -229,7 +229,7 @@ namespace Slang { if (diagSink) { - diagSink->diagnose(typeExp.exp.Ptr(), Diagnostics::unimplemented, "can't fill in default for generic type parameter"); + diagSink->diagnose(typeExp.exp, Diagnostics::unimplemented, "can't fill in default for generic type parameter"); *outProperType = m_astBuilder->getErrorType(); } return false; @@ -283,14 +283,14 @@ namespace Slang TypeExp SemanticsVisitor::CoerceToUsableType(TypeExp const& typeExp) { TypeExp result = CoerceToProperType(typeExp); - Type* type = result.type.Ptr(); + Type* type = result.type; if (auto basicType = as(type)) { // TODO: `void` shouldn't be a basic type, to make this easier to avoid if (basicType->baseType == BaseType::Void) { // TODO(tfoley): pick the right diagnostic message - getSink()->diagnose(result.exp.Ptr(), Diagnostics::invalidTypeVoid); + getSink()->diagnose(result.exp, Diagnostics::invalidTypeVoid); result.type = m_astBuilder->getErrorType(); return result; } @@ -304,8 +304,8 @@ namespace Slang } bool SemanticsVisitor::ValuesAreEqual( - RefPtr left, - RefPtr right) + IntVal* left, + IntVal* right) { if(left == right) return true; @@ -328,25 +328,25 @@ namespace Slang return false; } - RefPtr SemanticsVisitor::createVectorType( - RefPtr elementType, - RefPtr elementCount) + VectorExpressionType* SemanticsVisitor::createVectorType( + Type* elementType, + IntVal* elementCount) { - auto vectorGenericDecl = m_astBuilder->getSharedASTBuilder()->findMagicDecl("Vector").as(); + auto vectorGenericDecl = as(m_astBuilder->getSharedASTBuilder()->findMagicDecl("Vector")); auto vectorTypeDecl = vectorGenericDecl->inner; auto substitutions = m_astBuilder->create(); - substitutions->genericDecl = vectorGenericDecl.Ptr(); + substitutions->genericDecl = vectorGenericDecl; substitutions->args.add(elementType); substitutions->args.add(elementCount); - auto declRef = DeclRef(vectorTypeDecl.Ptr(), substitutions); + auto declRef = DeclRef(vectorTypeDecl, substitutions); - return DeclRefType::create(m_astBuilder, declRef).as(); + return as(DeclRefType::create(m_astBuilder, declRef)); } - RefPtr SemanticsExprVisitor::visitSharedTypeExpr(SharedTypeExpr* expr) + Expr* SemanticsExprVisitor::visitSharedTypeExpr(SharedTypeExpr* expr) { if (!expr->type.Ptr()) { @@ -356,12 +356,12 @@ namespace Slang return expr; } - RefPtr SemanticsExprVisitor::visitTaggedUnionTypeExpr(TaggedUnionTypeExpr* expr) + Expr* SemanticsExprVisitor::visitTaggedUnionTypeExpr(TaggedUnionTypeExpr* expr) { // We have an expression of the form `__TaggedUnion(A, B, ...)` // which will evaluate to a tagged-union type over `A`, `B`, etc. // - RefPtr type = m_astBuilder->create(); + TaggedUnionType* type = m_astBuilder->create(); expr->type = QualType(m_astBuilder->getTypeType(type)); for( auto& caseTypeExpr : expr->caseTypes ) -- cgit v1.2.3