Skip to content

Commit 318f1ec

Browse files
author
Finn Plummer
committed
review: conform to llvm method naming conventions
1 parent 2123282 commit 318f1ec

File tree

3 files changed

+62
-62
lines changed

3 files changed

+62
-62
lines changed

‎clang/include/clang/Parse/ParseHLSLRootSignature.h‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -35,10 +35,10 @@ class RootSignatureParser {
3535
/// error is encountered or the end of the buffer.
3636
///
3737
/// Returns true if a parsing error is encountered.
38-
bool Parse();
38+
bool parse();
3939

4040
private:
41-
DiagnosticsEngine &Diags() { return PP.getDiagnostics(); }
41+
DiagnosticsEngine &getDiags() { return PP.getDiagnostics(); }
4242

4343
// All private Parse.* methods follow a similar pattern:
4444
// - Each method will start with an assert to denote what the CurToken is
@@ -66,24 +66,24 @@ class RootSignatureParser {
6666
// expected, or, there is a lexing error
6767

6868
/// Root Element parse methods:
69-
bool ParseDescriptorTable();
70-
bool ParseDescriptorTableClause();
69+
bool parseDescriptorTable();
70+
bool parseDescriptorTableClause();
7171

7272
/// Invoke the Lexer to consume a token and update CurToken with the result
73-
void ConsumeNextToken() { CurToken = Lexer.ConsumeToken(); }
73+
void consumeNextToken() { CurToken = Lexer.ConsumeToken(); }
7474

7575
/// Return true if the next token one of the expected kinds
76-
bool PeekExpectedToken(TokenKind Expected);
77-
bool PeekExpectedToken(ArrayRef<TokenKind> AnyExpected);
76+
bool peekExpectedToken(TokenKind Expected);
77+
bool peekExpectedToken(ArrayRef<TokenKind> AnyExpected);
7878

7979
/// Consumes the next token and report an error if it is not of the expected
8080
/// kind.
8181
///
8282
/// Returns true if there was an error reported.
83-
bool ConsumeExpectedToken(TokenKind Expected,
83+
bool consumeExpectedToken(TokenKind Expected,
8484
unsigned DiagID = diag::err_expected,
8585
TokenKind Context = TokenKind::invalid);
86-
bool ConsumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
86+
bool consumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
8787
unsigned DiagID = diag::err_expected,
8888
TokenKind Context = TokenKind::invalid);
8989

@@ -92,8 +92,8 @@ class RootSignatureParser {
9292
///
9393
/// Returns true if it successfully matches the expected kind and the token
9494
/// was consumed.
95-
bool TryConsumeExpectedToken(TokenKind Expected);
96-
bool TryConsumeExpectedToken(ArrayRef<TokenKind> Expected);
95+
bool tryConsumeExpectedToken(TokenKind Expected);
96+
bool tryConsumeExpectedToken(ArrayRef<TokenKind> Expected);
9797

9898
private:
9999
SmallVector<llvm::hlsl::rootsig::RootElement> &Elements;

‎clang/lib/Parse/ParseHLSLRootSignature.cpp‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -34,59 +34,59 @@ RootSignatureParser::RootSignatureParser(SmallVector<RootElement> &Elements,
3434
Preprocessor &PP)
3535
: Elements(Elements), Lexer(Lexer), PP(PP), CurToken(SourceLocation()) {}
3636

37-
bool RootSignatureParser::Parse() {
37+
bool RootSignatureParser::parse() {
3838
// Iterate as many RootElements as possible
39-
while (TryConsumeExpectedToken(TokenKind::kw_DescriptorTable)) {
39+
while (tryConsumeExpectedToken(TokenKind::kw_DescriptorTable)) {
4040
// Dispatch onto parser method.
4141
// We guard against the unreachable here as we just ensured that CurToken
4242
// will be one of the kinds in the while condition
4343
switch (CurToken.Kind) {
4444
case TokenKind::kw_DescriptorTable:
45-
if (ParseDescriptorTable())
45+
if (parseDescriptorTable())
4646
return true;
4747
break;
4848
default:
4949
llvm_unreachable("Switch for consumed token was not provided");
5050
}
5151

52-
if (!TryConsumeExpectedToken(TokenKind::pu_comma))
52+
if (!tryConsumeExpectedToken(TokenKind::pu_comma))
5353
break;
5454
}
5555

56-
return ConsumeExpectedToken(TokenKind::end_of_stream, diag::err_expected);
56+
return consumeExpectedToken(TokenKind::end_of_stream, diag::err_expected);
5757
}
5858

59-
bool RootSignatureParser::ParseDescriptorTable() {
59+
bool RootSignatureParser::parseDescriptorTable() {
6060
assert(CurToken.Kind == TokenKind::kw_DescriptorTable &&
6161
"Expects to only be invoked starting at given keyword");
6262

6363
DescriptorTable Table;
6464

65-
if (ConsumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after,
65+
if (consumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after,
6666
CurToken.Kind))
6767
return true;
6868

6969
// Iterate as many Clauses as possible
70-
while (TryConsumeExpectedToken({TokenKind::kw_CBV, TokenKind::kw_SRV,
70+
while (tryConsumeExpectedToken({TokenKind::kw_CBV, TokenKind::kw_SRV,
7171
TokenKind::kw_UAV, TokenKind::kw_Sampler})) {
72-
if (ParseDescriptorTableClause())
72+
if (parseDescriptorTableClause())
7373
return true;
7474

7575
Table.NumClauses++;
7676

77-
if (!TryConsumeExpectedToken(TokenKind::pu_comma))
77+
if (!tryConsumeExpectedToken(TokenKind::pu_comma))
7878
break;
7979
}
8080

81-
if (ConsumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after,
81+
if (consumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after,
8282
CurToken.Kind))
8383
return true;
8484

8585
Elements.push_back(Table);
8686
return false;
8787
}
8888

89-
bool RootSignatureParser::ParseDescriptorTableClause() {
89+
bool RootSignatureParser::parseDescriptorTableClause() {
9090
assert((CurToken.Kind == TokenKind::kw_CBV ||
9191
CurToken.Kind == TokenKind::kw_SRV ||
9292
CurToken.Kind == TokenKind::kw_UAV ||
@@ -111,11 +111,11 @@ bool RootSignatureParser::ParseDescriptorTableClause() {
111111
break;
112112
}
113113

114-
if (ConsumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after,
114+
if (consumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after,
115115
CurToken.Kind))
116116
return true;
117117

118-
if (ConsumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after,
118+
if (consumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after,
119119
CurToken.Kind))
120120
return true;
121121

@@ -131,29 +131,29 @@ static bool IsExpectedToken(TokenKind Kind, ArrayRef<TokenKind> AnyExpected) {
131131
return false;
132132
}
133133

134-
bool RootSignatureParser::PeekExpectedToken(TokenKind Expected) {
135-
return PeekExpectedToken(ArrayRef{Expected});
134+
bool RootSignatureParser::peekExpectedToken(TokenKind Expected) {
135+
return peekExpectedToken(ArrayRef{Expected});
136136
}
137137

138-
bool RootSignatureParser::PeekExpectedToken(ArrayRef<TokenKind> AnyExpected) {
138+
bool RootSignatureParser::peekExpectedToken(ArrayRef<TokenKind> AnyExpected) {
139139
RootSignatureToken Result = Lexer.PeekNextToken();
140140
return IsExpectedToken(Result.Kind, AnyExpected);
141141
}
142142

143-
bool RootSignatureParser::ConsumeExpectedToken(TokenKind Expected,
143+
bool RootSignatureParser::consumeExpectedToken(TokenKind Expected,
144144
unsigned DiagID,
145145
TokenKind Context) {
146-
return ConsumeExpectedToken(ArrayRef{Expected}, DiagID, Context);
146+
return consumeExpectedToken(ArrayRef{Expected}, DiagID, Context);
147147
}
148148

149-
bool RootSignatureParser::ConsumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
149+
bool RootSignatureParser::consumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
150150
unsigned DiagID,
151151
TokenKind Context) {
152-
if (TryConsumeExpectedToken(AnyExpected))
152+
if (tryConsumeExpectedToken(AnyExpected))
153153
return false;
154154

155155
// Report unexpected token kind error
156-
DiagnosticBuilder DB = Diags().Report(CurToken.TokLoc, DiagID);
156+
DiagnosticBuilder DB = getDiags().Report(CurToken.TokLoc, DiagID);
157157
switch (DiagID) {
158158
case diag::err_expected:
159159
DB << FormatTokenKinds(AnyExpected);
@@ -168,16 +168,16 @@ bool RootSignatureParser::ConsumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
168168
return true;
169169
}
170170

171-
bool RootSignatureParser::TryConsumeExpectedToken(TokenKind Expected) {
172-
return TryConsumeExpectedToken(ArrayRef{Expected});
171+
bool RootSignatureParser::tryConsumeExpectedToken(TokenKind Expected) {
172+
return tryConsumeExpectedToken(ArrayRef{Expected});
173173
}
174174

175-
bool RootSignatureParser::TryConsumeExpectedToken(
175+
bool RootSignatureParser::tryConsumeExpectedToken(
176176
ArrayRef<TokenKind> AnyExpected) {
177177
// If not the expected token just return
178-
if (!PeekExpectedToken(AnyExpected))
178+
if (!peekExpectedToken(AnyExpected))
179179
return false;
180-
ConsumeNextToken();
180+
consumeNextToken();
181181
return true;
182182
}
183183

‎clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp‎

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -49,17 +49,17 @@ class ExpectedDiagConsumer : public DiagnosticConsumer {
4949
std::optional<unsigned> ExpectedDiagID;
5050

5151
public:
52-
void SetNoDiag() {
52+
void setNoDiag() {
5353
Satisfied = true;
5454
ExpectedDiagID = std::nullopt;
5555
}
5656

57-
void SetExpected(unsigned DiagID) {
57+
void setExpected(unsigned DiagID) {
5858
Satisfied = false;
5959
ExpectedDiagID = DiagID;
6060
}
6161

62-
bool IsSatisfied() { return Satisfied; }
62+
bool isSatisfied() { return Satisfied; }
6363
};
6464

6565
// The test fixture.
@@ -75,7 +75,7 @@ class ParseHLSLRootSignatureTest : public ::testing::Test {
7575
Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
7676
}
7777

78-
std::unique_ptr<Preprocessor> CreatePP(StringRef Source,
78+
std::unique_ptr<Preprocessor> createPP(StringRef Source,
7979
TrivialModuleLoader &ModLoader) {
8080
std::unique_ptr<llvm::MemoryBuffer> Buf =
8181
llvm::MemoryBuffer::getMemBuffer(Source);
@@ -111,20 +111,20 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseEmptyTest) {
111111
const llvm::StringLiteral Source = R"cc()cc";
112112

113113
TrivialModuleLoader ModLoader;
114-
auto PP = CreatePP(Source, ModLoader);
114+
auto PP = createPP(Source, ModLoader);
115115
auto TokLoc = SourceLocation();
116116

117117
hlsl::RootSignatureLexer Lexer(Source, TokLoc);
118118
SmallVector<RootElement> Elements;
119119
hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
120120

121121
// Test no diagnostics produced
122-
Consumer->SetNoDiag();
122+
Consumer->setNoDiag();
123123

124-
ASSERT_FALSE(Parser.Parse());
124+
ASSERT_FALSE(Parser.parse());
125125
ASSERT_EQ((int)Elements.size(), 0);
126126

127-
ASSERT_TRUE(Consumer->IsSatisfied());
127+
ASSERT_TRUE(Consumer->isSatisfied());
128128
}
129129

130130
TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
@@ -139,17 +139,17 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
139139
)cc";
140140

141141
TrivialModuleLoader ModLoader;
142-
auto PP = CreatePP(Source, ModLoader);
142+
auto PP = createPP(Source, ModLoader);
143143
auto TokLoc = SourceLocation();
144144

145145
hlsl::RootSignatureLexer Lexer(Source, TokLoc);
146146
SmallVector<RootElement> Elements;
147147
hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
148148

149149
// Test no diagnostics produced
150-
Consumer->SetNoDiag();
150+
Consumer->setNoDiag();
151151

152-
ASSERT_FALSE(Parser.Parse());
152+
ASSERT_FALSE(Parser.parse());
153153

154154
// First Descriptor Table with 4 elements
155155
RootElement Elem = Elements[0];
@@ -176,7 +176,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
176176
Elem = Elements[5];
177177
ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem));
178178
ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, 0u);
179-
ASSERT_TRUE(Consumer->IsSatisfied());
179+
ASSERT_TRUE(Consumer->isSatisfied());
180180
}
181181

182182
// Invalid Parser Tests
@@ -188,18 +188,18 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedTokenTest) {
188188
)cc";
189189

190190
TrivialModuleLoader ModLoader;
191-
auto PP = CreatePP(Source, ModLoader);
191+
auto PP = createPP(Source, ModLoader);
192192
auto TokLoc = SourceLocation();
193193

194194
hlsl::RootSignatureLexer Lexer(Source, TokLoc);
195195
SmallVector<RootElement> Elements;
196196
hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
197197

198198
// Test correct diagnostic produced
199-
Consumer->SetExpected(diag::err_expected);
200-
ASSERT_TRUE(Parser.Parse());
199+
Consumer->setExpected(diag::err_expected);
200+
ASSERT_TRUE(Parser.parse());
201201

202-
ASSERT_TRUE(Consumer->IsSatisfied());
202+
ASSERT_TRUE(Consumer->isSatisfied());
203203
}
204204

205205
TEST_F(ParseHLSLRootSignatureTest, InvalidParseInvalidTokenTest) {
@@ -208,18 +208,18 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseInvalidTokenTest) {
208208
)cc";
209209

210210
TrivialModuleLoader ModLoader;
211-
auto PP = CreatePP(Source, ModLoader);
211+
auto PP = createPP(Source, ModLoader);
212212
auto TokLoc = SourceLocation();
213213

214214
hlsl::RootSignatureLexer Lexer(Source, TokLoc);
215215
SmallVector<RootElement> Elements;
216216
hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
217217

218218
// Test correct diagnostic produced - invalid token
219-
Consumer->SetExpected(diag::err_expected);
220-
ASSERT_TRUE(Parser.Parse());
219+
Consumer->setExpected(diag::err_expected);
220+
ASSERT_TRUE(Parser.parse());
221221

222-
ASSERT_TRUE(Consumer->IsSatisfied());
222+
ASSERT_TRUE(Consumer->isSatisfied());
223223
}
224224

225225
TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedEndOfStreamTest) {
@@ -228,18 +228,18 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedEndOfStreamTest) {
228228
)cc";
229229

230230
TrivialModuleLoader ModLoader;
231-
auto PP = CreatePP(Source, ModLoader);
231+
auto PP = createPP(Source, ModLoader);
232232
auto TokLoc = SourceLocation();
233233

234234
hlsl::RootSignatureLexer Lexer(Source, TokLoc);
235235
SmallVector<RootElement> Elements;
236236
hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
237237

238238
// Test correct diagnostic produced - end of stream
239-
Consumer->SetExpected(diag::err_expected_after);
240-
ASSERT_TRUE(Parser.Parse());
239+
Consumer->setExpected(diag::err_expected_after);
240+
ASSERT_TRUE(Parser.parse());
241241

242-
ASSERT_TRUE(Consumer->IsSatisfied());
242+
ASSERT_TRUE(Consumer->isSatisfied());
243243
}
244244

245245
} // anonymous namespace

0 commit comments

Comments
 (0)