From 695c2700de54a5fec72ce7214c137a1dc3a02d7b Mon Sep 17 00:00:00 2001 From: Tim Foley Date: Wed, 9 Aug 2017 10:13:40 -0700 Subject: Major naming overhaul: - `ExpressionSyntaxNode` becomes `Expr` - `StatementSyntaxNode` becomes `Stmt` - `StructSyntaxNode` becomes `StructDecl` - `ProgramSyntaxNode` becomes `ModuleDecl` - `ExpressionType` becomes `Type` - Existing fields names `Type` become `type` - There might be some collateral damage here if there were, e.g., `enum`s named `Type`, but I can live with that for now and fix those up as a I see them --- source/slang/lower.cpp | 566 ++++++++++++++++++++++++------------------------- 1 file changed, 283 insertions(+), 283 deletions(-) (limited to 'source/slang/lower.cpp') diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp index e8aa06f03..611180415 100644 --- a/source/slang/lower.cpp +++ b/source/slang/lower.cpp @@ -28,7 +28,7 @@ struct StructuralTransformVisitorBase { V* visitor; - RefPtr transformDeclField(StatementSyntaxNode* stmt) + RefPtr transformDeclField(Stmt* stmt) { return visitor->translateStmtRef(stmt); } @@ -58,12 +58,12 @@ struct StructuralTransformVisitorBase return result; } - RefPtr transformSyntaxField(ExpressionSyntaxNode* expr) + RefPtr transformSyntaxField(Expr* expr) { return visitor->transformSyntaxField(expr); } - RefPtr transformSyntaxField(StatementSyntaxNode* stmt) + RefPtr transformSyntaxField(Stmt* stmt) { return visitor->transformSyntaxField(stmt); } @@ -92,8 +92,8 @@ struct StructuralTransformVisitorBase }; template -RefPtr structuralTransform( - StatementSyntaxNode* stmt, +RefPtr structuralTransform( + Stmt* stmt, V* visitor) { StructuralTransformStmtVisitor transformer; @@ -104,16 +104,16 @@ RefPtr structuralTransform( template struct StructuralTransformExprVisitor : StructuralTransformVisitorBase - , ExprVisitor, RefPtr> + , ExprVisitor, RefPtr> { - void transformFields(ExpressionSyntaxNode* result, ExpressionSyntaxNode* obj) + void transformFields(Expr* result, Expr* obj) { - result->Type = transformSyntaxField(obj->Type); + result->type = transformSyntaxField(obj->type); } #define SYNTAX_CLASS(NAME, BASE, ...) \ - RefPtr visit##NAME(NAME* obj) { \ + RefPtr visit##NAME(NAME* obj) { \ RefPtr result = new NAME(*obj); \ transformFields(result, obj); \ return result; \ @@ -136,8 +136,8 @@ struct StructuralTransformExprVisitor template -RefPtr structuralTransform( - ExpressionSyntaxNode* expr, +RefPtr structuralTransform( + Expr* expr, V* visitor) { StructuralTransformExprVisitor transformer; @@ -257,7 +257,7 @@ struct LoweredExpr : flavor(Flavor::Expr) {} - LoweredExpr(ExpressionSyntaxNode* expr) + LoweredExpr(Expr* expr) : value(expr) , flavor(Flavor::Expr) {} @@ -274,10 +274,10 @@ struct LoweredExpr Flavor getFlavor() const { return flavor; } - ExpressionSyntaxNode* getExpr() const + Expr* getExpr() const { assert(getFlavor() == Flavor::Expr); - return (ExpressionSyntaxNode*)value.Ptr(); + return (Expr*)value.Ptr(); } TupleExpr* getTupleExpr() const @@ -293,7 +293,7 @@ struct LoweredExpr return (VaryingTupleExpr*)value.Ptr(); } - ExpressionSyntaxNode* asExpr() const + Expr* asExpr() const { return (getFlavor() == Flavor::Expr) ? getExpr() : nullptr; } @@ -319,7 +319,7 @@ class PseudoVarDecl : public RefObject public: Token Name; CodePosition Position; - TypeExp Type; + TypeExp type; }; class TupleVarDecl : public PseudoVarDecl @@ -340,7 +340,7 @@ class PseudoExpr : public RefObject { public: CodePosition Position; - QualType Type; + QualType type; }; // Pseudo-syntax used during lowering: @@ -356,7 +356,7 @@ public: // Optional reference to the "primary" value of the tuple, // in the case of a tuple type with "orinary" fields - RefPtr primaryExpr; + RefPtr primaryExpr; // Additional fields to store values for any non-ordinary fields // (or fields that aren't exclusively orginary) @@ -418,14 +418,14 @@ struct SharedLoweringContext Dictionary reservedWords; - RefPtr loweredProgram; + RefPtr loweredProgram; Dictionary loweredDecls; Dictionary mapLoweredDeclToOriginal; // Work to be done at the very start and end of the entry point - RefPtr entryPointInitializeStmt; - RefPtr entryPointFinalizeStmt; + RefPtr entryPointInitializeStmt; + RefPtr entryPointFinalizeStmt; // Counter used for generating unique temporary names int nameCounter = 0; @@ -452,14 +452,14 @@ struct LoweringVisitor : ExprVisitor , StmtVisitor , DeclVisitor - , ValVisitor, RefPtr> + , ValVisitor, RefPtr> { // SharedLoweringContext* shared; RefPtr substitutions; bool isBuildingStmt = false; - RefPtr stmtBeingBuilt; + RefPtr stmtBeingBuilt; // If we *aren't* building a statement, then this // is the container we should be adding declarations to @@ -660,8 +660,8 @@ struct LoweringVisitor // Types // - RefPtr lowerType( - ExpressionType* type) + RefPtr lowerType( + Type* type) { if (!type) return nullptr; return TypeVisitor::dispatch(type); @@ -676,29 +676,29 @@ struct LoweringVisitor return result; } - RefPtr visitErrorType(ErrorType* type) + RefPtr visitErrorType(ErrorType* type) { return type; } - RefPtr visitOverloadGroupType(OverloadGroupType* type) + RefPtr visitOverloadGroupType(OverloadGroupType* type) { return type; } - RefPtr visitInitializerListType(InitializerListType* type) + RefPtr visitInitializerListType(InitializerListType* type) { return type; } - RefPtr visitGenericDeclRefType(GenericDeclRefType* type) + RefPtr visitGenericDeclRefType(GenericDeclRefType* type) { return getGenericDeclRefType( type->getSession(), translateDeclRef(DeclRef(type->declRef)).As()); } - RefPtr visitFuncType(FuncType* type) + RefPtr visitFuncType(FuncType* type) { RefPtr loweredType = getFuncType( getSession(), @@ -706,7 +706,7 @@ struct LoweringVisitor return loweredType; } - RefPtr visitDeclRefType(DeclRefType* type) + RefPtr visitDeclRefType(DeclRefType* type) { auto loweredDeclRef = translateDeclRef(type->declRef); return DeclRefType::Create( @@ -714,7 +714,7 @@ struct LoweringVisitor loweredDeclRef.As()); } - RefPtr visitNamedExpressionType(NamedExpressionType* type) + RefPtr visitNamedExpressionType(NamedExpressionType* type) { if (shared->target == CodeGenTarget::GLSL) { @@ -727,12 +727,12 @@ struct LoweringVisitor translateDeclRef(DeclRef(type->declRef)).As()); } - RefPtr visitTypeType(TypeType* type) + RefPtr visitTypeType(TypeType* type) { return getTypeType(lowerType(type->type)); } - RefPtr visitArrayExpressionType(ArrayExpressionType* type) + RefPtr visitArrayExpressionType(ArrayExpressionType* type) { RefPtr loweredType = Slang::getArrayType( lowerType(type->BaseType), @@ -740,7 +740,7 @@ struct LoweringVisitor return loweredType; } - RefPtr transformSyntaxField(ExpressionType* type) + RefPtr transformSyntaxField(Type* type) { return lowerType(type); } @@ -750,14 +750,14 @@ struct LoweringVisitor // LoweredExpr lowerExprOrTuple( - ExpressionSyntaxNode* expr) + Expr* expr) { if (!expr) return LoweredExpr(); return ExprVisitor::dispatch(expr); } - RefPtr lowerExpr( - ExpressionSyntaxNode* expr) + RefPtr lowerExpr( + Expr* expr) { if (!expr) return nullptr; @@ -766,28 +766,28 @@ struct LoweringVisitor } // catch-all - RefPtr visitExpressionSyntaxNode( - ExpressionSyntaxNode* expr) + LoweredExpr visitExpr( + Expr* expr) { - return structuralTransform(expr, this); + return LoweredExpr(structuralTransform(expr, this)); } - RefPtr transformSyntaxField(ExpressionSyntaxNode* expr) + RefPtr transformSyntaxField(Expr* expr) { return lowerExpr(expr); } void lowerExprCommon( - ExpressionSyntaxNode* loweredExpr, - ExpressionSyntaxNode* expr) + Expr* loweredExpr, + Expr* expr) { loweredExpr->Position = expr->Position; - loweredExpr->Type.type = lowerType(expr->Type.type); + loweredExpr->type.type = lowerType(expr->type.type); } void lowerExprCommon( LoweredExpr const& loweredExpr, - ExpressionSyntaxNode* expr) + Expr* expr) { if (auto simpleExpr = loweredExpr.asExpr()) { @@ -795,21 +795,21 @@ struct LoweringVisitor } } - RefPtr createUncheckedVarRef( + RefPtr createUncheckedVarRef( char const* name) { - RefPtr result = new VarExpressionSyntaxNode(); + RefPtr result = new VarExpr(); result->name = name; return result; } - RefPtr createSimpleVarRef( + RefPtr createSimpleVarRef( CodePosition const& loc, VarDeclBase* decl) { - RefPtr result = new VarExpressionSyntaxNode(); + RefPtr result = new VarExpr(); result->Position = loc; - result->Type.type = decl->Type.type; + result->type.type = decl->type.type; result->declRef = makeDeclRef(decl); result->name = decl->getName(); return result; @@ -843,7 +843,7 @@ struct LoweringVisitor { RefPtr result = new TupleExpr(); result->Position = loc; - result->Type.type = decl->Type.type; + result->type.type = decl->type.type; if (auto primaryDecl = decl->primaryDecl) { @@ -874,8 +874,8 @@ struct LoweringVisitor return decl->expr; } - LoweredExpr visitVarExpressionSyntaxNode( - VarExpressionSyntaxNode* expr) + LoweredExpr visitVarExpr( + VarExpr* expr) { doSampleRateInputCheck(expr->name); @@ -898,7 +898,7 @@ struct LoweringVisitor return createVaryingTupleRef(expr->Position, varyingTupleVarDecl); } - RefPtr loweredExpr = new VarExpressionSyntaxNode(); + RefPtr loweredExpr = new VarExpr(); lowerExprCommon(loweredExpr, expr); loweredExpr->declRef = loweredDeclRef.As(); loweredExpr->name = expr->name; @@ -915,12 +915,12 @@ struct LoweringVisitor return result; } - RefPtr moveTemp(RefPtr expr) + RefPtr moveTemp(RefPtr expr) { RefPtr varDecl = new Variable(); varDecl->Name.Content = generateName(); - varDecl->Type.type = expr->Type.type; - varDecl->Expr = expr; + varDecl->type.type = expr->type.type; + varDecl->initExpr = expr; addDecl(varDecl); @@ -931,16 +931,16 @@ struct LoweringVisitor // use/evaluate more than once, and if needed replace it with a // reference to a temporary (initialized with the expr) so that it // can safely be re-evaluated. - RefPtr maybeMoveTemp( - ExpressionSyntaxNode* expr) + RefPtr maybeMoveTemp( + Expr* expr) { // TODO: actually implement this properly! // Certain expressions are already in a form we can directly re-use, // so there is no reason to move them. - if (dynamic_cast(expr)) + if (dynamic_cast(expr)) return expr; - if (dynamic_cast(expr)) + if (dynamic_cast(expr)) return expr; // In the general case, though, we need to introduce a temporary @@ -954,7 +954,7 @@ struct LoweringVisitor { RefPtr resultExpr = new TupleExpr(); resultExpr->Position = tupleExpr->Position; - resultExpr->Type = tupleExpr->Type; + resultExpr->type = tupleExpr->type; if (tupleExpr->primaryExpr) { resultExpr->primaryExpr = maybeMoveTemp(tupleExpr->primaryExpr); @@ -974,7 +974,7 @@ struct LoweringVisitor { RefPtr resultExpr = new VaryingTupleExpr(); resultExpr->Position = varyingTupleExpr->Position; - resultExpr->Type = varyingTupleExpr->Type; + resultExpr->type = varyingTupleExpr->type; for (auto ee : varyingTupleExpr->elements) { VaryingTupleExpr::Element elem; @@ -995,8 +995,8 @@ struct LoweringVisitor // Similar to the above, this ensures that an l-value expression // is safe to re-evaluate, by recursively moving things off // to temporaries where needed. - RefPtr ensureSimpleLValue( - ExpressionSyntaxNode* expr) + RefPtr ensureSimpleLValue( + Expr* expr) { // TODO: actually implement this properly! @@ -1021,22 +1021,22 @@ struct LoweringVisitor WithFixups, }; - RefPtr createSimpleAssignExpr( - RefPtr leftExpr, - RefPtr rightExpr) + RefPtr createSimpleAssignExpr( + RefPtr leftExpr, + RefPtr rightExpr) { RefPtr loweredExpr = new AssignExpr(); - loweredExpr->Type = leftExpr->Type; + loweredExpr->type = leftExpr->type; loweredExpr->left = leftExpr; loweredExpr->right = rightExpr; return loweredExpr; } - RefPtr convertExprForAssignmentWithFixups( - RefPtr leftType, - RefPtr rightExpr) + RefPtr convertExprForAssignmentWithFixups( + RefPtr leftType, + RefPtr rightExpr) { - auto rightType = rightExpr->Type.type; + auto rightType = rightExpr->type.type; if (auto leftArrayType = leftType->As()) { // LHS type was an array @@ -1058,7 +1058,7 @@ struct LoweringVisitor RefPtr ctorExpr = new AggTypeCtorExpr(); ctorExpr->Position = rightExpr->Position; - ctorExpr->Type.type = leftType; + ctorExpr->type.type = leftType; ctorExpr->base.type = leftType; int elementCount = (int) GetIntVal(rightVecType->elementCount); @@ -1066,7 +1066,7 @@ struct LoweringVisitor { RefPtr swizzleExpr = new SwizzleExpr(); swizzleExpr->Position = rightExpr->Position; - swizzleExpr->Type.type = rightVecType->elementType; + swizzleExpr->type.type = rightVecType->elementType; swizzleExpr->base = rightExpr; swizzleExpr->elementCount = 1; swizzleExpr->elementIndices[0] = ee; @@ -1089,42 +1089,42 @@ struct LoweringVisitor } - RefPtr createConstIntExpr(IntegerLiteralValue value) + RefPtr createConstIntExpr(IntegerLiteralValue value) { - RefPtr expr = new ConstantExpressionSyntaxNode(); - expr->Type.type = getIntType(); - expr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Int; + RefPtr expr = new ConstantExpr(); + expr->type.type = getIntType(); + expr->ConstType = ConstantExpr::ConstantType::Int; expr->integerValue = value; return expr; } struct SeqExprBuilder { - RefPtr expr; - RefPtr* link = nullptr; + RefPtr expr; + RefPtr* link = nullptr; }; - RefPtr createSimpleVarExpr(char const* name) + RefPtr createSimpleVarExpr(char const* name) { - RefPtr varExpr = new VarExpressionSyntaxNode(); + RefPtr varExpr = new VarExpr(); varExpr->name = name; return varExpr; } - RefPtr createSeqExpr( - RefPtr left, - RefPtr right) + RefPtr createSeqExpr( + RefPtr left, + RefPtr right) { RefPtr seqExpr = new InfixExpr(); seqExpr->Position = left->Position; - seqExpr->Type = right->Type; + seqExpr->type = right->type; seqExpr->FunctionExpr = createSimpleVarExpr(","); seqExpr->Arguments.Add(left); seqExpr->Arguments.Add(right); return seqExpr; } - void addExpr(SeqExprBuilder* builder, RefPtr expr) + void addExpr(SeqExprBuilder* builder, RefPtr expr) { // No expression to add? Do nothing. if (!expr) return; @@ -1159,12 +1159,12 @@ struct LoweringVisitor builder->link = &seqExpr->Arguments[1]; } - RefPtr createSimpleAssignExprWithFixups( - RefPtr leftExpr, - RefPtr rightExpr) + RefPtr createSimpleAssignExprWithFixups( + RefPtr leftExpr, + RefPtr rightExpr) { - auto leftType = leftExpr->Type.type; - auto rightType = rightExpr->Type.type; + auto leftType = leftExpr->type.type; + auto rightType = rightExpr->type.type; // If types are unknown, or match, then just do // things the ordinary way. @@ -1206,16 +1206,16 @@ struct LoweringVisitor for (int ee = 0; ee < elementCount; ++ee) { // LHS array element - RefPtr arrayElemExpr = new IndexExpressionSyntaxNode(); + RefPtr arrayElemExpr = new IndexExpr(); arrayElemExpr->Position = leftExpr->Position; - arrayElemExpr->Type.type = leftArrayType->BaseType; + arrayElemExpr->type.type = leftArrayType->BaseType; arrayElemExpr->BaseExpression = leftExpr; arrayElemExpr->IndexExpression = createConstIntExpr(ee); // RHS swizzle RefPtr swizzleExpr = new SwizzleExpr(); swizzleExpr->Position = rightExpr->Position; - swizzleExpr->Type.type = rightVecType->elementType; + swizzleExpr->type.type = rightVecType->elementType; swizzleExpr->base = rightExpr; swizzleExpr->elementCount = 1; swizzleExpr->elementIndices[0] = ee; @@ -1243,9 +1243,9 @@ struct LoweringVisitor return createSimpleAssignExpr(leftExpr, convertedRightExpr); } - RefPtr createSimpleAssignExpr( - ExpressionSyntaxNode* leftExpr, - ExpressionSyntaxNode* rightExpr, + RefPtr createSimpleAssignExpr( + Expr* leftExpr, + Expr* rightExpr, AssignMode mode) { switch (mode) @@ -1268,7 +1268,7 @@ struct LoweringVisitor if (leftTuple && rightTuple) { RefPtr resultTuple = new TupleExpr(); - resultTuple->Type = leftTuple->Type; + resultTuple->type = leftTuple->type; if (leftTuple->primaryExpr) { @@ -1308,16 +1308,16 @@ struct LoweringVisitor auto leftVaryingTuple = leftExpr.asVaryingTuple(); auto rightVaryingTuple = rightExpr.asVaryingTuple(); - RefPtr leftSimpleExpr = leftExpr.asExpr(); - RefPtr rightSimpleExpr = rightExpr.asExpr(); + RefPtr leftSimpleExpr = leftExpr.asExpr(); + RefPtr rightSimpleExpr = rightExpr.asExpr(); if (leftVaryingTuple && rightVaryingTuple) { RefPtr resultTuple = new VaryingTupleExpr(); - resultTuple->Type.type = leftVaryingTuple->Type.type; + resultTuple->type.type = leftVaryingTuple->type.type; resultTuple->Position = leftVaryingTuple->Position; - SLANG_RELEASE_ASSERT(resultTuple->Type.type); + SLANG_RELEASE_ASSERT(resultTuple->type.type); UInt elementCount = leftVaryingTuple->elements.Count(); SLANG_RELEASE_ASSERT(elementCount == rightVaryingTuple->elements.Count()); @@ -1343,10 +1343,10 @@ struct LoweringVisitor // This will naturally yield a tuple expression. RefPtr resultTuple = new VaryingTupleExpr(); - resultTuple->Type.type = leftVaryingTuple->Type.type; + resultTuple->type.type = leftVaryingTuple->type.type; resultTuple->Position = leftVaryingTuple->Position; - SLANG_RELEASE_ASSERT(resultTuple->Type.type); + SLANG_RELEASE_ASSERT(resultTuple->type.type); UInt elementCount = leftVaryingTuple->elements.Count(); @@ -1365,9 +1365,9 @@ struct LoweringVisitor auto leftElem = leftVaryingTuple->elements[ee]; - RefPtr rightElemExpr = new MemberExpressionSyntaxNode(); + RefPtr rightElemExpr = new MemberExpr(); rightElemExpr->Position = rightSimpleExpr->Position; - rightElemExpr->Type.type = GetType(leftElem.originalFieldDeclRef); + rightElemExpr->type.type = GetType(leftElem.originalFieldDeclRef); rightElemExpr->declRef = leftElem.originalFieldDeclRef; rightElemExpr->name = leftElem.originalFieldDeclRef.GetName(); rightElemExpr->BaseExpression = rightSimpleExpr; @@ -1391,10 +1391,10 @@ struct LoweringVisitor RefPtr resultTuple = new VaryingTupleExpr(); - resultTuple->Type.type = leftSimpleExpr->Type.type; + resultTuple->type.type = leftSimpleExpr->type.type; resultTuple->Position = leftSimpleExpr->Position; - SLANG_RELEASE_ASSERT(resultTuple->Type.type); + SLANG_RELEASE_ASSERT(resultTuple->type.type); UInt elementCount = rightVaryingTuple->elements.Count(); @@ -1412,9 +1412,9 @@ struct LoweringVisitor auto rightElem = rightVaryingTuple->elements[ee]; - RefPtr leftElemExpr = new MemberExpressionSyntaxNode(); + RefPtr leftElemExpr = new MemberExpr(); leftElemExpr->Position = leftSimpleExpr->Position; - leftElemExpr->Type.type = GetType(rightElem.originalFieldDeclRef); + leftElemExpr->type.type = GetType(rightElem.originalFieldDeclRef); leftElemExpr->declRef = rightElem.originalFieldDeclRef; leftElemExpr->name = rightElem.originalFieldDeclRef.GetName(); leftElemExpr->BaseExpression = leftSimpleExpr; @@ -1455,8 +1455,8 @@ struct LoweringVisitor return loweredExpr; } - RefPtr getSubscripResultType( - RefPtr type) + RefPtr getSubscripResultType( + RefPtr type) { if (auto arrayType = type->As()) { @@ -1465,14 +1465,14 @@ struct LoweringVisitor return nullptr; } - RefPtr createSimpleSubscriptExpr( - RefPtr baseExpr, - RefPtr indexExpr) + RefPtr createSimpleSubscriptExpr( + RefPtr baseExpr, + RefPtr indexExpr) { // Default case: just reconstrut a subscript expr - auto loweredExpr = new IndexExpressionSyntaxNode(); + auto loweredExpr = new IndexExpr(); - loweredExpr->Type.type = getSubscripResultType(baseExpr->Type.type); + loweredExpr->type.type = getSubscripResultType(baseExpr->type.type); loweredExpr->BaseExpression = baseExpr; loweredExpr->IndexExpression = indexExpr; @@ -1481,7 +1481,7 @@ struct LoweringVisitor LoweredExpr createSubscriptExpr( LoweredExpr baseExpr, - RefPtr indexExpr) + RefPtr indexExpr) { // TODO: This logic ends up duplicating the `indexExpr` // that was given, without worrying about any side @@ -1492,7 +1492,7 @@ struct LoweringVisitor indexExpr = maybeMoveTemp(indexExpr); auto loweredExpr = new TupleExpr(); - loweredExpr->Type.type = getSubscripResultType(baseTuple->Type.type); + loweredExpr->type.type = getSubscripResultType(baseTuple->type.type); if (auto basePrimary = baseTuple->primaryExpr) { @@ -1518,9 +1518,9 @@ struct LoweringVisitor indexExpr = maybeMoveTemp(indexExpr); auto loweredExpr = new VaryingTupleExpr(); - loweredExpr->Type.type = getSubscripResultType(baseVaryingTuple->Type.type); + loweredExpr->type.type = getSubscripResultType(baseVaryingTuple->type.type); - SLANG_RELEASE_ASSERT(loweredExpr->Type.type); + SLANG_RELEASE_ASSERT(loweredExpr->type.type); for (auto elem : baseVaryingTuple->elements) { @@ -1541,8 +1541,8 @@ struct LoweringVisitor } } - LoweredExpr visitIndexExpressionSyntaxNode( - IndexExpressionSyntaxNode* subscriptExpr) + LoweredExpr visitIndexExpr( + IndexExpr* subscriptExpr) { auto baseExpr = lowerExprOrTuple(subscriptExpr->BaseExpression); auto indexExpr = lowerExpr(subscriptExpr->IndexExpression); @@ -1560,7 +1560,7 @@ struct LoweringVisitor else { // Default case: just reconstrut a subscript expr - RefPtr loweredExpr = new IndexExpressionSyntaxNode(); + RefPtr loweredExpr = new IndexExpr(); lowerExprCommon(loweredExpr, subscriptExpr); loweredExpr->BaseExpression = baseExpr.getExpr(); loweredExpr->IndexExpression = indexExpr; @@ -1568,7 +1568,7 @@ struct LoweringVisitor } } - RefPtr maybeReifyTuple( + RefPtr maybeReifyTuple( LoweredExpr expr) { if (auto tupleExpr = expr.asTuple()) @@ -1586,9 +1586,9 @@ struct LoweringVisitor // to handle that case... RefPtr resultExpr = new AggTypeCtorExpr(); - resultExpr->Type = varyingTupleExpr->Type; - resultExpr->base.type = varyingTupleExpr->Type.type; - SLANG_RELEASE_ASSERT(resultExpr->Type.type); + resultExpr->type = varyingTupleExpr->type; + resultExpr->base.type = varyingTupleExpr->type.type; + SLANG_RELEASE_ASSERT(resultExpr->type.type); for (auto elem : varyingTupleExpr->elements) { @@ -1603,7 +1603,7 @@ struct LoweringVisitor } bool needGlslangBug988Workaround( - RefPtr inExpr) + RefPtr inExpr) { switch (getTarget()) { @@ -1622,7 +1622,7 @@ struct LoweringVisitor // Issue (1): is the type of the expression something that needs the WAR? - auto exprType = inExpr->Type.type; + auto exprType = inExpr->type.type; exprType = unwrapArray(exprType); if (!isStructType(exprType)) @@ -1634,7 +1634,7 @@ struct LoweringVisitor auto expr = inExpr; for (;;) { - if (auto memberRefExpr = expr.As()) + if (auto memberRefExpr = expr.As()) { expr = memberRefExpr->BaseExpression; continue; @@ -1646,7 +1646,7 @@ struct LoweringVisitor continue; } - if (auto subscriptExpr = expr.As()) + if (auto subscriptExpr = expr.As()) { expr = subscriptExpr->BaseExpression; continue; @@ -1655,7 +1655,7 @@ struct LoweringVisitor break; } - if (auto varExpr = expr.As()) + if (auto varExpr = expr.As()) { auto declRef = varExpr->declRef; if (!declRef) @@ -1682,7 +1682,7 @@ struct LoweringVisitor void addArg( ExprWithArgsBase* callExpr, - RefPtr argExpr) + RefPtr argExpr) { // This should be the default case where we have a perfectly // ordinary expression, but we need to work around a glslang @@ -1726,9 +1726,9 @@ struct LoweringVisitor } } - RefPtr lowerCallExpr( - RefPtr loweredExpr, - InvokeExpressionSyntaxNode* expr) + RefPtr lowerCallExpr( + RefPtr loweredExpr, + InvokeExpr* expr) { lowerExprCommon(loweredExpr, expr); @@ -1743,10 +1743,10 @@ struct LoweringVisitor return loweredExpr; } - LoweredExpr visitInvokeExpressionSyntaxNode( - InvokeExpressionSyntaxNode* expr) + LoweredExpr visitInvokeExpr( + InvokeExpr* expr) { - return LoweredExpr(lowerCallExpr(new InvokeExpressionSyntaxNode(), expr)); + return LoweredExpr(lowerCallExpr(new InvokeExpr(), expr)); } LoweredExpr visitInfixExpr( @@ -1761,12 +1761,12 @@ struct LoweringVisitor return LoweredExpr(lowerCallExpr(new PrefixExpr(), expr)); } - LoweredExpr visitSelectExpressionSyntaxNode( - SelectExpressionSyntaxNode* expr) + LoweredExpr visitSelectExpr( + SelectExpr* expr) { // TODO: A tuple needs to be special-cased here - return LoweredExpr(lowerCallExpr(new SelectExpressionSyntaxNode(), expr)); + return LoweredExpr(lowerCallExpr(new SelectExpr(), expr)); } LoweredExpr visitPostfixExpr( @@ -1827,8 +1827,8 @@ struct LoweringVisitor return &shared->compileRequest->mSink; } - LoweredExpr visitMemberExpressionSyntaxNode( - MemberExpressionSyntaxNode* expr) + LoweredExpr visitMemberExpr( + MemberExpr* expr) { auto loweredBase = lowerExprOrTuple(expr->BaseExpression); @@ -1862,7 +1862,7 @@ struct LoweringVisitor SLANG_RELEASE_ASSERT(!tupleFieldTupleExpr->primaryExpr); - RefPtr loweredPrimaryExpr = new MemberExpressionSyntaxNode(); + RefPtr loweredPrimaryExpr = new MemberExpr(); lowerExprCommon(loweredPrimaryExpr, expr); loweredPrimaryExpr->BaseExpression = baseTuple->primaryExpr; loweredPrimaryExpr->declRef = loweredDeclRef.As(); @@ -1893,7 +1893,7 @@ struct LoweringVisitor // Default handling: - RefPtr loweredExpr = new MemberExpressionSyntaxNode(); + RefPtr loweredExpr = new MemberExpr(); lowerExprCommon(loweredExpr, expr); loweredExpr->BaseExpression = loweredBase.getExpr(); loweredExpr->declRef = loweredDeclRef.As(); @@ -1911,8 +1911,8 @@ struct LoweringVisitor // (or event to none), and in such a case this function wraps // the result up as a `SeqStmt` or `EmptyStmt` as appropriate. // - RefPtr lowerStmt( - StatementSyntaxNode* stmt) + RefPtr lowerStmt( + Stmt* stmt) { if (!stmt) return nullptr; @@ -1924,7 +1924,7 @@ struct LoweringVisitor if (!subVisitor.stmtBeingBuilt) { - return new EmptyStatementSyntaxNode(); + return new EmptyStmt(); } else { @@ -1940,14 +1940,14 @@ struct LoweringVisitor StmtLoweringState* parent = nullptr; // The outer statement (both lowered and original) - StatementSyntaxNode* loweredStmt = nullptr; - StatementSyntaxNode* originalStmt = nullptr; + Stmt* loweredStmt = nullptr; + Stmt* originalStmt = nullptr; }; StmtLoweringState stmtLoweringState; // Translate a reference from one statement to an outer statement - StatementSyntaxNode* translateStmtRef( - StatementSyntaxNode* originalStmt) + Stmt* translateStmtRef( + Stmt* originalStmt) { if (!originalStmt) return nullptr; @@ -1964,7 +1964,7 @@ struct LoweringVisitor // Expand a statement to be lowered into one or more statements void lowerStmtImpl( - StatementSyntaxNode* stmt) + Stmt* stmt) { StmtVisitor::dispatch(stmt); } @@ -1993,8 +1993,8 @@ struct LoweringVisitor } void addStmtImpl( - RefPtr& dest, - StatementSyntaxNode* stmt) + RefPtr& dest, + Stmt* stmt) { // add a statement to the code we are building... if (!dest) @@ -2026,17 +2026,17 @@ struct LoweringVisitor } void addStmt( - StatementSyntaxNode* stmt) + Stmt* stmt) { addStmtImpl(stmtBeingBuilt, stmt); } void addSimpleExprStmt( - RefPtr expr) + RefPtr expr) { if (auto infixExpr = expr.As()) { - if (auto varExpr = infixExpr->FunctionExpr.As()) + if (auto varExpr = infixExpr->FunctionExpr.As()) { if (varExpr->name == ",") { @@ -2049,13 +2049,13 @@ struct LoweringVisitor } } } - else if (auto varExpr = expr.As()) + else if (auto varExpr = expr.As()) { // Skip an expression that is just a reference to a single variable return; } - RefPtr stmt = new ExpressionStatementSyntaxNode(); + RefPtr stmt = new ExpressionStmt(); stmt->Expression = expr; addStmt(stmt); } @@ -2110,19 +2110,19 @@ struct LoweringVisitor } } - void visitExpressionStatementSyntaxNode(ExpressionStatementSyntaxNode* stmt) + void visitExpressionStmt(ExpressionStmt* stmt) { addExprStmt(lowerExprOrTuple(stmt->Expression)); } - void visitVarDeclrStatementSyntaxNode(VarDeclrStatementSyntaxNode* stmt) + void visitDeclStmt(DeclStmt* stmt) { DeclVisitor::dispatch(stmt->decl); } void lowerStmtFields( - StatementSyntaxNode* loweredStmt, - StatementSyntaxNode* originalStmt) + Stmt* loweredStmt, + Stmt* originalStmt) { loweredStmt->Position = originalStmt->Position; loweredStmt->modifiers = originalStmt->modifiers; @@ -2147,16 +2147,16 @@ struct LoweringVisitor loweredStmt->parentStmt = translateStmtRef(originalStmt->parentStmt); } - void visitContinueStatementSyntaxNode(ContinueStatementSyntaxNode* stmt) + void visitContinueStmt(ContinueStmt* stmt) { - RefPtr loweredStmt = new ContinueStatementSyntaxNode(); + RefPtr loweredStmt = new ContinueStmt(); lowerChildStmtFields(loweredStmt, stmt); addStmt(loweredStmt); } - void visitBreakStatementSyntaxNode(BreakStatementSyntaxNode* stmt) + void visitBreakStmt(BreakStmt* stmt) { - RefPtr loweredStmt = new BreakStatementSyntaxNode(); + RefPtr loweredStmt = new BreakStmt(); lowerChildStmtFields(loweredStmt, stmt); addStmt(loweredStmt); } @@ -2168,16 +2168,16 @@ struct LoweringVisitor addStmt(loweredStmt); } - void visitDiscardStatementSyntaxNode(DiscardStatementSyntaxNode* stmt) + void visitDiscardStmt(DiscardStmt* stmt) { - RefPtr loweredStmt = new DiscardStatementSyntaxNode(); + RefPtr loweredStmt = new DiscardStmt(); lowerStmtFields(loweredStmt, stmt); addStmt(loweredStmt); } - void visitEmptyStatementSyntaxNode(EmptyStatementSyntaxNode* stmt) + void visitEmptyStmt(EmptyStmt* stmt) { - RefPtr loweredStmt = new EmptyStatementSyntaxNode(); + RefPtr loweredStmt = new EmptyStmt(); lowerStmtFields(loweredStmt, stmt); addStmt(loweredStmt); } @@ -2189,7 +2189,7 @@ struct LoweringVisitor for (auto token : stmt->tokens) { - if (token.Type == TokenType::Identifier) + if (token.type == TokenType::Identifier) doSampleRateInputCheck(token.Content); } @@ -2208,9 +2208,9 @@ struct LoweringVisitor addStmt(loweredStmt); } - void visitIfStatementSyntaxNode(IfStatementSyntaxNode* stmt) + void visitIfStmt(IfStmt* stmt) { - RefPtr loweredStmt = new IfStatementSyntaxNode(); + RefPtr loweredStmt = new IfStmt(); lowerStmtFields(loweredStmt, stmt); loweredStmt->Predicate = lowerExpr(stmt->Predicate); @@ -2234,8 +2234,8 @@ struct LoweringVisitor } void lowerForStmtCommon( - RefPtr loweredStmt, - ForStatementSyntaxNode* stmt) + RefPtr loweredStmt, + ForStmt* stmt) { lowerScopeStmtFields(loweredStmt, stmt); @@ -2249,9 +2249,9 @@ struct LoweringVisitor addStmt(loweredStmt); } - void visitForStatementSyntaxNode(ForStatementSyntaxNode* stmt) + void visitForStmt(ForStmt* stmt) { - lowerForStmtCommon(new ForStatementSyntaxNode(), stmt); + lowerForStmtCommon(new ForStmt(), stmt); } void visitUnscopedForStmt(UnscopedForStmt* stmt) @@ -2274,18 +2274,18 @@ struct LoweringVisitor auto varDecl = stmt->varDecl; - auto varType = lowerType(varDecl->Type); + auto varType = lowerType(varDecl->type); for (IntegerLiteralValue ii = rangeBeginVal; ii < rangeEndVal; ++ii) { - RefPtr constExpr = new ConstantExpressionSyntaxNode(); - constExpr->Type.type = varType.type; - constExpr->ConstType = ConstantExpressionSyntaxNode::ConstantType::Int; + RefPtr constExpr = new ConstantExpr(); + constExpr->type.type = varType.type; + constExpr->ConstType = ConstantExpr::ConstantType::Int; constExpr->integerValue = ii; RefPtr loweredVarDecl = new VaryingTupleVarDecl(); loweredVarDecl->Position = varDecl->Position; - loweredVarDecl->Type = varType; + loweredVarDecl->type = varType; loweredVarDecl->expr = LoweredExpr(constExpr); shared->loweredDecls[varDecl] = LoweredDecl(loweredVarDecl); @@ -2294,9 +2294,9 @@ struct LoweringVisitor } } - void visitWhileStatementSyntaxNode(WhileStatementSyntaxNode* stmt) + void visitWhileStmt(WhileStmt* stmt) { - RefPtr loweredStmt = new WhileStatementSyntaxNode(); + RefPtr loweredStmt = new WhileStmt(); lowerScopeStmtFields(loweredStmt, stmt); LoweringVisitor subVisitor = pushScope(loweredStmt, stmt); @@ -2307,9 +2307,9 @@ struct LoweringVisitor addStmt(loweredStmt); } - void visitDoWhileStatementSyntaxNode(DoWhileStatementSyntaxNode* stmt) + void visitDoWhileStmt(DoWhileStmt* stmt) { - RefPtr loweredStmt = new DoWhileStatementSyntaxNode(); + RefPtr loweredStmt = new DoWhileStmt(); lowerScopeStmtFields(loweredStmt, stmt); LoweringVisitor subVisitor = pushScope(loweredStmt, stmt); @@ -2320,12 +2320,12 @@ struct LoweringVisitor addStmt(loweredStmt); } - RefPtr transformSyntaxField(StatementSyntaxNode* stmt) + RefPtr transformSyntaxField(Stmt* stmt) { return lowerStmt(stmt); } - void lowerStmtCommon(StatementSyntaxNode* loweredStmt, StatementSyntaxNode* stmt) + void lowerStmtCommon(Stmt* loweredStmt, Stmt* stmt) { loweredStmt->modifiers = stmt->modifiers; } @@ -2349,13 +2349,13 @@ struct LoweringVisitor assign(expr, LoweredExpr(createVarRef(getPosition(expr), varDecl))); } - RefPtr createCastExpr( - RefPtr type, - RefPtr expr) + RefPtr createCastExpr( + RefPtr type, + RefPtr expr) { RefPtr castExpr = new ExplicitCastExpr(); castExpr->Position = expr->Position; - castExpr->Type.type = type; + castExpr->type.type = type; castExpr->TargetType.type = type; castExpr->Expression = expr; return castExpr; @@ -2381,9 +2381,9 @@ struct LoweringVisitor assignWithFixups(expr, LoweredExpr(createVarRef(getPosition(expr), varDecl))); } - void visitReturnStatementSyntaxNode(ReturnStatementSyntaxNode* stmt) + void visitReturnStmt(ReturnStmt* stmt) { - auto loweredStmt = new ReturnStatementSyntaxNode(); + auto loweredStmt = new ReturnStmt(); lowerStmtCommon(loweredStmt, stmt); if (stmt->Expression) @@ -2409,7 +2409,7 @@ struct LoweringVisitor RefPtr translateVal(Val* val) { - if (auto type = dynamic_cast(val)) + if (auto type = dynamic_cast(val)) return lowerType(type); if (auto litVal = dynamic_cast(val)) @@ -2520,7 +2520,7 @@ struct LoweringVisitor if (isBuildingStmt) { - RefPtr declStmt = new VarDeclrStatementSyntaxNode(); + RefPtr declStmt = new DeclStmt(); declStmt->Position = decl->Position; declStmt->decl = decl; addStmt(declStmt); @@ -2659,7 +2659,7 @@ struct LoweringVisitor SLANG_UNEXPECTED("generics should be lowered to specialized decls"); } - LoweredDecl visitProgramSyntaxNode(ProgramSyntaxNode*) + LoweredDecl visitModuleDecl(ModuleDecl*) { SLANG_UNEXPECTED("module decls should be lowered explicitly"); } @@ -2696,7 +2696,7 @@ struct LoweringVisitor RefPtr loweredDecl = new TypeDefDecl(); lowerDeclCommon(loweredDecl, decl); - loweredDecl->Type = lowerType(decl->Type); + loweredDecl->type = lowerType(decl->type); addMember(shared->loweredProgram, loweredDecl); return LoweredDecl(loweredDecl); @@ -2741,7 +2741,7 @@ struct LoweringVisitor return LoweredDecl(loweredDecl); } - TupleTypeModifier* isTupleType(ExpressionType* type) + TupleTypeModifier* isTupleType(Type* type) { if (auto declRefType = type->As()) { @@ -2754,7 +2754,7 @@ struct LoweringVisitor return nullptr; } - ExpressionType* unwrapArray(ExpressionType* inType) + Type* unwrapArray(Type* inType) { auto type = inType; while (auto arrayType = type->As()) @@ -2764,12 +2764,12 @@ struct LoweringVisitor return type; } - TupleTypeModifier* isTupleTypeOrArrayOfTupleType(ExpressionType* type) + TupleTypeModifier* isTupleTypeOrArrayOfTupleType(Type* type) { return isTupleType(unwrapArray(type)); } - bool isResourceType(ExpressionType* type) + bool isResourceType(Type* type) { while (auto arrayType = type->As()) { @@ -2790,7 +2790,7 @@ struct LoweringVisitor return false; } - RefPtr visitAggTypeDecl(AggTypeDecl* decl) + LoweredDecl visitAggTypeDecl(AggTypeDecl* decl) { // We want to lower any aggregate type declaration // to just a `struct` type that contains its fields. @@ -2798,7 +2798,7 @@ struct LoweringVisitor // Any non-field members (e.g., methods) will be // lowered separately. - RefPtr loweredDecl = new StructSyntaxNode(); + RefPtr loweredDecl = new StructDecl(); lowerDeclCommon(loweredDecl, decl); // We need to be ready to turn this type into a "tuple" type, @@ -2842,7 +2842,7 @@ struct LoweringVisitor // If the field is of a type that requires special handling, // we need to make a note of it. - auto loweredFieldType = loweredField->Type.type; + auto loweredFieldType = loweredField->type.type; bool isTupleField = false; bool fieldHasAnyNonTupleFields = false; bool fieldHasTupleType = false; @@ -2911,7 +2911,7 @@ struct LoweringVisitor } - return loweredDecl; + return LoweredDecl(loweredDecl); } RefPtr lowerSimpleVarDeclCommon( @@ -2921,8 +2921,8 @@ struct LoweringVisitor { lowerDeclCommon(loweredDecl, decl); - loweredDecl->Type = loweredType; - loweredDecl->Expr = lowerExpr(decl->Expr); + loweredDecl->type = loweredType; + loweredDecl->initExpr = lowerExpr(decl->initExpr); return loweredDecl; } @@ -2931,7 +2931,7 @@ struct LoweringVisitor RefPtr loweredDecl, VarDeclBase* decl) { - auto loweredType = lowerType(decl->Type); + auto loweredType = lowerType(decl->type); return lowerSimpleVarDeclCommon(loweredDecl, decl, loweredType); } @@ -2953,13 +2953,13 @@ struct LoweringVisitor String name; // The parent tuple type (or array thereof) we are scalarizing - RefPtr tupleType; + RefPtr tupleType; // The actual declaration of the tuple type (which will give us the fields) DeclRef tupleTypeDecl; // An initializer expression to use for the tuple members - RefPtr initExpr; + RefPtr initExpr; // The original layout given to the top-level variable RefPtr primaryVarLayout; @@ -2999,7 +2999,7 @@ struct LoweringVisitor // TODO: need to extract the initializer for this field SLANG_RELEASE_ASSERT(!info.initExpr); - RefPtr fieldInitExpr; + RefPtr fieldInitExpr; String fieldName = info.name + "_" + dd.GetName(); @@ -3092,7 +3092,7 @@ struct LoweringVisitor { // Otherwise the field has a simple type, and we just need to declare the variable here - RefPtr fieldVarType = fieldType; + RefPtr fieldVarType = fieldType; for (auto aa = info.arraySpecs; aa; aa = aa->next) { RefPtr arrayType = Slang::getArrayType( @@ -3104,7 +3104,7 @@ struct LoweringVisitor RefPtr fieldVarDecl = info.varDeclClass.createInstance(); fieldVarDecl->Name.Content = fieldName; - fieldVarDecl->Type.type = fieldVarType; + fieldVarDecl->type.type = fieldVarType; addDecl(fieldVarDecl); @@ -3133,10 +3133,10 @@ struct LoweringVisitor SyntaxClass varDeclClass, RefPtr originalVarDecl, String const& name, - RefPtr tupleType, + RefPtr tupleType, DeclRef tupleTypeDecl, TupleTypeModifier* tupleTypeMod, - RefPtr initExpr, + RefPtr initExpr, RefPtr primaryVarLayout, RefPtr tupleTypeLayout) { @@ -3153,7 +3153,7 @@ struct LoweringVisitor { RefPtr primaryVarDecl = varDeclClass.createInstance(); primaryVarDecl->Name.Content = name; - primaryVarDecl->Type.type = tupleType; + primaryVarDecl->type.type = tupleType; primaryVarDecl->modifiers = originalVarDecl->modifiers; @@ -3211,9 +3211,9 @@ struct LoweringVisitor SyntaxClass varDeclClass, RefPtr originalVarDecl, String const& name, - RefPtr tupleType, + RefPtr tupleType, TupleTypeModifier* tupleTypeMod, - RefPtr initExpr, + RefPtr initExpr, RefPtr primaryVarLayout) { RefPtr tupleTypeLayout; @@ -3239,7 +3239,7 @@ struct LoweringVisitor VarDeclBase* decl, SyntaxClass loweredDeclClass) { - auto loweredType = lowerType(decl->Type); + auto loweredType = lowerType(decl->type); if (auto tupleTypeMod = isTupleTypeOrArrayOfTupleType(loweredType)) { @@ -3251,7 +3251,7 @@ struct LoweringVisitor // If the variable had an initializer, we expect it // to resolve to a tuple *value* - auto loweredInit = lowerExpr(decl->Expr); + auto loweredInit = lowerExpr(decl->initExpr); // TODO: need to extract layout here and propagate it down! @@ -3311,7 +3311,7 @@ struct LoweringVisitor // If this is a global variable (program scope), then add it // to the global scope. RefPtr pp = decl->ParentDecl; - if (auto parentModuleDecl = pp.As()) + if (auto parentModuleDecl = pp.As()) { LoweringVisitor subVisitor = *this; subVisitor.parentDecl = translateDeclRef(parentModuleDecl); @@ -3328,7 +3328,7 @@ struct LoweringVisitor } } - SourceLanguage getSourceLanguage(ProgramSyntaxNode* moduleDecl) + SourceLanguage getSourceLanguage(ModuleDecl* moduleDecl) { for (auto translationUnit : shared->compileRequest->translationUnits) { @@ -3366,7 +3366,7 @@ struct LoweringVisitor } } - AggTypeDecl* isStructType(RefPtr type) + AggTypeDecl* isStructType(RefPtr type) { if (type->As()) return nullptr; else if (type->As()) return nullptr; @@ -3384,7 +3384,7 @@ struct LoweringVisitor return nullptr; } - bool isImportedStructType(RefPtr type) + bool isImportedStructType(RefPtr type) { // TODO: make this use `isStructType` above @@ -3416,7 +3416,7 @@ struct LoweringVisitor Variable* decl) { // Global variable? Check if it is a sample-rate input. - if (dynamic_cast(decl->ParentDecl)) + if (dynamic_cast(decl->ParentDecl)) { if (decl->HasModifier()) { @@ -3429,7 +3429,7 @@ struct LoweringVisitor auto inRes = varLayout->FindResourceInfo(LayoutResourceKind::VertexInput); auto outRes = varLayout->FindResourceInfo(LayoutResourceKind::FragmentOutput); - if( (inRes || outRes) && isImportedStructType(decl->Type.type)) + if( (inRes || outRes) && isImportedStructType(decl->type.type)) { // We are seemingly looking at a GLSL global-scope varying // of an aggregate type which was imported from library @@ -3480,10 +3480,10 @@ struct LoweringVisitor return LoweredDecl(lowerSimpleVarDeclCommon(new StructField(), decl)); } - LoweredDecl visitParameterSyntaxNode( - ParameterSyntaxNode* decl) + LoweredDecl visitParamDecl( + ParamDecl* decl) { - auto loweredDecl = lowerVarDeclCommon(decl, getClass()); + auto loweredDecl = lowerVarDeclCommon(decl, getClass()); return loweredDecl; } @@ -3508,7 +3508,7 @@ struct LoweringVisitor { // TODO: need to generate a name - RefPtr loweredDecl = new FunctionSyntaxNode(); + RefPtr loweredDecl = new FuncDecl(); lowerDeclCommon(loweredDecl, decl); // TODO: push scope for parent decl here... @@ -3612,18 +3612,18 @@ struct LoweringVisitor VaryingParameterVarChain* varChain = nullptr; }; - RefPtr createGLSLBuiltinRef( + RefPtr createGLSLBuiltinRef( char const* name, - RefPtr type) + RefPtr type) { - RefPtr globalVarRef = new VarExpressionSyntaxNode(); + RefPtr globalVarRef = new VarExpr(); globalVarRef->name = name; - globalVarRef->Type.type = type; + globalVarRef->type.type = type; return globalVarRef; } bool isIntegralType( - ExpressionType* type) + Type* type) { if (auto baseType = type->As()) { @@ -3659,28 +3659,28 @@ struct LoweringVisitor Slang::requireGLSLVersion(entryPoint, version); } - RefPtr getFloatType() + RefPtr getFloatType() { return getSession()->getFloatType(); } - RefPtr getIntType() + RefPtr getIntType() { return getSession()->getIntType(); } - RefPtr getUIntType() + RefPtr getUIntType() { return getSession()->getUIntType(); } - RefPtr getBoolType() + RefPtr getBoolType() { return getSession()->getBoolType(); } RefPtr getVectorType( - RefPtr elementType, + RefPtr elementType, RefPtr elementCount) { auto session = getSession(); @@ -3709,21 +3709,21 @@ struct LoweringVisitor } RefPtr getVectorType( - RefPtr elementType, + RefPtr elementType, int elementCount) { return getVectorType(elementType, getConstantIntVal(elementCount)); } RefPtr getUnsizedArrayType( - RefPtr elementType) + RefPtr elementType) { RefPtr arrayType = Slang::getArrayType(elementType); return arrayType; } RefPtr getArrayType( - RefPtr elementType, + RefPtr elementType, IntegerLiteralValue elementCount) { return Slang::getArrayType(elementType, getConstantIntVal(elementCount)); @@ -3731,10 +3731,10 @@ struct LoweringVisitor LoweredExpr lowerSimpleShaderParameterToGLSLGlobal( VaryingParameterInfo const& info, - RefPtr varType, + RefPtr varType, RefPtr varLayout) { - RefPtr type = varType; + RefPtr type = varType; for (auto aa = info.arraySpecs; aa; aa = aa->next) { @@ -3750,7 +3750,7 @@ struct LoweringVisitor // We need to create a reference to the global-scope declaration // of the proper GLSL input/output variable. This might // be a user-defined input/output, or a system-defined `gl_` one. - RefPtr globalVarExpr; + RefPtr globalVarExpr; // Handle system-value inputs/outputs SLANG_RELEASE_ASSERT(varLayout); @@ -3941,7 +3941,7 @@ struct LoweringVisitor { RefPtr globalVarDecl = new Variable(); globalVarDecl->Name.Content = info.name; - globalVarDecl->Type.type = type; + globalVarDecl->type.type = type; ensureDeclHasAValidName(globalVarDecl); @@ -3998,9 +3998,9 @@ struct LoweringVisitor } - RefPtr globalVarRef = new VarExpressionSyntaxNode(); + RefPtr globalVarRef = new VarExpr(); globalVarRef->Position = globalVarDecl->Position; - globalVarRef->Type.type = globalVarDecl->Type.type; + globalVarRef->type.type = globalVarDecl->type.type; globalVarRef->declRef = makeDeclRef(globalVarDecl.Ptr()); globalVarRef->name = globalVarDecl->getName(); @@ -4012,7 +4012,7 @@ struct LoweringVisitor LoweredExpr lowerShaderParameterToGLSLGLobalsRec( VaryingParameterInfo const& info, - RefPtr varType, + RefPtr varType, RefPtr varLayout) { SLANG_RELEASE_ASSERT(varLayout); @@ -4063,9 +4063,9 @@ struct LoweringVisitor // to destructure it into its constituent fields RefPtr tupleExpr = new VaryingTupleExpr(); - tupleExpr->Type.type = varType; + tupleExpr->type.type = varType; - SLANG_RELEASE_ASSERT(tupleExpr->Type.type); + SLANG_RELEASE_ASSERT(tupleExpr->type.type); for (auto fieldDeclRef : getMembersOfType(aggTypeDeclRef)) { @@ -4143,7 +4143,7 @@ struct LoweringVisitor break; } - auto loweredType = lowerType(originalVarDecl->Type); + auto loweredType = lowerType(originalVarDecl->type); auto loweredExpr = lowerShaderParameterToGLSLGLobalsRec( info, @@ -4170,7 +4170,7 @@ struct LoweringVisitor { RefPtr loweredDecl = new VaryingTupleVarDecl(); loweredDecl->Name = originalVarDecl->Name; - loweredDecl->Type = loweredType; + loweredDecl->type = loweredType; loweredDecl->expr = loweredExpr; return loweredDecl; @@ -4180,26 +4180,26 @@ struct LoweringVisitor RefPtr originalVarDecl, LoweredExpr loweredExpr) { - auto loweredType = lowerType(originalVarDecl->Type); + auto loweredType = lowerType(originalVarDecl->type); return createVaryingTupleVarDecl(originalVarDecl, loweredType, loweredExpr); } struct EntryPointParamPair { - RefPtr original; + RefPtr original; RefPtr layout; RefPtr lowered; }; - RefPtr lowerEntryPointToGLSL( - FunctionSyntaxNode* entryPointDecl, + RefPtr lowerEntryPointToGLSL( + FuncDecl* entryPointDecl, RefPtr entryPointLayout) { // First, loer the entry-point function as an ordinary function: auto loweredEntryPointFunc = visitFunctionDeclBase(entryPointDecl).getDecl()->As(); // Now we will generate a `void main() { ... }` function to call the lowered code. - RefPtr mainDecl = new FunctionSyntaxNode(); + RefPtr mainDecl = new FuncDecl(); mainDecl->ReturnType.type = getSession()->getVoidType(); mainDecl->Name.Content = "main"; @@ -4232,7 +4232,7 @@ struct LoweringVisitor RefPtr localVarDecl = new Variable(); localVarDecl->Position = paramDecl->Position; localVarDecl->Name.Content = paramDecl->getName(); - localVarDecl->Type = lowerType(paramDecl->Type); + localVarDecl->type = lowerType(paramDecl->type); ensureDeclHasAValidName(localVarDecl); @@ -4270,7 +4270,7 @@ struct LoweringVisitor resultVarDecl = new Variable(); resultVarDecl->Position = loweredEntryPointFunc->Position; resultVarDecl->Name.Content = "main_result"; - resultVarDecl->Type = TypeExp(loweredEntryPointFunc->ReturnType); + resultVarDecl->type = TypeExp(loweredEntryPointFunc->ReturnType); ensureDeclHasAValidName(resultVarDecl); @@ -4284,24 +4284,24 @@ struct LoweringVisitor getSession(), entryPointDeclRef); - RefPtr entryPointRef = new VarExpressionSyntaxNode(); + RefPtr entryPointRef = new VarExpr(); entryPointRef->name = loweredEntryPointFunc->getName(); entryPointRef->declRef = entryPointDeclRef; - entryPointRef->Type = QualType(entryPointType); + entryPointRef->type = QualType(entryPointType); - RefPtr callExpr = new InvokeExpressionSyntaxNode(); + RefPtr callExpr = new InvokeExpr(); callExpr->FunctionExpr = entryPointRef; - callExpr->Type = QualType(loweredEntryPointFunc->ReturnType); + callExpr->type = QualType(loweredEntryPointFunc->ReturnType); // for (auto paramPair : params) { auto localVarDecl = paramPair.lowered; - RefPtr varRef = new VarExpressionSyntaxNode(); + RefPtr varRef = new VarExpr(); varRef->name = localVarDecl->getName(); varRef->declRef = makeDeclRef(localVarDecl.Ptr()); - varRef->Type = QualType(localVarDecl->getType()); + varRef->type = QualType(localVarDecl->getType()); callExpr->Arguments.Add(varRef); } @@ -4342,7 +4342,7 @@ struct LoweringVisitor auto loweredExpr = lowerShaderParameterToGLSLGLobalsRec( info, - resultVarDecl->Type.type, + resultVarDecl->type.type, entryPointLayout->resultLayout); subVisitor.assignWithFixups(loweredExpr, resultVarDecl); @@ -4364,7 +4364,7 @@ struct LoweringVisitor return mainDecl; #if 0 - RefPtr loweredDecl = new FunctionSyntaxNode(); + RefPtr loweredDecl = new FuncDecl(); lowerDeclCommon(loweredDecl, entryPointDecl); // We create a sub-context appropriate for lowering the function body @@ -4389,7 +4389,7 @@ struct LoweringVisitor resultGlobal = new Variable(); // TODO: need a scheme for generating unique names resultGlobal->Name.Content = "_main_result"; - resultGlobal->Type = loweredReturnType; + resultGlobal->type = loweredReturnType; addMember(shared->loweredProgram, resultGlobal); } @@ -4414,15 +4414,15 @@ struct LoweringVisitor #endif } - RefPtr lowerEntryPoint( - FunctionSyntaxNode* entryPointDecl, + RefPtr lowerEntryPoint( + FuncDecl* entryPointDecl, RefPtr entryPointLayout) { switch( getTarget() ) { // Default case: lower an entry point just like any other function default: - return visitFunctionDeclBase(entryPointDecl).getDecl()->As(); + return visitFunctionDeclBase(entryPointDecl).getDecl()->As(); // For Slang->GLSL translation, we need to lower things from HLSL-style // declarations over to GLSL conventions @@ -4431,7 +4431,7 @@ struct LoweringVisitor } } - RefPtr lowerEntryPoint( + RefPtr lowerEntryPoint( EntryPointRequest* entryPointRequest) { auto entryPointLayout = findEntryPointLayout(entryPointRequest); @@ -4533,7 +4533,7 @@ LoweredEntryPoint lowerEntryPoint( // Create a single module/program to hold all the lowered code // (with the exception of instrinsic/stdlib declarations, which // will be remain where they are) - RefPtr loweredProgram = new ProgramSyntaxNode(); + RefPtr loweredProgram = new ModuleDecl(); sharedContext.loweredProgram = loweredProgram; LoweringVisitor visitor; -- cgit v1.2.3