Skip to content

Commit bda5619

Browse files
erakerak
committed
Introduces new solt namespace and removes dead code.
1 parent 0a2630a commit bda5619

File tree

3 files changed

+142
-101
lines changed

3 files changed

+142
-101
lines changed

‎test/libsolidity/util/TestFileParser.cpp

+73-88
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,7 @@ using namespace langutil;
3131
using namespace solidity;
3232
using namespace dev::solidity::test;
3333
using namespace std;
34+
using namespace solt;
3435

3536
namespace
3637
{
@@ -47,14 +48,14 @@ namespace
4748
vector<dev::solidity::test::FunctionCall> TestFileParser::parseFunctionCalls()
4849
{
4950
vector<FunctionCall> calls;
50-
if (!accept(SoltToken::EOS))
51+
if (!accept(Token::EOS))
5152
{
52-
assert(m_scanner.currentToken() == SoltToken::Unknown);
53+
assert(m_scanner.currentToken() == Token::Unknown);
5354
m_scanner.scanNextToken();
5455

55-
while (!accept(SoltToken::EOS))
56+
while (!accept(Token::EOS))
5657
{
57-
if (!accept(SoltToken::Whitespace))
58+
if (!accept(Token::Whitespace))
5859
{
5960
FunctionCall call;
6061

@@ -64,63 +65,47 @@ vector<dev::solidity::test::FunctionCall> TestFileParser::parseFunctionCalls()
6465
/// token lookahead that checks parseParameter
6566
/// if the next token is an identifier.
6667
if (calls.empty())
67-
expect(SoltToken::Newline);
68+
expect(Token::Newline);
6869
else
69-
accept(SoltToken::Newline, true);
70+
accept(Token::Newline, true);
7071

7172
call.signature = parseFunctionSignature();
72-
if (accept(SoltToken::Comma, true))
73+
if (accept(Token::Comma, true))
7374
call.value = parseFunctionCallValue();
74-
if (accept(SoltToken::Colon, true))
75+
if (accept(Token::Colon, true))
7576
call.arguments = parseFunctionCallArguments();
7677

77-
if (accept(SoltToken::Newline, true))
78+
if (accept(Token::Newline, true))
7879
call.displayMode = FunctionCall::DisplayMode::MultiLine;
7980

8081
call.arguments.comment = parseComment();
8182

82-
if (accept(SoltToken::Newline, true))
83+
if (accept(Token::Newline, true))
8384
call.displayMode = FunctionCall::DisplayMode::MultiLine;
8485

85-
expect(SoltToken::Arrow);
86+
expect(Token::Arrow);
8687
call.expectations = parseFunctionCallExpectations();
8788
call.expectations.comment = parseComment();
8889

8990
calls.emplace_back(std::move(call));
9091
}
91-
else
92-
m_scanner.scanNextToken();
9392
}
9493
}
9594
return calls;
9695
}
9796

98-
string TestFileParser::formatToken(SoltToken _token)
99-
{
100-
switch (_token)
101-
{
102-
#define T(name, string, precedence) case SoltToken::name: return string;
103-
SOLT_TOKEN_LIST(T, T)
104-
#undef T
105-
default: // Token::NUM_TOKENS:
106-
return "";
107-
}
108-
}
109-
110-
bool TestFileParser::accept(SoltToken _token, bool const _expect)
97+
bool TestFileParser::accept(solt::Token _token, bool const _expect)
11198
{
112-
if (m_scanner.currentToken() == _token)
113-
{
114-
if (_expect)
115-
expect(_token);
116-
return true;
117-
}
118-
return false;
99+
if (m_scanner.currentToken() != _token)
100+
return false;
101+
if (_expect)
102+
return expect(_token);
103+
return true;
119104
}
120105

121-
bool TestFileParser::expect(SoltToken _token, bool const _advance)
106+
bool TestFileParser::expect(solt::Token _token, bool const _advance)
122107
{
123-
if (m_scanner.currentToken() != _token)
108+
if (m_scanner.currentToken() != _token || m_scanner.currentToken() == Token::Invalid)
124109
throw Error(
125110
Error::Type::ParserError,
126111
"Unexpected " + formatToken(m_scanner.currentToken()) + ": \"" +
@@ -135,35 +120,35 @@ bool TestFileParser::expect(SoltToken _token, bool const _advance)
135120
string TestFileParser::parseFunctionSignature()
136121
{
137122
string signature = m_scanner.currentLiteral();
138-
expect(SoltToken::Identifier);
123+
expect(Token::Identifier);
139124

140-
signature += formatToken(SoltToken::LParen);
141-
expect(SoltToken::LParen);
125+
signature += formatToken(Token::LParen);
126+
expect(Token::LParen);
142127

143128
string parameters;
144-
if (!accept(SoltToken::RParen, false))
129+
if (!accept(Token::RParen, false))
145130
parameters = parseIdentifierOrTuple();
146131

147-
while (accept(SoltToken::Comma))
132+
while (accept(Token::Comma))
148133
{
149-
parameters += formatToken(SoltToken::Comma);
150-
expect(SoltToken::Comma);
134+
parameters += formatToken(Token::Comma);
135+
expect(Token::Comma);
151136
parameters += parseIdentifierOrTuple();
152137
}
153-
if (accept(SoltToken::Arrow, true))
138+
if (accept(Token::Arrow, true))
154139
throw Error(Error::Type::ParserError, "Invalid signature detected: " + signature);
155140

156141
signature += parameters;
157142

158-
expect(SoltToken::RParen);
159-
signature += formatToken(SoltToken::RParen);
143+
expect(Token::RParen);
144+
signature += formatToken(Token::RParen);
160145
return signature;
161146
}
162147

163148
u256 TestFileParser::parseFunctionCallValue()
164149
{
165150
u256 value = convertNumber(parseNumber());
166-
expect(SoltToken::Ether);
151+
expect(Token::Ether);
167152
return value;
168153
}
169154

@@ -176,7 +161,7 @@ FunctionCallArgs TestFileParser::parseFunctionCallArguments()
176161
throw Error(Error::Type::ParserError, "No argument provided.");
177162
arguments.parameters.emplace_back(param);
178163

179-
while (accept(SoltToken::Comma, true))
164+
while (accept(Token::Comma, true))
180165
arguments.parameters.emplace_back(parseParameter());
181166
return arguments;
182167
}
@@ -193,7 +178,7 @@ FunctionCallExpectations TestFileParser::parseFunctionCallExpectations()
193178
}
194179
expectations.result.emplace_back(param);
195180

196-
while (accept(SoltToken::Comma, true))
181+
while (accept(Token::Comma, true))
197182
expectations.result.emplace_back(parseParameter());
198183

199184
/// We have always one virtual parameter in the parameter list.
@@ -206,7 +191,7 @@ FunctionCallExpectations TestFileParser::parseFunctionCallExpectations()
206191
Parameter TestFileParser::parseParameter()
207192
{
208193
Parameter parameter;
209-
if (accept(SoltToken::Newline, true))
194+
if (accept(Token::Newline, true))
210195
parameter.format.newline = true;
211196
auto literal = parseABITypeLiteral();
212197
parameter.rawBytes = literal.first;
@@ -221,20 +206,20 @@ pair<bytes, ABIType> TestFileParser::parseABITypeLiteral()
221206
u256 number{0};
222207
ABIType abiType{ABIType::None, 0};
223208

224-
if (accept(SoltToken::Sub))
209+
if (accept(Token::Sub))
225210
{
226211
abiType = ABIType{ABIType::SignedDec, 32};
227-
expect(SoltToken::Sub);
212+
expect(Token::Sub);
228213
number = convertNumber(parseNumber()) * -1;
229214
}
230215
else
231216
{
232-
if (accept(SoltToken::Number))
217+
if (accept(Token::Number))
233218
{
234219
abiType = ABIType{ABIType::UnsignedDec, 32};
235220
number = convertNumber(parseNumber());
236221
}
237-
else if (accept(SoltToken::Failure, true))
222+
else if (accept(Token::Failure, true))
238223
{
239224
abiType = ABIType{ABIType::Failure, 0};
240225
return make_pair(bytes{}, abiType);
@@ -252,42 +237,39 @@ string TestFileParser::parseIdentifierOrTuple()
252237
{
253238
string identOrTuple;
254239

255-
if (accept(SoltToken::Identifier))
240+
if (accept(Token::Identifier))
256241
{
257242
identOrTuple = m_scanner.currentLiteral();
258-
expect(SoltToken::Identifier);
243+
expect(Token::Identifier);
259244
return identOrTuple;
260245
}
261-
expect(SoltToken::LParen);
262-
identOrTuple += formatToken(SoltToken::LParen);
246+
expect(Token::LParen);
247+
identOrTuple += formatToken(Token::LParen);
263248
identOrTuple += parseIdentifierOrTuple();
264249

265-
if (identOrTuple == "()")
266-
throw Error(Error::Type::ParserError, "Empty tuples are not supported.");
267-
268-
while (accept(SoltToken::Comma))
250+
while (accept(Token::Comma))
269251
{
270-
identOrTuple += formatToken(SoltToken::Comma);
271-
expect(SoltToken::Comma);
252+
identOrTuple += formatToken(Token::Comma);
253+
expect(Token::Comma);
272254
identOrTuple += parseIdentifierOrTuple();
273255
}
274-
expect(SoltToken::RParen);
275-
identOrTuple += formatToken(SoltToken::RParen);
256+
expect(Token::RParen);
257+
identOrTuple += formatToken(Token::RParen);
276258
return identOrTuple;
277259
}
278260

279261
string TestFileParser::parseComment()
280262
{
281263
string comment = m_scanner.currentLiteral();
282-
if (accept(SoltToken::Comment, true))
264+
if (accept(Token::Comment, true))
283265
return comment;
284266
return string{};
285267
}
286268

287269
string TestFileParser::parseNumber()
288270
{
289271
string literal = m_scanner.currentLiteral();
290-
expect(SoltToken::Number);
272+
expect(Token::Number);
291273
return literal;
292274
}
293275

@@ -312,69 +294,72 @@ void TestFileParser::Scanner::readStream(istream& _stream)
312294

313295
void TestFileParser::Scanner::scanNextToken()
314296
{
315-
auto detectToken = [](std::string const& _literal = "") -> TokenDesc {
316-
if (_literal == "ether") return TokenDesc{SoltToken::Ether, _literal};
317-
if (_literal == "FAILURE") return TokenDesc{SoltToken::Failure, _literal};
318-
return TokenDesc{SoltToken::Identifier, _literal};
297+
// Make code coverage happy.
298+
assert(formatToken(Token::NUM_TOKENS) == "");
299+
300+
auto detectKeyword = [](std::string const& _literal = "") -> TokenDesc {
301+
if (_literal == "ether") return TokenDesc{Token::Ether, _literal};
302+
if (_literal == "FAILURE") return TokenDesc{Token::Failure, _literal};
303+
return TokenDesc{Token::Identifier, _literal};
319304
};
320305

321-
auto selectToken = [this](SoltToken _token, std::string const& _literal = "") -> TokenDesc {
306+
auto selectToken = [this](Token _token, std::string const& _literal = "") -> TokenDesc {
322307
advance();
323308
return make_pair(_token, !_literal.empty() ? _literal : formatToken(_token));
324309
};
325310

326-
TokenDesc token = make_pair(SoltToken::Unknown, "");
311+
TokenDesc token = make_pair(Token::Unknown, "");
327312
do
328313
{
329314
switch(current())
330315
{
331316
case '/':
332317
advance();
333318
if (current() == '/')
334-
token = selectToken(SoltToken::Newline);
319+
token = selectToken(Token::Newline);
320+
else
321+
token = selectToken(Token::Invalid);
335322
break;
336323
case '-':
337324
if (peek() == '>')
338325
{
339326
advance();
340-
token = selectToken(SoltToken::Arrow);
327+
token = selectToken(Token::Arrow);
341328
}
342329
else
343-
token = selectToken(SoltToken::Sub);
330+
token = selectToken(Token::Sub);
344331
break;
345332
case ':':
346-
token = selectToken(SoltToken::Colon);
333+
token = selectToken(Token::Colon);
347334
break;
348335
case '#':
349-
token = selectToken(SoltToken::Comment, scanComment());
336+
token = selectToken(Token::Comment, scanComment());
350337
break;
351338
case ',':
352-
token = selectToken(SoltToken::Comma);
339+
token = selectToken(Token::Comma);
353340
break;
354341
case '(':
355-
token = selectToken(SoltToken::LParen);
342+
token = selectToken(Token::LParen);
356343
break;
357344
case ')':
358-
token = selectToken(SoltToken::RParen);
345+
token = selectToken(Token::RParen);
359346
break;
360347
default:
361348
if (isIdentifierStart(current()))
362349
{
363-
TokenDesc detectedToken = detectToken(scanIdentifierOrKeyword());
350+
TokenDesc detectedToken = detectKeyword(scanIdentifierOrKeyword());
364351
token = selectToken(detectedToken.first, detectedToken.second);
365352
}
366353
else if (isdigit(current()))
367-
token = selectToken(SoltToken::Number, scanNumber());
354+
token = selectToken(Token::Number, scanNumber());
368355
else if (isspace(current()))
369-
token = selectToken(SoltToken::Whitespace);
356+
token = selectToken(Token::Whitespace);
370357
else if (isEndOfLine())
371-
token = selectToken(SoltToken::EOS);
372-
else
373-
token = selectToken(SoltToken::Invalid);
358+
token = selectToken(Token::EOS);
374359
break;
375360
}
376361
}
377-
while (token.first == SoltToken::Whitespace);
362+
while (token.first == Token::Whitespace);
378363
m_currentToken = token;
379364
}
380365

0 commit comments

Comments
 (0)