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-expr.cpp | 196 +++++++++++++++++++------------------- 1 file changed, 99 insertions(+), 97 deletions(-) (limited to 'source/slang/slang-check-expr.cpp') diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp index c0beb8262..307ec6316 100644 --- a/source/slang/slang-check-expr.cpp +++ b/source/slang/slang-check-expr.cpp @@ -15,10 +15,10 @@ namespace Slang { - RefPtr SemanticsVisitor::getExprDeclRefType(Expr * expr) + DeclRefType* SemanticsVisitor::getExprDeclRefType(Expr * expr) { if (auto typetype = as(expr->type)) - return typetype->type.dynamicCast(); + return dynamicCast(typetype->type); else return as(expr->type); } @@ -29,18 +29,18 @@ namespace Slang /// the temporary, and the computation created by `func`. /// template - RefPtr SemanticsVisitor::moveTemp(RefPtr const& expr, F const& func) + Expr* SemanticsVisitor::moveTemp(Expr* const& expr, F const& func) { - RefPtr varDecl = m_astBuilder->create(); + VarDecl* varDecl = m_astBuilder->create(); varDecl->parentDecl = nullptr; // TODO: need to fill this in somehow! varDecl->checkState = DeclCheckState::Checked; varDecl->nameAndLoc.loc = expr->loc; varDecl->initExpr = expr; varDecl->type.type = expr->type.type; - auto varDeclRef = makeDeclRef(varDecl.Ptr()); + auto varDeclRef = makeDeclRef(varDecl); - RefPtr letExpr = m_astBuilder->create(); + LetExpr* letExpr = m_astBuilder->create(); letExpr->decl = varDecl; auto body = func(varDeclRef); @@ -58,7 +58,7 @@ namespace Slang /// a new variable to hold `expr`, using `moveTemp()`. /// template - RefPtr SemanticsVisitor::maybeMoveTemp(RefPtr const& expr, F const& func) + Expr* SemanticsVisitor::maybeMoveTemp(Expr* const& expr, F const& func) { if(auto varExpr = as(expr)) { @@ -88,8 +88,8 @@ namespace Slang /// returns an expression that logically corresponds to `v`: an expression /// of type `X`, where the type carries the knowledge that `X` implements `IMover`. /// - RefPtr SemanticsVisitor::openExistential( - RefPtr expr, + Expr* SemanticsVisitor::openExistential( + Expr* expr, DeclRef interfaceDeclRef) { // If `expr` refers to an immutable binding, @@ -102,15 +102,15 @@ namespace Slang auto interfaceDecl = interfaceDeclRef.getDecl(); return maybeMoveTemp(expr, [&](DeclRef varDeclRef) { - RefPtr openedType = m_astBuilder->create(); + ExtractExistentialType* openedType = m_astBuilder->create(); openedType->declRef = varDeclRef; - RefPtr openedWitness = m_astBuilder->create(); + ExtractExistentialSubtypeWitness* openedWitness = m_astBuilder->create(); openedWitness->sub = openedType; openedWitness->sup = expr->type.type; openedWitness->declRef = varDeclRef; - RefPtr openedThisType = m_astBuilder->create(); + ThisTypeSubstitution* openedThisType = m_astBuilder->create(); openedThisType->outer = interfaceDeclRef.substitutions.substitutions; openedThisType->interfaceDecl = interfaceDecl; openedThisType->witness = openedWitness; @@ -118,7 +118,7 @@ namespace Slang DeclRef substDeclRef = DeclRef(interfaceDecl, openedThisType); auto substDeclRefType = DeclRefType::create(m_astBuilder, substDeclRef); - RefPtr openedValue = m_astBuilder->create(); + ExtractExistentialValueExpr* openedValue = m_astBuilder->create(); openedValue->declRef = varDeclRef; openedValue->type = QualType(substDeclRefType); @@ -134,7 +134,7 @@ namespace Slang /// See `openExistential` for a discussion of what "opening" an /// existential-type value means. /// - RefPtr SemanticsVisitor::maybeOpenExistential(RefPtr expr) + Expr* SemanticsVisitor::maybeOpenExistential(Expr* expr) { auto exprType = expr->type.type; @@ -151,7 +151,7 @@ namespace Slang // to the chosen interface decl must be the first substitution on // the list (which is a linked list from the "inside" out). // - auto thisTypeSubst = interfaceDeclRef.substitutions.substitutions.as(); + auto thisTypeSubst = as(interfaceDeclRef.substitutions.substitutions); if(thisTypeSubst && thisTypeSubst->interfaceDecl == interfaceDeclRef.decl) { // This isn't really an existential type, because somebody @@ -170,9 +170,9 @@ namespace Slang return expr; } - RefPtr SemanticsVisitor::ConstructDeclRefExpr( + Expr* SemanticsVisitor::ConstructDeclRefExpr( DeclRef declRef, - RefPtr baseExpr, + Expr* baseExpr, SourceLoc loc) { // Compute the type that this declaration reference will have in context. @@ -230,7 +230,7 @@ namespace Slang { // Extract the type of the baseExpr auto baseExprType = baseExpr->type.type; - RefPtr baseTypeExpr = m_astBuilder->create(); + SharedTypeExpr* baseTypeExpr = m_astBuilder->create(); baseTypeExpr->base.type = baseExprType; baseTypeExpr->type.type = m_astBuilder->getTypeType(baseExprType); @@ -283,8 +283,8 @@ namespace Slang } } - RefPtr SemanticsVisitor::ConstructDerefExpr( - RefPtr base, + Expr* SemanticsVisitor::ConstructDerefExpr( + Expr* base, SourceLoc loc) { auto ptrLikeType = as(base->type); @@ -300,9 +300,9 @@ namespace Slang return derefExpr; } - RefPtr SemanticsVisitor::ConstructLookupResultExpr( + Expr* SemanticsVisitor::ConstructLookupResultExpr( LookupResultItem const& item, - RefPtr baseExpr, + Expr* baseExpr, SourceLoc loc) { // If we collected any breadcrumbs, then these represent @@ -387,7 +387,7 @@ namespace Slang // refernece to `this.someStaticMember` will be translated // over to `This.someStaticMember`. // - RefPtr expr = m_astBuilder->create(); + ThisExpr* expr = m_astBuilder->create(); expr->type.type = thisType; expr->loc = loc; @@ -411,10 +411,10 @@ namespace Slang return ConstructDeclRefExpr(item.declRef, bb, loc); } - RefPtr SemanticsVisitor::createLookupResultExpr( + Expr* SemanticsVisitor::createLookupResultExpr( Name* name, LookupResult const& lookupResult, - RefPtr baseExpr, + Expr* baseExpr, SourceLoc loc) { if (lookupResult.isOverloaded()) @@ -513,7 +513,7 @@ namespace Slang } } - RefPtr SemanticsVisitor::_resolveOverloadedExprImpl(RefPtr overloadedExpr, LookupMask mask, DiagnosticSink* diagSink) + Expr* SemanticsVisitor::_resolveOverloadedExprImpl(OverloadedExpr* overloadedExpr, LookupMask mask, DiagnosticSink* diagSink) { auto lookupResult = overloadedExpr->lookupResult2; SLANG_RELEASE_ASSERT(lookupResult.isValid() && lookupResult.isOverloaded()); @@ -568,7 +568,7 @@ namespace Slang } } - RefPtr SemanticsVisitor::maybeResolveOverloadedExpr(RefPtr expr, LookupMask mask, DiagnosticSink* diagSink) + Expr* SemanticsVisitor::maybeResolveOverloadedExpr(Expr* expr, LookupMask mask, DiagnosticSink* diagSink) { if( auto overloadedExpr = as(expr) ) { @@ -580,12 +580,12 @@ namespace Slang } } - RefPtr SemanticsVisitor::resolveOverloadedExpr(RefPtr overloadedExpr, LookupMask mask) + Expr* SemanticsVisitor::resolveOverloadedExpr(OverloadedExpr* overloadedExpr, LookupMask mask) { return _resolveOverloadedExprImpl(overloadedExpr, mask, getSink()); } - RefPtr SemanticsVisitor::CheckTerm(RefPtr term) + Expr* SemanticsVisitor::CheckTerm(Expr* term) { if (!term) return nullptr; @@ -593,13 +593,13 @@ namespace Slang return exprVisitor.dispatch(term); } - RefPtr SemanticsVisitor::CreateErrorExpr(Expr* expr) + Expr* SemanticsVisitor::CreateErrorExpr(Expr* expr) { expr->type = QualType(m_astBuilder->getErrorType()); return expr; } - bool SemanticsVisitor::IsErrorExpr(RefPtr expr) + bool SemanticsVisitor::IsErrorExpr(Expr* expr) { // TODO: we may want other cases here... @@ -609,7 +609,7 @@ namespace Slang return false; } - RefPtr SemanticsVisitor::GetBaseExpr(RefPtr expr) + Expr* SemanticsVisitor::GetBaseExpr(Expr* expr) { if (auto memberExpr = as(expr)) { @@ -622,13 +622,13 @@ namespace Slang return nullptr; } - RefPtr SemanticsExprVisitor::visitBoolLiteralExpr(BoolLiteralExpr* expr) + Expr* SemanticsExprVisitor::visitBoolLiteralExpr(BoolLiteralExpr* expr) { expr->type = m_astBuilder->getBoolType(); return expr; } - RefPtr SemanticsExprVisitor::visitIntegerLiteralExpr(IntegerLiteralExpr* expr) + Expr* SemanticsExprVisitor::visitIntegerLiteralExpr(IntegerLiteralExpr* expr) { // The expression might already have a type, determined by its suffix. // It it doesn't, we will give it a default type. @@ -648,7 +648,7 @@ namespace Slang return expr; } - RefPtr SemanticsExprVisitor::visitFloatingPointLiteralExpr(FloatingPointLiteralExpr* expr) + Expr* SemanticsExprVisitor::visitFloatingPointLiteralExpr(FloatingPointLiteralExpr* expr) { if(!expr->type.type) { @@ -657,7 +657,7 @@ namespace Slang return expr; } - RefPtr SemanticsExprVisitor::visitStringLiteralExpr(StringLiteralExpr* expr) + Expr* SemanticsExprVisitor::visitStringLiteralExpr(StringLiteralExpr* expr) { expr->type = m_astBuilder->getStringType(); return expr; @@ -669,7 +669,7 @@ namespace Slang return m_astBuilder->create(expr->value); } - RefPtr SemanticsVisitor::TryConstantFoldExpr( + IntVal* SemanticsVisitor::TryConstantFoldExpr( InvokeExpr* invokeExpr) { // We need all the operands to the expression @@ -678,7 +678,7 @@ namespace Slang // // For right now we will look for calls to intrinsic functions, and then inspect // their names (this is bad and slow). - auto funcDeclRefExpr = invokeExpr->functionExpr.as(); + auto funcDeclRefExpr = as(invokeExpr->functionExpr); if (!funcDeclRefExpr) return nullptr; auto funcDeclRef = funcDeclRefExpr->declRef; @@ -701,13 +701,13 @@ namespace Slang return nullptr; // Before checking the operation name, let's look at the arguments - RefPtr argVals[kMaxArgs]; + IntVal* argVals[kMaxArgs]; IntegerLiteralValue constArgVals[kMaxArgs]; int argCount = 0; bool allConst = true; for (auto argExpr : invokeExpr->arguments) { - auto argVal = TryCheckIntegerConstantExpression(argExpr.Ptr()); + auto argVal = TryCheckIntegerConstantExpression(argExpr); if (!argVal) return nullptr; @@ -791,11 +791,11 @@ namespace Slang return nullptr; } - RefPtr result = m_astBuilder->create(resultValue); + IntVal* result = m_astBuilder->create(resultValue); return result; } - RefPtr SemanticsVisitor::TryConstantFoldExpr( + IntVal* SemanticsVisitor::TryConstantFoldExpr( Expr* expr) { // Unwrap any "identity" expressions @@ -835,7 +835,7 @@ namespace Slang // HLSL `static const` can be used as a constant expression if(auto initExpr = getInitExpr(m_astBuilder, varRef)) { - return TryConstantFoldExpr(initExpr.Ptr()); + return TryConstantFoldExpr(initExpr); } } } @@ -845,14 +845,14 @@ namespace Slang // The cases in an `enum` declaration can also be used as constant expressions, if(auto tagExpr = getTagExpr(m_astBuilder, enumRef)) { - return TryConstantFoldExpr(tagExpr.Ptr()); + return TryConstantFoldExpr(tagExpr); } } } if(auto castExpr = as(expr)) { - auto val = TryConstantFoldExpr(castExpr->arguments[0].Ptr()); + auto val = TryConstantFoldExpr(castExpr->arguments[0]); if(val) return val; } @@ -866,7 +866,7 @@ namespace Slang return nullptr; } - RefPtr SemanticsVisitor::TryCheckIntegerConstantExpression(Expr* exp) + IntVal* SemanticsVisitor::TryCheckIntegerConstantExpression(Expr* exp) { // Check if type is acceptable for an integer constant expression if(auto basicType = as(exp->type.type)) @@ -883,7 +883,7 @@ namespace Slang return TryConstantFoldExpr(exp); } - RefPtr SemanticsVisitor::CheckIntegerConstantExpression(Expr* inExpr, DiagnosticSink* sink) + IntVal* SemanticsVisitor::CheckIntegerConstantExpression(Expr* inExpr, DiagnosticSink* sink) { // No need to issue further errors if the expression didn't even type-check. if(IsErrorExpr(inExpr)) return nullptr; @@ -894,7 +894,7 @@ namespace Slang // No need to issue further errors if the type coercion failed. if(IsErrorExpr(expr)) return nullptr; - auto result = TryCheckIntegerConstantExpression(expr.Ptr()); + auto result = TryCheckIntegerConstantExpression(expr); if (!result && sink) { sink->diagnose(expr, Diagnostics::expectedIntegerConstantNotConstant); @@ -902,12 +902,12 @@ namespace Slang return result; } - RefPtr SemanticsVisitor::CheckIntegerConstantExpression(Expr* inExpr) + IntVal* SemanticsVisitor::CheckIntegerConstantExpression(Expr* inExpr) { return CheckIntegerConstantExpression(inExpr, getSink()); } - RefPtr SemanticsVisitor::CheckEnumConstantExpression(Expr* expr) + IntVal* SemanticsVisitor::CheckEnumConstantExpression(Expr* expr) { // No need to issue further errors if the expression didn't even type-check. if(IsErrorExpr(expr)) return nullptr; @@ -923,9 +923,9 @@ namespace Slang return result; } - RefPtr SemanticsVisitor::CheckSimpleSubscriptExpr( - RefPtr subscriptExpr, - RefPtr elementType) + Expr* SemanticsVisitor::CheckSimpleSubscriptExpr( + IndexExpr* subscriptExpr, + Type* elementType) { auto baseExpr = subscriptExpr->baseExpression; auto indexExpr = subscriptExpr->indexExpression; @@ -934,7 +934,7 @@ namespace Slang !indexExpr->type->equals(m_astBuilder->getUIntType())) { getSink()->diagnose(indexExpr, Diagnostics::subscriptIndexNonInteger); - return CreateErrorExpr(subscriptExpr.Ptr()); + return CreateErrorExpr(subscriptExpr); } subscriptExpr->type = QualType(elementType); @@ -945,12 +945,12 @@ namespace Slang return subscriptExpr; } - RefPtr SemanticsExprVisitor::visitIndexExpr(IndexExpr* subscriptExpr) + Expr* SemanticsExprVisitor::visitIndexExpr(IndexExpr* subscriptExpr) { auto baseExpr = subscriptExpr->baseExpression; baseExpr = CheckExpr(baseExpr); - RefPtr indexExpr = subscriptExpr->indexExpression; + Expr* indexExpr = subscriptExpr->indexExpression; if (indexExpr) { indexExpr = CheckExpr(indexExpr); @@ -972,10 +972,10 @@ namespace Slang // We are trying to "index" into a type, so we have an expression like `float[2]` // which should be interpreted as resolving to an array type. - RefPtr elementCount = nullptr; + IntVal* elementCount = nullptr; if (indexExpr) { - elementCount = CheckIntegerConstantExpression(indexExpr.Ptr()); + elementCount = CheckIntegerConstantExpression(indexExpr); } auto elementType = CoerceToUsableType(TypeExp(baseExpr, baseTypeType->type)); @@ -1033,17 +1033,17 @@ namespace Slang // Note: the expression may be an `OverloadedExpr`, in which // case the attempt to call it will trigger overload // resolution. - RefPtr subscriptFuncExpr = createLookupResultExpr( + Expr* subscriptFuncExpr = createLookupResultExpr( name, lookupResult, subscriptExpr->baseExpression, subscriptExpr->loc); - RefPtr subscriptCallExpr = m_astBuilder->create(); + InvokeExpr* subscriptCallExpr = m_astBuilder->create(); subscriptCallExpr->loc = subscriptExpr->loc; subscriptCallExpr->functionExpr = subscriptFuncExpr; // TODO(tfoley): This path can support multiple arguments easily subscriptCallExpr->arguments.add(subscriptExpr->indexExpression); - return CheckInvokeExprWithCheckedOperands(subscriptCallExpr.Ptr()); + return CheckInvokeExprWithCheckedOperands(subscriptCallExpr); } fail: @@ -1053,7 +1053,7 @@ namespace Slang } } - RefPtr SemanticsExprVisitor::visitParenExpr(ParenExpr* expr) + Expr* SemanticsExprVisitor::visitParenExpr(ParenExpr* expr) { auto base = expr->base; base = CheckTerm(base); @@ -1072,7 +1072,7 @@ namespace Slang // | e [ expr ] // // We will unwrap the `e.name` and `e[expr]` cases in a loop. - RefPtr e = expr; + Expr* e = expr; for(;;) { if(auto memberExpr = as(e)) @@ -1100,7 +1100,7 @@ namespace Slang } } - RefPtr SemanticsExprVisitor::visitAssignExpr(AssignExpr* expr) + Expr* SemanticsExprVisitor::visitAssignExpr(AssignExpr* expr) { expr->left = CheckExpr(expr->left); @@ -1130,7 +1130,7 @@ namespace Slang return expr; } - RefPtr SemanticsVisitor::CheckExpr(RefPtr expr) + Expr* SemanticsVisitor::CheckExpr(Expr* expr) { auto term = CheckTerm(expr); @@ -1140,10 +1140,10 @@ namespace Slang return term; } - RefPtr SemanticsVisitor::CheckInvokeExprWithCheckedOperands(InvokeExpr *expr) + Expr* SemanticsVisitor::CheckInvokeExprWithCheckedOperands(InvokeExpr *expr) { auto rs = ResolveInvoke(expr); - if (auto invoke = as(rs.Ptr())) + if (auto invoke = as(rs)) { // if this is still an invoke expression, test arguments passed to inout/out parameter are LValues if(auto funcType = as(invoke->functionExpr->type)) @@ -1212,7 +1212,7 @@ namespace Slang return rs; } - RefPtr SemanticsExprVisitor::visitInvokeExpr(InvokeExpr *expr) + Expr* SemanticsExprVisitor::visitInvokeExpr(InvokeExpr *expr) { // check the base expression first expr->functionExpr = CheckExpr(expr->functionExpr); @@ -1225,7 +1225,7 @@ namespace Slang return CheckInvokeExprWithCheckedOperands(expr); } - RefPtr SemanticsExprVisitor::visitVarExpr(VarExpr *expr) + Expr* SemanticsExprVisitor::visitVarExpr(VarExpr *expr) { // If we've already resolved this expression, don't try again. if (expr->declRef) @@ -1249,7 +1249,7 @@ namespace Slang return expr; } - RefPtr SemanticsExprVisitor::visitTypeCastExpr(TypeCastExpr * expr) + Expr* SemanticsExprVisitor::visitTypeCastExpr(TypeCastExpr * expr) { // Check the term we are applying first auto funcExpr = expr->functionExpr; @@ -1274,14 +1274,14 @@ namespace Slang // from a literal zero, with the semantics of default // initialization. // - if( auto declRefType = typeExp.type.as() ) + if( auto declRefType = as(typeExp.type) ) { - if(auto structDeclRef = declRefType->declRef.as()) + if(auto structDeclRef = as(declRefType->declRef)) { if( expr->arguments.getCount() == 1 ) { auto arg = expr->arguments[0]; - if( auto intLitArg = arg.as() ) + if( auto intLitArg = as(arg) ) { if(getIntegerLiteralValue(intLitArg->token) == 0) { @@ -1324,9 +1324,11 @@ namespace Slang // of explicit default initializers for `struct` fields to // make this a major concern (since they aren't supported in HLSL). // - RefPtr initListExpr = m_astBuilder->create(); + InitializerListExpr* initListExpr = m_astBuilder->create(); auto checkedInitListExpr = visitInitializerListExpr(initListExpr); - return coerce(typeExp.type, initListExpr); + + // TODO(JS): I changed this to checkInitListExpr form initListExpr + return coerce(typeExp.type, checkedInitListExpr); } } } @@ -1339,9 +1341,9 @@ namespace Slang return CheckInvokeExprWithCheckedOperands(expr); } - RefPtr SemanticsVisitor::MaybeDereference(RefPtr inExpr) + Expr* SemanticsVisitor::MaybeDereference(Expr* inExpr) { - RefPtr expr = inExpr; + Expr* expr = inExpr; for (;;) { auto baseType = expr->type; @@ -1363,13 +1365,13 @@ namespace Slang } } - RefPtr SemanticsVisitor::CheckMatrixSwizzleExpr( + Expr* SemanticsVisitor::CheckMatrixSwizzleExpr( MemberExpr* memberRefExpr, - RefPtr baseElementType, + Type* baseElementType, IntegerLiteralValue baseElementRowCount, IntegerLiteralValue baseElementColCount) { - RefPtr swizExpr = m_astBuilder->create(); + MatrixSwizzleExpr* swizExpr = m_astBuilder->create(); swizExpr->loc = memberRefExpr->loc; swizExpr->base = memberRefExpr->baseExpression; @@ -1503,11 +1505,11 @@ namespace Slang return swizExpr; } - RefPtr SemanticsVisitor::CheckMatrixSwizzleExpr( + Expr* SemanticsVisitor::CheckMatrixSwizzleExpr( MemberExpr* memberRefExpr, - RefPtr baseElementType, - RefPtr baseRowCount, - RefPtr baseColCount) + Type* baseElementType, + IntVal* baseRowCount, + IntVal* baseColCount) { if (auto constantRowCount = as(baseRowCount)) { @@ -1521,12 +1523,12 @@ namespace Slang return CreateErrorExpr(memberRefExpr); } - RefPtr SemanticsVisitor::CheckSwizzleExpr( + Expr* SemanticsVisitor::CheckSwizzleExpr( MemberExpr* memberRefExpr, - RefPtr baseElementType, + Type* baseElementType, IntegerLiteralValue baseElementCount) { - RefPtr swizExpr = m_astBuilder->create(); + SwizzleExpr* swizExpr = m_astBuilder->create(); swizExpr->loc = memberRefExpr->loc; swizExpr->base = memberRefExpr->baseExpression; @@ -1615,10 +1617,10 @@ namespace Slang return swizExpr; } - RefPtr SemanticsVisitor::CheckSwizzleExpr( + Expr* SemanticsVisitor::CheckSwizzleExpr( MemberExpr* memberRefExpr, - RefPtr baseElementType, - RefPtr baseElementCount) + Type* baseElementType, + IntVal* baseElementCount) { if (auto constantElementCount = as(baseElementCount)) { @@ -1631,7 +1633,7 @@ namespace Slang } } - RefPtr SemanticsVisitor::_lookupStaticMember(RefPtr expr, RefPtr baseExpression) + Expr* SemanticsVisitor::_lookupStaticMember(DeclRefExpr* expr, Expr* baseExpression) { auto& baseType = baseExpression->type; @@ -1779,7 +1781,7 @@ namespace Slang return lookupMemberResultFailure(expr, baseType); } - RefPtr SemanticsExprVisitor::visitStaticMemberExpr(StaticMemberExpr* expr) + Expr* SemanticsExprVisitor::visitStaticMemberExpr(StaticMemberExpr* expr) { expr->baseExpression = CheckExpr(expr->baseExpression); @@ -1798,7 +1800,7 @@ namespace Slang return _lookupStaticMember(expr, expr->baseExpression); } - RefPtr SemanticsVisitor::lookupMemberResultFailure( + Expr* SemanticsVisitor::lookupMemberResultFailure( DeclRefExpr* expr, QualType const& baseType) { @@ -1810,7 +1812,7 @@ namespace Slang return expr; } - RefPtr SemanticsExprVisitor::visitMemberExpr(MemberExpr * expr) + Expr* SemanticsExprVisitor::visitMemberExpr(MemberExpr * expr) { expr->baseExpression = CheckExpr(expr->baseExpression); @@ -1897,7 +1899,7 @@ namespace Slang } } - RefPtr SemanticsExprVisitor::visitInitializerListExpr(InitializerListExpr* expr) + Expr* SemanticsExprVisitor::visitInitializerListExpr(InitializerListExpr* expr) { // When faced with an initializer list, we first just check the sub-expressions blindly. // Actually making them conform to a desired type will wait for when we know the desired @@ -1915,7 +1917,7 @@ namespace Slang // Perform semantic checking of an object-oriented `this` // expression. - RefPtr SemanticsExprVisitor::visitThisExpr(ThisExpr* expr) + Expr* SemanticsExprVisitor::visitThisExpr(ThisExpr* expr) { // A `this` expression will default to immutable. expr->type.isLeftValue = false; @@ -1979,7 +1981,7 @@ namespace Slang return CreateErrorExpr(expr); } - RefPtr SemanticsExprVisitor::visitThisTypeExpr(ThisTypeExpr* expr) + Expr* SemanticsExprVisitor::visitThisTypeExpr(ThisTypeExpr* expr) { auto scope = expr->scope; while (scope) -- cgit v1.2.3