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-parser.cpp | 708 +++++++++++++++++++++--------------------- 1 file changed, 355 insertions(+), 353 deletions(-) (limited to 'source/slang/slang-parser.cpp') diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index 6fd51bea2..c939e0a38 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -50,11 +50,11 @@ namespace Slang { return find() != nullptr; } - RefPtr getFirst() { return m_result; }; + Modifier* getFirst() { return m_result; }; protected: - RefPtr m_result; - RefPtr* m_next; + Modifier* m_result = nullptr; + Modifier** m_next; }; enum Precedence : int @@ -151,28 +151,28 @@ namespace Slang bool LookAheadToken(TokenType type, int offset = 0); bool LookAheadToken(const char * string, int offset = 0); void parseSourceFile(ModuleDecl* program); - RefPtr ParseStruct(); - RefPtr ParseClass(); - RefPtr ParseStatement(); - RefPtr parseBlockStatement(); - RefPtr parseVarDeclrStatement(Modifiers modifiers); - RefPtr parseIfStatement(); - RefPtr ParseForStatement(); - RefPtr ParseWhileStatement(); - RefPtr ParseDoWhileStatement(); - RefPtr ParseBreakStatement(); - RefPtr ParseContinueStatement(); - RefPtr ParseReturnStatement(); - RefPtr ParseExpressionStatement(); - RefPtr ParseExpression(Precedence level = Precedence::Comma); + Decl* ParseStruct(); + ClassDecl* ParseClass(); + Stmt* ParseStatement(); + Stmt* parseBlockStatement(); + DeclStmt* parseVarDeclrStatement(Modifiers modifiers); + IfStmt* parseIfStatement(); + ForStmt* ParseForStatement(); + WhileStmt* ParseWhileStatement(); + DoWhileStmt* ParseDoWhileStatement(); + BreakStmt* ParseBreakStatement(); + ContinueStmt* ParseContinueStatement(); + ReturnStmt* ParseReturnStatement(); + ExpressionStmt* ParseExpressionStatement(); + Expr* ParseExpression(Precedence level = Precedence::Comma); // Parse an expression that might be used in an initializer or argument context, so we should avoid operator-comma - inline RefPtr ParseInitExpr() { return ParseExpression(Precedence::Assignment); } - inline RefPtr ParseArgExpr() { return ParseExpression(Precedence::Assignment); } + inline Expr* ParseInitExpr() { return ParseExpression(Precedence::Assignment); } + inline Expr* ParseArgExpr() { return ParseExpression(Precedence::Assignment); } - RefPtr ParseLeafExpression(); - RefPtr ParseParameter(); - RefPtr ParseType(); + Expr* ParseLeafExpression(); + ParamDecl* ParseParameter(); + Expr* ParseType(); TypeExp ParseTypeExp(); Parser & operator = (const Parser &) = delete; @@ -191,20 +191,20 @@ namespace Slang Parser* parser, ContainerDecl* parent); - static RefPtr parseEnumDecl(Parser* parser); + static Decl* parseEnumDecl(Parser* parser); - static RefPtr ParseOptSemantics( + static Modifier* ParseOptSemantics( Parser* parser); static void ParseOptSemantics( Parser* parser, Decl* decl); - static RefPtr ParseDecl( + static DeclBase* ParseDecl( Parser* parser, ContainerDecl* containerDecl); - static RefPtr ParseSingleDecl( + static Decl* ParseSingleDecl( Parser* parser, ContainerDecl* containerDecl); @@ -586,9 +586,9 @@ namespace Slang return false; } - RefPtr ParseTypeDef(Parser* parser, void* /*userData*/) + NodeBase* ParseTypeDef(Parser* parser, void* /*userData*/) { - RefPtr typeDefDecl = parser->astBuilder->create(); + TypeDefDecl* typeDefDecl = parser->astBuilder->create(); // TODO(tfoley): parse an actual declarator auto type = parser->ParseTypeExp(); @@ -603,9 +603,9 @@ namespace Slang } // Add a modifier to a list of modifiers being built - static void AddModifier(RefPtr** ioModifierLink, RefPtr modifier) + static void AddModifier(Modifier*** ioModifierLink, Modifier* modifier) { - RefPtr*& modifierLink = *ioModifierLink; + Modifier**& modifierLink = *ioModifierLink; // We'd like to add the modifier to the end of the list, // but we need to be careful, in case there is a "shared" @@ -620,7 +620,7 @@ namespace Slang break; // About to look at shared modifiers? Done. - RefPtr linkMod = *modifierLink; + Modifier* linkMod = *modifierLink; if(as(linkMod)) { break; @@ -648,8 +648,8 @@ namespace Slang } void addModifier( - RefPtr syntax, - RefPtr modifier) + ModifiableSyntaxNode* syntax, + Modifier* modifier) { auto modifierLink = &syntax->modifiers.first; AddModifier(&modifierLink, modifier); @@ -706,7 +706,7 @@ namespace Slang } // Parse HLSL-style `[name(arg, ...)]` style "attribute" modifiers - static void ParseSquareBracketAttributes(Parser* parser, RefPtr** ioModifierLink) + static void ParseSquareBracketAttributes(Parser* parser, Modifier*** ioModifierLink) { parser->ReadToken(TokenType::LBracket); @@ -725,7 +725,7 @@ namespace Slang Token nameToken = parseAttributeName(parser); - RefPtr modifier = parser->astBuilder->create(); + UncheckedAttribute* modifier = parser->astBuilder->create(); modifier->name = nameToken.getName(); modifier->loc = nameToken.getLoc(); modifier->scope = parser->currentScope; @@ -811,7 +811,7 @@ namespace Slang bool tryParseUsingSyntaxDecl( Parser* parser, SyntaxDecl* syntaxDecl, - RefPtr* outSyntax) + T** outSyntax) { if (!syntaxDecl) return false; @@ -822,7 +822,7 @@ namespace Slang // Consume the token that specified the keyword auto keywordToken = advanceToken(parser); - RefPtr parsedObject = syntaxDecl->parseCallback(parser, syntaxDecl->parseUserData); + NodeBase* parsedObject = syntaxDecl->parseCallback(parser, syntaxDecl->parseUserData); if (!parsedObject) { return false; @@ -849,7 +849,7 @@ namespace Slang template bool tryParseUsingSyntaxDecl( Parser* parser, - RefPtr* outSyntax) + T** outSyntax) { if (peekTokenType(parser) != TokenType::Identifier) return false; @@ -868,7 +868,7 @@ namespace Slang static Modifiers ParseModifiers(Parser* parser) { Modifiers modifiers; - RefPtr* modifierLink = &modifiers.first; + Modifier** modifierLink = &modifiers.first; for (;;) { SourceLoc loc = parser->tokenReader.peekLoc(); @@ -887,7 +887,7 @@ namespace Slang Token nameToken = peekToken(parser); - RefPtr parsedModifier; + Modifier* parsedModifier = nullptr; if (tryParseUsingSyntaxDecl(parser, &parsedModifier)) { parsedModifier->name = nameToken.getName(); @@ -926,7 +926,7 @@ namespace Slang } - static RefPtr parseImportDecl( + static NodeBase* parseImportDecl( Parser* parser, void* /*userData*/) { parser->haveSeenAnyImportDecls = true; @@ -1060,30 +1060,30 @@ namespace Slang SourceLoc openBracketLoc; // The expression that yields the element count, or NULL - RefPtr elementCountExpr; + Expr* elementCountExpr = nullptr; }; // "Unwrapped" information about a declarator struct DeclaratorInfo { - RefPtr typeSpec; + Expr* typeSpec = nullptr; NameLoc nameAndLoc; - RefPtr semantics; - RefPtr initializer; + Modifier* semantics = nullptr; + Expr* initializer = nullptr; }; // Add a member declaration to its container, and ensure that its // parent link is set up correctly. - static void AddMember(RefPtr container, RefPtr member) + static void AddMember(ContainerDecl* container, Decl* member) { if (container) { - member->parentDecl = container.Ptr(); + member->parentDecl = container; container->members.add(member); } } - static void AddMember(RefPtr scope, RefPtr member) + static void AddMember(RefPtr scope, Decl* member) { if (scope) { @@ -1091,9 +1091,9 @@ namespace Slang } } - static RefPtr ParseGenericParamDecl( + static Decl* ParseGenericParamDecl( Parser* parser, - RefPtr genericDecl) + GenericDecl* genericDecl) { // simple syntax to introduce a value parameter if (AdvanceIf(parser, "let")) @@ -1114,7 +1114,7 @@ namespace Slang else { // default case is a type parameter - RefPtr paramDecl = parser->astBuilder->create(); + GenericTypeParamDecl* paramDecl = parser->astBuilder->create(); parser->FillPosition(paramDecl); paramDecl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); if (AdvanceIf(parser, TokenType::Colon)) @@ -1178,13 +1178,13 @@ namespace Slang } template - static RefPtr parseOptGenericDecl( + static Decl* parseOptGenericDecl( Parser* parser, const ParseFunc& parseInner) { // TODO: may want more advanced disambiguation than this... if (parser->LookAheadToken(TokenType::OpLess)) { - RefPtr genericDecl = parser->astBuilder->create(); + GenericDecl* genericDecl = parser->astBuilder->create(); parser->FillPosition(genericDecl); parser->PushScope(genericDecl); ParseGenericDeclImpl(parser, genericDecl, parseInner); @@ -1197,19 +1197,19 @@ namespace Slang } } - static RefPtr ParseGenericDecl(Parser* parser, void*) + static NodeBase* ParseGenericDecl(Parser* parser, void*) { - RefPtr decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); - parser->PushScope(decl.Ptr()); - ParseGenericDeclImpl(parser, decl.Ptr(), [=](GenericDecl* genDecl) {return ParseSingleDecl(parser, genDecl); }); + GenericDecl* decl = parser->astBuilder->create(); + parser->FillPosition(decl); + parser->PushScope(decl); + ParseGenericDeclImpl(parser, decl, [=](GenericDecl* genDecl) {return ParseSingleDecl(parser, genDecl); }); parser->PopScope(); return decl; } static void parseParameterList( Parser* parser, - RefPtr decl) + CallableDecl* decl) { parser->ReadToken(TokenType::LParent); @@ -1270,7 +1270,7 @@ namespace Slang }; /// Parse an optional body statement for a declaration that can have a body. - static RefPtr parseOptBody(Parser* parser) + static Stmt* parseOptBody(Parser* parser) { if (AdvanceIf(parser, TokenType::Semicolon)) { @@ -1284,12 +1284,12 @@ namespace Slang } /// Complete parsing of a function using traditional (C-like) declarator syntax - static RefPtr parseTraditionalFuncDecl( + static Decl* parseTraditionalFuncDecl( Parser* parser, DeclaratorInfo const& declaratorInfo) { - RefPtr decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); + FuncDecl* decl = parser->astBuilder->create(); + parser->FillPosition(decl); decl->loc = declaratorInfo.nameAndLoc.loc; decl->nameAndLoc = declaratorInfo.nameAndLoc; @@ -1315,7 +1315,7 @@ namespace Slang parser->PushScope(decl); parseParameterList(parser, decl); - ParseOptSemantics(parser, decl.Ptr()); + ParseOptSemantics(parser, decl); decl->body = parseOptBody(parser); parser->PopScope(); @@ -1324,7 +1324,7 @@ namespace Slang }); } - static RefPtr CreateVarDeclForContext( + static VarDeclBase* CreateVarDeclForContext( ASTBuilder* astBuilder, ContainerDecl* containerDecl ) { @@ -1343,12 +1343,12 @@ namespace Slang } // Add modifiers to the end of the modifier list for a declaration - void AddModifiers(Decl* decl, RefPtr modifiers) + void AddModifiers(Decl* decl, Modifier* modifiers) { if (!modifiers) return; - RefPtr* link = &decl->modifiers.first; + Modifier** link = &decl->modifiers.first; while (*link) { link = &(*link)->next; @@ -1371,10 +1371,10 @@ namespace Slang // Set up a variable declaration based on what we saw in its declarator... static void CompleteVarDecl( Parser* parser, - RefPtr decl, + VarDeclBase* decl, DeclaratorInfo const& declaratorInfo) { - parser->FillPosition(decl.Ptr()); + parser->FillPosition(decl); if( !declaratorInfo.nameAndLoc.name ) { @@ -1388,7 +1388,7 @@ namespace Slang } decl->type = TypeExp(declaratorInfo.typeSpec); - AddModifiers(decl.Ptr(), declaratorInfo.semantics); + AddModifiers(decl, declaratorInfo.semantics); decl->initExpr = declaratorInfo.initializer; } @@ -1527,8 +1527,8 @@ namespace Slang struct InitDeclarator { RefPtr declarator; - RefPtr semantics; - RefPtr initializer; + Modifier* semantics = nullptr; + Expr* initializer = nullptr; }; // Parse a declarator plus optional semantics @@ -1619,13 +1619,13 @@ namespace Slang struct DeclGroupBuilder { SourceLoc startPosition; - RefPtr decl; - RefPtr group; + Decl* decl = nullptr; + DeclGroup* group = nullptr; ASTBuilder* astBuilder = nullptr; // Add a new declaration to the potential group void addDecl( - RefPtr newDecl) + Decl* newDecl) { SLANG_ASSERT(newDecl); @@ -1647,7 +1647,7 @@ namespace Slang } } - RefPtr getResult() + DeclBase* getResult() { if(group) return group; return decl; @@ -1655,14 +1655,14 @@ namespace Slang }; // Pares an argument to an application of a generic - RefPtr ParseGenericArg(Parser* parser) + Expr* ParseGenericArg(Parser* parser) { return parser->ParseArgExpr(); } // Create a type expression that will refer to the given declaration - static RefPtr - createDeclRefType(Parser* parser, RefPtr decl) + static Expr* + createDeclRefType(Parser* parser, Decl* decl) { // For now we just construct an expression that // will look up the given declaration by name. @@ -1681,19 +1681,19 @@ namespace Slang struct TypeSpec { // If the type-spec declared something, then put it here - RefPtr decl; + Decl* decl = nullptr; // Put the resulting expression (which should evaluate to a type) here - RefPtr expr; + Expr* expr = nullptr; }; - static RefPtr parseGenericApp( + static Expr* parseGenericApp( Parser* parser, - RefPtr base) + Expr* base) { - RefPtr genericApp = parser->astBuilder->create(); + GenericAppExpr* genericApp = parser->astBuilder->create(); - parser->FillPosition(genericApp.Ptr()); // set up scope for lookup + parser->FillPosition(genericApp); // set up scope for lookup genericApp->functionExpr = base; parser->ReadToken(TokenType::OpLess); parser->genericDepth++; @@ -1730,9 +1730,9 @@ namespace Slang return lookupResult.item.declRef.is(); } - static RefPtr tryParseGenericApp( + static Expr* tryParseGenericApp( Parser* parser, - RefPtr base) + Expr* base) { Name * baseName = nullptr; if (auto varExpr = as(base)) @@ -1748,7 +1748,9 @@ namespace Slang DiagnosticSink newSink(parser->sink->getSourceManager()); Parser newParser(*parser); newParser.sink = &newSink; - auto speculateParseRs = parseGenericApp(&newParser, base); + + /* auto speculateParseRs = */parseGenericApp(&newParser, base); + if (newSink.getErrorCount() == 0) { // disambiguate based on FOLLOW set @@ -1771,27 +1773,27 @@ namespace Slang } return base; } - static RefPtr parseMemberType(Parser * parser, RefPtr base) + static Expr* parseMemberType(Parser * parser, Expr* base) { // When called the :: or . have been consumed, so don't need to consume here. - RefPtr memberExpr = parser->astBuilder->create(); + MemberExpr* memberExpr = parser->astBuilder->create(); - parser->FillPosition(memberExpr.Ptr()); + parser->FillPosition(memberExpr); memberExpr->baseExpression = base; memberExpr->name = expectIdentifier(parser).name; return memberExpr; } // Parse option `[]` braces after a type expression, that indicate an array type - static RefPtr parsePostfixTypeSuffix( + static Expr* parsePostfixTypeSuffix( Parser* parser, - RefPtr inTypeExpr) + Expr* inTypeExpr) { auto typeExpr = inTypeExpr; while (parser->LookAheadToken(TokenType::LBracket)) { - RefPtr arrType = parser->astBuilder->create(); + IndexExpr* arrType = parser->astBuilder->create(); arrType->loc = typeExpr->loc; arrType->baseExpression = typeExpr; parser->ReadToken(TokenType::LBracket); @@ -1805,9 +1807,9 @@ namespace Slang return typeExpr; } - static RefPtr parseTaggedUnionType(Parser* parser) + static Expr* parseTaggedUnionType(Parser* parser) { - RefPtr taggedUnionType = parser->astBuilder->create(); + TaggedUnionTypeExpr* taggedUnionType = parser->astBuilder->create(); parser->ReadToken(TokenType::LParent); while(!AdvanceIfMatch(parser, TokenType::RParent)) @@ -1824,20 +1826,20 @@ namespace Slang return taggedUnionType; } - static RefPtr parseTaggedUnionType(Parser* parser, void* /*unused*/) + static NodeBase* parseTaggedUnionType(Parser* parser, void* /*unused*/) { return parseTaggedUnionType(parser); } /// Parse a `This` type expression - static RefPtr parseThisTypeExpr(Parser* parser) + static Expr* parseThisTypeExpr(Parser* parser) { - RefPtr expr = parser->astBuilder->create(); + ThisTypeExpr* expr = parser->astBuilder->create(); expr->scope = parser->currentScope; return expr; } - static RefPtr parseThisTypeExpr(Parser* parser, void* /*userData*/) + static NodeBase* parseThisTypeExpr(Parser* parser, void* /*userData*/) { return parseThisTypeExpr(parser); } @@ -1909,7 +1911,7 @@ namespace Slang basicType->loc = typeName.loc; basicType->name = typeName.getNameOrNull(); - RefPtr typeExpr = basicType; + Expr* typeExpr = basicType; bool shouldLoop = true; while (shouldLoop) @@ -1936,7 +1938,7 @@ namespace Slang return typeSpec; } - static RefPtr ParseDeclaratorDecl( + static DeclBase* ParseDeclaratorDecl( Parser* parser, ContainerDecl* containerDecl) { @@ -2045,7 +2047,7 @@ namespace Slang { // easy case: we only had a single declaration! UnwrapDeclarator(parser->astBuilder, initDeclarator, &declaratorInfo); - RefPtr firstDecl = CreateVarDeclForContext(parser->astBuilder, containerDecl); + VarDeclBase* firstDecl = CreateVarDeclForContext(parser->astBuilder, containerDecl); CompleteVarDecl(parser, firstDecl, declaratorInfo); declGroupBuilder.addDecl(firstDecl); @@ -2068,7 +2070,7 @@ namespace Slang declaratorInfo.typeSpec = sharedTypeSpec; UnwrapDeclarator(parser->astBuilder, initDeclarator, &declaratorInfo); - RefPtr varDecl = CreateVarDeclForContext(parser->astBuilder, containerDecl); + VarDeclBase* varDecl = CreateVarDeclForContext(parser->astBuilder, containerDecl); CompleteVarDecl(parser, varDecl, declaratorInfo); declGroupBuilder.addDecl(varDecl); @@ -2182,26 +2184,26 @@ namespace Slang // // semantic ::= identifier ( '(' args ')' )? // - static RefPtr ParseSemantic( + static Modifier* ParseSemantic( Parser* parser) { if (parser->LookAheadToken("register")) { - RefPtr semantic = parser->astBuilder->create(); + HLSLRegisterSemantic* semantic = parser->astBuilder->create(); parser->FillPosition(semantic); - parseHLSLRegisterSemantic(parser, semantic.Ptr()); + parseHLSLRegisterSemantic(parser, semantic); return semantic; } else if (parser->LookAheadToken("packoffset")) { - RefPtr semantic = parser->astBuilder->create(); + HLSLPackOffsetSemantic* semantic = parser->astBuilder->create(); parser->FillPosition(semantic); - parseHLSLPackOffsetSemantic(parser, semantic.Ptr()); + parseHLSLPackOffsetSemantic(parser, semantic); return semantic; } else if (parser->LookAheadToken(TokenType::Identifier)) { - RefPtr semantic = parser->astBuilder->create(); + HLSLSimpleSemantic* semantic = parser->astBuilder->create(); parser->FillPosition(semantic); semantic->name = parser->ReadToken(TokenType::Identifier); return semantic; @@ -2217,19 +2219,19 @@ namespace Slang // // opt-semantics ::= (':' semantic)* // - static RefPtr ParseOptSemantics( + static Modifier* ParseOptSemantics( Parser* parser) { if (!AdvanceIf(parser, TokenType::Colon)) return nullptr; - RefPtr result; - RefPtr* link = &result; + Modifier* result = nullptr; + Modifier** link = &result; SLANG_ASSERT(!*link); for (;;) { - RefPtr semantic = ParseSemantic(parser); + Modifier* semantic = ParseSemantic(parser); if (semantic) { *link = semantic; @@ -2268,7 +2270,7 @@ namespace Slang AddModifiers(decl, ParseOptSemantics(parser)); } - static RefPtr ParseHLSLBufferDecl( + static Decl* ParseHLSLBufferDecl( Parser* parser, String bufferWrapperTypeName) { @@ -2291,12 +2293,12 @@ 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 bufferDataTypeDecl = parser->astBuilder->create(); - RefPtr bufferVarDecl = parser->astBuilder->create(); + StructDecl* bufferDataTypeDecl = parser->astBuilder->create(); + VarDecl* bufferVarDecl = parser->astBuilder->create(); // Both declarations will have a location that points to the name - parser->FillPosition(bufferDataTypeDecl.Ptr()); - parser->FillPosition(bufferVarDecl.Ptr()); + parser->FillPosition(bufferDataTypeDecl); + parser->FillPosition(bufferVarDecl); auto reflectionNameToken = parser->ReadToken(TokenType::Identifier); @@ -2343,10 +2345,10 @@ namespace Slang // Any semantics applied to the buffer declaration are taken as applying // to the variable instead. - ParseOptSemantics(parser, bufferVarDecl.Ptr()); + ParseOptSemantics(parser, bufferVarDecl); // The declarations in the body belong to the data type. - parseDeclBody(parser, bufferDataTypeDecl.Ptr()); + parseDeclBody(parser, bufferDataTypeDecl); // All HLSL buffer declarations are "transparent" in that their // members are implicitly made visible in the parent scope. @@ -2370,13 +2372,13 @@ namespace Slang return bufferVarDecl; } - static RefPtr parseHLSLCBufferDecl( + static NodeBase* parseHLSLCBufferDecl( Parser* parser, void* /*userData*/) { return ParseHLSLBufferDecl(parser, "ConstantBuffer"); } - static RefPtr parseHLSLTBufferDecl( + static NodeBase* parseHLSLTBufferDecl( Parser* parser, void* /*userData*/) { return ParseHLSLBufferDecl(parser, "TextureBuffer"); @@ -2401,31 +2403,31 @@ namespace Slang } } - static RefPtr ParseExtensionDecl(Parser* parser, void* /*userData*/) + static NodeBase* ParseExtensionDecl(Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); + ExtensionDecl* decl = parser->astBuilder->create(); + parser->FillPosition(decl); decl->targetType = parser->ParseTypeExp(); parseOptionalInheritanceClause(parser, decl); - parseDeclBody(parser, decl.Ptr()); + parseDeclBody(parser, decl); return decl; } - void parseOptionalGenericConstraints(Parser* parser, ContainerDecl* decl) + static void parseOptionalGenericConstraints(Parser* parser, ContainerDecl* decl) { if (AdvanceIf(parser, TokenType::Colon)) { do { - RefPtr paramConstraint = parser->astBuilder->create(); + GenericTypeConstraintDecl* paramConstraint = parser->astBuilder->create(); parser->FillPosition(paramConstraint); // substitution needs to be filled during check - RefPtr paramType = DeclRefType::create(parser->astBuilder, DeclRef(decl, nullptr)); + DeclRefType* paramType = DeclRefType::create(parser->astBuilder, DeclRef(decl, nullptr)); - RefPtr paramTypeExpr = parser->astBuilder->create(); + SharedTypeExpr* paramTypeExpr = parser->astBuilder->create(); paramTypeExpr->loc = decl->loc; paramTypeExpr->base.type = paramType; paramTypeExpr->type = QualType(parser->astBuilder->getTypeType(paramType)); @@ -2438,9 +2440,9 @@ namespace Slang } } - RefPtr parseAssocType(Parser* parser, void *) + static NodeBase* parseAssocType(Parser* parser, void *) { - RefPtr assocTypeDecl = parser->astBuilder->create(); + AssocTypeDecl* assocTypeDecl = parser->astBuilder->create(); auto nameToken = parser->ReadToken(TokenType::Identifier); assocTypeDecl->nameAndLoc = NameLoc(nameToken); @@ -2450,9 +2452,9 @@ namespace Slang return assocTypeDecl; } - RefPtr parseGlobalGenericTypeParamDecl(Parser * parser, void *) + static NodeBase* parseGlobalGenericTypeParamDecl(Parser * parser, void *) { - RefPtr genParamDecl = parser->astBuilder->create(); + GlobalGenericParamDecl* genParamDecl = parser->astBuilder->create(); auto nameToken = parser->ReadToken(TokenType::Identifier); genParamDecl->nameAndLoc = NameLoc(nameToken); genParamDecl->loc = nameToken.loc; @@ -2461,9 +2463,9 @@ namespace Slang return genParamDecl; } - RefPtr parseGlobalGenericValueParamDecl(Parser * parser, void *) + static NodeBase* parseGlobalGenericValueParamDecl(Parser * parser, void *) { - RefPtr genericParamDecl = parser->astBuilder->create(); + GlobalGenericValueParamDecl* genericParamDecl = parser->astBuilder->create(); auto nameToken = parser->ReadToken(TokenType::Identifier); genericParamDecl->nameAndLoc = NameLoc(nameToken); genericParamDecl->loc = nameToken.loc; @@ -2482,20 +2484,20 @@ namespace Slang return genericParamDecl; } - static RefPtr parseInterfaceDecl(Parser* parser, void* /*userData*/) + static NodeBase* parseInterfaceDecl(Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); + InterfaceDecl* decl = parser->astBuilder->create(); + parser->FillPosition(decl); decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); - parseOptionalInheritanceClause(parser, decl.Ptr()); + parseOptionalInheritanceClause(parser, decl); - parseDeclBody(parser, decl.Ptr()); + parseDeclBody(parser, decl); return decl; } - static RefPtr parseNamespaceDecl(Parser* parser, void* /*userData*/) + static NodeBase* parseNamespaceDecl(Parser* parser, void* /*userData*/) { // We start by parsing the name of the namespace that is being opened. // @@ -2535,8 +2537,8 @@ namespace Slang // a declaration to the caller (since they will try to add // any non-null pointer we return to the AST). // - RefPtr namespaceDecl; - RefPtr result; + NamespaceDecl* namespaceDecl = nullptr; + NodeBase* result = nullptr; // // In order to find out what case we are in, we start by looking // for a namespace declaration of the same name in the parent @@ -2609,15 +2611,15 @@ namespace Slang // `{}`-enclosed body to add declarations as children // of the namespace. // - parseDeclBody(parser, namespaceDecl.Ptr()); + parseDeclBody(parser, namespaceDecl); return result; } - static RefPtr parseConstructorDecl(Parser* parser, void* /*userData*/) + static NodeBase* parseConstructorDecl(Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); + ConstructorDecl* decl = parser->astBuilder->create(); + parser->FillPosition(decl); parser->PushScope(decl); // TODO: we need to make sure that all initializers have @@ -2638,11 +2640,11 @@ namespace Slang return decl; } - static RefPtr parseAccessorDecl(Parser* parser) + static AccessorDecl* parseAccessorDecl(Parser* parser) { Modifiers modifiers = ParseModifiers(parser); - RefPtr decl; + AccessorDecl* decl = nullptr; if( AdvanceIf(parser, "get") ) { decl = parser->astBuilder->create(); @@ -2675,10 +2677,10 @@ namespace Slang return decl; } - static RefPtr ParseSubscriptDecl(Parser* parser, void* /*userData*/) + static NodeBase* ParseSubscriptDecl(Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); + SubscriptDecl* decl = parser->astBuilder->create(); + parser->FillPosition(decl); parser->PushScope(decl); // TODO: the use of this name here is a bit magical... @@ -2718,9 +2720,9 @@ namespace Slang static void parseModernVarDeclBaseCommon( Parser* parser, - RefPtr decl) + VarDeclBase* decl) { - parser->FillPosition(decl.Ptr()); + parser->FillPosition(decl); decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); if(AdvanceIf(parser, TokenType::Colon)) @@ -2736,32 +2738,32 @@ namespace Slang static void parseModernVarDeclCommon( Parser* parser, - RefPtr decl) + VarDecl* decl) { parseModernVarDeclBaseCommon(parser, decl); expect(parser, TokenType::Semicolon); } - static RefPtr parseLetDecl( + static NodeBase* parseLetDecl( Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); + LetDecl* decl = parser->astBuilder->create(); parseModernVarDeclCommon(parser, decl); return decl; } - static RefPtr parseVarDecl( + static NodeBase* parseVarDecl( Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); + VarDecl* decl = parser->astBuilder->create(); parseModernVarDeclCommon(parser, decl); return decl; } - static RefPtr parseModernParamDecl( + static ParamDecl* parseModernParamDecl( Parser* parser) { - RefPtr decl = parser->astBuilder->create(); + ParamDecl* decl = parser->astBuilder->create(); // TODO: "modern" parameters should not accept keyword-based // modifiers and should only accept `[attribute]` syntax for @@ -2777,7 +2779,7 @@ namespace Slang static void parseModernParamList( Parser* parser, - RefPtr decl) + CallableDecl* decl) { parser->ReadToken(TokenType::LParent); @@ -2790,17 +2792,17 @@ namespace Slang } } - static RefPtr parseFuncDecl( + static NodeBase* parseFuncDecl( Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); + FuncDecl* decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); + parser->FillPosition(decl); decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); return parseOptGenericDecl(parser, [&](GenericDecl*) { - parser->PushScope(decl.Ptr()); + parser->PushScope(decl); parseModernParamList(parser, decl); if(AdvanceIf(parser, TokenType::RightArrow)) { @@ -2812,12 +2814,12 @@ namespace Slang }); } - static RefPtr parseTypeAliasDecl( + static NodeBase* parseTypeAliasDecl( Parser* parser, void* /*userData*/) { - RefPtr decl = parser->astBuilder->create(); + TypeAliasDecl* decl = parser->astBuilder->create(); - parser->FillPosition(decl.Ptr()); + parser->FillPosition(decl); decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier)); return parseOptGenericDecl(parser, [&](GenericDecl*) @@ -2834,14 +2836,14 @@ namespace Slang // This is a catch-all syntax-construction callback to handle cases where // a piece of syntax is fully defined by the keyword to use, along with // the class of AST node to construct. - static RefPtr parseSimpleSyntax(Parser* parser, void* userData) + static NodeBase* parseSimpleSyntax(Parser* parser, void* userData) { SyntaxClassBase syntaxClass((ReflectClassInfo*) userData); - return (RefObject*) syntaxClass.createInstanceImpl(parser->astBuilder); + return (NodeBase*)syntaxClass.createInstanceImpl(parser->astBuilder); } // Parse a declaration of a keyword that can be used to define further syntax. - static RefPtr parseSyntaxDecl(Parser* parser, void* /*userData*/) + static NodeBase* parseSyntaxDecl(Parser* parser, void* /*userData*/) { // Right now the basic form is: // @@ -2857,7 +2859,7 @@ namespace Slang auto nameAndLoc = expectIdentifier(parser); // Next we look for a clause that specified the AST node class. - SyntaxClass syntaxClass; + SyntaxClass syntaxClass; if (AdvanceIf(parser, TokenType::Colon)) { // User is specifying the class that should be construted @@ -2914,7 +2916,7 @@ namespace Slang // TODO: skip creating the declaration if anything failed, just to not screw things // up for downstream code? - RefPtr syntaxDecl = parser->astBuilder->create(); + SyntaxDecl* syntaxDecl = parser->astBuilder->create(); syntaxDecl->nameAndLoc = nameAndLoc; syntaxDecl->loc = nameAndLoc.loc; syntaxDecl->syntaxClass = syntaxClass; @@ -2928,11 +2930,11 @@ namespace Slang // We are going to use `name: type` syntax just for simplicty, and let the type // be optional, because we don't actually need it in all cases. // - static RefPtr parseAttributeParamDecl(Parser* parser) + static ParamDecl* parseAttributeParamDecl(Parser* parser) { auto nameAndLoc = expectIdentifier(parser); - RefPtr paramDecl = parser->astBuilder->create(); + ParamDecl* paramDecl = parser->astBuilder->create(); paramDecl->nameAndLoc = nameAndLoc; if(AdvanceIf(parser, TokenType::Colon)) @@ -2957,7 +2959,7 @@ namespace Slang // using the default attribute-parsing logic and then all specialized behavior takes // place during semantic checking. // - static RefPtr parseAttributeSyntaxDecl(Parser* parser, void* /*userData*/) + static NodeBase* parseAttributeSyntaxDecl(Parser* parser, void* /*userData*/) { // Right now the basic form is: // @@ -2974,7 +2976,7 @@ namespace Slang // First we parse the attribute name. auto nameAndLoc = expectIdentifier(parser); - RefPtr attrDecl = parser->astBuilder->create(); + AttributeDecl* attrDecl = parser->astBuilder->create(); if(AdvanceIf(parser, TokenType::LParent)) { while(!AdvanceIfMatch(parser, TokenType::RParent)) @@ -2996,7 +2998,7 @@ namespace Slang // on the amount of per-attribute-type logic that has to occur later. // Next we look for a clause that specified the AST node class. - SyntaxClass syntaxClass; + SyntaxClass syntaxClass; if (AdvanceIf(parser, TokenType::Colon)) { // User is specifying the class that should be construted @@ -3027,7 +3029,7 @@ namespace Slang // Finish up work on a declaration that was parsed static void CompleteDecl( Parser* /*parser*/, - RefPtr decl, + Decl* decl, ContainerDecl* containerDecl, Modifiers modifiers) { @@ -3037,10 +3039,10 @@ namespace Slang // We need to be careful, because if `decl` is a generic declaration, // then we really want the modifiers to apply to the inner declaration. // - RefPtr declToModify = decl; + Decl* declToModify = decl; if(auto genericDecl = as(decl)) declToModify = genericDecl->inner; - AddModifiers(declToModify.Ptr(), modifiers.first); + AddModifiers(declToModify, modifiers.first); // Make sure the decl is properly nested inside its lexical parent if (containerDecl) @@ -3049,12 +3051,12 @@ namespace Slang } } - static RefPtr ParseDeclWithModifiers( + static DeclBase* ParseDeclWithModifiers( Parser* parser, ContainerDecl* containerDecl, Modifiers modifiers ) { - RefPtr decl; + DeclBase* decl = nullptr; auto loc = parser->tokenReader.peekLoc(); @@ -3070,7 +3072,7 @@ namespace Slang // First we will check whether we can use the identifier token // as a declaration keyword and parse a declaration using // its associated callback: - RefPtr parsedDecl; + Decl* parsedDecl = nullptr; if (tryParseUsingSyntaxDecl(parser, &parsedDecl)) { decl = parsedDecl; @@ -3129,7 +3131,7 @@ namespace Slang return decl; } - static RefPtr ParseDecl( + static DeclBase* ParseDecl( Parser* parser, ContainerDecl* containerDecl) { @@ -3137,7 +3139,7 @@ namespace Slang return ParseDeclWithModifiers(parser, containerDecl, modifiers); } - static RefPtr ParseSingleDecl( + static Decl* ParseSingleDecl( Parser* parser, ContainerDecl* containerDecl) { @@ -3218,10 +3220,10 @@ namespace Slang currentScope = nullptr; } - RefPtr Parser::ParseStruct() + Decl* Parser::ParseStruct() { - RefPtr rs = astBuilder->create(); - FillPosition(rs.Ptr()); + StructDecl* rs = astBuilder->create(); + FillPosition(rs); ReadToken("struct"); // TODO: support `struct` declaration without tag @@ -3231,28 +3233,28 @@ namespace Slang { // We allow for an inheritance clause on a `struct` // so that it can conform to interfaces. - parseOptionalInheritanceClause(this, rs.Ptr()); - parseDeclBody(this, rs.Ptr()); + parseOptionalInheritanceClause(this, rs); + parseDeclBody(this, rs); return rs; }); } - RefPtr Parser::ParseClass() + ClassDecl* Parser::ParseClass() { - RefPtr rs = astBuilder->create(); - FillPosition(rs.Ptr()); + ClassDecl* rs = astBuilder->create(); + FillPosition(rs); ReadToken("class"); rs->nameAndLoc = expectIdentifier(this); - parseOptionalInheritanceClause(this, rs.Ptr()); + parseOptionalInheritanceClause(this, rs); - parseDeclBody(this, rs.Ptr()); + parseDeclBody(this, rs); return rs; } - static RefPtr parseEnumCaseDecl(Parser* parser) + static EnumCaseDecl* parseEnumCaseDecl(Parser* parser) { - RefPtr decl = parser->astBuilder->create(); + EnumCaseDecl* decl = parser->astBuilder->create(); decl->nameAndLoc = expectIdentifier(parser); if(AdvanceIf(parser, TokenType::OpAssign)) @@ -3263,9 +3265,9 @@ namespace Slang return decl; } - static RefPtr parseEnumDecl(Parser* parser) + static Decl* parseEnumDecl(Parser* parser) { - RefPtr decl = parser->astBuilder->create(); + EnumDecl* decl = parser->astBuilder->create(); parser->FillPosition(decl); parser->ReadToken("enum"); @@ -3288,7 +3290,7 @@ namespace Slang while(!AdvanceIfMatch(parser, TokenType::RBrace)) { - RefPtr caseDecl = parseEnumCaseDecl(parser); + EnumCaseDecl* caseDecl = parseEnumCaseDecl(parser); AddMember(decl, caseDecl); if(AdvanceIf(parser, TokenType::RBrace)) @@ -3300,10 +3302,10 @@ namespace Slang }); } - static RefPtr ParseSwitchStmt(Parser* parser) + static Stmt* ParseSwitchStmt(Parser* parser) { - RefPtr stmt = parser->astBuilder->create(); - parser->FillPosition(stmt.Ptr()); + SwitchStmt* stmt = parser->astBuilder->create(); + parser->FillPosition(stmt); parser->ReadToken("switch"); parser->ReadToken(TokenType::LParent); stmt->condition = parser->ParseExpression(); @@ -3312,20 +3314,20 @@ namespace Slang return stmt; } - static RefPtr ParseCaseStmt(Parser* parser) + static Stmt* ParseCaseStmt(Parser* parser) { - RefPtr stmt = parser->astBuilder->create(); - parser->FillPosition(stmt.Ptr()); + CaseStmt* stmt = parser->astBuilder->create(); + parser->FillPosition(stmt); parser->ReadToken("case"); stmt->expr = parser->ParseExpression(); parser->ReadToken(TokenType::Colon); return stmt; } - static RefPtr ParseDefaultStmt(Parser* parser) + static Stmt* ParseDefaultStmt(Parser* parser) { - RefPtr stmt = parser->astBuilder->create(); - parser->FillPosition(stmt.Ptr()); + DefaultStmt* stmt = parser->astBuilder->create(); + parser->FillPosition(stmt); parser->ReadToken("default"); parser->ReadToken(TokenType::Colon); return stmt; @@ -3365,11 +3367,11 @@ namespace Slang return isTypeName(parser, name); } - RefPtr parseCompileTimeForStmt( + Stmt* parseCompileTimeForStmt( Parser* parser) { - RefPtr scopeDecl = parser->astBuilder->create(); - RefPtr stmt = parser->astBuilder->create(); + ScopeDecl* scopeDecl = parser->astBuilder->create(); + CompileTimeForStmt* stmt = parser->astBuilder->create(); stmt->scopeDecl = scopeDecl; @@ -3377,7 +3379,7 @@ namespace Slang parser->ReadToken(TokenType::LParent); NameLoc varNameAndLoc = expectIdentifier(parser); - RefPtr varDecl = parser->astBuilder->create(); + VarDecl* varDecl = parser->astBuilder->create(); varDecl->nameAndLoc = varNameAndLoc; varDecl->loc = varNameAndLoc.loc; @@ -3387,8 +3389,8 @@ namespace Slang parser->ReadToken("Range"); parser->ReadToken(TokenType::LParent); - RefPtr rangeBeginExpr; - RefPtr rangeEndExpr = parser->ParseArgExpr(); + Expr* rangeBeginExpr = nullptr; + Expr* rangeEndExpr = parser->ParseArgExpr(); if (AdvanceIf(parser, TokenType::Comma)) { rangeBeginExpr = rangeEndExpr; @@ -3411,7 +3413,7 @@ namespace Slang return stmt; } - RefPtr parseCompileTimeStmt( + Stmt* parseCompileTimeStmt( Parser* parser) { parser->ReadToken(TokenType::Dollar); @@ -3426,11 +3428,11 @@ namespace Slang } } - RefPtr Parser::ParseStatement() + Stmt* Parser::ParseStatement() { auto modifiers = ParseModifiers(this); - RefPtr statement; + Stmt* statement = nullptr; if (LookAheadToken(TokenType::LBrace)) statement = parseBlockStatement(); else if (LookAheadToken("if")) @@ -3450,7 +3452,7 @@ namespace Slang else if (LookAheadToken("discard")) { statement = astBuilder->create(); - FillPosition(statement.Ptr()); + FillPosition(statement); ReadToken("discard"); ReadToken(TokenType::Semicolon); } @@ -3492,7 +3494,7 @@ namespace Slang // isn't a keyword should we fall back to the approach // here. // - RefPtr type = ParseType(); + Expr* type = ParseType(); // We don't actually care about the type, though, so // don't retain it @@ -3547,7 +3549,7 @@ namespace Slang else if (LookAheadToken(TokenType::Semicolon)) { statement = astBuilder->create(); - FillPosition(statement.Ptr()); + FillPosition(statement); ReadToken(TokenType::Semicolon); } else @@ -3569,19 +3571,19 @@ namespace Slang return statement; } - RefPtr Parser::parseBlockStatement() + Stmt* Parser::parseBlockStatement() { - RefPtr scopeDecl = astBuilder->create(); - RefPtr blockStatement = astBuilder->create(); + ScopeDecl* scopeDecl = astBuilder->create(); + BlockStmt* blockStatement = astBuilder->create(); blockStatement->scopeDecl = scopeDecl; - pushScopeAndSetParent(scopeDecl.Ptr()); + pushScopeAndSetParent(scopeDecl); ReadToken(TokenType::LBrace); - RefPtr body; + Stmt* body = nullptr; if(!tokenReader.isAtEnd()) { - FillPosition(blockStatement.Ptr()); + FillPosition(blockStatement); } while (!AdvanceIfMatch(this, TokenType::RBrace)) { @@ -3598,7 +3600,7 @@ namespace Slang } else { - RefPtr newBody = astBuilder->create(); + SeqStmt* newBody = astBuilder->create(); newBody->loc = blockStatement->loc; newBody->stmts.add(body); newBody->stmts.add(stmt); @@ -3620,21 +3622,21 @@ namespace Slang return blockStatement; } - RefPtr Parser::parseVarDeclrStatement( + DeclStmt* Parser::parseVarDeclrStatement( Modifiers modifiers) { - RefPtrvarDeclrStatement = astBuilder->create(); + DeclStmt*varDeclrStatement = astBuilder->create(); - FillPosition(varDeclrStatement.Ptr()); + FillPosition(varDeclrStatement); auto decl = ParseDeclWithModifiers(this, currentScope->containerDecl, modifiers); varDeclrStatement->decl = decl; return varDeclrStatement; } - RefPtr Parser::parseIfStatement() + IfStmt* Parser::parseIfStatement() { - RefPtr ifStatement = astBuilder->create(); - FillPosition(ifStatement.Ptr()); + IfStmt* ifStatement = astBuilder->create(); + FillPosition(ifStatement); ReadToken("if"); ReadToken(TokenType::LParent); ifStatement->predicate = ParseExpression(); @@ -3648,9 +3650,9 @@ namespace Slang return ifStatement; } - RefPtr Parser::ParseForStatement() + ForStmt* Parser::ParseForStatement() { - RefPtr scopeDecl = astBuilder->create(); + ScopeDecl* scopeDecl = astBuilder->create(); // HLSL implements the bad approach to scoping a `for` loop // variable, and we want to respect that, but *only* when @@ -3663,7 +3665,7 @@ namespace Slang // case, just so that we can correctly handle it in downstream // logic. // - RefPtr stmt; + ForStmt* stmt = nullptr; if (brokenScoping) { stmt = astBuilder->create(); @@ -3676,8 +3678,8 @@ namespace Slang stmt->scopeDecl = scopeDecl; if(!brokenScoping) - pushScopeAndSetParent(scopeDecl.Ptr()); - FillPosition(stmt.Ptr()); + pushScopeAndSetParent(scopeDecl); + FillPosition(stmt); ReadToken("for"); ReadToken(TokenType::LParent); if (peekTypeName(this)) @@ -3709,10 +3711,10 @@ namespace Slang return stmt; } - RefPtr Parser::ParseWhileStatement() + WhileStmt* Parser::ParseWhileStatement() { - RefPtr whileStatement = astBuilder->create(); - FillPosition(whileStatement.Ptr()); + WhileStmt* whileStatement = astBuilder->create(); + FillPosition(whileStatement); ReadToken("while"); ReadToken(TokenType::LParent); whileStatement->predicate = ParseExpression(); @@ -3721,10 +3723,10 @@ namespace Slang return whileStatement; } - RefPtr Parser::ParseDoWhileStatement() + DoWhileStmt* Parser::ParseDoWhileStatement() { - RefPtr doWhileStatement = astBuilder->create(); - FillPosition(doWhileStatement.Ptr()); + DoWhileStmt* doWhileStatement = astBuilder->create(); + FillPosition(doWhileStatement); ReadToken("do"); doWhileStatement->statement = ParseStatement(); ReadToken("while"); @@ -3735,28 +3737,28 @@ namespace Slang return doWhileStatement; } - RefPtr Parser::ParseBreakStatement() + BreakStmt* Parser::ParseBreakStatement() { - RefPtr breakStatement = astBuilder->create(); - FillPosition(breakStatement.Ptr()); + BreakStmt* breakStatement = astBuilder->create(); + FillPosition(breakStatement); ReadToken("break"); ReadToken(TokenType::Semicolon); return breakStatement; } - RefPtr Parser::ParseContinueStatement() + ContinueStmt* Parser::ParseContinueStatement() { - RefPtr continueStatement = astBuilder->create(); - FillPosition(continueStatement.Ptr()); + ContinueStmt* continueStatement = astBuilder->create(); + FillPosition(continueStatement); ReadToken("continue"); ReadToken(TokenType::Semicolon); return continueStatement; } - RefPtr Parser::ParseReturnStatement() + ReturnStmt* Parser::ParseReturnStatement() { - RefPtr returnStatement = astBuilder->create(); - FillPosition(returnStatement.Ptr()); + ReturnStmt* returnStatement = astBuilder->create(); + FillPosition(returnStatement); ReadToken("return"); if (!LookAheadToken(TokenType::Semicolon)) returnStatement->expression = ParseExpression(); @@ -3764,20 +3766,20 @@ namespace Slang return returnStatement; } - RefPtr Parser::ParseExpressionStatement() + ExpressionStmt* Parser::ParseExpressionStatement() { - RefPtr statement = astBuilder->create(); + ExpressionStmt* statement = astBuilder->create(); - FillPosition(statement.Ptr()); + FillPosition(statement); statement->expression = ParseExpression(); ReadToken(TokenType::Semicolon); return statement; } - RefPtr Parser::ParseParameter() + ParamDecl* Parser::ParseParameter() { - RefPtr parameter = astBuilder->create(); + ParamDecl* parameter = astBuilder->create(); parameter->modifiers = ParseModifiers(this); DeclaratorInfo declaratorInfo; @@ -3791,7 +3793,7 @@ namespace Slang return parameter; } - RefPtr Parser::ParseType() + Expr* Parser::ParseType() { auto typeSpec = parseTypeSpec(this); if( typeSpec.decl ) @@ -3889,7 +3891,7 @@ namespace Slang } } - static RefPtr parseOperator(Parser* parser) + static Expr* parseOperator(Parser* parser) { Token opToken; switch(parser->tokenReader.peekTokenType()) @@ -3913,13 +3915,13 @@ namespace Slang } - static RefPtr createInfixExpr( + static Expr* createInfixExpr( Parser* parser, - RefPtr left, - RefPtr op, - RefPtr right) + Expr* left, + Expr* op, + Expr* right) { - RefPtr expr = parser->astBuilder->create(); + InfixExpr* expr = parser->astBuilder->create(); expr->loc = op->loc; expr->functionExpr = op; expr->arguments.add(left); @@ -3927,9 +3929,9 @@ namespace Slang return expr; } - static RefPtr parseInfixExprWithPrecedence( + static Expr* parseInfixExprWithPrecedence( Parser* parser, - RefPtr inExpr, + Expr* inExpr, Precedence prec) { auto expr = inExpr; @@ -3946,7 +3948,7 @@ namespace Slang // one non-binary case we need to deal with. if(opTokenType == TokenType::QuestionMark) { - RefPtr select = parser->astBuilder->create(); + SelectExpr* select = parser->astBuilder->create(); select->loc = op->loc; select->functionExpr = op; @@ -3974,7 +3976,7 @@ namespace Slang if (opTokenType == TokenType::OpAssign) { - RefPtr assignExpr = parser->astBuilder->create(); + AssignExpr* assignExpr = parser->astBuilder->create(); assignExpr->loc = op->loc; assignExpr->left = expr; assignExpr->right = right; @@ -3989,7 +3991,7 @@ namespace Slang return expr; } - RefPtr Parser::ParseExpression(Precedence level) + Expr* Parser::ParseExpression(Precedence level) { auto expr = ParseLeafExpression(); return parseInfixExprWithPrecedence(this, expr, level); @@ -4004,7 +4006,7 @@ namespace Slang auto condition = ParseExpression(Precedence(level + 1)); if (LookAheadToken(TokenType::QuestionMark)) { - RefPtr select = new SelectExpr(); + SelectExpr* select = new SelectExpr(); FillPosition(select.Ptr()); select->Arguments.Add(condition); @@ -4026,7 +4028,7 @@ namespace Slang auto left = ParseExpression(Precedence(level + 1)); while (GetOpLevel(this, tokenReader.PeekTokenType()) == level) { - RefPtr tmp = new InfixExpr(); + OperatorExpr* tmp = new InfixExpr(); tmp->FunctionExpr = parseOperator(this); tmp->Arguments.Add(left); @@ -4041,7 +4043,7 @@ namespace Slang auto left = ParseExpression(Precedence(level + 1)); if (GetOpLevel(this, tokenReader.PeekTokenType()) == level) { - RefPtr tmp = new InfixExpr(); + OperatorExpr* tmp = new InfixExpr(); tmp->Arguments.Add(left); FillPosition(tmp.Ptr()); tmp->FunctionExpr = parseOperator(this); @@ -4056,40 +4058,40 @@ namespace Slang // We *might* be looking at an application of a generic to arguments, // but we need to disambiguate to make sure. - static RefPtr maybeParseGenericApp( + static Expr* maybeParseGenericApp( Parser* parser, // TODO: need to support more general expressions here - RefPtr base) + Expr* base) { if(peekTokenType(parser) != TokenType::OpLess) return base; return tryParseGenericApp(parser, base); } - static RefPtr parsePrefixExpr(Parser* parser); + static Expr* parsePrefixExpr(Parser* parser); // Parse OOP `this` expression syntax - static RefPtr parseThisExpr(Parser* parser, void* /*userData*/) + static NodeBase* parseThisExpr(Parser* parser, void* /*userData*/) { - RefPtr expr = parser->astBuilder->create(); + ThisExpr* expr = parser->astBuilder->create(); expr->scope = parser->currentScope; return expr; } - static RefPtr parseBoolLitExpr(Parser* parser, bool value) + static Expr* parseBoolLitExpr(Parser* parser, bool value) { - RefPtr expr = parser->astBuilder->create(); + BoolLiteralExpr* expr = parser->astBuilder->create(); expr->value = value; return expr; } - static RefPtr parseTrueExpr(Parser* parser, void* /*userData*/) + static NodeBase* parseTrueExpr(Parser* parser, void* /*userData*/) { return parseBoolLitExpr(parser, true); } - static RefPtr parseFalseExpr(Parser* parser, void* /*userData*/) + static NodeBase* parseFalseExpr(Parser* parser, void* /*userData*/) { return parseBoolLitExpr(parser, false); } @@ -4261,7 +4263,7 @@ namespace Slang return value; } - static RefPtr parseAtomicExpr(Parser* parser) + static Expr* parseAtomicExpr(Parser* parser) { switch( peekTokenType(parser) ) { @@ -4283,8 +4285,8 @@ namespace Slang if (peekTypeName(parser) && parser->LookAheadToken(TokenType::RParent, 1)) { - RefPtr tcexpr = parser->astBuilder->create(); - parser->FillPosition(tcexpr.Ptr()); + TypeCastExpr* tcexpr = parser->astBuilder->create(); + parser->FillPosition(tcexpr); tcexpr->functionExpr = parser->ParseType(); parser->ReadToken(TokenType::RParent); @@ -4295,10 +4297,10 @@ namespace Slang } else { - RefPtr base = parser->ParseExpression(); + Expr* base = parser->ParseExpression(); parser->ReadToken(TokenType::RParent); - RefPtr parenExpr = parser->astBuilder->create(); + ParenExpr* parenExpr = parser->astBuilder->create(); parenExpr->loc = openParen.loc; parenExpr->base = base; return parenExpr; @@ -4308,13 +4310,13 @@ namespace Slang // An initializer list `{ expr, ... }` case TokenType::LBrace: { - RefPtr initExpr = parser->astBuilder->create(); - parser->FillPosition(initExpr.Ptr()); + InitializerListExpr* initExpr = parser->astBuilder->create(); + parser->FillPosition(initExpr); // Initializer list parser->ReadToken(TokenType::LBrace); - List> exprs; + List exprs; for(;;) { @@ -4338,8 +4340,8 @@ namespace Slang case TokenType::IntegerLiteral: { - RefPtr constExpr = parser->astBuilder->create(); - parser->FillPosition(constExpr.Ptr()); + IntegerLiteralExpr* constExpr = parser->astBuilder->create(); + parser->FillPosition(constExpr); auto token = parser->tokenReader.advanceToken(); constExpr->token = token; @@ -4427,8 +4429,8 @@ namespace Slang case TokenType::FloatingPointLiteral: { - RefPtr constExpr = parser->astBuilder->create(); - parser->FillPosition(constExpr.Ptr()); + FloatingPointLiteralExpr* constExpr = parser->astBuilder->create(); + parser->FillPosition(constExpr); auto token = parser->tokenReader.advanceToken(); constExpr->token = token; @@ -4541,10 +4543,10 @@ namespace Slang case TokenType::StringLiteral: { - RefPtr constExpr = parser->astBuilder->create(); + StringLiteralExpr* constExpr = parser->astBuilder->create(); auto token = parser->tokenReader.advanceToken(); constExpr->token = token; - parser->FillPosition(constExpr.Ptr()); + parser->FillPosition(constExpr); if (!parser->LookAheadToken(TokenType::StringLiteral)) { @@ -4572,7 +4574,7 @@ namespace Slang // keywords registered for use as expressions. Token nameToken = peekToken(parser); - RefPtr parsedExpr; + Expr* parsedExpr = nullptr; if (tryParseUsingSyntaxDecl(parser, &parsedExpr)) { if (!parsedExpr->loc.isValid()) @@ -4583,9 +4585,9 @@ namespace Slang } // Default behavior is just to create a name expression - RefPtr varExpr = parser->astBuilder->create(); - varExpr->scope = parser->currentScope.Ptr(); - parser->FillPosition(varExpr.Ptr()); + VarExpr* varExpr = parser->astBuilder->create(); + varExpr->scope = parser->currentScope; + parser->FillPosition(varExpr); auto nameAndLoc = expectIdentifier(parser); varExpr->name = nameAndLoc.name; @@ -4600,7 +4602,7 @@ namespace Slang } } - static RefPtr parsePostfixExpr(Parser* parser) + static Expr* parsePostfixExpr(Parser* parser) { auto expr = parseAtomicExpr(parser); for(;;) @@ -4614,8 +4616,8 @@ namespace Slang case TokenType::OpInc: case TokenType::OpDec: { - RefPtr postfixExpr = parser->astBuilder->create(); - parser->FillPosition(postfixExpr.Ptr()); + OperatorExpr* postfixExpr = parser->astBuilder->create(); + parser->FillPosition(postfixExpr); postfixExpr->functionExpr = parseOperator(parser); postfixExpr->arguments.add(expr); @@ -4626,9 +4628,9 @@ namespace Slang // Subscript operation `a[i]` case TokenType::LBracket: { - RefPtr indexExpr = parser->astBuilder->create(); + IndexExpr* indexExpr = parser->astBuilder->create(); indexExpr->baseExpression = expr; - parser->FillPosition(indexExpr.Ptr()); + parser->FillPosition(indexExpr); parser->ReadToken(TokenType::LBracket); // TODO: eventually we may want to support multiple arguments inside the `[]` if (!parser->LookAheadToken(TokenType::RBracket)) @@ -4644,9 +4646,9 @@ namespace Slang // Call oepration `f(x)` case TokenType::LParent: { - RefPtr invokeExpr = parser->astBuilder->create(); + InvokeExpr* invokeExpr = parser->astBuilder->create(); invokeExpr->functionExpr = expr; - parser->FillPosition(invokeExpr.Ptr()); + parser->FillPosition(invokeExpr); parser->ReadToken(TokenType::LParent); while (!parser->tokenReader.isAtEnd()) { @@ -4669,12 +4671,12 @@ namespace Slang // Scope access `x::m` case TokenType::Scope: { - RefPtr staticMemberExpr = parser->astBuilder->create(); + StaticMemberExpr* staticMemberExpr = parser->astBuilder->create(); // TODO(tfoley): why would a member expression need this? - staticMemberExpr->scope = parser->currentScope.Ptr(); + staticMemberExpr->scope = parser->currentScope; - parser->FillPosition(staticMemberExpr.Ptr()); + parser->FillPosition(staticMemberExpr); staticMemberExpr->baseExpression = expr; parser->ReadToken(TokenType::Scope); staticMemberExpr->name = expectIdentifier(parser).name; @@ -4689,12 +4691,12 @@ namespace Slang // Member access `x.m` case TokenType::Dot: { - RefPtr memberExpr = parser->astBuilder->create(); + MemberExpr* memberExpr = parser->astBuilder->create(); // TODO(tfoley): why would a member expression need this? memberExpr->scope = parser->currentScope.Ptr(); - parser->FillPosition(memberExpr.Ptr()); + parser->FillPosition(memberExpr); memberExpr->baseExpression = expr; parser->ReadToken(TokenType::Dot); memberExpr->name = expectIdentifier(parser).name; @@ -4738,7 +4740,7 @@ namespace Slang } } - static RefPtr parsePrefixExpr(Parser* parser) + static Expr* parsePrefixExpr(Parser* parser) { auto tokenType = peekTokenType(parser); switch( tokenType ) @@ -4750,8 +4752,8 @@ namespace Slang case TokenType::OpInc: case TokenType::OpDec: { - RefPtr prefixExpr = parser->astBuilder->create(); - parser->FillPosition(prefixExpr.Ptr()); + PrefixExpr* prefixExpr = parser->astBuilder->create(); + parser->FillPosition(prefixExpr); prefixExpr->functionExpr = parseOperator(parser); auto arg = parsePrefixExpr(parser); @@ -4763,15 +4765,15 @@ namespace Slang case TokenType::OpAdd: case TokenType::OpSub: { - RefPtr prefixExpr = parser->astBuilder->create(); - parser->FillPosition(prefixExpr.Ptr()); + PrefixExpr* prefixExpr = parser->astBuilder->create(); + parser->FillPosition(prefixExpr); prefixExpr->functionExpr = parseOperator(parser); auto arg = parsePrefixExpr(parser); if (auto intLit = as(arg)) { - RefPtr newLiteral = parser->astBuilder->create(*intLit); + IntegerLiteralExpr* newLiteral = parser->astBuilder->create(*intLit); IRIntegerValue value = _foldIntegerPrefixOp(tokenType, newLiteral->value); @@ -4786,7 +4788,7 @@ namespace Slang } else if (auto floatLit = as(arg)) { - RefPtr newLiteral = parser->astBuilder->create(*floatLit); + FloatingPointLiteralExpr* newLiteral = parser->astBuilder->create(*floatLit); newLiteral->value = _foldFloatPrefixOp(tokenType, floatLit->value); return newLiteral; } @@ -4799,12 +4801,12 @@ namespace Slang } } - RefPtr Parser::ParseLeafExpression() + Expr* Parser::ParseLeafExpression() { return parsePrefixExpr(this); } - RefPtr parseTermFromSourceFile( + Expr* parseTermFromSourceFile( ASTBuilder* astBuilder, TokenSpan const& tokens, DiagnosticSink* sink, @@ -4840,13 +4842,13 @@ namespace Slang char const* nameText, SyntaxParseCallback callback, void* userData, - SyntaxClass syntaxClass) + SyntaxClass syntaxClass) { Name* name = session->getNamePool()->getName(nameText); ASTBuilder* globalASTBuilder = session->getGlobalASTBuilder(); - RefPtr syntaxDecl = globalASTBuilder->create(); + SyntaxDecl* syntaxDecl = globalASTBuilder->create(); syntaxDecl->nameAndLoc = NameLoc(name); syntaxDecl->syntaxClass = syntaxClass; syntaxDecl->parseCallback = callback; @@ -4876,9 +4878,9 @@ namespace Slang addBuiltinSyntaxImpl(session, scope, name, &parseSimpleSyntax, (void*) syntaxClass.classInfo, getClass()); } - static RefPtr parseIntrinsicOpModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseIntrinsicOpModifier(Parser* parser, void* /*userData*/) { - RefPtr modifier = parser->astBuilder->create(); + IntrinsicOpModifier* modifier = parser->astBuilder->create(); // We allow a few difference forms here: // @@ -4924,7 +4926,7 @@ namespace Slang return modifier; } - static RefPtr parseTargetIntrinsicModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseTargetIntrinsicModifier(Parser* parser, void* /*userData*/) { auto modifier = parser->astBuilder->create(); @@ -4950,7 +4952,7 @@ namespace Slang return modifier; } - static RefPtr parseSpecializedForTargetModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseSpecializedForTargetModifier(Parser* parser, void* /*userData*/) { auto modifier = parser->astBuilder->create(); if (AdvanceIf(parser, TokenType::LParent)) @@ -4961,7 +4963,7 @@ namespace Slang return modifier; } - static RefPtr parseGLSLExtensionModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseGLSLExtensionModifier(Parser* parser, void* /*userData*/) { auto modifier = parser->astBuilder->create(); @@ -4972,7 +4974,7 @@ namespace Slang return modifier; } - static RefPtr parseGLSLVersionModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseGLSLVersionModifier(Parser* parser, void* /*userData*/) { auto modifier = parser->astBuilder->create(); @@ -5013,7 +5015,7 @@ namespace Slang return SemanticVersion::parse(content, outVersion); } - static RefPtr parseSPIRVVersionModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseSPIRVVersionModifier(Parser* parser, void* /*userData*/) { Token token; SemanticVersion version; @@ -5024,10 +5026,10 @@ namespace Slang return modifier; } parser->sink->diagnose(token, Diagnostics::invalidSPIRVVersion); - return RefPtr(); + return nullptr; } - static RefPtr parseCUDASMVersionModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseCUDASMVersionModifier(Parser* parser, void* /*userData*/) { Token token; SemanticVersion version; @@ -5038,14 +5040,14 @@ namespace Slang return modifier; } parser->sink->diagnose(token, Diagnostics::invalidCUDASMVersion); - return RefPtr(); + return nullptr; } - static RefPtr parseLayoutModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseLayoutModifier(Parser* parser, void* /*userData*/) { ModifierListBuilder listBuilder; - RefPtr numThreadsAttrib; + UncheckedAttribute* numThreadsAttrib = nullptr; listBuilder.add(parser->astBuilder->create()); @@ -5121,7 +5123,7 @@ namespace Slang } else { - RefPtr modifier; + Modifier* modifier = nullptr; #define CASE(key, type) if (nameText == #key) { modifier = parser->astBuilder->create(); } else CASE(push_constant, PushConstantAttribute) @@ -5164,9 +5166,9 @@ namespace Slang return listBuilder.getFirst(); } - static RefPtr parseBuiltinTypeModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseBuiltinTypeModifier(Parser* parser, void* /*userData*/) { - RefPtr modifier = parser->astBuilder->create(); + BuiltinTypeModifier* modifier = parser->astBuilder->create(); parser->ReadToken(TokenType::LParent); modifier->tag = BaseType(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).getContent())); parser->ReadToken(TokenType::RParent); @@ -5174,9 +5176,9 @@ namespace Slang return modifier; } - static RefPtr parseMagicTypeModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseMagicTypeModifier(Parser* parser, void* /*userData*/) { - RefPtr modifier = parser->astBuilder->create(); + MagicTypeModifier* modifier = parser->astBuilder->create(); parser->ReadToken(TokenType::LParent); modifier->name = parser->ReadToken(TokenType::Identifier).getContent(); if (AdvanceIf(parser, TokenType::Comma)) @@ -5188,9 +5190,9 @@ namespace Slang return modifier; } - static RefPtr parseIntrinsicTypeModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseIntrinsicTypeModifier(Parser* parser, void* /*userData*/) { - RefPtr modifier = parser->astBuilder->create(); + IntrinsicTypeModifier* modifier = parser->astBuilder->create(); parser->ReadToken(TokenType::LParent); modifier->irOp = uint32_t(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).getContent())); while( AdvanceIf(parser, TokenType::Comma) ) @@ -5202,9 +5204,9 @@ namespace Slang return modifier; } - static RefPtr parseImplicitConversionModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseImplicitConversionModifier(Parser* parser, void* /*userData*/) { - RefPtr modifier = parser->astBuilder->create(); + ImplicitConversionModifier* modifier = parser->astBuilder->create(); ConversionCost cost = kConversionCost_Default; if( AdvanceIf(parser, TokenType::LParent) ) @@ -5216,7 +5218,7 @@ namespace Slang return modifier; } - static RefPtr parseAttributeTargetModifier(Parser* parser, void* /*userData*/) + static NodeBase* parseAttributeTargetModifier(Parser* parser, void* /*userData*/) { expect(parser, TokenType::LParent); auto syntaxClassNameAndLoc = expectIdentifier(parser); @@ -5224,19 +5226,19 @@ namespace Slang auto syntaxClass = parser->astBuilder->findSyntaxClass(syntaxClassNameAndLoc.name); - RefPtr modifier = parser->astBuilder->create(); + AttributeTargetModifier* modifier = parser->astBuilder->create(); modifier->syntaxClass = syntaxClass; return modifier; } - RefPtr populateBaseLanguageModule( + ModuleDecl* populateBaseLanguageModule( ASTBuilder* astBuilder, RefPtr scope) { Session* session = astBuilder->getGlobalSession(); - RefPtr moduleDecl = astBuilder->create(); + ModuleDecl* moduleDecl = astBuilder->create(); scope->containerDecl = moduleDecl; // Add syntax for declaration keywords -- cgit v1.2.3