From 076a4c06767cca12c5205d950e9cd37451f91488 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Fri, 22 May 2020 14:21:37 -0400 Subject: Tidy up around AST nodes (#1353) * Fields from upper to lower case in slang-ast-decl.h * Lower camel field names in slang-ast-stmt.h * Fix fields in slang-ast-expr.h * slang-ast-type.h make fields lowerCamel. * slang-ast-base.h members functions lowerCamel. * Method names in slang-ast-type.h to lowerCamel. * GetCanonicalType -> getCanonicalType * Substitute -> substitute * Equals -> equals ToString -> toString * ParentDecl -> parentDecl Members -> members --- source/slang/slang-parser.cpp | 124 +++++++++++++++++++++--------------------- 1 file changed, 62 insertions(+), 62 deletions(-) (limited to 'source/slang/slang-parser.cpp') diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index 8d4ba36c0..f8622964f 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -122,7 +122,7 @@ namespace Slang void pushScopeAndSetParent(ContainerDecl* containerDecl) { - containerDecl->ParentDecl = currentScope->containerDecl; + containerDecl->parentDecl = currentScope->containerDecl; PushScope(containerDecl); } @@ -1078,8 +1078,8 @@ namespace Slang { if (container) { - member->ParentDecl = container.Ptr(); - container->Members.add(member); + member->parentDecl = container.Ptr(); + container->members.add(member); } } @@ -1166,7 +1166,7 @@ namespace Slang parser->genericDepth--; parser->ReadToken(TokenType::OpGreater); decl->inner = parseInnerFunc(decl); - decl->inner->ParentDecl = decl; + decl->inner->parentDecl = decl; // A generic decl hijacks the name of the declaration // it wraps, so that lookup can find it. @@ -1246,23 +1246,23 @@ namespace Slang } void visitGenericAppExpr(GenericAppExpr * expr) { - expr->FunctionExpr->accept(this, nullptr); - for (auto arg : expr->Arguments) + 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); + expr->baseExpression->accept(this, nullptr); + expr->indexExpression->accept(this, nullptr); } void visitMemberExpr(MemberExpr * expr) { - expr->BaseExpression->accept(this, nullptr); + expr->baseExpression->accept(this, nullptr); expr->scope = scope; } void visitStaticMemberExpr(StaticMemberExpr * expr) { - expr->BaseExpression->accept(this, nullptr); + expr->baseExpression->accept(this, nullptr); expr->scope = scope; } void visitExpr(Expr* /*expr*/) @@ -1310,13 +1310,13 @@ namespace Slang replaceScopeVisitor.scope = parser->currentScope; declaratorInfo.typeSpec->accept(&replaceScopeVisitor, nullptr); - decl->ReturnType = TypeExp(declaratorInfo.typeSpec); + decl->returnType = TypeExp(declaratorInfo.typeSpec); parser->PushScope(decl); parseParameterList(parser, decl); ParseOptSemantics(parser, decl.Ptr()); - decl->Body = parseOptBody(parser); + decl->body = parseOptBody(parser); parser->PopScope(); @@ -1588,8 +1588,8 @@ namespace Slang auto arrayTypeExpr = new IndexExpr(); arrayTypeExpr->loc = arrayDeclarator->openBracketLoc; - arrayTypeExpr->BaseExpression = ioInfo->typeSpec; - arrayTypeExpr->IndexExpression = arrayDeclarator->elementCountExpr; + arrayTypeExpr->baseExpression = ioInfo->typeSpec; + arrayTypeExpr->indexExpression = arrayDeclarator->elementCountExpr; ioInfo->typeSpec = arrayTypeExpr; declarator = arrayDeclarator->inner; @@ -1690,14 +1690,14 @@ namespace Slang RefPtr genericApp = new GenericAppExpr(); parser->FillPosition(genericApp.Ptr()); // set up scope for lookup - genericApp->FunctionExpr = base; + genericApp->functionExpr = base; parser->ReadToken(TokenType::OpLess); parser->genericDepth++; // For now assume all generics have at least one argument - genericApp->Arguments.add(ParseGenericArg(parser)); + genericApp->arguments.add(ParseGenericArg(parser)); while (AdvanceIf(parser, TokenType::Comma)) { - genericApp->Arguments.add(ParseGenericArg(parser)); + genericApp->arguments.add(ParseGenericArg(parser)); } parser->genericDepth--; @@ -1774,7 +1774,7 @@ namespace Slang RefPtr memberExpr = new MemberExpr(); parser->FillPosition(memberExpr.Ptr()); - memberExpr->BaseExpression = base; + memberExpr->baseExpression = base; memberExpr->name = expectIdentifier(parser).name; return memberExpr; } @@ -1789,11 +1789,11 @@ namespace Slang { RefPtr arrType = new IndexExpr(); arrType->loc = typeExpr->loc; - arrType->BaseExpression = typeExpr; + arrType->baseExpression = typeExpr; parser->ReadToken(TokenType::LBracket); if (!parser->LookAheadToken(TokenType::RBracket)) { - arrType->IndexExpression = parser->ParseExpression(); + arrType->indexExpression = parser->ParseExpression(); } parser->ReadToken(TokenType::RBracket); typeExpr = arrType; @@ -2331,8 +2331,8 @@ namespace Slang // 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); + bufferVarTypeExpr->functionExpr = bufferWrapperTypeExpr; + bufferVarTypeExpr->arguments.add(bufferDataTypeExpr); bufferVarDecl->type.exp = bufferVarTypeExpr; @@ -2629,7 +2629,7 @@ namespace Slang parseParameterList(parser, decl); - decl->Body = parseOptBody(parser); + decl->body = parseOptBody(parser); parser->PopScope(); return decl; @@ -2662,7 +2662,7 @@ namespace Slang if( parser->tokenReader.peekTokenType() == TokenType::LBrace ) { - decl->Body = parser->parseBlockStatement(); + decl->body = parser->parseBlockStatement(); } else { @@ -2685,7 +2685,7 @@ namespace Slang if( AdvanceIf(parser, TokenType::RightArrow) ) { - decl->ReturnType = parser->ParseTypeExp(); + decl->returnType = parser->ParseTypeExp(); } if( AdvanceIf(parser, TokenType::LBrace) ) @@ -2801,9 +2801,9 @@ namespace Slang parseModernParamList(parser, decl); if(AdvanceIf(parser, TokenType::RightArrow)) { - decl->ReturnType = parser->ParseTypeExp(); + decl->returnType = parser->ParseTypeExp(); } - decl->Body = parseOptBody(parser); + decl->body = parseOptBody(parser); parser->PopScope(); return decl; }); @@ -3634,13 +3634,13 @@ namespace Slang FillPosition(ifStatement.Ptr()); ReadToken("if"); ReadToken(TokenType::LParent); - ifStatement->Predicate = ParseExpression(); + ifStatement->predicate = ParseExpression(); ReadToken(TokenType::RParent); - ifStatement->PositiveStatement = ParseStatement(); + ifStatement->positiveStatement = ParseStatement(); if (LookAheadToken("else")) { ReadToken("else"); - ifStatement->NegativeStatement = ParseStatement(); + ifStatement->negativeStatement = ParseStatement(); } return ifStatement; } @@ -3679,13 +3679,13 @@ namespace Slang ReadToken(TokenType::LParent); if (peekTypeName(this)) { - stmt->InitialStatement = parseVarDeclrStatement(Modifiers()); + stmt->initialStatement = parseVarDeclrStatement(Modifiers()); } else { if (!LookAheadToken(TokenType::Semicolon)) { - stmt->InitialStatement = ParseExpressionStatement(); + stmt->initialStatement = ParseExpressionStatement(); } else { @@ -3693,12 +3693,12 @@ namespace Slang } } if (!LookAheadToken(TokenType::Semicolon)) - stmt->PredicateExpression = ParseExpression(); + stmt->predicateExpression = ParseExpression(); ReadToken(TokenType::Semicolon); if (!LookAheadToken(TokenType::RParent)) - stmt->SideEffectExpression = ParseExpression(); + stmt->sideEffectExpression = ParseExpression(); ReadToken(TokenType::RParent); - stmt->Statement = ParseStatement(); + stmt->statement = ParseStatement(); if (!brokenScoping) PopScope(); @@ -3712,9 +3712,9 @@ namespace Slang FillPosition(whileStatement.Ptr()); ReadToken("while"); ReadToken(TokenType::LParent); - whileStatement->Predicate = ParseExpression(); + whileStatement->predicate = ParseExpression(); ReadToken(TokenType::RParent); - whileStatement->Statement = ParseStatement(); + whileStatement->statement = ParseStatement(); return whileStatement; } @@ -3723,10 +3723,10 @@ namespace Slang RefPtr doWhileStatement = new DoWhileStmt(); FillPosition(doWhileStatement.Ptr()); ReadToken("do"); - doWhileStatement->Statement = ParseStatement(); + doWhileStatement->statement = ParseStatement(); ReadToken("while"); ReadToken(TokenType::LParent); - doWhileStatement->Predicate = ParseExpression(); + doWhileStatement->predicate = ParseExpression(); ReadToken(TokenType::RParent); ReadToken(TokenType::Semicolon); return doWhileStatement; @@ -3756,7 +3756,7 @@ namespace Slang FillPosition(returnStatement.Ptr()); ReadToken("return"); if (!LookAheadToken(TokenType::Semicolon)) - returnStatement->Expression = ParseExpression(); + returnStatement->expression = ParseExpression(); ReadToken(TokenType::Semicolon); return returnStatement; } @@ -3766,7 +3766,7 @@ namespace Slang RefPtr statement = new ExpressionStmt(); FillPosition(statement.Ptr()); - statement->Expression = ParseExpression(); + statement->expression = ParseExpression(); ReadToken(TokenType::Semicolon); return statement; @@ -3918,9 +3918,9 @@ namespace Slang { RefPtr expr = new InfixExpr(); expr->loc = op->loc; - expr->FunctionExpr = op; - expr->Arguments.add(left); - expr->Arguments.add(right); + expr->functionExpr = op; + expr->arguments.add(left); + expr->arguments.add(right); return expr; } @@ -3945,13 +3945,13 @@ namespace Slang { RefPtr select = new SelectExpr(); select->loc = op->loc; - select->FunctionExpr = op; + select->functionExpr = op; - select->Arguments.add(expr); + select->arguments.add(expr); - select->Arguments.add(parser->ParseExpression(opPrec)); + select->arguments.add(parser->ParseExpression(opPrec)); parser->ReadToken(TokenType::Colon); - select->Arguments.add(parser->ParseExpression(opPrec)); + select->arguments.add(parser->ParseExpression(opPrec)); expr = select; continue; @@ -4282,11 +4282,11 @@ namespace Slang { RefPtr tcexpr = new ExplicitCastExpr(); parser->FillPosition(tcexpr.Ptr()); - tcexpr->FunctionExpr = parser->ParseType(); + tcexpr->functionExpr = parser->ParseType(); parser->ReadToken(TokenType::RParent); auto arg = parsePrefixExpr(parser); - tcexpr->Arguments.add(arg); + tcexpr->arguments.add(arg); return tcexpr; } @@ -4613,8 +4613,8 @@ namespace Slang { RefPtr postfixExpr = new PostfixExpr(); parser->FillPosition(postfixExpr.Ptr()); - postfixExpr->FunctionExpr = parseOperator(parser); - postfixExpr->Arguments.add(expr); + postfixExpr->functionExpr = parseOperator(parser); + postfixExpr->arguments.add(expr); expr = postfixExpr; } @@ -4624,13 +4624,13 @@ namespace Slang case TokenType::LBracket: { RefPtr indexExpr = new IndexExpr(); - indexExpr->BaseExpression = expr; + 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(); + indexExpr->indexExpression = parser->ParseExpression(); } parser->ReadToken(TokenType::RBracket); @@ -4642,13 +4642,13 @@ namespace Slang case TokenType::LParent: { RefPtr invokeExpr = new InvokeExpr(); - invokeExpr->FunctionExpr = expr; + 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()); + invokeExpr->arguments.add(parser->ParseArgExpr()); else { break; @@ -4672,7 +4672,7 @@ namespace Slang staticMemberExpr->scope = parser->currentScope.Ptr(); parser->FillPosition(staticMemberExpr.Ptr()); - staticMemberExpr->BaseExpression = expr; + staticMemberExpr->baseExpression = expr; parser->ReadToken(TokenType::Scope); staticMemberExpr->name = expectIdentifier(parser).name; @@ -4692,7 +4692,7 @@ namespace Slang memberExpr->scope = parser->currentScope.Ptr(); parser->FillPosition(memberExpr.Ptr()); - memberExpr->BaseExpression = expr; + memberExpr->baseExpression = expr; parser->ReadToken(TokenType::Dot); memberExpr->name = expectIdentifier(parser).name; @@ -4749,11 +4749,11 @@ namespace Slang { RefPtr prefixExpr = new PrefixExpr(); parser->FillPosition(prefixExpr.Ptr()); - prefixExpr->FunctionExpr = parseOperator(parser); + prefixExpr->functionExpr = parseOperator(parser); auto arg = parsePrefixExpr(parser); - prefixExpr->Arguments.add(arg); + prefixExpr->arguments.add(arg); return prefixExpr; } case TokenType::OpBitNot: @@ -4762,7 +4762,7 @@ namespace Slang { RefPtr prefixExpr = new PrefixExpr(); parser->FillPosition(prefixExpr.Ptr()); - prefixExpr->FunctionExpr = parseOperator(parser); + prefixExpr->functionExpr = parseOperator(parser); auto arg = parsePrefixExpr(parser); @@ -4788,7 +4788,7 @@ namespace Slang return newLiteral; } - prefixExpr->Arguments.add(arg); + prefixExpr->arguments.add(arg); return prefixExpr; } -- cgit v1.2.3