summaryrefslogtreecommitdiffstats
path: root/source/slang/slang-parser.cpp
diff options
context:
space:
mode:
authorjsmall-nvidia <jsmall@nvidia.com>2019-05-31 17:20:37 -0400
committerGitHub <noreply@github.com>2019-05-31 17:20:37 -0400
commit6cbc3929a54d37bd23cb5efa8e3320ba02f78b2f (patch)
tree5a23cb47782e9e2a77762c90dd35da1005eba8d0 /source/slang/slang-parser.cpp
parentb81ff3ef968d1cc4e954b31a1812b3c391d17b02 (diff)
Use slang- prefix on slang compiler and core source (#973)
* Prefixing source files in source/slang with slang- * Prefix source in source/slang with slang- prefix. * Rename core source files with slang- prefix. * Update project files. * Fix problems from automatic merge.
Diffstat (limited to 'source/slang/slang-parser.cpp')
-rw-r--r--source/slang/slang-parser.cpp4725
1 files changed, 4725 insertions, 0 deletions
diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp
new file mode 100644
index 000000000..bb70347c9
--- /dev/null
+++ b/source/slang/slang-parser.cpp
@@ -0,0 +1,4725 @@
+#include "slang-parser.h"
+
+#include <assert.h>
+
+#include "slang-compiler.h"
+#include "slang-lookup.h"
+#include "slang-visitor.h"
+
+namespace Slang
+{
+ // pre-declare
+ static Name* getName(Parser* parser, String const& text);
+
+ // Helper class useful to build a list of modifiers.
+ struct ModifierListBuilder
+ {
+ ModifierListBuilder()
+ {
+ m_next = &m_result;
+ }
+ void add(Modifier* modifier)
+ {
+ // Doesn't handle SharedModifiers
+ SLANG_ASSERT(as<SharedModifiers>(modifier) == nullptr);
+
+ // Splice at end
+ *m_next = modifier;
+ m_next = &modifier->next;
+ }
+ template <typename T>
+ T* find() const
+ {
+ Modifier* cur = m_result;
+ while (cur)
+ {
+ T* castCur = as<T>(cur);
+ if (castCur)
+ {
+ return castCur;
+ }
+ cur = cur->next;
+ }
+ return nullptr;
+ }
+ template <typename T>
+ bool hasType() const
+ {
+ return find<T>() != nullptr;
+ }
+ RefPtr<Modifier> getFirst() { return m_result; };
+ protected:
+
+ RefPtr<Modifier> m_result;
+ RefPtr<Modifier>* m_next;
+ };
+
+ enum Precedence : int
+ {
+ Invalid = -1,
+ Comma,
+ Assignment,
+ TernaryConditional,
+ LogicalOr,
+ LogicalAnd,
+ BitOr,
+ BitXor,
+ BitAnd,
+ EqualityComparison,
+ RelationalComparison,
+ BitShift,
+ Additive,
+ Multiplicative,
+ Prefix,
+ Postfix,
+ };
+
+ // TODO: implement two pass parsing for file reference and struct type recognition
+
+ class Parser
+ {
+ public:
+ NamePool* namePool;
+ SourceLanguage sourceLanguage;
+
+ NamePool* getNamePool() { return namePool; }
+ SourceLanguage getSourceLanguage() { return sourceLanguage; }
+
+ int anonymousCounter = 0;
+
+ RefPtr<Scope> outerScope;
+ RefPtr<Scope> currentScope;
+
+ TokenReader tokenReader;
+ DiagnosticSink* sink;
+ int genericDepth = 0;
+
+ // Have we seen any `import` declarations? If so, we need
+ // to parse function bodies completely, even if we are in
+ // "rewrite" mode.
+ bool haveSeenAnyImportDecls = false;
+
+ // Is the parser in a "recovering" state?
+ // During recovery we don't emit additional errors, until we find
+ // a token that we expected, when we exit recovery.
+ bool isRecovering = false;
+
+ void FillPosition(SyntaxNode * node)
+ {
+ node->loc = tokenReader.PeekLoc();
+ }
+ void PushScope(ContainerDecl* containerDecl)
+ {
+ RefPtr<Scope> newScope = new Scope();
+ newScope->containerDecl = containerDecl;
+ newScope->parent = currentScope;
+
+ currentScope = newScope;
+ }
+
+ void pushScopeAndSetParent(ContainerDecl* containerDecl)
+ {
+ containerDecl->ParentDecl = currentScope->containerDecl;
+ PushScope(containerDecl);
+ }
+
+ void PopScope()
+ {
+ currentScope = currentScope->parent;
+ }
+ Parser(
+ Session* session,
+ TokenSpan const& _tokens,
+ DiagnosticSink * sink,
+ RefPtr<Scope> const& outerScope)
+ : tokenReader(_tokens)
+ , sink(sink)
+ , outerScope(outerScope)
+ , m_session(session)
+ {}
+ Parser(const Parser & other) = default;
+
+ Session* m_session = nullptr;
+ Session* getSession() { return m_session; }
+
+ Token ReadToken();
+ Token ReadToken(TokenType type);
+ Token ReadToken(const char * string);
+ bool LookAheadToken(TokenType type, int offset = 0);
+ bool LookAheadToken(const char * string, int offset = 0);
+ void parseSourceFile(ModuleDecl* program);
+ RefPtr<Decl> ParseStruct();
+ RefPtr<ClassDecl> ParseClass();
+ RefPtr<Stmt> ParseStatement();
+ RefPtr<Stmt> parseBlockStatement();
+ RefPtr<DeclStmt> parseVarDeclrStatement(Modifiers modifiers);
+ RefPtr<IfStmt> parseIfStatement();
+ RefPtr<ForStmt> ParseForStatement();
+ RefPtr<WhileStmt> ParseWhileStatement();
+ RefPtr<DoWhileStmt> ParseDoWhileStatement();
+ RefPtr<BreakStmt> ParseBreakStatement();
+ RefPtr<ContinueStmt> ParseContinueStatement();
+ RefPtr<ReturnStmt> ParseReturnStatement();
+ RefPtr<ExpressionStmt> ParseExpressionStatement();
+ RefPtr<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<Expr> ParseInitExpr() { return ParseExpression(Precedence::Assignment); }
+ inline RefPtr<Expr> ParseArgExpr() { return ParseExpression(Precedence::Assignment); }
+
+ RefPtr<Expr> ParseLeafExpression();
+ RefPtr<ParamDecl> ParseParameter();
+ RefPtr<Expr> ParseType();
+ TypeExp ParseTypeExp();
+
+ Parser & operator = (const Parser &) = delete;
+ };
+
+ // Forward Declarations
+
+ static void ParseDeclBody(
+ Parser* parser,
+ ContainerDecl* containerDecl,
+ TokenType closingToken);
+
+ static RefPtr<Decl> parseEnumDecl(Parser* parser);
+
+ // Parse the `{}`-delimeted body of an aggregate type declaration
+ static void parseAggTypeDeclBody(
+ Parser* parser,
+ AggTypeDeclBase* decl);
+
+ static RefPtr<Modifier> ParseOptSemantics(
+ Parser* parser);
+
+ static void ParseOptSemantics(
+ Parser* parser,
+ Decl* decl);
+
+ static RefPtr<DeclBase> ParseDecl(
+ Parser* parser,
+ ContainerDecl* containerDecl);
+
+ static RefPtr<Decl> ParseSingleDecl(
+ Parser* parser,
+ ContainerDecl* containerDecl);
+
+ //
+
+ static void Unexpected(
+ Parser* parser)
+ {
+ // Don't emit "unexpected token" errors if we are in recovering mode
+ if (!parser->isRecovering)
+ {
+ parser->sink->diagnose(parser->tokenReader.PeekLoc(), Diagnostics::unexpectedToken,
+ parser->tokenReader.PeekTokenType());
+
+ // Switch into recovery mode, to suppress additional errors
+ parser->isRecovering = true;
+ }
+ }
+
+ static void Unexpected(
+ Parser* parser,
+ char const* expected)
+ {
+ // Don't emit "unexpected token" errors if we are in recovering mode
+ if (!parser->isRecovering)
+ {
+ parser->sink->diagnose(parser->tokenReader.PeekLoc(), Diagnostics::unexpectedTokenExpectedTokenName,
+ parser->tokenReader.PeekTokenType(),
+ expected);
+
+ // Switch into recovery mode, to suppress additional errors
+ parser->isRecovering = true;
+ }
+ }
+
+ static void Unexpected(
+ Parser* parser,
+ TokenType expected)
+ {
+ // Don't emit "unexpected token" errors if we are in recovering mode
+ if (!parser->isRecovering)
+ {
+ parser->sink->diagnose(parser->tokenReader.PeekLoc(), Diagnostics::unexpectedTokenExpectedTokenType,
+ parser->tokenReader.PeekTokenType(),
+ expected);
+
+ // Switch into recovery mode, to suppress additional errors
+ parser->isRecovering = true;
+ }
+ }
+
+ static TokenType SkipToMatchingToken(TokenReader* reader, TokenType tokenType);
+
+ // Skip a singel balanced token, which is either a single token in
+ // the common case, or a matched pair of tokens for `()`, `[]`, and `{}`
+ static TokenType SkipBalancedToken(
+ TokenReader* reader)
+ {
+ TokenType tokenType = reader->AdvanceToken().type;
+ switch (tokenType)
+ {
+ default:
+ break;
+
+ case TokenType::LParent: tokenType = SkipToMatchingToken(reader, TokenType::RParent); break;
+ case TokenType::LBrace: tokenType = SkipToMatchingToken(reader, TokenType::RBrace); break;
+ case TokenType::LBracket: tokenType = SkipToMatchingToken(reader, TokenType::RBracket); break;
+ }
+ return tokenType;
+ }
+
+ // Skip balanced
+ static TokenType SkipToMatchingToken(
+ TokenReader* reader,
+ TokenType tokenType)
+ {
+ for (;;)
+ {
+ if (reader->IsAtEnd()) return TokenType::EndOfFile;
+ if (reader->PeekTokenType() == tokenType)
+ {
+ reader->AdvanceToken();
+ return tokenType;
+ }
+ SkipBalancedToken(reader);
+ }
+ }
+
+ // Is the given token type one that is used to "close" a
+ // balanced construct.
+ static bool IsClosingToken(TokenType tokenType)
+ {
+ switch (tokenType)
+ {
+ case TokenType::EndOfFile:
+ case TokenType::RBracket:
+ case TokenType::RParent:
+ case TokenType::RBrace:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+
+ // Expect an identifier token with the given content, and consume it.
+ Token Parser::ReadToken(const char* expected)
+ {
+ if (tokenReader.PeekTokenType() == TokenType::Identifier
+ && tokenReader.PeekToken().Content == expected)
+ {
+ isRecovering = false;
+ return tokenReader.AdvanceToken();
+ }
+
+ if (!isRecovering)
+ {
+ Unexpected(this, expected);
+ return tokenReader.PeekToken();
+ }
+ else
+ {
+ // Try to find a place to recover
+ for (;;)
+ {
+ // The token we expected?
+ // Then exit recovery mode and pretend like all is well.
+ if (tokenReader.PeekTokenType() == TokenType::Identifier
+ && tokenReader.PeekToken().Content == expected)
+ {
+ isRecovering = false;
+ return tokenReader.AdvanceToken();
+ }
+
+
+ // Don't skip past any "closing" tokens.
+ if (IsClosingToken(tokenReader.PeekTokenType()))
+ {
+ return tokenReader.PeekToken();
+ }
+
+ // Skip balanced tokens and try again.
+ SkipBalancedToken(&tokenReader);
+ }
+ }
+ }
+
+ Token Parser::ReadToken()
+ {
+ return tokenReader.AdvanceToken();
+ }
+
+ static bool TryRecover(
+ Parser* parser,
+ TokenType const* recoverBefore,
+ int recoverBeforeCount,
+ TokenType const* recoverAfter,
+ int recoverAfterCount)
+ {
+ if (!parser->isRecovering)
+ return true;
+
+ // Determine if we are looking for common closing tokens,
+ // so that we can know whether or we are allowed to skip
+ // over them.
+
+ bool lookingForEOF = false;
+ bool lookingForRCurly = false;
+ bool lookingForRParen = false;
+ bool lookingForRSquare = false;
+
+ for (int ii = 0; ii < recoverBeforeCount; ++ii)
+ {
+ switch (recoverBefore[ii])
+ {
+ default:
+ break;
+
+ case TokenType::EndOfFile: lookingForEOF = true; break;
+ case TokenType::RBrace: lookingForRCurly = true; break;
+ case TokenType::RParent: lookingForRParen = true; break;
+ case TokenType::RBracket: lookingForRSquare = true; break;
+ }
+ }
+ for (int ii = 0; ii < recoverAfterCount; ++ii)
+ {
+ switch (recoverAfter[ii])
+ {
+ default:
+ break;
+
+ case TokenType::EndOfFile: lookingForEOF = true; break;
+ case TokenType::RBrace: lookingForRCurly = true; break;
+ case TokenType::RParent: lookingForRParen = true; break;
+ case TokenType::RBracket: lookingForRSquare = true; break;
+ }
+ }
+
+ TokenReader* tokenReader = &parser->tokenReader;
+ for (;;)
+ {
+ TokenType peek = tokenReader->PeekTokenType();
+
+ // Is the next token in our recover-before set?
+ // If so, then we have recovered successfully!
+ for (int ii = 0; ii < recoverBeforeCount; ++ii)
+ {
+ if (peek == recoverBefore[ii])
+ {
+ parser->isRecovering = false;
+ return true;
+ }
+ }
+
+ // If we are looking at a token in our recover-after set,
+ // then consume it and recover
+ for (int ii = 0; ii < recoverAfterCount; ++ii)
+ {
+ if (peek == recoverAfter[ii])
+ {
+ tokenReader->AdvanceToken();
+ parser->isRecovering = false;
+ return true;
+ }
+ }
+
+ // Don't try to skip past end of file
+ if (peek == TokenType::EndOfFile)
+ return false;
+
+ switch (peek)
+ {
+ // Don't skip past simple "closing" tokens, *unless*
+ // we are looking for a closing token
+ case TokenType::RParent:
+ case TokenType::RBracket:
+ if (lookingForRParen || lookingForRSquare || lookingForRCurly || lookingForEOF)
+ {
+ // We are looking for a closing token, so it is okay to skip these
+ }
+ else
+ return false;
+ break;
+
+ // Don't skip a `}`, to avoid spurious errors,
+ // with the exception of when we are looking for EOF
+ case TokenType::RBrace:
+ if (lookingForRCurly || lookingForEOF)
+ {
+ // We are looking for end-of-file, so it is okay to skip here
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ // Skip balanced tokens and try again.
+ TokenType skipped = SkipBalancedToken(tokenReader);
+
+ // If we happened to find a matched pair of tokens, and
+ // the end of it was a token we were looking for,
+ // then recover here
+ for (int ii = 0; ii < recoverAfterCount; ++ii)
+ {
+ if (skipped == recoverAfter[ii])
+ {
+ parser->isRecovering = false;
+ return true;
+ }
+ }
+ }
+ }
+
+ static bool TryRecoverBefore(
+ Parser* parser,
+ TokenType before0)
+ {
+ TokenType recoverBefore[] = { before0 };
+ return TryRecover(parser, recoverBefore, 1, nullptr, 0);
+ }
+
+ // Default recovery strategy, to use inside `{}`-delimeted blocks.
+ static bool TryRecover(
+ Parser* parser)
+ {
+ TokenType recoverBefore[] = { TokenType::RBrace };
+ TokenType recoverAfter[] = { TokenType::Semicolon };
+ return TryRecover(parser, recoverBefore, 1, recoverAfter, 1);
+ }
+
+ Token Parser::ReadToken(TokenType expected)
+ {
+ if (tokenReader.PeekTokenType() == expected)
+ {
+ isRecovering = false;
+ return tokenReader.AdvanceToken();
+ }
+
+ if (!isRecovering)
+ {
+ Unexpected(this, expected);
+ return tokenReader.PeekToken();
+ }
+ else
+ {
+ // Try to find a place to recover
+ if (TryRecoverBefore(this, expected))
+ {
+ isRecovering = false;
+ return tokenReader.AdvanceToken();
+ }
+
+ return tokenReader.PeekToken();
+ }
+ }
+
+ bool Parser::LookAheadToken(const char * string, int offset)
+ {
+ TokenReader r = tokenReader;
+ for (int ii = 0; ii < offset; ++ii)
+ r.AdvanceToken();
+
+ return r.PeekTokenType() == TokenType::Identifier
+ && r.PeekToken().Content == string;
+}
+
+ bool Parser::LookAheadToken(TokenType type, int offset)
+ {
+ TokenReader r = tokenReader;
+ for (int ii = 0; ii < offset; ++ii)
+ r.AdvanceToken();
+
+ return r.PeekTokenType() == type;
+ }
+
+ // Consume a token and return true it if matches, otherwise false
+ bool AdvanceIf(Parser* parser, TokenType tokenType)
+ {
+ if (parser->LookAheadToken(tokenType))
+ {
+ parser->ReadToken();
+ return true;
+ }
+ return false;
+ }
+
+ // Consume a token and return true it if matches, otherwise false
+ bool AdvanceIf(Parser* parser, char const* text)
+ {
+ if (parser->LookAheadToken(text))
+ {
+ parser->ReadToken();
+ return true;
+ }
+ return false;
+ }
+
+ // Consume a token and return true if it matches, otherwise check
+ // for end-of-file and expect that token (potentially producing
+ // an error) and return true to maintain forward progress.
+ // Otherwise return false.
+ bool AdvanceIfMatch(Parser* parser, TokenType tokenType)
+ {
+ // If we've run into a syntax error, but haven't recovered inside
+ // the block, then try to recover here.
+ if (parser->isRecovering)
+ {
+ TryRecoverBefore(parser, tokenType);
+ }
+ if (AdvanceIf(parser, tokenType))
+ return true;
+ if (parser->tokenReader.PeekTokenType() == TokenType::EndOfFile)
+ {
+ parser->ReadToken(tokenType);
+ return true;
+ }
+ return false;
+ }
+
+ RefPtr<RefObject> ParseTypeDef(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<TypeDefDecl> typeDefDecl = new TypeDefDecl();
+
+ // TODO(tfoley): parse an actual declarator
+ auto type = parser->ParseTypeExp();
+
+ auto nameToken = parser->ReadToken(TokenType::Identifier);
+ typeDefDecl->loc = nameToken.loc;
+
+ typeDefDecl->nameAndLoc = NameLoc(nameToken);
+ typeDefDecl->type = type;
+
+ return typeDefDecl;
+ }
+
+ // Add a modifier to a list of modifiers being built
+ static void AddModifier(RefPtr<Modifier>** ioModifierLink, RefPtr<Modifier> modifier)
+ {
+ RefPtr<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"
+ // section of modifiers for multiple declarations.
+ //
+ // TODO: This whole approach is a mess because we are "accidentally quadratic"
+ // when adding many modifiers.
+ for(;;)
+ {
+ // At end of the chain? Done.
+ if(!*modifierLink)
+ break;
+
+ // About to look at shared modifiers? Done.
+ RefPtr<Modifier> linkMod = *modifierLink;
+ if(as<SharedModifiers>(linkMod))
+ {
+ break;
+ }
+
+ // Otherwise: keep traversing the modifier list.
+ modifierLink = &(*modifierLink)->next;
+ }
+
+ // Splice the modifier into the linked list
+
+ // We need to deal with the case where the modifier to
+ // be spliced in might actually be a modifier *list*,
+ // so that we actually want to splice in at the
+ // end of the new list...
+ auto spliceLink = &modifier->next;
+ while(*spliceLink)
+ spliceLink = &(*spliceLink)->next;
+
+ // Do the splice.
+ *spliceLink = *modifierLink;
+
+ *modifierLink = modifier;
+ modifierLink = &modifier->next;
+ }
+
+ void addModifier(
+ RefPtr<ModifiableSyntaxNode> syntax,
+ RefPtr<Modifier> modifier)
+ {
+ auto modifierLink = &syntax->modifiers.first;
+ AddModifier(&modifierLink, modifier);
+ }
+
+ //
+ // '::'? identifier ('::' identifier)*
+ static Token parseAttributeName(Parser* parser)
+ {
+ const SourceLoc scopedIdSourceLoc = parser->tokenReader.PeekLoc();
+
+ // Strip initial :: if there is one
+ const TokenType initialTokenType = parser->tokenReader.PeekTokenType();
+ if (initialTokenType == TokenType::Scope)
+ {
+ parser->ReadToken(TokenType::Scope);
+ }
+
+ const Token firstIdentifier = parser->ReadToken(TokenType::Identifier);
+ if (initialTokenType != TokenType::Scope && parser->tokenReader.PeekTokenType() != TokenType::Scope)
+ {
+ return firstIdentifier;
+ }
+
+ // Build up scoped string
+ StringBuilder scopedIdentifierBuilder;
+ if (initialTokenType == TokenType::Scope)
+ {
+ scopedIdentifierBuilder.Append('_');
+ }
+ scopedIdentifierBuilder.Append(firstIdentifier.Content);
+
+ while (parser->tokenReader.PeekTokenType() == TokenType::Scope)
+ {
+ parser->ReadToken(TokenType::Scope);
+ scopedIdentifierBuilder.Append('_');
+
+ const Token nextIdentifier(parser->ReadToken(TokenType::Identifier));
+ scopedIdentifierBuilder.Append(nextIdentifier.Content);
+ }
+
+ // Make a 'token'
+ SourceManager* sourceManager = parser->sink->sourceManager;
+ const UnownedStringSlice scopedIdentifier(sourceManager->allocateStringSlice(scopedIdentifierBuilder.getUnownedSlice()));
+ Token token(TokenType::Identifier, scopedIdentifier, scopedIdSourceLoc);
+
+ // Get the name pool
+ auto namePool = parser->getNamePool();
+
+ // Since it's an Identifier have to set the name.
+ token.ptrValue = namePool->getName(token.Content);
+
+ return token;
+ }
+
+ // Parse HLSL-style `[name(arg, ...)]` style "attribute" modifiers
+ static void ParseSquareBracketAttributes(Parser* parser, RefPtr<Modifier>** ioModifierLink)
+ {
+ parser->ReadToken(TokenType::LBracket);
+
+ const bool hasDoubleBracket = AdvanceIf(parser, TokenType::LBracket);
+
+ for(;;)
+ {
+ // Note: When parsing we just construct an AST node for an
+ // "unchecked" attribute, and defer all detailed semantic
+ // checking until later.
+ //
+ // An alternative would be to perform lookup of an `AttributeDecl`
+ // at this point, similar to what we do for `SyntaxDecl`, but it
+ // seems better to not complicate the parsing process any more.
+ //
+
+ Token nameToken = parseAttributeName(parser);
+
+ RefPtr<UncheckedAttribute> modifier = new UncheckedAttribute();
+ modifier->name = nameToken.getName();
+ modifier->loc = nameToken.getLoc();
+ modifier->scope = parser->currentScope;
+
+ if (AdvanceIf(parser, TokenType::LParent))
+ {
+ // HLSL-style `[name(arg0, ...)]` attribute
+
+ while (!AdvanceIfMatch(parser, TokenType::RParent))
+ {
+ auto arg = parser->ParseArgExpr();
+ if (arg)
+ {
+ modifier->args.add(arg);
+ }
+
+ if (AdvanceIfMatch(parser, TokenType::RParent))
+ break;
+
+ parser->ReadToken(TokenType::Comma);
+ }
+ }
+ AddModifier(ioModifierLink, modifier);
+
+
+ if (AdvanceIfMatch(parser, TokenType::RBracket))
+ break;
+
+ parser->ReadToken(TokenType::Comma);
+ }
+
+ if (hasDoubleBracket)
+ {
+ // Read the second ]
+ parser->ReadToken(TokenType::RBracket);
+ }
+ }
+
+ static TokenType peekTokenType(Parser* parser)
+ {
+ return parser->tokenReader.PeekTokenType();
+ }
+
+ static Token advanceToken(Parser* parser)
+ {
+ return parser->ReadToken();
+ }
+
+ static Token peekToken(Parser* parser)
+ {
+ return parser->tokenReader.PeekToken();
+ }
+
+ static SyntaxDecl* tryLookUpSyntaxDecl(
+ Parser* parser,
+ Name* name)
+ {
+ // Let's look up the name and see what we find.
+
+ auto lookupResult = lookUp(
+ parser->getSession(),
+ nullptr, // no semantics visitor available yet
+ name,
+ parser->currentScope);
+
+ // If we didn't find anything, or the result was overloaded,
+ // then we aren't going to be able to extract a single decl.
+ if(!lookupResult.isValid() || lookupResult.isOverloaded())
+ return nullptr;
+
+ auto decl = lookupResult.item.declRef.getDecl();
+ if( auto syntaxDecl = as<SyntaxDecl>(decl) )
+ {
+ return syntaxDecl;
+ }
+ else
+ {
+ return nullptr;
+ }
+ }
+
+ template<typename T>
+ bool tryParseUsingSyntaxDecl(
+ Parser* parser,
+ SyntaxDecl* syntaxDecl,
+ RefPtr<T>* outSyntax)
+ {
+ if (!syntaxDecl)
+ return false;
+
+ if (!syntaxDecl->syntaxClass.isSubClassOf<T>())
+ return false;
+
+ // Consume the token that specified the keyword
+ auto keywordToken = advanceToken(parser);
+
+ RefPtr<RefObject> parsedObject = syntaxDecl->parseCallback(parser, syntaxDecl->parseUserData);
+ if (!parsedObject)
+ {
+ return false;
+ }
+
+ auto syntax = as<T>(parsedObject);
+ if (syntax)
+ {
+ if (!syntax->loc.isValid())
+ {
+ syntax->loc = keywordToken.loc;
+ }
+ }
+ else if (parsedObject)
+ {
+ // Something was parsed, but it didn't have the expected type!
+ SLANG_DIAGNOSE_UNEXPECTED(parser->sink, keywordToken, "parser callback did not return the expected type");
+ }
+
+ *outSyntax = syntax;
+ return true;
+ }
+
+ template<typename T>
+ bool tryParseUsingSyntaxDecl(
+ Parser* parser,
+ RefPtr<T>* outSyntax)
+ {
+ if (peekTokenType(parser) != TokenType::Identifier)
+ return false;
+
+ auto nameToken = peekToken(parser);
+ auto name = nameToken.getName();
+
+ auto syntaxDecl = tryLookUpSyntaxDecl(parser, name);
+
+ if (!syntaxDecl)
+ return false;
+
+ return tryParseUsingSyntaxDecl(parser, syntaxDecl, outSyntax);
+ }
+
+ static Modifiers ParseModifiers(Parser* parser)
+ {
+ Modifiers modifiers;
+ RefPtr<Modifier>* modifierLink = &modifiers.first;
+ for (;;)
+ {
+ SourceLoc loc = parser->tokenReader.PeekLoc();
+
+ switch (peekTokenType(parser))
+ {
+ default:
+ // If we don't see a token type that we recognize, then
+ // assume we are done with the modifier sequence.
+ return modifiers;
+
+ case TokenType::Identifier:
+ {
+ // We see an identifier ahead, and it might be the name
+ // of a modifier keyword of some kind.
+
+ Token nameToken = peekToken(parser);
+
+ RefPtr<Modifier> parsedModifier;
+ if (tryParseUsingSyntaxDecl<Modifier>(parser, &parsedModifier))
+ {
+ parsedModifier->name = nameToken.getName();
+ if (!parsedModifier->loc.isValid())
+ {
+ parsedModifier->loc = nameToken.loc;
+ }
+
+ AddModifier(&modifierLink, parsedModifier);
+ continue;
+ }
+
+ // If there was no match for a modifier keyword, then we
+ // must be at the end of the modifier sequence
+ return modifiers;
+ }
+ break;
+
+ // HLSL uses `[attributeName]` style for its modifiers, which closely
+ // matches the C++ `[[attributeName]]` style.
+ case TokenType::LBracket:
+ ParseSquareBracketAttributes(parser, &modifierLink);
+ break;
+ }
+ }
+ }
+
+ static Name* getName(Parser* parser, String const& text)
+ {
+ return parser->getNamePool()->getName(text);
+ }
+
+ static NameLoc expectIdentifier(Parser* parser)
+ {
+ return NameLoc(parser->ReadToken(TokenType::Identifier));
+ }
+
+
+ static RefPtr<RefObject> parseImportDecl(
+ Parser* parser, void* /*userData*/)
+ {
+ parser->haveSeenAnyImportDecls = true;
+
+ auto decl = new ImportDecl();
+ decl->scope = parser->currentScope;
+
+ if (peekTokenType(parser) == TokenType::StringLiteral)
+ {
+ auto nameToken = parser->ReadToken(TokenType::StringLiteral);
+ auto nameString = getStringLiteralTokenValue(nameToken);
+ auto moduleName = getName(parser, nameString);
+
+ decl->moduleNameAndLoc = NameLoc(moduleName, nameToken.loc);
+ }
+ else
+ {
+ auto moduleNameAndLoc = expectIdentifier(parser);
+
+ // We allow a dotted format for the name, as sugar
+ if (peekTokenType(parser) == TokenType::Dot)
+ {
+ StringBuilder sb;
+ sb << getText(moduleNameAndLoc.name);
+ while (AdvanceIf(parser, TokenType::Dot))
+ {
+ sb << "/";
+ sb << parser->ReadToken(TokenType::Identifier).Content;
+ }
+
+ moduleNameAndLoc.name = getName(parser, sb.ProduceString());
+ }
+
+ decl->moduleNameAndLoc = moduleNameAndLoc;
+ }
+
+ parser->ReadToken(TokenType::Semicolon);
+
+ return decl;
+ }
+
+ static NameLoc ParseDeclName(
+ Parser* parser)
+ {
+ Token nameToken;
+ if (AdvanceIf(parser, "operator"))
+ {
+ nameToken = parser->ReadToken();
+ switch (nameToken.type)
+ {
+ case TokenType::OpAdd: case TokenType::OpSub: case TokenType::OpMul: case TokenType::OpDiv:
+ case TokenType::OpMod: case TokenType::OpNot: case TokenType::OpBitNot: case TokenType::OpLsh: case TokenType::OpRsh:
+ case TokenType::OpEql: case TokenType::OpNeq: case TokenType::OpGreater: case TokenType::OpLess: case TokenType::OpGeq:
+ case TokenType::OpLeq: case TokenType::OpAnd: case TokenType::OpOr: case TokenType::OpBitXor: case TokenType::OpBitAnd:
+ case TokenType::OpBitOr: case TokenType::OpInc: case TokenType::OpDec:
+ case TokenType::OpAddAssign:
+ case TokenType::OpSubAssign:
+ case TokenType::OpMulAssign:
+ case TokenType::OpDivAssign:
+ case TokenType::OpModAssign:
+ case TokenType::OpShlAssign:
+ case TokenType::OpShrAssign:
+ case TokenType::OpOrAssign:
+ case TokenType::OpAndAssign:
+ case TokenType::OpXorAssign:
+
+ // Note(tfoley): A bit of a hack:
+ case TokenType::Comma:
+ case TokenType::OpAssign:
+ break;
+
+ // Note(tfoley): Even more of a hack!
+ case TokenType::QuestionMark:
+ if (AdvanceIf(parser, TokenType::Colon))
+ {
+ // Concat : onto ?
+ nameToken.Content = UnownedStringSlice::fromLiteral("?:");
+ break;
+ }
+ ; // fall-thru
+ default:
+ parser->sink->diagnose(nameToken.loc, Diagnostics::invalidOperator, nameToken);
+ break;
+ }
+
+ return NameLoc(
+ getName(parser, nameToken.Content),
+ nameToken.loc);
+ }
+ else
+ {
+ nameToken = parser->ReadToken(TokenType::Identifier);
+ return NameLoc(nameToken);
+ }
+ }
+
+ // A "declarator" as used in C-style languages
+ struct Declarator : RefObject
+ {
+ // Different cases of declarator appear as "flavors" here
+ enum class Flavor
+ {
+ name,
+ Pointer,
+ Array,
+ };
+ Flavor flavor;
+ };
+
+ // The most common case of declarator uses a simple name
+ struct NameDeclarator : Declarator
+ {
+ NameLoc nameAndLoc;
+ };
+
+ // A declarator that declares a pointer type
+ struct PointerDeclarator : Declarator
+ {
+ // location of the `*` token
+ SourceLoc starLoc;
+
+ RefPtr<Declarator> inner;
+ };
+
+ // A declarator that declares an array type
+ struct ArrayDeclarator : Declarator
+ {
+ RefPtr<Declarator> inner;
+
+ // location of the `[` token
+ SourceLoc openBracketLoc;
+
+ // The expression that yields the element count, or NULL
+ RefPtr<Expr> elementCountExpr;
+ };
+
+ // "Unwrapped" information about a declarator
+ struct DeclaratorInfo
+ {
+ RefPtr<Expr> typeSpec;
+ NameLoc nameAndLoc;
+ RefPtr<Modifier> semantics;
+ RefPtr<Expr> initializer;
+ };
+
+ // Add a member declaration to its container, and ensure that its
+ // parent link is set up correctly.
+ static void AddMember(RefPtr<ContainerDecl> container, RefPtr<Decl> member)
+ {
+ if (container)
+ {
+ member->ParentDecl = container.Ptr();
+ container->Members.add(member);
+
+ container->memberDictionaryIsValid = false;
+ }
+ }
+
+ static void AddMember(RefPtr<Scope> scope, RefPtr<Decl> member)
+ {
+ if (scope)
+ {
+ AddMember(scope->containerDecl, member);
+ }
+ }
+
+ static RefPtr<Decl> ParseGenericParamDecl(
+ Parser* parser,
+ RefPtr<GenericDecl> genericDecl)
+ {
+ // simple syntax to introduce a value parameter
+ if (AdvanceIf(parser, "let"))
+ {
+ // default case is a type parameter
+ auto paramDecl = new GenericValueParamDecl();
+ paramDecl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
+ if (AdvanceIf(parser, TokenType::Colon))
+ {
+ paramDecl->type = parser->ParseTypeExp();
+ }
+ if (AdvanceIf(parser, TokenType::OpAssign))
+ {
+ paramDecl->initExpr = parser->ParseInitExpr();
+ }
+ return paramDecl;
+ }
+ else
+ {
+ // default case is a type parameter
+ RefPtr<GenericTypeParamDecl> paramDecl = new GenericTypeParamDecl();
+ parser->FillPosition(paramDecl);
+ paramDecl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
+ if (AdvanceIf(parser, TokenType::Colon))
+ {
+ // The user is apply a constraint to this type parameter...
+
+ auto paramConstraint = new GenericTypeConstraintDecl();
+ parser->FillPosition(paramConstraint);
+
+ auto paramType = DeclRefType::Create(
+ parser->getSession(),
+ DeclRef<Decl>(paramDecl, nullptr));
+
+ auto paramTypeExpr = new SharedTypeExpr();
+ paramTypeExpr->loc = paramDecl->loc;
+ paramTypeExpr->base.type = paramType;
+ paramTypeExpr->type = QualType(getTypeType(paramType));
+
+ paramConstraint->sub = TypeExp(paramTypeExpr);
+ paramConstraint->sup = parser->ParseTypeExp();
+
+ AddMember(genericDecl, paramConstraint);
+
+
+ }
+ if (AdvanceIf(parser, TokenType::OpAssign))
+ {
+ paramDecl->initType = parser->ParseTypeExp();
+ }
+ return paramDecl;
+ }
+ }
+
+ template<typename TFunc>
+ static void ParseGenericDeclImpl(
+ Parser* parser, GenericDecl* decl, const TFunc & parseInnerFunc)
+ {
+ parser->ReadToken(TokenType::OpLess);
+ parser->genericDepth++;
+ while (!parser->LookAheadToken(TokenType::OpGreater))
+ {
+ AddMember(decl, ParseGenericParamDecl(parser, decl));
+
+ if (parser->LookAheadToken(TokenType::OpGreater))
+ break;
+
+ parser->ReadToken(TokenType::Comma);
+ }
+ parser->genericDepth--;
+ parser->ReadToken(TokenType::OpGreater);
+ decl->inner = parseInnerFunc(decl);
+ decl->inner->ParentDecl = decl;
+
+ // A generic decl hijacks the name of the declaration
+ // it wraps, so that lookup can find it.
+ if (decl->inner)
+ {
+ decl->nameAndLoc = decl->inner->nameAndLoc;
+ decl->loc = decl->inner->loc;
+ }
+ }
+
+ template<typename ParseFunc>
+ static RefPtr<Decl> parseOptGenericDecl(
+ Parser* parser, const ParseFunc& parseInner)
+ {
+ // TODO: may want more advanced disambiguation than this...
+ if (parser->LookAheadToken(TokenType::OpLess))
+ {
+ RefPtr<GenericDecl> genericDecl = new GenericDecl();
+ parser->FillPosition(genericDecl);
+ parser->PushScope(genericDecl);
+ ParseGenericDeclImpl(parser, genericDecl, parseInner);
+ parser->PopScope();
+ return genericDecl;
+ }
+ else
+ {
+ return parseInner(nullptr);
+ }
+ }
+
+ static RefPtr<RefObject> ParseGenericDecl(Parser* parser, void*)
+ {
+ RefPtr<GenericDecl> decl = new GenericDecl();
+ parser->FillPosition(decl.Ptr());
+ parser->PushScope(decl.Ptr());
+ ParseGenericDeclImpl(parser, decl.Ptr(), [=](GenericDecl* genDecl) {return ParseSingleDecl(parser, genDecl); });
+ parser->PopScope();
+ return decl;
+ }
+
+ static void parseParameterList(
+ Parser* parser,
+ RefPtr<CallableDecl> decl)
+ {
+ parser->ReadToken(TokenType::LParent);
+
+ // Allow a declaration to use the keyword `void` for a parameter list,
+ // since that was required in ancient C, and continues to be supported
+ // in a bunc hof its derivatives even if it is a Bad Design Choice
+ //
+ // TODO: conditionalize this so we don't keep this around for "pure"
+ // Slang code
+ if( parser->LookAheadToken("void") && parser->LookAheadToken(TokenType::RParent, 1) )
+ {
+ parser->ReadToken("void");
+ parser->ReadToken(TokenType::RParent);
+ return;
+ }
+
+ while (!AdvanceIfMatch(parser, TokenType::RParent))
+ {
+ AddMember(decl, parser->ParseParameter());
+ if (AdvanceIf(parser, TokenType::RParent))
+ break;
+ parser->ReadToken(TokenType::Comma);
+ }
+ }
+
+ // systematically replace all scopes in an expression tree
+ class ReplaceScopeVisitor : public ExprVisitor<ReplaceScopeVisitor>
+ {
+ public:
+ RefPtr<Scope> scope;
+ void visitDeclRefExpr(DeclRefExpr* expr)
+ {
+ expr->scope = scope;
+ }
+ void visitGenericAppExpr(GenericAppExpr * expr)
+ {
+ expr->FunctionExpr->accept(this, nullptr);
+ for (auto arg : expr->Arguments)
+ arg->accept(this, nullptr);
+ }
+ void visitIndexExpr(IndexExpr * expr)
+ {
+ expr->BaseExpression->accept(this, nullptr);
+ expr->IndexExpression->accept(this, nullptr);
+ }
+ void visitMemberExpr(MemberExpr * expr)
+ {
+ expr->BaseExpression->accept(this, nullptr);
+ expr->scope = scope;
+ }
+ void visitStaticMemberExpr(StaticMemberExpr * expr)
+ {
+ expr->BaseExpression->accept(this, nullptr);
+ expr->scope = scope;
+ }
+ void visitExpr(Expr* /*expr*/)
+ {}
+ };
+
+ /// Parse an optional body statement for a declaration that can have a body.
+ static RefPtr<Stmt> parseOptBody(Parser* parser)
+ {
+ if (AdvanceIf(parser, TokenType::Semicolon))
+ {
+ // empty body
+ return nullptr;
+ }
+ else
+ {
+ return parser->parseBlockStatement();
+ }
+ }
+
+ /// Complete parsing of a function using traditional (C-like) declarator syntax
+ static RefPtr<Decl> parseTraditionalFuncDecl(
+ Parser* parser,
+ DeclaratorInfo const& declaratorInfo)
+ {
+ RefPtr<FuncDecl> decl = new FuncDecl();
+ parser->FillPosition(decl.Ptr());
+ decl->loc = declaratorInfo.nameAndLoc.loc;
+ decl->nameAndLoc = declaratorInfo.nameAndLoc;
+
+ return parseOptGenericDecl(parser, [&](GenericDecl*)
+ {
+ // HACK: The return type of the function will already have been
+ // parsed in a scope that didn't include the function's generic
+ // parameters.
+ //
+ // We will use a visitor here to try and replace the scope associated
+ // with any name expressiosn in the reuslt type.
+ //
+ // TODO: This should be fixed by not associating scopes with
+ // such expressions at parse time, and instead pushing down scopes
+ // as part of the state during semantic checking.
+ //
+ ReplaceScopeVisitor replaceScopeVisitor;
+ replaceScopeVisitor.scope = parser->currentScope;
+ declaratorInfo.typeSpec->accept(&replaceScopeVisitor, nullptr);
+
+ decl->ReturnType = TypeExp(declaratorInfo.typeSpec);
+
+ parser->PushScope(decl);
+
+ parseParameterList(parser, decl);
+ ParseOptSemantics(parser, decl.Ptr());
+ decl->Body = parseOptBody(parser);
+
+ parser->PopScope();
+
+ return decl;
+ });
+ }
+
+ static RefPtr<VarDeclBase> CreateVarDeclForContext(
+ ContainerDecl* containerDecl )
+ {
+ if (as<CallableDecl>(containerDecl))
+ {
+ // Function parameters always use their dedicated syntax class.
+ //
+ return new ParamDecl();
+ }
+ else
+ {
+ // Globals, locals, and member variables all use the same syntax class.
+ //
+ return new VarDecl();
+ }
+ }
+
+ // Add modifiers to the end of the modifier list for a declaration
+ void AddModifiers(Decl* decl, RefPtr<Modifier> modifiers)
+ {
+ if (!modifiers)
+ return;
+
+ RefPtr<Modifier>* link = &decl->modifiers.first;
+ while (*link)
+ {
+ link = &(*link)->next;
+ }
+ *link = modifiers;
+ }
+
+ static Name* generateName(Parser* parser, String const& base)
+ {
+ // TODO: somehow mangle the name to avoid clashes
+ return getName(parser, "SLANG_" + base);
+ }
+
+ static Name* generateName(Parser* parser)
+ {
+ return generateName(parser, "anonymous_" + String(parser->anonymousCounter++));
+ }
+
+
+ // Set up a variable declaration based on what we saw in its declarator...
+ static void CompleteVarDecl(
+ Parser* parser,
+ RefPtr<VarDeclBase> decl,
+ DeclaratorInfo const& declaratorInfo)
+ {
+ parser->FillPosition(decl.Ptr());
+
+ if( !declaratorInfo.nameAndLoc.name )
+ {
+ // HACK(tfoley): we always give a name, even if the declarator didn't include one... :(
+ decl->nameAndLoc = NameLoc(generateName(parser));
+ }
+ else
+ {
+ decl->loc = declaratorInfo.nameAndLoc.loc;
+ decl->nameAndLoc = declaratorInfo.nameAndLoc;
+ }
+ decl->type = TypeExp(declaratorInfo.typeSpec);
+
+ AddModifiers(decl.Ptr(), declaratorInfo.semantics);
+
+ decl->initExpr = declaratorInfo.initializer;
+ }
+
+ static RefPtr<Declarator> ParseDeclarator(Parser* parser);
+
+ static RefPtr<Declarator> ParseDirectAbstractDeclarator(
+ Parser* parser)
+ {
+ RefPtr<Declarator> declarator;
+ switch( parser->tokenReader.PeekTokenType() )
+ {
+ case TokenType::Identifier:
+ {
+ auto nameDeclarator = new NameDeclarator();
+ nameDeclarator->flavor = Declarator::Flavor::name;
+ nameDeclarator->nameAndLoc = ParseDeclName(parser);
+ declarator = nameDeclarator;
+ }
+ break;
+
+ case TokenType::LParent:
+ {
+ // Note(tfoley): This is a point where disambiguation is required.
+ // We could be looking at an abstract declarator for a function-type
+ // parameter:
+ //
+ // void F( int(int) );
+ //
+ // Or we could be looking at the use of parenthesese in an ordinary
+ // declarator:
+ //
+ // void (*f)(int);
+ //
+ // The difference really doesn't matter right now, but we err in
+ // the direction of assuming the second case.
+ parser->ReadToken(TokenType::LParent);
+ declarator = ParseDeclarator(parser);
+ parser->ReadToken(TokenType::RParent);
+ }
+ break;
+
+ default:
+ // an empty declarator is allowed
+ return nullptr;
+ }
+
+ // postifx additions
+ for( ;;)
+ {
+ switch( parser->tokenReader.PeekTokenType() )
+ {
+ case TokenType::LBracket:
+ {
+ auto arrayDeclarator = new ArrayDeclarator();
+ arrayDeclarator->openBracketLoc = parser->tokenReader.PeekLoc();
+ arrayDeclarator->flavor = Declarator::Flavor::Array;
+ arrayDeclarator->inner = declarator;
+
+ parser->ReadToken(TokenType::LBracket);
+ if( parser->tokenReader.PeekTokenType() != TokenType::RBracket )
+ {
+ arrayDeclarator->elementCountExpr = parser->ParseExpression();
+ }
+ parser->ReadToken(TokenType::RBracket);
+
+ declarator = arrayDeclarator;
+ continue;
+ }
+
+ case TokenType::LParent:
+ break;
+
+ default:
+ break;
+ }
+
+ break;
+ }
+
+ return declarator;
+ }
+
+ // Parse a declarator (or at least as much of one as we support)
+ static RefPtr<Declarator> ParseDeclarator(
+ Parser* parser)
+ {
+ if( parser->tokenReader.PeekTokenType() == TokenType::OpMul )
+ {
+ auto ptrDeclarator = new PointerDeclarator();
+ ptrDeclarator->starLoc = parser->tokenReader.PeekLoc();
+ ptrDeclarator->flavor = Declarator::Flavor::Pointer;
+
+ parser->ReadToken(TokenType::OpMul);
+
+ // TODO(tfoley): allow qualifiers like `const` here?
+
+ ptrDeclarator->inner = ParseDeclarator(parser);
+ return ptrDeclarator;
+ }
+ else
+ {
+ return ParseDirectAbstractDeclarator(parser);
+ }
+ }
+
+ // A declarator plus optional semantics and initializer
+ struct InitDeclarator
+ {
+ RefPtr<Declarator> declarator;
+ RefPtr<Modifier> semantics;
+ RefPtr<Expr> initializer;
+ };
+
+ // Parse a declarator plus optional semantics
+ static InitDeclarator ParseSemanticDeclarator(
+ Parser* parser)
+ {
+ InitDeclarator result;
+ result.declarator = ParseDeclarator(parser);
+ result.semantics = ParseOptSemantics(parser);
+ return result;
+ }
+
+ // Parse a declarator plus optional semantics and initializer
+ static InitDeclarator ParseInitDeclarator(
+ Parser* parser)
+ {
+ InitDeclarator result = ParseSemanticDeclarator(parser);
+ if (AdvanceIf(parser, TokenType::OpAssign))
+ {
+ result.initializer = parser->ParseInitExpr();
+ }
+ return result;
+ }
+
+ static void UnwrapDeclarator(
+ RefPtr<Declarator> declarator,
+ DeclaratorInfo* ioInfo)
+ {
+ while( declarator )
+ {
+ switch(declarator->flavor)
+ {
+ case Declarator::Flavor::name:
+ {
+ auto nameDeclarator = (NameDeclarator*) declarator.Ptr();
+ ioInfo->nameAndLoc = nameDeclarator->nameAndLoc;
+ return;
+ }
+ break;
+
+ case Declarator::Flavor::Pointer:
+ {
+ auto ptrDeclarator = (PointerDeclarator*) declarator.Ptr();
+
+ // TODO(tfoley): we don't support pointers for now
+ // ioInfo->typeSpec = new PointerTypeExpr(ioInfo->typeSpec);
+
+ declarator = ptrDeclarator->inner;
+ }
+ break;
+
+ case Declarator::Flavor::Array:
+ {
+ // TODO(tfoley): we don't support pointers for now
+ auto arrayDeclarator = (ArrayDeclarator*) declarator.Ptr();
+
+ auto arrayTypeExpr = new IndexExpr();
+ arrayTypeExpr->loc = arrayDeclarator->openBracketLoc;
+ arrayTypeExpr->BaseExpression = ioInfo->typeSpec;
+ arrayTypeExpr->IndexExpression = arrayDeclarator->elementCountExpr;
+ ioInfo->typeSpec = arrayTypeExpr;
+
+ declarator = arrayDeclarator->inner;
+ }
+ break;
+
+ default:
+ SLANG_UNREACHABLE("all cases handled");
+ break;
+ }
+ }
+ }
+
+ static void UnwrapDeclarator(
+ InitDeclarator const& initDeclarator,
+ DeclaratorInfo* ioInfo)
+ {
+ UnwrapDeclarator(initDeclarator.declarator, ioInfo);
+ ioInfo->semantics = initDeclarator.semantics;
+ ioInfo->initializer = initDeclarator.initializer;
+ }
+
+ // Either a single declaration, or a group of them
+ struct DeclGroupBuilder
+ {
+ SourceLoc startPosition;
+ RefPtr<Decl> decl;
+ RefPtr<DeclGroup> group;
+
+ // Add a new declaration to the potential group
+ void addDecl(
+ RefPtr<Decl> newDecl)
+ {
+ SLANG_ASSERT(newDecl);
+
+ if( decl )
+ {
+ group = new DeclGroup();
+ group->loc = startPosition;
+ group->decls.add(decl);
+ decl = nullptr;
+ }
+
+ if( group )
+ {
+ group->decls.add(newDecl);
+ }
+ else
+ {
+ decl = newDecl;
+ }
+ }
+
+ RefPtr<DeclBase> getResult()
+ {
+ if(group) return group;
+ return decl;
+ }
+ };
+
+ // Pares an argument to an application of a generic
+ RefPtr<Expr> ParseGenericArg(Parser* parser)
+ {
+ return parser->ParseArgExpr();
+ }
+
+ // Create a type expression that will refer to the given declaration
+ static RefPtr<Expr>
+ createDeclRefType(Parser* parser, RefPtr<Decl> decl)
+ {
+ // For now we just construct an expression that
+ // will look up the given declaration by name.
+ //
+ // TODO: do this better, e.g. by filling in the `declRef` field directly
+
+ auto expr = new VarExpr();
+ expr->scope = parser->currentScope.Ptr();
+ expr->loc = decl->getNameLoc();
+ expr->name = decl->getName();
+ return expr;
+ }
+
+ // Representation for a parsed type specifier, which might
+ // include a declaration (e.g., of a `struct` type)
+ struct TypeSpec
+ {
+ // If the type-spec declared something, then put it here
+ RefPtr<Decl> decl;
+
+ // Put the resulting expression (which should evaluate to a type) here
+ RefPtr<Expr> expr;
+ };
+
+ static RefPtr<Expr> parseGenericApp(
+ Parser* parser,
+ RefPtr<Expr> base)
+ {
+ RefPtr<GenericAppExpr> genericApp = new GenericAppExpr();
+
+ parser->FillPosition(genericApp.Ptr()); // set up scope for lookup
+ genericApp->FunctionExpr = base;
+ parser->ReadToken(TokenType::OpLess);
+ parser->genericDepth++;
+ // For now assume all generics have at least one argument
+ genericApp->Arguments.add(ParseGenericArg(parser));
+ while (AdvanceIf(parser, TokenType::Comma))
+ {
+ genericApp->Arguments.add(ParseGenericArg(parser));
+ }
+ parser->genericDepth--;
+
+ if (parser->tokenReader.PeekToken().type == TokenType::OpRsh)
+ {
+ parser->tokenReader.PeekToken().type = TokenType::OpGreater;
+ parser->tokenReader.PeekToken().loc.setRaw(parser->tokenReader.PeekToken().loc.getRaw() + 1);
+ }
+ else if (parser->LookAheadToken(TokenType::OpGreater))
+ parser->ReadToken(TokenType::OpGreater);
+ else
+ parser->sink->diagnose(parser->tokenReader.PeekToken(), Diagnostics::tokenTypeExpected, "'>'");
+ return genericApp;
+ }
+
+ static bool isGenericName(Parser* parser, Name* name)
+ {
+ auto lookupResult = lookUp(
+ parser->getSession(),
+ nullptr, // no semantics visitor available yet
+ name,
+ parser->currentScope);
+ if (!lookupResult.isValid() || lookupResult.isOverloaded())
+ return false;
+
+ return lookupResult.item.declRef.is<GenericDecl>();
+ }
+
+ static RefPtr<Expr> tryParseGenericApp(
+ Parser* parser,
+ RefPtr<Expr> base)
+ {
+ Name * baseName = nullptr;
+ if (auto varExpr = as<VarExpr>(base))
+ baseName = varExpr->name;
+ // if base is a known generics, parse as generics
+ if (baseName && isGenericName(parser, baseName))
+ return parseGenericApp(parser, base);
+
+ // otherwise, we speculate as generics, and fallback to comparison when parsing failed
+ TokenSpan tokenSpan;
+ tokenSpan.mBegin = parser->tokenReader.mCursor;
+ tokenSpan.mEnd = parser->tokenReader.mEnd;
+ DiagnosticSink newSink;
+ newSink.sourceManager = parser->sink->sourceManager;
+ Parser newParser(*parser);
+ newParser.sink = &newSink;
+ auto speculateParseRs = parseGenericApp(&newParser, base);
+ if (newSink.errorCount == 0)
+ {
+ // disambiguate based on FOLLOW set
+ switch (peekTokenType(&newParser))
+ {
+ case TokenType::Dot:
+ case TokenType::LParent:
+ case TokenType::RParent:
+ case TokenType::RBracket:
+ case TokenType::Colon:
+ case TokenType::Comma:
+ case TokenType::QuestionMark:
+ case TokenType::Semicolon:
+ case TokenType::OpEql:
+ case TokenType::OpNeq:
+ {
+ return parseGenericApp(parser, base);
+ }
+ }
+ }
+ return base;
+ }
+ static RefPtr<Expr> parseMemberType(Parser * parser, RefPtr<Expr> base)
+ {
+ // When called the :: or . have been consumed, so don't need to consume here.
+
+ RefPtr<MemberExpr> memberExpr = new MemberExpr();
+
+ parser->FillPosition(memberExpr.Ptr());
+ memberExpr->BaseExpression = base;
+ memberExpr->name = expectIdentifier(parser).name;
+ return memberExpr;
+ }
+
+ // Parse option `[]` braces after a type expression, that indicate an array type
+ static RefPtr<Expr> parsePostfixTypeSuffix(
+ Parser* parser,
+ RefPtr<Expr> inTypeExpr)
+ {
+ auto typeExpr = inTypeExpr;
+ while (parser->LookAheadToken(TokenType::LBracket))
+ {
+ RefPtr<IndexExpr> arrType = new IndexExpr();
+ arrType->loc = typeExpr->loc;
+ arrType->BaseExpression = typeExpr;
+ parser->ReadToken(TokenType::LBracket);
+ if (!parser->LookAheadToken(TokenType::RBracket))
+ {
+ arrType->IndexExpression = parser->ParseExpression();
+ }
+ parser->ReadToken(TokenType::RBracket);
+ typeExpr = arrType;
+ }
+ return typeExpr;
+ }
+
+ static RefPtr<Expr> parseTaggedUnionType(Parser* parser)
+ {
+ RefPtr<TaggedUnionTypeExpr> taggedUnionType = new TaggedUnionTypeExpr();
+
+ parser->ReadToken(TokenType::LParent);
+ while(!AdvanceIfMatch(parser, TokenType::RParent))
+ {
+ auto caseType = parser->ParseTypeExp();
+ taggedUnionType->caseTypes.add(caseType);
+
+ if(AdvanceIf(parser, TokenType::RParent))
+ break;
+
+ parser->ReadToken(TokenType::Comma);
+ }
+
+ return taggedUnionType;
+ }
+
+ static TypeSpec parseTypeSpec(Parser* parser)
+ {
+ TypeSpec typeSpec;
+
+ // We may see a `struct` (or `enum` or `class`) tag specified here, and need to act accordingly
+ //
+ // TODO(tfoley): Handle the case where the user is just using `struct`
+ // as a way to name an existing struct "tag" (e.g., `struct Foo foo;`)
+ //
+ // TODO: We should really make these keywords be registered like any other
+ // syntax category, rather than be special-cased here. The main issue here
+ // is that we need to allow them to be used as type specifiers, as in:
+ //
+ // struct Foo { int x } foo;
+ //
+ // The ideal answer would be to register certain keywords as being able
+ // to parse a type specifier, and look for those keywords here.
+ // We should ideally add special case logic that bails out of declarator
+ // parsing iff we have one of these kinds of type specifiers and the
+ // closing `}` is at the end of its line, as a bit of a special case
+ // to allow the common idiom.
+ //
+ if( parser->LookAheadToken("struct") )
+ {
+ auto decl = parser->ParseStruct();
+ typeSpec.decl = decl;
+ typeSpec.expr = createDeclRefType(parser, decl);
+ return typeSpec;
+ }
+ else if( parser->LookAheadToken("class") )
+ {
+ auto decl = parser->ParseClass();
+ typeSpec.decl = decl;
+ typeSpec.expr = createDeclRefType(parser, decl);
+ return typeSpec;
+ }
+ else if(parser->LookAheadToken("enum"))
+ {
+ auto decl = parseEnumDecl(parser);
+ typeSpec.decl = decl;
+ typeSpec.expr = createDeclRefType(parser, decl);
+ return typeSpec;
+ }
+ else if(AdvanceIf(parser, "__TaggedUnion"))
+ {
+ typeSpec.expr = parseTaggedUnionType(parser);
+ return typeSpec;
+ }
+
+ Token typeName = parser->ReadToken(TokenType::Identifier);
+
+ auto basicType = new VarExpr();
+ basicType->scope = parser->currentScope.Ptr();
+ basicType->loc = typeName.loc;
+ basicType->name = typeName.getNameOrNull();
+
+ RefPtr<Expr> typeExpr = basicType;
+
+ bool shouldLoop = true;
+ while (shouldLoop)
+ {
+ switch (peekTokenType(parser))
+ {
+ case TokenType::OpLess:
+ typeExpr = parseGenericApp(parser, typeExpr);
+ break;
+ case TokenType::Scope:
+ parser->ReadToken(TokenType::Scope);
+ typeExpr = parseMemberType(parser, typeExpr);
+ break;
+ case TokenType::Dot:
+ parser->ReadToken(TokenType::Dot);
+ typeExpr = parseMemberType(parser, typeExpr);
+ break;
+ default:
+ shouldLoop = false;
+ }
+ }
+
+ typeSpec.expr = typeExpr;
+ return typeSpec;
+ }
+
+ static RefPtr<DeclBase> ParseDeclaratorDecl(
+ Parser* parser,
+ ContainerDecl* containerDecl)
+ {
+ SourceLoc startPosition = parser->tokenReader.PeekLoc();
+
+ auto typeSpec = parseTypeSpec(parser);
+
+ // We may need to build up multiple declarations in a group,
+ // but the common case will be when we have just a single
+ // declaration
+ DeclGroupBuilder declGroupBuilder;
+ declGroupBuilder.startPosition = startPosition;
+
+ // The type specifier may include a declaration. E.g.,
+ // it might declare a `struct` type.
+ if(typeSpec.decl)
+ declGroupBuilder.addDecl(typeSpec.decl);
+
+ if( AdvanceIf(parser, TokenType::Semicolon) )
+ {
+ // No actual variable is being declared here, but
+ // that might not be an error.
+
+ auto result = declGroupBuilder.getResult();
+ if( !result )
+ {
+ parser->sink->diagnose(startPosition, Diagnostics::declarationDidntDeclareAnything);
+ }
+ return result;
+ }
+
+ // It is possible that we have a plain `struct`, `enum`,
+ // or similar declaration that isn't being used to declare
+ // any variable, and the user didn't put a trailing
+ // semicolon on it:
+ //
+ // struct Batman
+ // {
+ // int cape;
+ // }
+ //
+ // We want to allow this syntax (rather than give an
+ // inscrutable error), but also support the less common
+ // idiom where that declaration is used as part of
+ // a variable declaration:
+ //
+ // struct Robin
+ // {
+ // float tights;
+ // } boyWonder;
+ //
+ // As a bit of a hack (insofar as it means we aren't
+ // *really* compatible with arbitrary HLSL code), we
+ // will check if there are any more tokens on the
+ // same line as the closing `}`, and if not, we
+ // will treat it like the end of the declaration.
+ //
+ // Just as a safety net, only apply this logic for
+ // a file that is being passed in as "true" Slang code.
+ //
+ if(parser->getSourceLanguage() == SourceLanguage::Slang)
+ {
+ if(typeSpec.decl)
+ {
+ if(peekToken(parser).flags & TokenFlag::AtStartOfLine)
+ {
+ // The token after the `}` is at the start of its
+ // own line, which means it can't be on the same line.
+ //
+ // This means the programmer probably wants to
+ // just treat this as a declaration.
+ return declGroupBuilder.getResult();
+ }
+ }
+ }
+
+
+ InitDeclarator initDeclarator = ParseInitDeclarator(parser);
+
+ DeclaratorInfo declaratorInfo;
+ declaratorInfo.typeSpec = typeSpec.expr;
+
+
+ // Rather than parse function declarators properly for now,
+ // we'll just do a quick disambiguation here. This won't
+ // matter unless we actually decide to support function-type parameters,
+ // using C syntax.
+ //
+ if ((parser->tokenReader.PeekTokenType() == TokenType::LParent ||
+ parser->tokenReader.PeekTokenType() == TokenType::OpLess)
+
+ // Only parse as a function if we didn't already see mutually-exclusive
+ // constructs when parsing the declarator.
+ && !initDeclarator.initializer
+ && !initDeclarator.semantics)
+ {
+ // Looks like a function, so parse it like one.
+ UnwrapDeclarator(initDeclarator, &declaratorInfo);
+ return parseTraditionalFuncDecl(parser, declaratorInfo);
+ }
+
+ // Otherwise we are looking at a variable declaration, which could be one in a sequence...
+
+ if( AdvanceIf(parser, TokenType::Semicolon) )
+ {
+ // easy case: we only had a single declaration!
+ UnwrapDeclarator(initDeclarator, &declaratorInfo);
+ RefPtr<VarDeclBase> firstDecl = CreateVarDeclForContext(containerDecl);
+ CompleteVarDecl(parser, firstDecl, declaratorInfo);
+
+ declGroupBuilder.addDecl(firstDecl);
+ return declGroupBuilder.getResult();
+ }
+
+ // Otherwise we have multiple declarations in a sequence, and these
+ // declarations need to somehow share both the type spec and modifiers.
+ //
+ // If there are any errors in the type specifier, we only want to hear
+ // about it once, so we need to share structure rather than just
+ // clone syntax.
+
+ auto sharedTypeSpec = new SharedTypeExpr();
+ sharedTypeSpec->loc = typeSpec.expr->loc;
+ sharedTypeSpec->base = TypeExp(typeSpec.expr);
+
+ for(;;)
+ {
+ declaratorInfo.typeSpec = sharedTypeSpec;
+ UnwrapDeclarator(initDeclarator, &declaratorInfo);
+
+ RefPtr<VarDeclBase> varDecl = CreateVarDeclForContext(containerDecl);
+ CompleteVarDecl(parser, varDecl, declaratorInfo);
+
+ declGroupBuilder.addDecl(varDecl);
+
+ // end of the sequence?
+ if(AdvanceIf(parser, TokenType::Semicolon))
+ return declGroupBuilder.getResult();
+
+ // ad-hoc recovery, to avoid infinite loops
+ if( parser->isRecovering )
+ {
+ parser->ReadToken(TokenType::Semicolon);
+ return declGroupBuilder.getResult();
+ }
+
+ // Let's default to assuming that a missing `,`
+ // indicates the end of a declaration,
+ // where a `;` would be expected, and not
+ // a continuation of this declaration, where
+ // a `,` would be expected (this is tailoring
+ // the diagnostic message a bit).
+ //
+ // TODO: a more advanced heuristic here might
+ // look at whether the next token is on the
+ // same line, to predict whether `,` or `;`
+ // would be more likely...
+
+ if (!AdvanceIf(parser, TokenType::Comma))
+ {
+ parser->ReadToken(TokenType::Semicolon);
+ return declGroupBuilder.getResult();
+ }
+
+ // expect another variable declaration...
+ initDeclarator = ParseInitDeclarator(parser);
+ }
+ }
+
+ /// Parse the "register name" part of a `register` or `packoffset` semantic.
+ ///
+ /// The syntax matched is:
+ ///
+ /// register-name-and-component-mask ::= register-name component-mask?
+ /// register-name ::= identifier
+ /// component-mask ::= '.' identifier
+ ///
+ static void parseHLSLRegisterNameAndOptionalComponentMask(
+ Parser* parser,
+ HLSLLayoutSemantic* semantic)
+ {
+ semantic->registerName = parser->ReadToken(TokenType::Identifier);
+ if (AdvanceIf(parser, TokenType::Dot))
+ {
+ semantic->componentMask = parser->ReadToken(TokenType::Identifier);
+ }
+ }
+
+ /// Parse an HLSL `register` semantic.
+ ///
+ /// The syntax matched is:
+ ///
+ /// register-semantic ::= 'register' '(' register-name-and-component-mask register-space? ')'
+ /// register-space ::= ',' identifier
+ ///
+ static void parseHLSLRegisterSemantic(
+ Parser* parser,
+ HLSLRegisterSemantic* semantic)
+ {
+ // Read the `register` keyword
+ semantic->name = parser->ReadToken(TokenType::Identifier);
+
+ // Expect a parenthized list of additional arguments
+ parser->ReadToken(TokenType::LParent);
+
+ // First argument is a required register name and optional component mask
+ parseHLSLRegisterNameAndOptionalComponentMask(parser, semantic);
+
+ // Second argument is an optional register space
+ if(AdvanceIf(parser, TokenType::Comma))
+ {
+ semantic->spaceName = parser->ReadToken(TokenType::Identifier);
+ }
+
+ parser->ReadToken(TokenType::RParent);
+ }
+
+ /// Parse an HLSL `packoffset` semantic.
+ ///
+ /// The syntax matched is:
+ ///
+ /// packoffset-semantic ::= 'packoffset' '(' register-name-and-component-mask ')'
+ ///
+ static void parseHLSLPackOffsetSemantic(
+ Parser* parser,
+ HLSLPackOffsetSemantic* semantic)
+ {
+ // Read the `packoffset` keyword
+ semantic->name = parser->ReadToken(TokenType::Identifier);
+
+ // Expect a parenthized list of additional arguments
+ parser->ReadToken(TokenType::LParent);
+
+ // First and only argument is a required register name and optional component mask
+ parseHLSLRegisterNameAndOptionalComponentMask(parser, semantic);
+
+ parser->ReadToken(TokenType::RParent);
+
+ parser->sink->diagnose(semantic, Diagnostics::packOffsetNotSupported);
+ }
+
+ //
+ // semantic ::= identifier ( '(' args ')' )?
+ //
+ static RefPtr<Modifier> ParseSemantic(
+ Parser* parser)
+ {
+ if (parser->LookAheadToken("register"))
+ {
+ RefPtr<HLSLRegisterSemantic> semantic = new HLSLRegisterSemantic();
+ parser->FillPosition(semantic);
+ parseHLSLRegisterSemantic(parser, semantic.Ptr());
+ return semantic;
+ }
+ else if (parser->LookAheadToken("packoffset"))
+ {
+ RefPtr<HLSLPackOffsetSemantic> semantic = new HLSLPackOffsetSemantic();
+ parser->FillPosition(semantic);
+ parseHLSLPackOffsetSemantic(parser, semantic.Ptr());
+ return semantic;
+ }
+ else if (parser->LookAheadToken(TokenType::Identifier))
+ {
+ RefPtr<HLSLSimpleSemantic> semantic = new HLSLSimpleSemantic();
+ parser->FillPosition(semantic);
+ semantic->name = parser->ReadToken(TokenType::Identifier);
+ return semantic;
+ }
+ else
+ {
+ // expect an identifier, just to produce an error message
+ parser->ReadToken(TokenType::Identifier);
+ return nullptr;
+ }
+ }
+
+ //
+ // opt-semantics ::= (':' semantic)*
+ //
+ static RefPtr<Modifier> ParseOptSemantics(
+ Parser* parser)
+ {
+ if (!AdvanceIf(parser, TokenType::Colon))
+ return nullptr;
+
+ RefPtr<Modifier> result;
+ RefPtr<Modifier>* link = &result;
+ SLANG_ASSERT(!*link);
+
+ for (;;)
+ {
+ RefPtr<Modifier> semantic = ParseSemantic(parser);
+ if (semantic)
+ {
+ *link = semantic;
+ link = &semantic->next;
+ }
+
+ // If we see another `:`, then that means there
+ // is yet another semantic to be processed.
+ // Otherwise we assume we are at the end of the list.
+ //
+ // TODO: This could produce sub-optimal diagnostics
+ // when the user *meant* to apply multiple semantics
+ // to a single declaration:
+ //
+ // Foo foo : register(t0) register(s0);
+ // ^
+ // missing ':' here |
+ //
+ // However, that is an uncommon occurence, and trying
+ // to continue parsing semantics here even if we didn't
+ // see a colon forces us to be careful about
+ // avoiding an infinite loop here.
+ if (!AdvanceIf(parser, TokenType::Colon))
+ {
+ return result;
+ }
+ }
+
+ }
+
+
+ static void ParseOptSemantics(
+ Parser* parser,
+ Decl* decl)
+ {
+ AddModifiers(decl, ParseOptSemantics(parser));
+ }
+
+ static RefPtr<Decl> ParseHLSLBufferDecl(
+ Parser* parser,
+ String bufferWrapperTypeName)
+ {
+ // An HLSL declaration of a constant buffer like this:
+ //
+ // cbuffer Foo : register(b0) { int a; float b; };
+ //
+ // is treated as syntax sugar for a type declaration
+ // and then a global variable declaration using that type:
+ //
+ // struct $anonymous { int a; float b; };
+ // ConstantBuffer<$anonymous> Foo;
+ //
+ // where `$anonymous` is a fresh name, and the variable
+ // declaration is made to be "transparent" so that lookup
+ // will see through it to the members inside.
+
+ auto bufferWrapperTypeNamePos = parser->tokenReader.PeekLoc();
+
+ // We are going to represent each buffer as a pair of declarations.
+ // The first is a type declaration that holds all the members, while
+ // the second is a variable declaration that uses the buffer type.
+ RefPtr<StructDecl> bufferDataTypeDecl = new StructDecl();
+ RefPtr<VarDecl> bufferVarDecl = new VarDecl();
+
+ // Both declarations will have a location that points to the name
+ parser->FillPosition(bufferDataTypeDecl.Ptr());
+ parser->FillPosition(bufferVarDecl.Ptr());
+
+ auto reflectionNameToken = parser->ReadToken(TokenType::Identifier);
+
+ // Attach the reflection name to the block so we can use it
+ auto reflectionNameModifier = new ParameterGroupReflectionName();
+ reflectionNameModifier->nameAndLoc = NameLoc(reflectionNameToken);
+ addModifier(bufferVarDecl, reflectionNameModifier);
+
+ // Both the buffer variable and its type need to have names generated
+ bufferVarDecl->nameAndLoc.name = generateName(parser, "parameterGroup_" + String(reflectionNameToken.Content));
+ bufferDataTypeDecl->nameAndLoc.name = generateName(parser, "ParameterGroup_" + String(reflectionNameToken.Content));
+
+ addModifier(bufferDataTypeDecl, new ImplicitParameterGroupElementTypeModifier());
+ addModifier(bufferVarDecl, new ImplicitParameterGroupVariableModifier());
+
+ // TODO(tfoley): We end up constructing unchecked syntax here that
+ // is expected to type check into the right form, but it might be
+ // cleaner to have a more explicit desugaring pass where we parse
+ // these constructs directly into the AST and *then* desugar them.
+
+ // Construct a type expression to reference the buffer data type
+ auto bufferDataTypeExpr = new VarExpr();
+ bufferDataTypeExpr->loc = bufferDataTypeDecl->loc;
+ bufferDataTypeExpr->name = bufferDataTypeDecl->nameAndLoc.name;
+ bufferDataTypeExpr->scope = parser->currentScope.Ptr();
+
+ // Construct a type expression to reference the type constructor
+ auto bufferWrapperTypeExpr = new VarExpr();
+ bufferWrapperTypeExpr->loc = bufferWrapperTypeNamePos;
+ bufferWrapperTypeExpr->name = getName(parser, bufferWrapperTypeName);
+
+ // Always need to look this up in the outer scope,
+ // so that it won't collide with, e.g., a local variable called `ConstantBuffer`
+ bufferWrapperTypeExpr->scope = parser->outerScope;
+
+ // Construct a type expression that represents the type for the variable,
+ // which is the wrapper type applied to the data type
+ auto bufferVarTypeExpr = new GenericAppExpr();
+ bufferVarTypeExpr->loc = bufferVarDecl->loc;
+ bufferVarTypeExpr->FunctionExpr = bufferWrapperTypeExpr;
+ bufferVarTypeExpr->Arguments.add(bufferDataTypeExpr);
+
+ bufferVarDecl->type.exp = bufferVarTypeExpr;
+
+ // Any semantics applied to the buffer declaration are taken as applying
+ // to the variable instead.
+ ParseOptSemantics(parser, bufferVarDecl.Ptr());
+
+ // The declarations in the body belong to the data type.
+ parseAggTypeDeclBody(parser, bufferDataTypeDecl.Ptr());
+
+ // All HLSL buffer declarations are "transparent" in that their
+ // members are implicitly made visible in the parent scope.
+ // We achieve this by applying the transparent modifier to the variable.
+ auto transparentModifier = new TransparentModifier();
+ transparentModifier->next = bufferVarDecl->modifiers.first;
+ bufferVarDecl->modifiers.first = transparentModifier;
+
+ // Because we are constructing two declarations, we have a thorny
+ // issue that were are only supposed to return one.
+ // For now we handle this by adding the type declaration to
+ // the current scope manually, and then returning the variable
+ // declaration.
+ //
+ // Note: this means that any modifiers that have already been parsed
+ // will get attached to the variable declaration, not the type.
+ // There might be cases where we need to shuffle things around.
+
+ AddMember(parser->currentScope, bufferDataTypeDecl);
+
+ return bufferVarDecl;
+ }
+
+ static RefPtr<RefObject> parseHLSLCBufferDecl(
+ Parser* parser, void* /*userData*/)
+ {
+ return ParseHLSLBufferDecl(parser, "ConstantBuffer");
+ }
+
+ static RefPtr<RefObject> parseHLSLTBufferDecl(
+ Parser* parser, void* /*userData*/)
+ {
+ return ParseHLSLBufferDecl(parser, "TextureBuffer");
+ }
+
+ static void parseOptionalInheritanceClause(Parser* parser, AggTypeDeclBase* decl)
+ {
+ if (AdvanceIf(parser, TokenType::Colon))
+ {
+ do
+ {
+ auto base = parser->ParseTypeExp();
+
+ auto inheritanceDecl = new InheritanceDecl();
+ inheritanceDecl->loc = base.exp->loc;
+ inheritanceDecl->nameAndLoc.name = getName(parser, "$inheritance");
+ inheritanceDecl->base = base;
+
+ AddMember(decl, inheritanceDecl);
+
+ } while (AdvanceIf(parser, TokenType::Comma));
+ }
+ }
+
+ static RefPtr<RefObject> ParseExtensionDecl(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<ExtensionDecl> decl = new ExtensionDecl();
+ parser->FillPosition(decl.Ptr());
+ decl->targetType = parser->ParseTypeExp();
+ parseOptionalInheritanceClause(parser, decl);
+ parseAggTypeDeclBody(parser, decl.Ptr());
+
+ return decl;
+ }
+
+
+ void parseOptionalGenericConstraints(Parser * parser, ContainerDecl* decl)
+ {
+ if (AdvanceIf(parser, TokenType::Colon))
+ {
+ do
+ {
+ RefPtr<GenericTypeConstraintDecl> paramConstraint = new GenericTypeConstraintDecl();
+ parser->FillPosition(paramConstraint);
+
+ // substitution needs to be filled during check
+ RefPtr<DeclRefType> paramType = DeclRefType::Create(
+ parser->getSession(),
+ DeclRef<Decl>(decl, nullptr));
+
+ RefPtr<SharedTypeExpr> paramTypeExpr = new SharedTypeExpr();
+ paramTypeExpr->loc = decl->loc;
+ paramTypeExpr->base.type = paramType;
+ paramTypeExpr->type = QualType(getTypeType(paramType));
+
+ paramConstraint->sub = TypeExp(paramTypeExpr);
+ paramConstraint->sup = parser->ParseTypeExp();
+
+ AddMember(decl, paramConstraint);
+ } while (AdvanceIf(parser, TokenType::Comma));
+ }
+ }
+
+ RefPtr<RefObject> parseAssocType(Parser * parser, void *)
+ {
+ RefPtr<AssocTypeDecl> assocTypeDecl = new AssocTypeDecl();
+
+ auto nameToken = parser->ReadToken(TokenType::Identifier);
+ assocTypeDecl->nameAndLoc = NameLoc(nameToken);
+ assocTypeDecl->loc = nameToken.loc;
+ parseOptionalGenericConstraints(parser, assocTypeDecl);
+ parser->ReadToken(TokenType::Semicolon);
+ return assocTypeDecl;
+ }
+
+ RefPtr<RefObject> parseGlobalGenericParamDecl(Parser * parser, void *)
+ {
+ RefPtr<GlobalGenericParamDecl> genParamDecl = new GlobalGenericParamDecl();
+ auto nameToken = parser->ReadToken(TokenType::Identifier);
+ genParamDecl->nameAndLoc = NameLoc(nameToken);
+ genParamDecl->loc = nameToken.loc;
+ parseOptionalGenericConstraints(parser, genParamDecl);
+ parser->ReadToken(TokenType::Semicolon);
+ return genParamDecl;
+ }
+
+ static RefPtr<RefObject> parseInterfaceDecl(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<InterfaceDecl> decl = new InterfaceDecl();
+ parser->FillPosition(decl.Ptr());
+ decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
+
+ parseOptionalInheritanceClause(parser, decl.Ptr());
+
+ parseAggTypeDeclBody(parser, decl.Ptr());
+
+ return decl;
+ }
+
+ static RefPtr<RefObject> parseConstructorDecl(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<ConstructorDecl> decl = new ConstructorDecl();
+ parser->FillPosition(decl.Ptr());
+
+ // TODO: we need to make sure that all initializers have
+ // the same name, but that this name doesn't conflict
+ // with any user-defined names.
+ // Giving them a name (rather than leaving it null)
+ // ensures that we can use name-based lookup to find
+ // all of the initializers on a type (and has
+ // the potential to unify initializer lookup with
+ // ordinary member lookup).
+ decl->nameAndLoc.name = getName(parser, "$init");
+
+ parseParameterList(parser, decl);
+
+ decl->Body = parseOptBody(parser);
+
+ return decl;
+ }
+
+ static RefPtr<AccessorDecl> parseAccessorDecl(Parser* parser)
+ {
+ Modifiers modifiers = ParseModifiers(parser);
+
+ RefPtr<AccessorDecl> decl;
+ if( AdvanceIf(parser, "get") )
+ {
+ decl = new GetterDecl();
+ }
+ else if( AdvanceIf(parser, "set") )
+ {
+ decl = new SetterDecl();
+ }
+ else if( AdvanceIf(parser, "ref") )
+ {
+ decl = new RefAccessorDecl();
+ }
+ else
+ {
+ Unexpected(parser);
+ return nullptr;
+ }
+
+ AddModifiers(decl, modifiers.first);
+
+ if( parser->tokenReader.PeekTokenType() == TokenType::LBrace )
+ {
+ decl->Body = parser->parseBlockStatement();
+ }
+ else
+ {
+ parser->ReadToken(TokenType::Semicolon);
+ }
+
+ return decl;
+ }
+
+ static RefPtr<RefObject> ParseSubscriptDecl(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<SubscriptDecl> decl = new SubscriptDecl();
+ parser->FillPosition(decl.Ptr());
+
+ // TODO: the use of this name here is a bit magical...
+ decl->nameAndLoc.name = getName(parser, "operator[]");
+
+ parseParameterList(parser, decl);
+
+ if( AdvanceIf(parser, TokenType::RightArrow) )
+ {
+ decl->ReturnType = parser->ParseTypeExp();
+ }
+
+ if( AdvanceIf(parser, TokenType::LBrace) )
+ {
+ // We want to parse nested "accessor" declarations
+ while( !AdvanceIfMatch(parser, TokenType::RBrace) )
+ {
+ auto accessor = parseAccessorDecl(parser);
+ AddMember(decl, accessor);
+ }
+ }
+ else
+ {
+ parser->ReadToken(TokenType::Semicolon);
+
+ // empty body should be treated like `{ get; }`
+ }
+
+ return decl;
+ }
+
+ static bool expect(Parser* parser, TokenType tokenType)
+ {
+ return parser->ReadToken(tokenType).type == tokenType;
+ }
+
+ static void parseModernVarDeclBaseCommon(
+ Parser* parser,
+ RefPtr<VarDeclBase> decl)
+ {
+ parser->FillPosition(decl.Ptr());
+ decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
+
+ if(AdvanceIf(parser, TokenType::Colon))
+ {
+ decl->type = parser->ParseTypeExp();
+ }
+
+ if(AdvanceIf(parser, TokenType::OpAssign))
+ {
+ decl->initExpr = parser->ParseInitExpr();
+ }
+ }
+
+ static void parseModernVarDeclCommon(
+ Parser* parser,
+ RefPtr<VarDecl> decl)
+ {
+ parseModernVarDeclBaseCommon(parser, decl);
+ expect(parser, TokenType::Semicolon);
+ }
+
+ static RefPtr<RefObject> parseLetDecl(
+ Parser* parser, void* /*userData*/)
+ {
+ RefPtr<LetDecl> decl = new LetDecl();
+ parseModernVarDeclCommon(parser, decl);
+ return decl;
+ }
+
+ static RefPtr<RefObject> parseVarDecl(
+ Parser* parser, void* /*userData*/)
+ {
+ RefPtr<VarDecl> decl = new VarDecl();
+ parseModernVarDeclCommon(parser, decl);
+ return decl;
+ }
+
+ static RefPtr<ParamDecl> parseModernParamDecl(
+ Parser* parser)
+ {
+ RefPtr<ParamDecl> decl = new ParamDecl();
+
+ // TODO: "modern" parameters should not accept keyword-based
+ // modifiers and should only accept `[attribute]` syntax for
+ // modifiers to keep the grammar as simple as possible.
+ //
+ // Further, they should accept `out` and `in out`/`inout`
+ // before the type (e.g., `a: inout float4`).
+ //
+ decl->modifiers = ParseModifiers(parser);
+ parseModernVarDeclBaseCommon(parser, decl);
+ return decl;
+ }
+
+ static void parseModernParamList(
+ Parser* parser,
+ RefPtr<CallableDecl> decl)
+ {
+ parser->ReadToken(TokenType::LParent);
+
+ while (!AdvanceIfMatch(parser, TokenType::RParent))
+ {
+ AddMember(decl, parseModernParamDecl(parser));
+ if (AdvanceIf(parser, TokenType::RParent))
+ break;
+ parser->ReadToken(TokenType::Comma);
+ }
+ }
+
+ static RefPtr<RefObject> parseFuncDecl(
+ Parser* parser, void* /*userData*/)
+ {
+ RefPtr<FuncDecl> decl = new FuncDecl();
+
+ parser->FillPosition(decl.Ptr());
+ decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
+
+ return parseOptGenericDecl(parser, [&](GenericDecl*)
+ {
+ parser->PushScope(decl.Ptr());
+ parseModernParamList(parser, decl);
+ if(AdvanceIf(parser, TokenType::RightArrow))
+ {
+ decl->ReturnType = parser->ParseTypeExp();
+ }
+ decl->Body = parseOptBody(parser);
+ parser->PopScope();
+ return decl;
+ });
+ }
+
+ static RefPtr<RefObject> parseTypeAliasDecl(
+ Parser* parser, void* /*userData*/)
+ {
+ RefPtr<TypeAliasDecl> decl = new TypeAliasDecl();
+
+ parser->FillPosition(decl.Ptr());
+ decl->nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
+
+ return parseOptGenericDecl(parser, [&](GenericDecl*)
+ {
+ if( expect(parser, TokenType::OpAssign) )
+ {
+ decl->type = parser->ParseTypeExp();
+ }
+ expect(parser, TokenType::Semicolon);
+ return decl;
+ });
+ }
+
+ // 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<RefObject> parseSimpleSyntax(Parser* /*parser*/, void* userData)
+ {
+ SyntaxClassBase syntaxClass((SyntaxClassBase::ClassInfo*) userData);
+ return (RefObject*) syntaxClass.createInstanceImpl();
+ }
+
+ // Parse a declaration of a keyword that can be used to define further syntax.
+ static RefPtr<RefObject> parseSyntaxDecl(Parser* parser, void* /*userData*/)
+ {
+ // Right now the basic form is:
+ //
+ // syntax <name:id> [: <syntaxClass:id>] [= <existingKeyword:id>];
+ //
+ // - `name` gives the name of the keyword to define.
+ // - `syntaxClass` is the name of an AST node class that we expect
+ // this syntax to construct when parsed.
+ // - `existingKeyword` is the name of an existing keyword that
+ // the new syntax should be an alias for.
+
+ // First we parse the keyword name.
+ auto nameAndLoc = expectIdentifier(parser);
+
+ // Next we look for a clause that specified the AST node class.
+ SyntaxClass<RefObject> syntaxClass;
+ if (AdvanceIf(parser, TokenType::Colon))
+ {
+ // User is specifying the class that should be construted
+ auto classNameAndLoc = expectIdentifier(parser);
+
+ syntaxClass = parser->getSession()->findSyntaxClass(classNameAndLoc.name);
+ }
+
+ // If the user specified a syntax class, then we will default
+ // to the `parseSimpleSyntax` callback that will just construct
+ // an instance of that type to represent the keyword in the AST.
+ SyntaxParseCallback parseCallback = &parseSimpleSyntax;
+ void* parseUserData = (void*) syntaxClass.classInfo;
+
+ // Next we look for an initializer that will make this keyword
+ // an alias for some existing keyword.
+ if (AdvanceIf(parser, TokenType::OpAssign))
+ {
+ auto existingKeywordNameAndLoc = expectIdentifier(parser);
+
+ auto existingSyntax = tryLookUpSyntaxDecl(parser, existingKeywordNameAndLoc.name);
+ if (!existingSyntax)
+ {
+ // TODO: diagnose: keyword did not name syntax
+ }
+ else
+ {
+ // The user is expecting us to parse our new syntax like
+ // the existing syntax given, so we need to override
+ // the callback.
+ parseCallback = existingSyntax->parseCallback;
+ parseUserData = existingSyntax->parseUserData;
+
+ // If we don't already have a syntax class specified, then
+ // we will crib the one from the existing syntax, to ensure
+ // that we are creating a drop-in alias.
+ if (!syntaxClass.classInfo)
+ syntaxClass = existingSyntax->syntaxClass;
+ }
+ }
+
+ // It is an error if the user didn't give us either an existing keyword
+ // to use to the define the callback, or a valid AST node class to construct.
+ //
+ // TODO: down the line this should be expanded so that the user can reference
+ // an existing *function* to use to parse the chosen syntax.
+ if (!syntaxClass.classInfo)
+ {
+ // TODO: diagnose: either a type or an existing keyword needs to be specified
+ }
+
+ expect(parser, TokenType::Semicolon);
+
+ // TODO: skip creating the declaration if anything failed, just to not screw things
+ // up for downstream code?
+
+ RefPtr<SyntaxDecl> syntaxDecl = new SyntaxDecl();
+ syntaxDecl->nameAndLoc = nameAndLoc;
+ syntaxDecl->loc = nameAndLoc.loc;
+ syntaxDecl->syntaxClass = syntaxClass;
+ syntaxDecl->parseCallback = parseCallback;
+ syntaxDecl->parseUserData = parseUserData;
+ return syntaxDecl;
+ }
+
+ // A parameter declaration in an attribute declaration.
+ //
+ // 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<ParamDecl> parseAttributeParamDecl(Parser* parser)
+ {
+ auto nameAndLoc = expectIdentifier(parser);
+
+ RefPtr<ParamDecl> paramDecl = new ParamDecl();
+ paramDecl->nameAndLoc = nameAndLoc;
+
+ if(AdvanceIf(parser, TokenType::Colon))
+ {
+ paramDecl->type = parser->ParseTypeExp();
+ }
+
+ if(AdvanceIf(parser, TokenType::OpAssign))
+ {
+ paramDecl->initExpr = parser->ParseInitExpr();
+ }
+
+ return paramDecl;
+ }
+
+ // Parse declaration of a name to be used for resolving `[attribute(...)]` style modifiers.
+ //
+ // These are distinct from `syntax` declarations, because their names don't get added
+ // to the current scope using their default name.
+ //
+ // Also, attribute-specific code doesn't get invokved during parsing. We always parse
+ // using the default attribute-parsing logic and then all specialized behavior takes
+ // place during semantic checking.
+ //
+ static RefPtr<RefObject> parseAttributeSyntaxDecl(Parser* parser, void* /*userData*/)
+ {
+ // Right now the basic form is:
+ //
+ // attribute_syntax <name:id> : <syntaxClass:id>;
+ //
+ // - `name` gives the name of the attribute to define.
+ // - `syntaxClass` is the name of an AST node class that we expect
+ // this attribute to create when checked.
+ // - `existingKeyword` is the name of an existing keyword that
+ // the new syntax should be an alias for.
+
+ expect(parser, TokenType::LBracket);
+
+ // First we parse the attribute name.
+ auto nameAndLoc = expectIdentifier(parser);
+
+ RefPtr<AttributeDecl> attrDecl = new AttributeDecl();
+ if(AdvanceIf(parser, TokenType::LParent))
+ {
+ while(!AdvanceIfMatch(parser, TokenType::RParent))
+ {
+ auto param = parseAttributeParamDecl(parser);
+
+ AddMember(attrDecl, param);
+
+ if(AdvanceIfMatch(parser, TokenType::RParent))
+ break;
+
+ expect(parser, TokenType::Comma);
+ }
+ }
+
+ expect(parser, TokenType::RBracket);
+
+ // TODO: we should allow parameters to be specified here, to cut down
+ // 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<RefObject> syntaxClass;
+ if (AdvanceIf(parser, TokenType::Colon))
+ {
+ // User is specifying the class that should be construted
+ auto classNameAndLoc = expectIdentifier(parser);
+
+ syntaxClass = parser->getSession()->findSyntaxClass(classNameAndLoc.name);
+ }
+ else
+ {
+ // For now we don't support the alternative approach where
+ // an existing piece of syntax is named to provide the parsing
+ // support.
+
+ // TODO: diagnose: a syntax class must be specified.
+ }
+
+ expect(parser, TokenType::Semicolon);
+
+ // TODO: skip creating the declaration if anything failed, just to not screw things
+ // up for downstream code?
+
+ attrDecl->nameAndLoc = nameAndLoc;
+ attrDecl->loc = nameAndLoc.loc;
+ attrDecl->syntaxClass = syntaxClass;
+ return attrDecl;
+ }
+
+ // Finish up work on a declaration that was parsed
+ static void CompleteDecl(
+ Parser* /*parser*/,
+ RefPtr<Decl> decl,
+ ContainerDecl* containerDecl,
+ Modifiers modifiers)
+ {
+ // Add any modifiers we parsed before the declaration to the list
+ // of modifiers on the declaration itself.
+ //
+ // 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<Decl> declToModify = decl;
+ if(auto genericDecl = as<GenericDecl>(decl))
+ declToModify = genericDecl->inner;
+ AddModifiers(declToModify.Ptr(), modifiers.first);
+
+ // Make sure the decl is properly nested inside its lexical parent
+ if (containerDecl)
+ {
+ AddMember(containerDecl, decl);
+ }
+ }
+
+ static RefPtr<DeclBase> ParseDeclWithModifiers(
+ Parser* parser,
+ ContainerDecl* containerDecl,
+ Modifiers modifiers )
+ {
+ RefPtr<DeclBase> decl;
+
+ auto loc = parser->tokenReader.PeekLoc();
+
+ switch (peekTokenType(parser))
+ {
+ case TokenType::Identifier:
+ {
+ // A declaration that starts with an identifier might be:
+ //
+ // - A keyword-based declaration (e.g., `cbuffer ...`)
+ // - The beginning of a type in a declarator-based declaration (e.g., `int ...`)
+
+ // First we will check whether we can use the identifier token
+ // as a declaration keyword and parse a declaration using
+ // its associated callback:
+ RefPtr<Decl> parsedDecl;
+ if (tryParseUsingSyntaxDecl<Decl>(parser, &parsedDecl))
+ {
+ decl = parsedDecl;
+ break;
+ }
+
+ // Our final fallback case is to assume that the user is
+ // probably writing a C-style declarator-based declaration.
+ decl = ParseDeclaratorDecl(parser, containerDecl);
+ break;
+ }
+ break;
+
+ // It is valid in HLSL/GLSL to have an "empty" declaration
+ // that consists of just a semicolon. In particular, this
+ // gets used a lot in GLSL to attach custom semantics to
+ // shader input or output.
+ //
+ case TokenType::Semicolon:
+ {
+ advanceToken(parser);
+
+ decl = new EmptyDecl();
+ decl->loc = loc;
+ }
+ break;
+
+ // If nothing else matched, we try to parse an "ordinary" declarator-based declaration
+ default:
+ decl = ParseDeclaratorDecl(parser, containerDecl);
+ break;
+ }
+
+ if (decl)
+ {
+ if( auto dd = as<Decl>(decl) )
+ {
+ CompleteDecl(parser, dd, containerDecl, modifiers);
+ }
+ else if(auto declGroup = as<DeclGroup>(decl))
+ {
+ // We are going to add the same modifiers to *all* of these declarations,
+ // so we want to give later passes a way to detect which modifiers
+ // were shared, vs. which ones are specific to a single declaration.
+
+ auto sharedModifiers = new SharedModifiers();
+ sharedModifiers->next = modifiers.first;
+ modifiers.first = sharedModifiers;
+
+ for( auto subDecl : declGroup->decls )
+ {
+ CompleteDecl(parser, subDecl, containerDecl, modifiers);
+ }
+ }
+ }
+ return decl;
+ }
+
+ static RefPtr<DeclBase> ParseDecl(
+ Parser* parser,
+ ContainerDecl* containerDecl)
+ {
+ Modifiers modifiers = ParseModifiers(parser);
+ return ParseDeclWithModifiers(parser, containerDecl, modifiers);
+ }
+
+ static RefPtr<Decl> ParseSingleDecl(
+ Parser* parser,
+ ContainerDecl* containerDecl)
+ {
+ auto declBase = ParseDecl(parser, containerDecl);
+ if(!declBase)
+ return nullptr;
+ if( auto decl = as<Decl>(declBase) )
+ {
+ return decl;
+ }
+ else if( auto declGroup = as<DeclGroup>(declBase) )
+ {
+ if( declGroup->decls.getCount() == 1 )
+ {
+ return declGroup->decls[0];
+ }
+ }
+
+ parser->sink->diagnose(declBase->loc, Diagnostics::unimplemented, "didn't expect multiple declarations here");
+ return nullptr;
+ }
+
+
+ // Parse a body consisting of declarations
+ static void ParseDeclBody(
+ Parser* parser,
+ ContainerDecl* containerDecl,
+ TokenType closingToken)
+ {
+ while(!AdvanceIfMatch(parser, closingToken))
+ {
+ ParseDecl(parser, containerDecl);
+ }
+ }
+
+ // Parse the `{}`-delimeted body of an aggregate type declaration
+ static void parseAggTypeDeclBody(
+ Parser* parser,
+ AggTypeDeclBase* decl)
+ {
+ // TODO: the scope used for the body might need to be
+ // slightly specialized to deal with the complexity
+ // of how `this` works.
+ //
+ // Alternatively, that complexity can be pushed down
+ // to semantic analysis so that it doesn't clutter
+ // things here.
+ parser->PushScope(decl);
+
+ parser->ReadToken(TokenType::LBrace);
+ ParseDeclBody(parser, decl, TokenType::RBrace);
+
+ parser->PopScope();
+ }
+
+
+ void Parser::parseSourceFile(ModuleDecl* program)
+ {
+ if (outerScope)
+ {
+ currentScope = outerScope;
+ }
+
+ PushScope(program);
+ program->loc = tokenReader.PeekLoc();
+ program->scope = currentScope;
+ ParseDeclBody(this, program, TokenType::EndOfFile);
+ PopScope();
+
+ SLANG_RELEASE_ASSERT(currentScope == outerScope);
+ currentScope = nullptr;
+ }
+
+ RefPtr<Decl> Parser::ParseStruct()
+ {
+ RefPtr<StructDecl> rs = new StructDecl();
+ FillPosition(rs.Ptr());
+ ReadToken("struct");
+
+ // TODO: support `struct` declaration without tag
+ rs->nameAndLoc = expectIdentifier(this);
+
+ return parseOptGenericDecl(this, [&](GenericDecl*)
+ {
+ // We allow for an inheritance clause on a `struct`
+ // so that it can conform to interfaces.
+ parseOptionalInheritanceClause(this, rs.Ptr());
+ parseAggTypeDeclBody(this, rs.Ptr());
+ return rs;
+ });
+ }
+
+ RefPtr<ClassDecl> Parser::ParseClass()
+ {
+ RefPtr<ClassDecl> rs = new ClassDecl();
+ FillPosition(rs.Ptr());
+ ReadToken("class");
+ rs->nameAndLoc = expectIdentifier(this);
+
+ parseOptionalInheritanceClause(this, rs.Ptr());
+
+ parseAggTypeDeclBody(this, rs.Ptr());
+ return rs;
+ }
+
+ static RefPtr<EnumCaseDecl> parseEnumCaseDecl(Parser* parser)
+ {
+ RefPtr<EnumCaseDecl> decl = new EnumCaseDecl();
+ decl->nameAndLoc = expectIdentifier(parser);
+
+ if(AdvanceIf(parser, TokenType::OpAssign))
+ {
+ decl->tagExpr = parser->ParseArgExpr();
+ }
+
+ return decl;
+ }
+
+ static RefPtr<Decl> parseEnumDecl(Parser* parser)
+ {
+ RefPtr<EnumDecl> decl = new EnumDecl();
+ parser->FillPosition(decl);
+
+ parser->ReadToken("enum");
+
+ // HACK: allow the user to write `enum class` in case
+ // they are trying to share a header between C++ and Slang.
+ //
+ // TODO: diagnose this with a warning some day, and move
+ // toward deprecating it.
+ //
+ AdvanceIf(parser, "class");
+
+ decl->nameAndLoc = expectIdentifier(parser);
+
+
+ return parseOptGenericDecl(parser, [&](GenericDecl*)
+ {
+ parseOptionalInheritanceClause(parser, decl);
+ parser->ReadToken(TokenType::LBrace);
+
+ while(!AdvanceIfMatch(parser, TokenType::RBrace))
+ {
+ RefPtr<EnumCaseDecl> caseDecl = parseEnumCaseDecl(parser);
+ AddMember(decl, caseDecl);
+
+ if(AdvanceIf(parser, TokenType::RBrace))
+ break;
+
+ parser->ReadToken(TokenType::Comma);
+ }
+ return decl;
+ });
+ }
+
+ static RefPtr<Stmt> ParseSwitchStmt(Parser* parser)
+ {
+ RefPtr<SwitchStmt> stmt = new SwitchStmt();
+ parser->FillPosition(stmt.Ptr());
+ parser->ReadToken("switch");
+ parser->ReadToken(TokenType::LParent);
+ stmt->condition = parser->ParseExpression();
+ parser->ReadToken(TokenType::RParent);
+ stmt->body = parser->parseBlockStatement();
+ return stmt;
+ }
+
+ static RefPtr<Stmt> ParseCaseStmt(Parser* parser)
+ {
+ RefPtr<CaseStmt> stmt = new CaseStmt();
+ parser->FillPosition(stmt.Ptr());
+ parser->ReadToken("case");
+ stmt->expr = parser->ParseExpression();
+ parser->ReadToken(TokenType::Colon);
+ return stmt;
+ }
+
+ static RefPtr<Stmt> ParseDefaultStmt(Parser* parser)
+ {
+ RefPtr<DefaultStmt> stmt = new DefaultStmt();
+ parser->FillPosition(stmt.Ptr());
+ parser->ReadToken("default");
+ parser->ReadToken(TokenType::Colon);
+ return stmt;
+ }
+
+ static bool isTypeName(Parser* parser, Name* name)
+ {
+ auto lookupResult = lookUp(
+ parser->getSession(),
+ nullptr, // no semantics visitor available yet
+ name,
+ parser->currentScope);
+ if(!lookupResult.isValid() || lookupResult.isOverloaded())
+ return false;
+
+ auto decl = lookupResult.item.declRef.getDecl();
+ if( auto typeDecl = as<AggTypeDecl>(decl) )
+ {
+ return true;
+ }
+ else if( auto typeVarDecl = as<SimpleTypeDecl>(decl) )
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ static bool peekTypeName(Parser* parser)
+ {
+ if(!parser->LookAheadToken(TokenType::Identifier))
+ return false;
+
+ auto name = parser->tokenReader.PeekToken().getName();
+ return isTypeName(parser, name);
+ }
+
+ RefPtr<Stmt> parseCompileTimeForStmt(
+ Parser* parser)
+ {
+ RefPtr<ScopeDecl> scopeDecl = new ScopeDecl();
+ RefPtr<CompileTimeForStmt> stmt = new CompileTimeForStmt();
+ stmt->scopeDecl = scopeDecl;
+
+
+ parser->ReadToken("for");
+ parser->ReadToken(TokenType::LParent);
+
+ NameLoc varNameAndLoc = expectIdentifier(parser);
+ RefPtr<VarDecl> varDecl = new VarDecl();
+ varDecl->nameAndLoc = varNameAndLoc;
+ varDecl->loc = varNameAndLoc.loc;
+
+ stmt->varDecl = varDecl;
+
+ parser->ReadToken("in");
+ parser->ReadToken("Range");
+ parser->ReadToken(TokenType::LParent);
+
+ RefPtr<Expr> rangeBeginExpr;
+ RefPtr<Expr> rangeEndExpr = parser->ParseArgExpr();
+ if (AdvanceIf(parser, TokenType::Comma))
+ {
+ rangeBeginExpr = rangeEndExpr;
+ rangeEndExpr = parser->ParseArgExpr();
+ }
+
+ stmt->rangeBeginExpr = rangeBeginExpr;
+ stmt->rangeEndExpr = rangeEndExpr;
+
+ parser->ReadToken(TokenType::RParent);
+ parser->ReadToken(TokenType::RParent);
+
+ parser->pushScopeAndSetParent(scopeDecl);
+ AddMember(parser->currentScope, varDecl);
+
+ stmt->body = parser->ParseStatement();
+
+ parser->PopScope();
+
+ return stmt;
+ }
+
+ RefPtr<Stmt> parseCompileTimeStmt(
+ Parser* parser)
+ {
+ parser->ReadToken(TokenType::Dollar);
+ if (parser->LookAheadToken("for"))
+ {
+ return parseCompileTimeForStmt(parser);
+ }
+ else
+ {
+ Unexpected(parser);
+ return nullptr;
+ }
+ }
+
+ RefPtr<Stmt> Parser::ParseStatement()
+ {
+ auto modifiers = ParseModifiers(this);
+
+ RefPtr<Stmt> statement;
+ if (LookAheadToken(TokenType::LBrace))
+ statement = parseBlockStatement();
+ else if (peekTypeName(this))
+ statement = parseVarDeclrStatement(modifiers);
+ else if (LookAheadToken("if"))
+ statement = parseIfStatement();
+ else if (LookAheadToken("for"))
+ statement = ParseForStatement();
+ else if (LookAheadToken("while"))
+ statement = ParseWhileStatement();
+ else if (LookAheadToken("do"))
+ statement = ParseDoWhileStatement();
+ else if (LookAheadToken("break"))
+ statement = ParseBreakStatement();
+ else if (LookAheadToken("continue"))
+ statement = ParseContinueStatement();
+ else if (LookAheadToken("return"))
+ statement = ParseReturnStatement();
+ else if (LookAheadToken("discard"))
+ {
+ statement = new DiscardStmt();
+ FillPosition(statement.Ptr());
+ ReadToken("discard");
+ ReadToken(TokenType::Semicolon);
+ }
+ else if (LookAheadToken("switch"))
+ statement = ParseSwitchStmt(this);
+ else if (LookAheadToken("case"))
+ statement = ParseCaseStmt(this);
+ else if (LookAheadToken("default"))
+ statement = ParseDefaultStmt(this);
+ else if (LookAheadToken(TokenType::Dollar))
+ {
+ statement = parseCompileTimeStmt(this);
+ }
+ else if (LookAheadToken(TokenType::Identifier))
+ {
+ // We might be looking at a local declaration, or an
+ // expression statement, and we need to figure out which.
+ //
+ // We'll solve this with backtracking for now.
+
+ TokenReader::ParsingCursor startPos = tokenReader.getCursor();
+
+ // Try to parse a type (knowing that the type grammar is
+ // a subset of the expression grammar, and so this should
+ // always succeed).
+ RefPtr<Expr> type = ParseType();
+ // We don't actually care about the type, though, so
+ // don't retain it
+ type = nullptr;
+
+ // If the next token after we parsed a type looks like
+ // we are going to declare a variable, then lets guess
+ // that this is a declaration.
+ //
+ // TODO(tfoley): this wouldn't be robust for more
+ // general kinds of declarators (notably pointer declarators),
+ // so we'll need to be careful about this.
+ if (LookAheadToken(TokenType::Identifier))
+ {
+ // Reset the cursor and try to parse a declaration now.
+ // Note: the declaration will consume any modifiers
+ // that had been in place on the statement.
+ tokenReader.setCursor(startPos);
+ statement = parseVarDeclrStatement(modifiers);
+ return statement;
+ }
+
+ // Fallback: reset and parse an expression
+ tokenReader.setCursor(startPos);
+ statement = ParseExpressionStatement();
+ }
+ else if (LookAheadToken(TokenType::Semicolon))
+ {
+ statement = new EmptyStmt();
+ FillPosition(statement.Ptr());
+ ReadToken(TokenType::Semicolon);
+ }
+ else
+ {
+ // Default case should always fall back to parsing an expression,
+ // and then let that detect any errors
+ statement = ParseExpressionStatement();
+ }
+
+ if (statement && !as<DeclStmt>(statement))
+ {
+ // Install any modifiers onto the statement.
+ // Note: this path is bypassed in the case of a
+ // declaration statement, so we don't end up
+ // doubling up the modifiers.
+ statement->modifiers = modifiers;
+ }
+
+ return statement;
+ }
+
+ RefPtr<Stmt> Parser::parseBlockStatement()
+ {
+ RefPtr<ScopeDecl> scopeDecl = new ScopeDecl();
+ RefPtr<BlockStmt> blockStatement = new BlockStmt();
+ blockStatement->scopeDecl = scopeDecl;
+ pushScopeAndSetParent(scopeDecl.Ptr());
+ ReadToken(TokenType::LBrace);
+
+ RefPtr<Stmt> body;
+
+ if(!tokenReader.IsAtEnd())
+ {
+ FillPosition(blockStatement.Ptr());
+ }
+ while (!AdvanceIfMatch(this, TokenType::RBrace))
+ {
+ auto stmt = ParseStatement();
+ if(stmt)
+ {
+ if (!body)
+ {
+ body = stmt;
+ }
+ else if (auto seqStmt = as<SeqStmt>(body))
+ {
+ seqStmt->stmts.add(stmt);
+ }
+ else
+ {
+ RefPtr<SeqStmt> newBody = new SeqStmt();
+ newBody->loc = blockStatement->loc;
+ newBody->stmts.add(body);
+ newBody->stmts.add(stmt);
+
+ body = newBody;
+ }
+ }
+ TryRecover(this);
+ }
+ PopScope();
+
+ if(!body)
+ {
+ body = new EmptyStmt();
+ body->loc = blockStatement->loc;
+ }
+
+ blockStatement->body = body;
+ return blockStatement;
+ }
+
+ RefPtr<DeclStmt> Parser::parseVarDeclrStatement(
+ Modifiers modifiers)
+ {
+ RefPtr<DeclStmt>varDeclrStatement = new DeclStmt();
+
+ FillPosition(varDeclrStatement.Ptr());
+ auto decl = ParseDeclWithModifiers(this, currentScope->containerDecl, modifiers);
+ varDeclrStatement->decl = decl;
+ return varDeclrStatement;
+ }
+
+ RefPtr<IfStmt> Parser::parseIfStatement()
+ {
+ RefPtr<IfStmt> ifStatement = new IfStmt();
+ FillPosition(ifStatement.Ptr());
+ ReadToken("if");
+ ReadToken(TokenType::LParent);
+ ifStatement->Predicate = ParseExpression();
+ ReadToken(TokenType::RParent);
+ ifStatement->PositiveStatement = ParseStatement();
+ if (LookAheadToken("else"))
+ {
+ ReadToken("else");
+ ifStatement->NegativeStatement = ParseStatement();
+ }
+ return ifStatement;
+ }
+
+ RefPtr<ForStmt> Parser::ParseForStatement()
+ {
+ RefPtr<ScopeDecl> scopeDecl = new ScopeDecl();
+
+ // HLSL implements the bad approach to scoping a `for` loop
+ // variable, and we want to respect that, but *only* when
+ // parsing HLSL code.
+ //
+
+ bool brokenScoping = getSourceLanguage() == SourceLanguage::HLSL;
+
+ // We will create a distinct syntax node class for the unscoped
+ // case, just so that we can correctly handle it in downstream
+ // logic.
+ //
+ RefPtr<ForStmt> stmt;
+ if (brokenScoping)
+ {
+ stmt = new UnscopedForStmt();
+ }
+ else
+ {
+ stmt = new ForStmt();
+ }
+
+ stmt->scopeDecl = scopeDecl;
+
+ if(!brokenScoping)
+ pushScopeAndSetParent(scopeDecl.Ptr());
+ FillPosition(stmt.Ptr());
+ ReadToken("for");
+ ReadToken(TokenType::LParent);
+ if (peekTypeName(this))
+ {
+ stmt->InitialStatement = parseVarDeclrStatement(Modifiers());
+ }
+ else
+ {
+ if (!LookAheadToken(TokenType::Semicolon))
+ {
+ stmt->InitialStatement = ParseExpressionStatement();
+ }
+ else
+ {
+ ReadToken(TokenType::Semicolon);
+ }
+ }
+ if (!LookAheadToken(TokenType::Semicolon))
+ stmt->PredicateExpression = ParseExpression();
+ ReadToken(TokenType::Semicolon);
+ if (!LookAheadToken(TokenType::RParent))
+ stmt->SideEffectExpression = ParseExpression();
+ ReadToken(TokenType::RParent);
+ stmt->Statement = ParseStatement();
+
+ if (!brokenScoping)
+ PopScope();
+
+ return stmt;
+ }
+
+ RefPtr<WhileStmt> Parser::ParseWhileStatement()
+ {
+ RefPtr<WhileStmt> whileStatement = new WhileStmt();
+ FillPosition(whileStatement.Ptr());
+ ReadToken("while");
+ ReadToken(TokenType::LParent);
+ whileStatement->Predicate = ParseExpression();
+ ReadToken(TokenType::RParent);
+ whileStatement->Statement = ParseStatement();
+ return whileStatement;
+ }
+
+ RefPtr<DoWhileStmt> Parser::ParseDoWhileStatement()
+ {
+ RefPtr<DoWhileStmt> doWhileStatement = new DoWhileStmt();
+ FillPosition(doWhileStatement.Ptr());
+ ReadToken("do");
+ doWhileStatement->Statement = ParseStatement();
+ ReadToken("while");
+ ReadToken(TokenType::LParent);
+ doWhileStatement->Predicate = ParseExpression();
+ ReadToken(TokenType::RParent);
+ ReadToken(TokenType::Semicolon);
+ return doWhileStatement;
+ }
+
+ RefPtr<BreakStmt> Parser::ParseBreakStatement()
+ {
+ RefPtr<BreakStmt> breakStatement = new BreakStmt();
+ FillPosition(breakStatement.Ptr());
+ ReadToken("break");
+ ReadToken(TokenType::Semicolon);
+ return breakStatement;
+ }
+
+ RefPtr<ContinueStmt> Parser::ParseContinueStatement()
+ {
+ RefPtr<ContinueStmt> continueStatement = new ContinueStmt();
+ FillPosition(continueStatement.Ptr());
+ ReadToken("continue");
+ ReadToken(TokenType::Semicolon);
+ return continueStatement;
+ }
+
+ RefPtr<ReturnStmt> Parser::ParseReturnStatement()
+ {
+ RefPtr<ReturnStmt> returnStatement = new ReturnStmt();
+ FillPosition(returnStatement.Ptr());
+ ReadToken("return");
+ if (!LookAheadToken(TokenType::Semicolon))
+ returnStatement->Expression = ParseExpression();
+ ReadToken(TokenType::Semicolon);
+ return returnStatement;
+ }
+
+ RefPtr<ExpressionStmt> Parser::ParseExpressionStatement()
+ {
+ RefPtr<ExpressionStmt> statement = new ExpressionStmt();
+
+ FillPosition(statement.Ptr());
+ statement->Expression = ParseExpression();
+
+ ReadToken(TokenType::Semicolon);
+ return statement;
+ }
+
+ RefPtr<ParamDecl> Parser::ParseParameter()
+ {
+ RefPtr<ParamDecl> parameter = new ParamDecl();
+ parameter->modifiers = ParseModifiers(this);
+
+ DeclaratorInfo declaratorInfo;
+ declaratorInfo.typeSpec = ParseType();
+
+ InitDeclarator initDeclarator = ParseInitDeclarator(this);
+ UnwrapDeclarator(initDeclarator, &declaratorInfo);
+
+ // Assume it is a variable-like declarator
+ CompleteVarDecl(this, parameter, declaratorInfo);
+ return parameter;
+ }
+
+ RefPtr<Expr> Parser::ParseType()
+ {
+ auto typeSpec = parseTypeSpec(this);
+ if( typeSpec.decl )
+ {
+ AddMember(currentScope, typeSpec.decl);
+ }
+ auto typeExpr = typeSpec.expr;
+
+ typeExpr = parsePostfixTypeSuffix(this, typeExpr);
+
+ return typeExpr;
+ }
+
+
+
+ TypeExp Parser::ParseTypeExp()
+ {
+ return TypeExp(ParseType());
+ }
+
+ enum class Associativity
+ {
+ Left, Right
+ };
+
+
+
+ Associativity GetAssociativityFromLevel(Precedence level)
+ {
+ if (level == Precedence::Assignment)
+ return Associativity::Right;
+ else
+ return Associativity::Left;
+ }
+
+
+
+
+ Precedence GetOpLevel(Parser* parser, TokenType type)
+ {
+ switch(type)
+ {
+ case TokenType::QuestionMark:
+ return Precedence::TernaryConditional;
+ case TokenType::Comma:
+ return Precedence::Comma;
+ case TokenType::OpAssign:
+ case TokenType::OpMulAssign:
+ case TokenType::OpDivAssign:
+ case TokenType::OpAddAssign:
+ case TokenType::OpSubAssign:
+ case TokenType::OpModAssign:
+ case TokenType::OpShlAssign:
+ case TokenType::OpShrAssign:
+ case TokenType::OpOrAssign:
+ case TokenType::OpAndAssign:
+ case TokenType::OpXorAssign:
+ return Precedence::Assignment;
+ case TokenType::OpOr:
+ return Precedence::LogicalOr;
+ case TokenType::OpAnd:
+ return Precedence::LogicalAnd;
+ case TokenType::OpBitOr:
+ return Precedence::BitOr;
+ case TokenType::OpBitXor:
+ return Precedence::BitXor;
+ case TokenType::OpBitAnd:
+ return Precedence::BitAnd;
+ case TokenType::OpEql:
+ case TokenType::OpNeq:
+ return Precedence::EqualityComparison;
+ case TokenType::OpGreater:
+ case TokenType::OpGeq:
+ // Don't allow these ops inside a generic argument
+ if (parser->genericDepth > 0) return Precedence::Invalid;
+ ; // fall-thru
+ case TokenType::OpLeq:
+ case TokenType::OpLess:
+ return Precedence::RelationalComparison;
+ case TokenType::OpRsh:
+ // Don't allow this op inside a generic argument
+ if (parser->genericDepth > 0) return Precedence::Invalid;
+ ; // fall-thru
+ case TokenType::OpLsh:
+ return Precedence::BitShift;
+ case TokenType::OpAdd:
+ case TokenType::OpSub:
+ return Precedence::Additive;
+ case TokenType::OpMul:
+ case TokenType::OpDiv:
+ case TokenType::OpMod:
+ return Precedence::Multiplicative;
+ default:
+ return Precedence::Invalid;
+ }
+ }
+
+ static RefPtr<Expr> parseOperator(Parser* parser)
+ {
+ Token opToken;
+ switch(parser->tokenReader.PeekTokenType())
+ {
+ case TokenType::QuestionMark:
+ opToken = parser->ReadToken();
+ opToken.Content = UnownedStringSlice::fromLiteral("?:");
+ break;
+
+ default:
+ opToken = parser->ReadToken();
+ break;
+ }
+
+ auto opExpr = new VarExpr();
+ opExpr->name = getName(parser, opToken.Content);
+ opExpr->scope = parser->currentScope;
+ opExpr->loc = opToken.loc;
+
+ return opExpr;
+
+ }
+
+ static RefPtr<Expr> createInfixExpr(
+ Parser* /*parser*/,
+ RefPtr<Expr> left,
+ RefPtr<Expr> op,
+ RefPtr<Expr> right)
+ {
+ RefPtr<InfixExpr> expr = new InfixExpr();
+ expr->loc = op->loc;
+ expr->FunctionExpr = op;
+ expr->Arguments.add(left);
+ expr->Arguments.add(right);
+ return expr;
+ }
+
+ static RefPtr<Expr> parseInfixExprWithPrecedence(
+ Parser* parser,
+ RefPtr<Expr> inExpr,
+ Precedence prec)
+ {
+ auto expr = inExpr;
+ for(;;)
+ {
+ auto opTokenType = parser->tokenReader.PeekTokenType();
+ auto opPrec = GetOpLevel(parser, opTokenType);
+ if(opPrec < prec)
+ break;
+
+ auto op = parseOperator(parser);
+
+ // Special case the `?:` operator since it is the
+ // one non-binary case we need to deal with.
+ if(opTokenType == TokenType::QuestionMark)
+ {
+ RefPtr<SelectExpr> select = new SelectExpr();
+ select->loc = op->loc;
+ select->FunctionExpr = op;
+
+ select->Arguments.add(expr);
+
+ select->Arguments.add(parser->ParseExpression(opPrec));
+ parser->ReadToken(TokenType::Colon);
+ select->Arguments.add(parser->ParseExpression(opPrec));
+
+ expr = select;
+ continue;
+ }
+
+ auto right = parser->ParseLeafExpression();
+
+ for(;;)
+ {
+ auto nextOpPrec = GetOpLevel(parser, parser->tokenReader.PeekTokenType());
+
+ if((GetAssociativityFromLevel(nextOpPrec) == Associativity::Right) ? (nextOpPrec < opPrec) : (nextOpPrec <= opPrec))
+ break;
+
+ right = parseInfixExprWithPrecedence(parser, right, nextOpPrec);
+ }
+
+ if (opTokenType == TokenType::OpAssign)
+ {
+ RefPtr<AssignExpr> assignExpr = new AssignExpr();
+ assignExpr->loc = op->loc;
+ assignExpr->left = expr;
+ assignExpr->right = right;
+
+ expr = assignExpr;
+ }
+ else
+ {
+ expr = createInfixExpr(parser, expr, op, right);
+ }
+ }
+ return expr;
+ }
+
+ RefPtr<Expr> Parser::ParseExpression(Precedence level)
+ {
+ auto expr = ParseLeafExpression();
+ return parseInfixExprWithPrecedence(this, expr, level);
+
+#if 0
+
+ if (level == Precedence::Prefix)
+ return ParseLeafExpression();
+ if (level == Precedence::TernaryConditional)
+ {
+ // parse select clause
+ auto condition = ParseExpression(Precedence(level + 1));
+ if (LookAheadToken(TokenType::QuestionMark))
+ {
+ RefPtr<SelectExpr> select = new SelectExpr();
+ FillPosition(select.Ptr());
+
+ select->Arguments.Add(condition);
+
+ select->FunctionExpr = parseOperator(this);
+
+ select->Arguments.Add(ParseExpression(level));
+ ReadToken(TokenType::Colon);
+ select->Arguments.Add(ParseExpression(level));
+ return select;
+ }
+ else
+ return condition;
+ }
+ else
+ {
+ if (GetAssociativityFromLevel(level) == Associativity::Left)
+ {
+ auto left = ParseExpression(Precedence(level + 1));
+ while (GetOpLevel(this, tokenReader.PeekTokenType()) == level)
+ {
+ RefPtr<OperatorExpr> tmp = new InfixExpr();
+ tmp->FunctionExpr = parseOperator(this);
+
+ tmp->Arguments.Add(left);
+ FillPosition(tmp.Ptr());
+ tmp->Arguments.Add(ParseExpression(Precedence(level + 1)));
+ left = tmp;
+ }
+ return left;
+ }
+ else
+ {
+ auto left = ParseExpression(Precedence(level + 1));
+ if (GetOpLevel(this, tokenReader.PeekTokenType()) == level)
+ {
+ RefPtr<OperatorExpr> tmp = new InfixExpr();
+ tmp->Arguments.Add(left);
+ FillPosition(tmp.Ptr());
+ tmp->FunctionExpr = parseOperator(this);
+ tmp->Arguments.Add(ParseExpression(level));
+ left = tmp;
+ }
+ return left;
+ }
+ }
+#endif
+ }
+
+ // We *might* be looking at an application of a generic to arguments,
+ // but we need to disambiguate to make sure.
+ static RefPtr<Expr> maybeParseGenericApp(
+ Parser* parser,
+
+ // TODO: need to support more general expressions here
+ RefPtr<Expr> base)
+ {
+ if(peekTokenType(parser) != TokenType::OpLess)
+ return base;
+ return tryParseGenericApp(parser, base);
+ }
+
+ static RefPtr<Expr> parsePrefixExpr(Parser* parser);
+
+ // Parse OOP `this` expression syntax
+ static RefPtr<RefObject> parseThisExpr(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<ThisExpr> expr = new ThisExpr();
+ expr->scope = parser->currentScope;
+ return expr;
+ }
+
+ static RefPtr<Expr> parseBoolLitExpr(Parser* /*parser*/, bool value)
+ {
+ RefPtr<BoolLiteralExpr> expr = new BoolLiteralExpr();
+ expr->value = value;
+ return expr;
+ }
+
+ static RefPtr<RefObject> parseTrueExpr(Parser* parser, void* /*userData*/)
+ {
+ return parseBoolLitExpr(parser, true);
+ }
+
+ static RefPtr<RefObject> parseFalseExpr(Parser* parser, void* /*userData*/)
+ {
+ return parseBoolLitExpr(parser, false);
+ }
+
+ static RefPtr<Expr> parseAtomicExpr(Parser* parser)
+ {
+ switch( peekTokenType(parser) )
+ {
+ default:
+ // TODO: should this return an error expression instead of NULL?
+ parser->sink->diagnose(parser->tokenReader.PeekLoc(), Diagnostics::syntaxError);
+ return nullptr;
+
+ // Either:
+ // - parenthized expression `(exp)`
+ // - cast `(type) exp`
+ //
+ // Proper disambiguation requires mixing up parsing
+ // and semantic checking (which we should do eventually)
+ // but for now we will follow some heuristics.
+ case TokenType::LParent:
+ {
+ Token openParen = parser->ReadToken(TokenType::LParent);
+
+ if (peekTypeName(parser) && parser->LookAheadToken(TokenType::RParent, 1))
+ {
+ RefPtr<TypeCastExpr> tcexpr = new ExplicitCastExpr();
+ parser->FillPosition(tcexpr.Ptr());
+ tcexpr->FunctionExpr = parser->ParseType();
+ parser->ReadToken(TokenType::RParent);
+
+ auto arg = parsePrefixExpr(parser);
+ tcexpr->Arguments.add(arg);
+
+ return tcexpr;
+ }
+ else
+ {
+ RefPtr<Expr> base = parser->ParseExpression();
+ parser->ReadToken(TokenType::RParent);
+
+ RefPtr<ParenExpr> parenExpr = new ParenExpr();
+ parenExpr->loc = openParen.loc;
+ parenExpr->base = base;
+ return parenExpr;
+ }
+ }
+
+ // An initializer list `{ expr, ... }`
+ case TokenType::LBrace:
+ {
+ RefPtr<InitializerListExpr> initExpr = new InitializerListExpr();
+ parser->FillPosition(initExpr.Ptr());
+
+ // Initializer list
+ parser->ReadToken(TokenType::LBrace);
+
+ List<RefPtr<Expr>> exprs;
+
+ for(;;)
+ {
+ if(AdvanceIfMatch(parser, TokenType::RBrace))
+ break;
+
+ auto expr = parser->ParseArgExpr();
+ if( expr )
+ {
+ initExpr->args.add(expr);
+ }
+
+ if(AdvanceIfMatch(parser, TokenType::RBrace))
+ break;
+
+ parser->ReadToken(TokenType::Comma);
+ }
+
+ return initExpr;
+ }
+
+ case TokenType::IntegerLiteral:
+ {
+ RefPtr<IntegerLiteralExpr> constExpr = new IntegerLiteralExpr();
+ parser->FillPosition(constExpr.Ptr());
+
+ auto token = parser->tokenReader.AdvanceToken();
+ constExpr->token = token;
+
+ UnownedStringSlice suffix;
+ IntegerLiteralValue value = getIntegerLiteralValue(token, &suffix);
+
+ // Look at any suffix on the value
+ char const* suffixCursor = suffix.begin();
+ const char*const suffixEnd = suffix.end();
+
+ RefPtr<Type> suffixType = nullptr;
+ if( suffixCursor < suffixEnd )
+ {
+ int lCount = 0;
+ int uCount = 0;
+ int unknownCount = 0;
+ while(suffixCursor < suffixEnd)
+ {
+ switch( *suffixCursor++ )
+ {
+ case 'l': case 'L':
+ lCount++;
+ break;
+
+ case 'u': case 'U':
+ uCount++;
+ break;
+
+ default:
+ unknownCount++;
+ break;
+ }
+ }
+
+ if(unknownCount)
+ {
+ parser->sink->diagnose(token, Diagnostics::invalidIntegerLiteralSuffix, suffix);
+ suffixType = parser->getSession()->getErrorType();
+ }
+ // `u` or `ul` suffix -> `uint`
+ else if(uCount == 1 && (lCount <= 1))
+ {
+ suffixType = parser->getSession()->getUIntType();
+ }
+ // `l` suffix on integer -> `int` (== `long`)
+ else if(lCount == 1 && !uCount)
+ {
+ suffixType = parser->getSession()->getIntType();
+ }
+ // `ull` suffix -> `uint64_t`
+ else if(uCount == 1 && lCount == 2)
+ {
+ suffixType = parser->getSession()->getUInt64Type();
+ }
+ // `ll` suffix -> `int64_t`
+ else if(uCount == 0 && lCount == 2)
+ {
+ suffixType = parser->getSession()->getInt64Type();
+ }
+ // TODO: do we need suffixes for smaller integer types?
+ else
+ {
+ parser->sink->diagnose(token, Diagnostics::invalidIntegerLiteralSuffix, suffix);
+ suffixType = parser->getSession()->getErrorType();
+ }
+ }
+
+ constExpr->value = value;
+ constExpr->type = QualType(suffixType);
+
+ return constExpr;
+ }
+
+
+ case TokenType::FloatingPointLiteral:
+ {
+ RefPtr<FloatingPointLiteralExpr> constExpr = new FloatingPointLiteralExpr();
+ parser->FillPosition(constExpr.Ptr());
+
+ auto token = parser->tokenReader.AdvanceToken();
+ constExpr->token = token;
+
+ UnownedStringSlice suffix;
+ FloatingPointLiteralValue value = getFloatingPointLiteralValue(token, &suffix);
+
+ // Look at any suffix on the value
+ char const* suffixCursor = suffix.begin();
+ const char*const suffixEnd = suffix.end();
+
+ RefPtr<Type> suffixType = nullptr;
+ if( suffixCursor < suffixEnd )
+ {
+ int fCount = 0;
+ int lCount = 0;
+ int hCount = 0;
+ int unknownCount = 0;
+ while(suffixCursor < suffixEnd)
+ {
+ switch( *suffixCursor++ )
+ {
+ case 'f': case 'F':
+ fCount++;
+ break;
+
+ case 'l': case 'L':
+ lCount++;
+ break;
+
+ case 'h': case 'H':
+ hCount++;
+ break;
+
+ default:
+ unknownCount++;
+ break;
+ }
+ }
+
+ if (unknownCount)
+ {
+ parser->sink->diagnose(token, Diagnostics::invalidFloatingPointLiteralSuffix, suffix);
+ suffixType = parser->getSession()->getErrorType();
+ }
+ // `f` suffix -> `float`
+ if(fCount == 1 && !lCount)
+ {
+ suffixType = parser->getSession()->getFloatType();
+ }
+ // `l` or `lf` suffix on floating-point literal -> `double`
+ else if(lCount == 1 && (fCount <= 1))
+ {
+ suffixType = parser->getSession()->getDoubleType();
+ }
+ // `h` or `hf` suffix on floating-point literal -> `half`
+ else if(lCount == 1 && (fCount <= 1))
+ {
+ suffixType = parser->getSession()->getHalfType();
+ }
+ // TODO: are there other suffixes we need to handle?
+ else
+ {
+ parser->sink->diagnose(token, Diagnostics::invalidFloatingPointLiteralSuffix, suffix);
+ suffixType = parser->getSession()->getErrorType();
+ }
+ }
+
+ constExpr->value = value;
+ constExpr->type = QualType(suffixType);
+
+ return constExpr;
+ }
+
+ case TokenType::StringLiteral:
+ {
+ RefPtr<StringLiteralExpr> constExpr = new StringLiteralExpr();
+ auto token = parser->tokenReader.AdvanceToken();
+ constExpr->token = token;
+ parser->FillPosition(constExpr.Ptr());
+
+ if (!parser->LookAheadToken(TokenType::StringLiteral))
+ {
+ // Easy/common case: a single string
+ constExpr->value = getStringLiteralTokenValue(token);
+ }
+ else
+ {
+ StringBuilder sb;
+ sb << getStringLiteralTokenValue(token);
+ while (parser->LookAheadToken(TokenType::StringLiteral))
+ {
+ token = parser->tokenReader.AdvanceToken();
+ sb << getStringLiteralTokenValue(token);
+ }
+ constExpr->value = sb.ProduceString();
+ }
+
+ return constExpr;
+ }
+
+ case TokenType::Identifier:
+ {
+ // We will perform name lookup here so that we can find syntax
+ // keywords registered for use as expressions.
+ Token nameToken = peekToken(parser);
+
+ RefPtr<Expr> parsedExpr;
+ if (tryParseUsingSyntaxDecl<Expr>(parser, &parsedExpr))
+ {
+ if (!parsedExpr->loc.isValid())
+ {
+ parsedExpr->loc = nameToken.loc;
+ }
+ return parsedExpr;
+ }
+
+ // Default behavior is just to create a name expression
+ RefPtr<VarExpr> varExpr = new VarExpr();
+ varExpr->scope = parser->currentScope.Ptr();
+ parser->FillPosition(varExpr.Ptr());
+
+ auto nameAndLoc = expectIdentifier(parser);
+ varExpr->name = nameAndLoc.name;
+
+ if(peekTokenType(parser) == TokenType::OpLess)
+ {
+ return maybeParseGenericApp(parser, varExpr);
+ }
+
+ return varExpr;
+ }
+ }
+ }
+
+ static RefPtr<Expr> parsePostfixExpr(Parser* parser)
+ {
+ auto expr = parseAtomicExpr(parser);
+ for(;;)
+ {
+ switch( peekTokenType(parser) )
+ {
+ default:
+ return expr;
+
+ // Postfix increment/decrement
+ case TokenType::OpInc:
+ case TokenType::OpDec:
+ {
+ RefPtr<OperatorExpr> postfixExpr = new PostfixExpr();
+ parser->FillPosition(postfixExpr.Ptr());
+ postfixExpr->FunctionExpr = parseOperator(parser);
+ postfixExpr->Arguments.add(expr);
+
+ expr = postfixExpr;
+ }
+ break;
+
+ // Subscript operation `a[i]`
+ case TokenType::LBracket:
+ {
+ RefPtr<IndexExpr> indexExpr = new IndexExpr();
+ indexExpr->BaseExpression = expr;
+ parser->FillPosition(indexExpr.Ptr());
+ parser->ReadToken(TokenType::LBracket);
+ // TODO: eventually we may want to support multiple arguments inside the `[]`
+ if (!parser->LookAheadToken(TokenType::RBracket))
+ {
+ indexExpr->IndexExpression = parser->ParseExpression();
+ }
+ parser->ReadToken(TokenType::RBracket);
+
+ expr = indexExpr;
+ }
+ break;
+
+ // Call oepration `f(x)`
+ case TokenType::LParent:
+ {
+ RefPtr<InvokeExpr> invokeExpr = new InvokeExpr();
+ invokeExpr->FunctionExpr = expr;
+ parser->FillPosition(invokeExpr.Ptr());
+ parser->ReadToken(TokenType::LParent);
+ while (!parser->tokenReader.IsAtEnd())
+ {
+ if (!parser->LookAheadToken(TokenType::RParent))
+ invokeExpr->Arguments.add(parser->ParseArgExpr());
+ else
+ {
+ break;
+ }
+ if (!parser->LookAheadToken(TokenType::Comma))
+ break;
+ parser->ReadToken(TokenType::Comma);
+ }
+ parser->ReadToken(TokenType::RParent);
+
+ expr = invokeExpr;
+ }
+ break;
+
+ // Scope access `x::m`
+ case TokenType::Scope:
+ {
+ RefPtr<StaticMemberExpr> staticMemberExpr = new StaticMemberExpr();
+
+ // TODO(tfoley): why would a member expression need this?
+ staticMemberExpr->scope = parser->currentScope.Ptr();
+
+ parser->FillPosition(staticMemberExpr.Ptr());
+ staticMemberExpr->BaseExpression = expr;
+ parser->ReadToken(TokenType::Scope);
+ staticMemberExpr->name = expectIdentifier(parser).name;
+
+ if (peekTokenType(parser) == TokenType::OpLess)
+ expr = maybeParseGenericApp(parser, staticMemberExpr);
+ else
+ expr = staticMemberExpr;
+
+ break;
+ }
+ // Member access `x.m`
+ case TokenType::Dot:
+ {
+ RefPtr<MemberExpr> memberExpr = new MemberExpr();
+
+ // TODO(tfoley): why would a member expression need this?
+ memberExpr->scope = parser->currentScope.Ptr();
+
+ parser->FillPosition(memberExpr.Ptr());
+ memberExpr->BaseExpression = expr;
+ parser->ReadToken(TokenType::Dot);
+ memberExpr->name = expectIdentifier(parser).name;
+
+ if (peekTokenType(parser) == TokenType::OpLess)
+ expr = maybeParseGenericApp(parser, memberExpr);
+ else
+ expr = memberExpr;
+ }
+ break;
+ }
+ }
+ }
+
+ static RefPtr<Expr> parsePrefixExpr(Parser* parser)
+ {
+ switch( peekTokenType(parser) )
+ {
+ default:
+ return parsePostfixExpr(parser);
+
+ case TokenType::OpInc:
+ case TokenType::OpDec:
+ case TokenType::OpNot:
+ case TokenType::OpBitNot:
+ case TokenType::OpAdd:
+ case TokenType::OpSub:
+ {
+ RefPtr<PrefixExpr> prefixExpr = new PrefixExpr();
+ parser->FillPosition(prefixExpr.Ptr());
+ prefixExpr->FunctionExpr = parseOperator(parser);
+ prefixExpr->Arguments.add(parsePrefixExpr(parser));
+ return prefixExpr;
+ }
+ break;
+ }
+ }
+
+ RefPtr<Expr> Parser::ParseLeafExpression()
+ {
+ return parsePrefixExpr(this);
+ }
+
+ RefPtr<Expr> parseTypeFromSourceFile(
+ Session* session,
+ TokenSpan const& tokens,
+ DiagnosticSink* sink,
+ RefPtr<Scope> const& outerScope,
+ NamePool* namePool,
+ SourceLanguage sourceLanguage)
+ {
+ Parser parser(session, tokens, sink, outerScope);
+ parser.currentScope = outerScope;
+ parser.namePool = namePool;
+ parser.sourceLanguage = sourceLanguage;
+ return parser.ParseType();
+ }
+
+ // Parse a source file into an existing translation unit
+ void parseSourceFile(
+ TranslationUnitRequest* translationUnit,
+ TokenSpan const& tokens,
+ DiagnosticSink* sink,
+ RefPtr<Scope> const& outerScope)
+ {
+ Parser parser(translationUnit->getSession(), tokens, sink, outerScope);
+ parser.namePool = translationUnit->getNamePool();
+ parser.sourceLanguage = translationUnit->sourceLanguage;
+
+ return parser.parseSourceFile(translationUnit->getModuleDecl());
+ }
+
+ static void addBuiltinSyntaxImpl(
+ Session* session,
+ Scope* scope,
+ char const* nameText,
+ SyntaxParseCallback callback,
+ void* userData,
+ SyntaxClass<RefObject> syntaxClass)
+ {
+ Name* name = session->getNamePool()->getName(nameText);
+
+ RefPtr<SyntaxDecl> syntaxDecl = new SyntaxDecl();
+ syntaxDecl->nameAndLoc = NameLoc(name);
+ syntaxDecl->syntaxClass = syntaxClass;
+ syntaxDecl->parseCallback = callback;
+ syntaxDecl->parseUserData = userData;
+
+ AddMember(scope, syntaxDecl);
+ }
+
+ template<typename T>
+ static void addBuiltinSyntax(
+ Session* session,
+ Scope* scope,
+ char const* name,
+ SyntaxParseCallback callback,
+ void* userData = nullptr)
+ {
+ addBuiltinSyntaxImpl(session, scope, name, callback, userData, getClass<T>());
+ }
+
+ template<typename T>
+ static void addSimpleModifierSyntax(
+ Session* session,
+ Scope* scope,
+ char const* name)
+ {
+ auto syntaxClass = getClass<T>();
+ addBuiltinSyntaxImpl(session, scope, name, &parseSimpleSyntax, (void*) syntaxClass.classInfo, getClass<T>());
+ }
+
+ static RefPtr<RefObject> parseIntrinsicOpModifier(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<IntrinsicOpModifier> modifier = new IntrinsicOpModifier();
+
+ // We allow a few difference forms here:
+ //
+ // First, we can specify the intrinsic op `enum` value directly:
+ //
+ // __intrinsic_op(<integer literal>)
+ //
+ // Second, we can specify the operation by name:
+ //
+ // __intrinsic_op(<identifier>)
+ //
+ // Finally, we can leave off the specification, so that the
+ // op name will be derived from the function name:
+ //
+ // __intrinsic_op
+ //
+ if (AdvanceIf(parser, TokenType::LParent))
+ {
+ if (AdvanceIf(parser, TokenType::OpSub))
+ {
+ modifier->op = IROp(-StringToInt(parser->ReadToken().Content));
+ }
+ else if (parser->LookAheadToken(TokenType::IntegerLiteral))
+ {
+ modifier->op = IROp(StringToInt(parser->ReadToken().Content));
+ }
+ else
+ {
+ modifier->opToken = parser->ReadToken(TokenType::Identifier);
+
+ modifier->op = findIROp(modifier->opToken.Content);
+
+ if (modifier->op == kIROp_Invalid)
+ {
+ parser->sink->diagnose(modifier->opToken, Diagnostics::unimplemented, "unknown intrinsic op");
+ }
+ }
+
+ parser->ReadToken(TokenType::RParent);
+ }
+
+
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseTargetIntrinsicModifier(Parser* parser, void* /*userData*/)
+ {
+ auto modifier = new TargetIntrinsicModifier();
+
+ if (AdvanceIf(parser, TokenType::LParent))
+ {
+ modifier->targetToken = parser->ReadToken(TokenType::Identifier);
+
+ if( AdvanceIf(parser, TokenType::Comma) )
+ {
+ if( parser->LookAheadToken(TokenType::StringLiteral) )
+ {
+ modifier->definitionToken = parser->ReadToken();
+ }
+ else
+ {
+ modifier->definitionToken = parser->ReadToken(TokenType::Identifier);
+ }
+ }
+
+ parser->ReadToken(TokenType::RParent);
+ }
+
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseSpecializedForTargetModifier(Parser* parser, void* /*userData*/)
+ {
+ auto modifier = new SpecializedForTargetModifier();
+ if (AdvanceIf(parser, TokenType::LParent))
+ {
+ modifier->targetToken = parser->ReadToken(TokenType::Identifier);
+ parser->ReadToken(TokenType::RParent);
+ }
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseGLSLExtensionModifier(Parser* parser, void* /*userData*/)
+ {
+ auto modifier = new RequiredGLSLExtensionModifier();
+
+ parser->ReadToken(TokenType::LParent);
+ modifier->extensionNameToken = parser->ReadToken(TokenType::Identifier);
+ parser->ReadToken(TokenType::RParent);
+
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseGLSLVersionModifier(Parser* parser, void* /*userData*/)
+ {
+ auto modifier = new RequiredGLSLVersionModifier();
+
+ parser->ReadToken(TokenType::LParent);
+ modifier->versionNumberToken = parser->ReadToken(TokenType::IntegerLiteral);
+ parser->ReadToken(TokenType::RParent);
+
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseLayoutModifier(Parser* parser, void* /*userData*/)
+ {
+ ModifierListBuilder listBuilder;
+
+ listBuilder.add(new GLSLLayoutModifierGroupBegin());
+
+ parser->ReadToken(TokenType::LParent);
+ while (!AdvanceIfMatch(parser, TokenType::RParent))
+ {
+ auto nameAndLoc = expectIdentifier(parser);
+ const String& nameText = nameAndLoc.name->text;
+
+ if (nameText == "binding" ||
+ nameText == "set")
+ {
+ GLSLBindingAttribute* attr = listBuilder.find<GLSLBindingAttribute>();
+ if (!attr)
+ {
+ attr = new GLSLBindingAttribute();
+ listBuilder.add(attr);
+ }
+
+ parser->ReadToken(TokenType::OpAssign);
+
+ // If the token asked for is not returned found will put in recovering state, and return token found
+ Token valToken = parser->ReadToken(TokenType::IntegerLiteral);
+ // If wasn't the desired IntegerLiteral return that couldn't parse
+ if (valToken.type != TokenType::IntegerLiteral)
+ {
+ return nullptr;
+ }
+
+ // Work out the value
+ auto value = getIntegerLiteralValue(valToken);
+
+ if (nameText == "binding")
+ {
+ attr->binding = int32_t(value);
+ }
+ else
+ {
+ attr->set = int32_t(value);
+ }
+ }
+ else
+ {
+ RefPtr<Modifier> modifier;
+
+#define CASE(key, type) if (nameText == #key) { modifier = new type; } else
+ CASE(push_constant, PushConstantAttribute)
+ CASE(shaderRecordNV, ShaderRecordAttribute)
+ CASE(constant_id, GLSLConstantIDLayoutModifier)
+ CASE(location, GLSLLocationLayoutModifier)
+ CASE(local_size_x, GLSLLocalSizeXLayoutModifier)
+ CASE(local_size_y, GLSLLocalSizeYLayoutModifier)
+ CASE(local_size_z, GLSLLocalSizeZLayoutModifier)
+ {
+ modifier = new GLSLUnparsedLayoutModifier();
+ }
+ SLANG_ASSERT(modifier);
+#undef CASE
+
+ modifier->name = nameAndLoc.name;
+ modifier->loc = nameAndLoc.loc;
+
+ // Special handling for GLSLLayoutModifier
+ if (auto glslModifier = as<GLSLLayoutModifier>(modifier))
+ {
+ if (AdvanceIf(parser, TokenType::OpAssign))
+ {
+ glslModifier->valToken = parser->ReadToken(TokenType::IntegerLiteral);
+ }
+ }
+
+ listBuilder.add(modifier);
+ }
+
+ if (AdvanceIf(parser, TokenType::RParent))
+ break;
+ parser->ReadToken(TokenType::Comma);
+ }
+
+ listBuilder.add(new GLSLLayoutModifierGroupEnd());
+
+ return listBuilder.getFirst();
+ }
+
+ static RefPtr<RefObject> parseBuiltinTypeModifier(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<BuiltinTypeModifier> modifier = new BuiltinTypeModifier();
+ parser->ReadToken(TokenType::LParent);
+ modifier->tag = BaseType(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).Content));
+ parser->ReadToken(TokenType::RParent);
+
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseMagicTypeModifier(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<MagicTypeModifier> modifier = new MagicTypeModifier();
+ parser->ReadToken(TokenType::LParent);
+ modifier->name = parser->ReadToken(TokenType::Identifier).Content;
+ if (AdvanceIf(parser, TokenType::Comma))
+ {
+ modifier->tag = uint32_t(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).Content));
+ }
+ parser->ReadToken(TokenType::RParent);
+
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseIntrinsicTypeModifier(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<IntrinsicTypeModifier> modifier = new IntrinsicTypeModifier();
+ parser->ReadToken(TokenType::LParent);
+ modifier->irOp = uint32_t(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).Content));
+ while( AdvanceIf(parser, TokenType::Comma) )
+ {
+ auto operand = uint32_t(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).Content));
+ modifier->irOperands.add(operand);
+ }
+ parser->ReadToken(TokenType::RParent);
+
+ return modifier;
+ }
+ static RefPtr<RefObject> parseImplicitConversionModifier(Parser* parser, void* /*userData*/)
+ {
+ RefPtr<ImplicitConversionModifier> modifier = new ImplicitConversionModifier();
+
+ ConversionCost cost = kConversionCost_Default;
+ if( AdvanceIf(parser, TokenType::LParent) )
+ {
+ cost = ConversionCost(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).Content));
+ parser->ReadToken(TokenType::RParent);
+ }
+ modifier->cost = cost;
+ return modifier;
+ }
+
+ static RefPtr<RefObject> parseAttributeTargetModifier(Parser* parser, void* /*userData*/)
+ {
+ expect(parser, TokenType::LParent);
+ auto syntaxClassNameAndLoc = expectIdentifier(parser);
+ expect(parser, TokenType::RParent);
+
+ auto syntaxClass = parser->getSession()->findSyntaxClass(syntaxClassNameAndLoc.name);
+
+ RefPtr<AttributeTargetModifier> modifier = new AttributeTargetModifier();
+ modifier->syntaxClass = syntaxClass;
+
+ return modifier;
+ }
+
+ RefPtr<ModuleDecl> populateBaseLanguageModule(
+ Session* session,
+ RefPtr<Scope> scope)
+ {
+ RefPtr<ModuleDecl> moduleDecl = new ModuleDecl();
+ scope->containerDecl = moduleDecl;
+
+ // Add syntax for declaration keywords
+ #define DECL(KEYWORD, CALLBACK) \
+ addBuiltinSyntax<Decl>(session, scope, #KEYWORD, &CALLBACK)
+ DECL(typedef, ParseTypeDef);
+ DECL(associatedtype, parseAssocType);
+ DECL(type_param, parseGlobalGenericParamDecl);
+ DECL(cbuffer, parseHLSLCBufferDecl);
+ DECL(tbuffer, parseHLSLTBufferDecl);
+ DECL(__generic, ParseGenericDecl);
+ DECL(__extension, ParseExtensionDecl);
+ DECL(extension, ParseExtensionDecl);
+ DECL(__init, parseConstructorDecl);
+ DECL(__subscript, ParseSubscriptDecl);
+ DECL(interface, parseInterfaceDecl);
+ DECL(syntax, parseSyntaxDecl);
+ DECL(attribute_syntax,parseAttributeSyntaxDecl);
+ DECL(__import, parseImportDecl);
+ DECL(import, parseImportDecl);
+ DECL(let, parseLetDecl);
+ DECL(var, parseVarDecl);
+ DECL(func, parseFuncDecl);
+ DECL(typealias, parseTypeAliasDecl);
+
+ #undef DECL
+
+ // Add syntax for "simple" modifier keywords.
+ // These are the ones that just appear as a single
+ // keyword (no further tokens expected/allowed),
+ // and which can be represented just by creating
+ // a new AST node of the corresponding type.
+ #define MODIFIER(KEYWORD, CLASS) \
+ addSimpleModifierSyntax<CLASS>(session, scope, #KEYWORD)
+
+ MODIFIER(in, InModifier);
+ MODIFIER(input, InputModifier);
+ MODIFIER(out, OutModifier);
+ MODIFIER(inout, InOutModifier);
+ MODIFIER(__ref, RefModifier);
+ MODIFIER(const, ConstModifier);
+ MODIFIER(instance, InstanceModifier);
+ MODIFIER(__builtin, BuiltinModifier);
+
+ MODIFIER(inline, InlineModifier);
+ MODIFIER(public, PublicModifier);
+ MODIFIER(require, RequireModifier);
+ MODIFIER(param, ParamModifier);
+ MODIFIER(extern, ExternModifier);
+
+ MODIFIER(row_major, HLSLRowMajorLayoutModifier);
+ MODIFIER(column_major, HLSLColumnMajorLayoutModifier);
+
+ MODIFIER(nointerpolation, HLSLNoInterpolationModifier);
+ MODIFIER(noperspective, HLSLNoPerspectiveModifier);
+ MODIFIER(linear, HLSLLinearModifier);
+ MODIFIER(sample, HLSLSampleModifier);
+ MODIFIER(centroid, HLSLCentroidModifier);
+ MODIFIER(precise, PreciseModifier);
+ MODIFIER(shared, HLSLEffectSharedModifier);
+ MODIFIER(groupshared, HLSLGroupSharedModifier);
+ MODIFIER(static, HLSLStaticModifier);
+ MODIFIER(uniform, HLSLUniformModifier);
+ MODIFIER(volatile, HLSLVolatileModifier);
+
+ // Modifiers for geometry shader input
+ MODIFIER(point, HLSLPointModifier);
+ MODIFIER(line, HLSLLineModifier);
+ MODIFIER(triangle, HLSLTriangleModifier);
+ MODIFIER(lineadj, HLSLLineAdjModifier);
+ MODIFIER(triangleadj, HLSLTriangleAdjModifier);
+
+ // Modifiers for unary operator declarations
+ MODIFIER(__prefix, PrefixModifier);
+ MODIFIER(__postfix, PostfixModifier);
+
+ // Modifier to apply to `import` that should be re-exported
+ MODIFIER(__exported, ExportedModifier);
+
+ #undef MODIFIER
+
+ // Add syntax for more complex modifiers, which allow
+ // or expect more tokens after the initial keyword.
+ #define MODIFIER(KEYWORD, CALLBACK) \
+ addBuiltinSyntax<Modifier>(session, scope, #KEYWORD, &CALLBACK)
+
+ MODIFIER(layout, parseLayoutModifier);
+
+ MODIFIER(__intrinsic_op, parseIntrinsicOpModifier);
+ MODIFIER(__target_intrinsic, parseTargetIntrinsicModifier);
+ MODIFIER(__specialized_for_target, parseSpecializedForTargetModifier);
+ MODIFIER(__glsl_extension, parseGLSLExtensionModifier);
+ MODIFIER(__glsl_version, parseGLSLVersionModifier);
+
+ MODIFIER(__builtin_type, parseBuiltinTypeModifier);
+ MODIFIER(__magic_type, parseMagicTypeModifier);
+ MODIFIER(__intrinsic_type, parseIntrinsicTypeModifier);
+ MODIFIER(__implicit_conversion, parseImplicitConversionModifier);
+
+ MODIFIER(__attributeTarget, parseAttributeTargetModifier);
+
+
+#undef MODIFIER
+
+ // Add syntax for expression keywords
+ #define EXPR(KEYWORD, CALLBACK) \
+ addBuiltinSyntax<Expr>(session, scope, #KEYWORD, &CALLBACK)
+
+ EXPR(this, parseThisExpr);
+ EXPR(true, parseTrueExpr);
+ EXPR(false, parseFalseExpr);
+
+ #undef EXPR
+
+ return moduleDecl;
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-01 21:14:45 +0000