cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'inlineArrays' into develop

Browse Source
This commit is contained in:
RJ Catalano 2015-12-16 16:01:45 -06:00
commit 559c210643
5 changed files with 108 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
libsolidity/analysis/TypeChecker.cpp
View File

@ -780,6 +780,7 @@ bool TypeChecker::visit(Assignment const& _assignment)
bool TypeChecker::visit(TupleExpression const& _tuple)
{
vector<ASTPointer<Expression>> const& components = _tuple.components();
solAssert(!_tuple.isInlineArray(), "Tuple type not properly declared");
TypePointers types;
if (_tuple.annotation().lValueRequested)
{

14
libsolidity/ast/AST.h
View File

@ -1127,9 +1127,10 @@ private:
ASTPointer<Expression> m_rightHandSide;
};
/**
* Tuple or just parenthesized expression.
* Examples: (1, 2), (x,), (x), ()
* Tuple, parenthesized expression, or bracketed expression.
* Examples: (1, 2), (x,), (x), (), [1, 2],
* Individual components might be empty shared pointers (as in the second example).
* The respective types in lvalue context are: 2-tuple, 2-tuple (with wildcard), type of x, 0-tuple
* Not in lvalue context: 2-tuple, _1_-tuple, type of x, 0-tuple.
@ -1139,16 +1140,21 @@ class TupleExpression: public Expression
public:
TupleExpression(
SourceLocation const& _location,
std::vector<ASTPointer<Expression>> const& _components
std::vector<ASTPointer<Expression>> const& _components,
bool _isArray
):
Expression(_location), m_components(_components) {}
Expression(_location),
m_components(_components),
m_isArray(_isArray) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
std::vector<ASTPointer<Expression>> const& components() const { return m_components; }
bool isInlineArray() const { return m_isArray; }
private:
std::vector<ASTPointer<Expression>> m_components;
bool m_isArray;
};
/**

23
libsolidity/parsing/Parser.cpp
View File

@ -1035,27 +1035,36 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
break;
case Token::LParen:
case Token::LBrack:
{
// Tuple or parenthesized expression.
// Special cases: () is empty tuple type, (x) is not a real tuple, (x,) is one-dimensional tuple
// Tuple/parenthesized expression or inline array/bracketed expression.
// Special cases: ()/[] is empty tuple/array type, (x)/[] is not a real tuple/array,
// (x,) is one-dimensional tuple
m_scanner->next();
vector<ASTPointer<Expression>> components;
if (m_scanner->currentToken() != Token::RParen)
Token::Value oppositeToken = (token == Token::LParen ? Token::RParen : Token::RBrack);
bool isArray = (token == Token::LBrack ? true : false);
if (isArray && (m_scanner->currentToken() == Token::Comma))
fatalParserError(std::string("Expected value in array cell after '[' ."));
if (m_scanner->currentToken() != oppositeToken)
while (true)
{
if (m_scanner->currentToken() != Token::Comma && m_scanner->currentToken() != Token::RParen)
if (m_scanner->currentToken() != Token::Comma && m_scanner->currentToken() != oppositeToken)
components.push_back(parseExpression());
else
components.push_back(ASTPointer<Expression>());
if (m_scanner->currentToken() == Token::RParen)
if (m_scanner->currentToken() == oppositeToken)
break;
else if (m_scanner->currentToken() == Token::Comma)
if (isArray && (m_scanner->peekNextToken() == Token::Comma || m_scanner->peekNextToken() == oppositeToken))
fatalParserError(std::string("Expected value in array cell after ',' ."));
m_scanner->next();
}
nodeFactory.markEndPosition();
expectToken(Token::RParen);
return nodeFactory.createNode<TupleExpression>(components);
expectToken(oppositeToken);
return nodeFactory.createNode<TupleExpression>(components, isArray);
}
default:
if (Token::isElementaryTypeName(token))
{

26
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -2743,6 +2743,32 @@ BOOST_AUTO_TEST_CASE(invalid_args_creating_memory_array)
BOOST_CHECK(expectError(text) == Error::Type::TypeError);
}
/*BOOST_AUTO_TEST_CASE(inline_array_declaration_and_passing)
{
char const* text = R"(
contract C {
uint[] a;
function f() returns (uint, uint) {
a = [1,2,3];
return (a[3], [3,4][0]);
}
}
)";
BOOST_CHECK(success(text));
}
BOOST_AUTO_TEST_CASE(invalid_types_in_inline_array)
{
char const* text = R"(
contract C {
function f() {
uint[] x = [45, "foo", true];
}
}
)";
BOOST_CHECK(expectError(text) == Error::Type::TypeError);
}*/
BOOST_AUTO_TEST_SUITE_END()
}

55
test/libsolidity/SolidityParser.cpp
View File

@ -1047,6 +1047,61 @@ BOOST_AUTO_TEST_CASE(using_for)
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(inline_array_declaration_lvalue)
{
char const* text = R"(
contract c {
uint[] a;
function f() returns (uint) {
a = [1,2,3];
return (a[3]);
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(inline_array_declaration_self)
{
char const* text = R"(
contract c {
uint[] a;
function f() returns (uint) {
return ([1,2,3][0]);
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(inline_array_empty_cells_check_beginning)
{
char const* text = R"(
contract c {
uint[] a;
function f() returns (uint, uint) {
a = [,2,3];
return (a[3], [,3,4][0]);
}
}
)";
BOOST_CHECK(!successParse(text));
}
BOOST_AUTO_TEST_CASE(inline_array_empty_cells_check_commas)
{
char const* text = R"(
contract c {
uint[] a;
function f() returns (uint, uint) {
a = [1, ,3];
return (a[3], [3, ,4][0]);
}
}
)";
BOOST_CHECK(!successParse(text));
}
BOOST_AUTO_TEST_SUITE_END()
}