Merge pull request #626 from LefterisJP/sol_forStatement

ForStatement for Solidity

libsolidity/AST.cpp

@@ -130,6 +130,17 @@ void WhileStatement::checkTypeRequirements()
 	m_body->checkTypeRequirements();
 }
 
+void ForStatement::checkTypeRequirements()
+{
+	if (m_initExpression)
+		m_initExpression->checkTypeRequirements();
+	if (m_condExpression)
+		m_condExpression->expectType(BoolType());
+	if (m_loopExpression)
+		m_loopExpression->checkTypeRequirements();
+	m_body->checkTypeRequirements();
+}
+
 void Return::checkTypeRequirements()
 {
 	if (!m_expression)

libsolidity/AST.h

@@ -509,6 +509,42 @@ private:
 	ASTPointer<Statement> m_body;
 };
 
+/**
+ * For loop statement
+ */
+class ForStatement: public BreakableStatement
+{
+public:
+	ForStatement(Location const& _location,
+				 ASTPointer<Statement> const& _initExpression,
+				 ASTPointer<Expression> const& _conditionExpression,
+				 ASTPointer<ExpressionStatement> const& _loopExpression,
+				 ASTPointer<Statement> const& _body):
+		BreakableStatement(_location),
+		m_initExpression(_initExpression),
+		m_condExpression(_conditionExpression),
+		m_loopExpression(_loopExpression),
+		m_body(_body) {}
+	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+	virtual void checkTypeRequirements() override;
+
+	Statement const* getInitializationExpression() const { return m_initExpression.get(); }
+	Expression const* getCondition() const { return m_condExpression.get(); }
+	ExpressionStatement const* getLoopExpression() const { return m_loopExpression.get(); }
+	Statement const& getBody() const { return *m_body; }
+
+private:
+	/// For statement's initialization expresion. for(XXX; ; ). Can be empty
+	ASTPointer<Statement> m_initExpression;
+	/// For statement's condition expresion. for(; XXX ; ). Can be empty
+	ASTPointer<Expression> m_condExpression;
+	/// For statement's loop expresion. for(;;XXX). Can be empty
+	ASTPointer<ExpressionStatement> m_loopExpression;
+	/// The body of the loop
+	ASTPointer<Statement> m_body;
+};
+
 class Continue: public Statement
 {
 public:

libsolidity/ASTForward.h

@@ -52,6 +52,7 @@ class Block;
 class IfStatement;
 class BreakableStatement;
 class WhileStatement;
+class ForStatement;
 class Continue;
 class Break;
 class Return;

libsolidity/ASTPrinter.cpp

@@ -150,6 +150,13 @@ bool ASTPrinter::visit(WhileStatement const& _node)
 	return goDeeper();
 }
 
+bool ASTPrinter::visit(ForStatement const& _node)
+{
+	writeLine("ForStatement");
+	printSourcePart(_node);
+	return goDeeper();
+}
+
 bool ASTPrinter::visit(Continue const& _node)
 {
 	writeLine("Continue");
@@ -360,6 +367,11 @@ void ASTPrinter::endVisit(WhileStatement const&)
 	m_indentation--;
 }
 
+void ASTPrinter::endVisit(ForStatement const&)
+{
+	m_indentation--;
+}
+
 void ASTPrinter::endVisit(Continue const&)
 {
 	m_indentation--;

libsolidity/ASTPrinter.h

@@ -57,6 +57,7 @@ public:
 	bool visit(IfStatement const& _node) override;
 	bool visit(BreakableStatement const& _node) override;
 	bool visit(WhileStatement const& _node) override;
+	bool visit(ForStatement const& _node) override;
 	bool visit(Continue const& _node) override;
 	bool visit(Break const& _node) override;
 	bool visit(Return const& _node) override;
@@ -90,6 +91,7 @@ public:
 	void endVisit(IfStatement const&) override;
 	void endVisit(BreakableStatement const&) override;
 	void endVisit(WhileStatement const&) override;
+	void endVisit(ForStatement const&) override;
 	void endVisit(Continue const&) override;
 	void endVisit(Break const&) override;
 	void endVisit(Return const&) override;

libsolidity/ASTVisitor.h

@@ -58,6 +58,7 @@ public:
 	virtual bool visit(IfStatement&) { return true; }
 	virtual bool visit(BreakableStatement&) { return true; }
 	virtual bool visit(WhileStatement&) { return true; }
+	virtual bool visit(ForStatement&) { return true; }
 	virtual bool visit(Continue&) { return true; }
 	virtual bool visit(Break&) { return true; }
 	virtual bool visit(Return&) { return true; }
@@ -93,6 +94,7 @@ public:
 	virtual void endVisit(IfStatement&) { }
 	virtual void endVisit(BreakableStatement&) { }
 	virtual void endVisit(WhileStatement&) { }
+	virtual void endVisit(ForStatement&) { }
 	virtual void endVisit(Continue&) { }
 	virtual void endVisit(Break&) { }
 	virtual void endVisit(Return&) { }
@@ -132,6 +134,7 @@ public:
 	virtual bool visit(IfStatement const&) { return true; }
 	virtual bool visit(BreakableStatement const&) { return true; }
 	virtual bool visit(WhileStatement const&) { return true; }
+	virtual bool visit(ForStatement const&) { return true; }
 	virtual bool visit(Continue const&) { return true; }
 	virtual bool visit(Break const&) { return true; }
 	virtual bool visit(Return const&) { return true; }
@@ -167,6 +170,7 @@ public:
 	virtual void endVisit(IfStatement const&) { }
 	virtual void endVisit(BreakableStatement const&) { }
 	virtual void endVisit(WhileStatement const&) { }
+	virtual void endVisit(ForStatement const&) { }
 	virtual void endVisit(Continue const&) { }
 	virtual void endVisit(Break const&) { }
 	virtual void endVisit(Return const&) { }

libsolidity/AST_accept.h

@@ -267,6 +267,36 @@ void WhileStatement::accept(ASTConstVisitor& _visitor) const
 	_visitor.endVisit(*this);
 }
 
+void ForStatement::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		if (m_initExpression)
+			m_initExpression->accept(_visitor);
+		if (m_condExpression)
+			m_condExpression->accept(_visitor);
+		if (m_loopExpression)
+			m_loopExpression->accept(_visitor);
+		m_body->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void ForStatement::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		if (m_initExpression)
+			m_initExpression->accept(_visitor);
+		if (m_condExpression)
+			m_condExpression->accept(_visitor);
+		if (m_loopExpression)
+			m_loopExpression->accept(_visitor);
+		m_body->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
 void Continue::accept(ASTVisitor& _visitor)
 {
 	_visitor.visit(*this);

libsolidity/Compiler.cpp

@@ -287,6 +287,40 @@ bool Compiler::visit(WhileStatement const& _whileStatement)
 	return false;
 }
 
+bool Compiler::visit(ForStatement const& _forStatement)
+{
+	eth::AssemblyItem loopStart = m_context.newTag();
+	eth::AssemblyItem loopEnd = m_context.newTag();
+	m_continueTags.push_back(loopStart);
+	m_breakTags.push_back(loopEnd);
+
+	if (_forStatement.getInitializationExpression())
+		_forStatement.getInitializationExpression()->accept(*this);
+
+	m_context << loopStart;
+
+	// if there is no terminating condition in for, default is to always be true
+	if (_forStatement.getCondition())
+	{
+		compileExpression(*_forStatement.getCondition());
+		m_context << eth::Instruction::ISZERO;
+		m_context.appendConditionalJumpTo(loopEnd);
+	}
+
+	_forStatement.getBody().accept(*this);
+
+	// for's loop expression if existing
+	if (_forStatement.getLoopExpression())
+		_forStatement.getLoopExpression()->accept(*this);
+
+	m_context.appendJumpTo(loopStart);
+	m_context << loopEnd;
+
+	m_continueTags.pop_back();
+	m_breakTags.pop_back();
+	return false;
+}
+
 bool Compiler::visit(Continue const&)
 {
 	if (!m_continueTags.empty())

libsolidity/Compiler.h

@@ -53,6 +53,7 @@ private:
 	virtual bool visit(FunctionDefinition const& _function) override;
 	virtual bool visit(IfStatement const& _ifStatement) override;
 	virtual bool visit(WhileStatement const& _whileStatement) override;
+	virtual bool visit(ForStatement const& _forStatement) override;
 	virtual bool visit(Continue const& _continue) override;
 	virtual bool visit(Break const& _break) override;
 	virtual bool visit(Return const& _return) override;

libsolidity/Parser.cpp

@@ -304,6 +304,8 @@ ASTPointer<Statement> Parser::parseStatement()
 		return parseIfStatement();
 	case Token::WHILE:
 		return parseWhileStatement();
+	case Token::FOR:
+		return parseForStatement();
 	case Token::LBRACE:
 		return parseBlock();
 		// starting from here, all statements must be terminated by a semicolon
@@ -328,18 +330,7 @@ ASTPointer<Statement> Parser::parseStatement()
 	}
 	break;
 	default:
-		// distinguish between variable definition (and potentially assignment) and expression statement
-		// (which include assignments to other expressions and pre-declared variables)
-		// We have a variable definition if we get a keyword that specifies a type name, or
-		// in the case of a user-defined type, we have two identifiers following each other.
-		if (m_scanner->getCurrentToken() == Token::MAPPING ||
-				m_scanner->getCurrentToken() == Token::VAR ||
-				((Token::isElementaryTypeName(m_scanner->getCurrentToken()) ||
-				m_scanner->getCurrentToken() == Token::IDENTIFIER) &&
-				m_scanner->peekNextToken() == Token::IDENTIFIER))
-			statement = parseVariableDefinition();
-		else // "ordinary" expression statement
-			statement = parseExpressionStatement();
+		statement = parseVarDefOrExprStmt();
 	}
 	expectToken(Token::SEMICOLON);
 	return statement;
@@ -377,6 +368,44 @@ ASTPointer<WhileStatement> Parser::parseWhileStatement()
 	return nodeFactory.createNode<WhileStatement>(condition, body);
 }
 
+ASTPointer<ForStatement> Parser::parseForStatement()
+{
+	ASTNodeFactory nodeFactory(*this);
+	ASTPointer<Statement> initExpression;
+	ASTPointer<Expression> conditionExpression;
+	ASTPointer<ExpressionStatement> loopExpression;
+	expectToken(Token::FOR);
+	expectToken(Token::LPAREN);
+
+	// LTODO: Maybe here have some predicate like peekExpression() instead of checking for semicolon and RPAREN?
+	if (m_scanner->getCurrentToken() != Token::SEMICOLON)
+		initExpression = parseVarDefOrExprStmt();
+	expectToken(Token::SEMICOLON);
+
+	if (m_scanner->getCurrentToken() != Token::SEMICOLON)
+		conditionExpression = parseExpression();
+	expectToken(Token::SEMICOLON);
+
+	if (m_scanner->getCurrentToken() != Token::RPAREN)
+		loopExpression = parseExpressionStatement();
+	expectToken(Token::RPAREN);
+
+	ASTPointer<Statement> body = parseStatement();
+	nodeFactory.setEndPositionFromNode(body);
+	return nodeFactory.createNode<ForStatement>(initExpression,
+												conditionExpression,
+												loopExpression,
+												body);
+}
+
+ASTPointer<Statement> Parser::parseVarDefOrExprStmt()
+{
+	if (peekVariableDefinition())
+		return parseVariableDefinition();
+	else
+		return parseExpressionStatement();
+}
+
 ASTPointer<VariableDefinition> Parser::parseVariableDefinition()
 {
 	ASTNodeFactory nodeFactory(*this);
@@ -566,6 +595,20 @@ vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments()
 	return arguments;
 }
 
+
+bool Parser::peekVariableDefinition()
+{
+	// distinguish between variable definition (and potentially assignment) and expression statement
+	// (which include assignments to other expressions and pre-declared variables)
+	// We have a variable definition if we get a keyword that specifies a type name, or
+	// in the case of a user-defined type, we have two identifiers following each other.
+	return (m_scanner->getCurrentToken() == Token::MAPPING ||
+			m_scanner->getCurrentToken() == Token::VAR ||
+			((Token::isElementaryTypeName(m_scanner->getCurrentToken()) ||
+			  m_scanner->getCurrentToken() == Token::IDENTIFIER) &&
+			 m_scanner->peekNextToken() == Token::IDENTIFIER));
+}
+
 void Parser::expectToken(Token::Value _value)
 {
 	if (m_scanner->getCurrentToken() != _value)

libsolidity/Parser.h

@@ -59,6 +59,8 @@ private:
 	ASTPointer<Statement> parseStatement();
 	ASTPointer<IfStatement> parseIfStatement();
 	ASTPointer<WhileStatement> parseWhileStatement();
+	ASTPointer<ForStatement> parseForStatement();
+	ASTPointer<Statement> parseVarDefOrExprStmt();
 	ASTPointer<VariableDefinition> parseVariableDefinition();
 	ASTPointer<ExpressionStatement> parseExpressionStatement();
 	ASTPointer<Expression> parseExpression();
@@ -72,6 +74,9 @@ private:
 	///@{
 	///@name Helper functions
 
+	/// Peeks ahead in the scanner to determine if a variable definition is going to follow
+	bool peekVariableDefinition();
+
 	/// If current token value is not _value, throw exception otherwise advance token.
 	void expectToken(Token::Value _value);
 	Token::Value expectAssignmentOperator();

libsolidity/grammar.txt

@@ -16,10 +16,13 @@ Mapping = 'mapping' '(' ElementaryTypeName '=>' TypeName ')'
 
 Block = '{' Statement* '}'
 Statement = IfStatement | WhileStatement | Block |
-			( Continue | Break | Return | VariableDefinition | Expression ) ';'
+			( Continue | Break | Return | VariableDefinition | ExpressionStatement ) ';'
 
+ExpressionStatement = Expression
 IfStatement = 'if' '(' Expression ')' Statement ( 'else' Statement )?
 WhileStatement = 'while' '(' Expression ')' Statement
+VardefOrExprStmt = Variabledefinition | ExpressionStatement
+ForStatement = 'for' '(' (VardefOrExprStmt)? ';' (Expression)? ';' (ExpressionStatement)? ')' Statement
 Continue = 'continue' ';'
 Break = 'break' ';'
 Return = 'return' Expression? ';'

test/solidityEndToEndTest.cpp

@@ -176,6 +176,80 @@ BOOST_AUTO_TEST_CASE(nested_loops)
 	testSolidityAgainstCppOnRange(0, nested_loops_cpp, 0, 12);
 }
 
+BOOST_AUTO_TEST_CASE(for_loop)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint n) returns(uint nfac) {\n"
+							 "    nfac = 1;\n"
+							 "    for (var i = 2; i <= n; i++)\n"
+							 "        nfac *= i;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+
+	auto for_loop_cpp = [](u256 const& n) -> u256
+	{
+		u256 nfac = 1;
+		for (auto i = 2; i <= n; i++)
+			nfac *= i;
+		return nfac;
+	};
+
+	testSolidityAgainstCppOnRange(0, for_loop_cpp, 0, 5);
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_empty)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f() returns(uint ret) {\n"
+							 "    ret = 1;\n"
+							 "    for (;;)\n"
+							 "    {\n"
+							 "        ret += 1;\n"
+							 "        if (ret >= 10) break;\n"
+							 "    }\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+
+	auto for_loop_empty_cpp = []() -> u256
+	{
+		u256 ret = 1;
+		for (;;)
+		{
+			ret += 1;
+			if (ret >= 10) break;
+		}
+		return ret;
+	};
+
+	testSolidityAgainstCpp(0, for_loop_empty_cpp);
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_simple_init_expr)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  function f(uint n) returns(uint nfac) {\n"
+							 "    nfac = 1;\n"
+							 "    uint256 i;\n"
+							 "    for (i = 2; i <= n; i++)\n"
+							 "        nfac *= i;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+
+	auto for_loop_simple_init_expr_cpp = [](u256 const& n) -> u256
+	{
+		u256 nfac = 1;
+		u256 i;
+		for (i = 2; i <= n; i++)
+			nfac *= i;
+		return nfac;
+	};
+
+	testSolidityAgainstCppOnRange(0, for_loop_simple_init_expr_cpp, 0, 5);
+}
+
 BOOST_AUTO_TEST_CASE(calling_other_functions)
 {
 	// note that the index of a function is its index in the sorted sequence of functions

test/solidityParser.cpp

@@ -49,6 +49,23 @@ ASTPointer<ContractDefinition> parseText(std::string const& _source)
 	BOOST_FAIL("No contract found in source.");
 	return ASTPointer<ContractDefinition>();
 }
+
+ASTPointer<ContractDefinition> parseTextExplainError(std::string const& _source)
+{
+	try
+	{
+		return parseText(_source);
+	}
+	catch (Exception const& exception)
+	{
+		// LTODO: Print the error in a kind of a better way?
+		// In absence of CompilerStack we can't use SourceReferenceFormatter
+		cout << "Exception while parsing: " << diagnostic_information(exception);
+		// rethrow to signal test failure
+		throw exception;
+	}
+}
+
 }
 
 
@@ -357,6 +374,53 @@ BOOST_AUTO_TEST_CASE(while_loop)
 	BOOST_CHECK_NO_THROW(parseText(text));
 }
 
+BOOST_AUTO_TEST_CASE(for_loop_vardef_initexpr)
+{
+	char const* text = "contract test {\n"
+					   "  function fun(uint256 a) {\n"
+					   "    for (uint256 i = 0; i < 10; i++)\n"
+					   "    { uint256 x = i; break; continue; }\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseTextExplainError(text));
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_simple_initexpr)
+{
+	char const* text = "contract test {\n"
+					   "  function fun(uint256 a) {\n"
+					   "    uint256 i =0;\n"
+					   "    for (i = 0; i < 10; i++)\n"
+					   "    { uint256 x = i; break; continue; }\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseTextExplainError(text));
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_simple_noexpr)
+{
+	char const* text = "contract test {\n"
+					   "  function fun(uint256 a) {\n"
+					   "    uint256 i =0;\n"
+					   "    for (;;)\n"
+					   "    { uint256 x = i; break; continue; }\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseTextExplainError(text));
+}
+
+BOOST_AUTO_TEST_CASE(for_loop_single_stmt_body)
+{
+	char const* text = "contract test {\n"
+					   "  function fun(uint256 a) {\n"
+					   "    uint256 i =0;\n"
+					   "    for (i = 0; i < 10; i++)\n"
+					   "        continue;\n"
+					   "  }\n"
+					   "}\n";
+	BOOST_CHECK_NO_THROW(parseTextExplainError(text));
+}
+
 BOOST_AUTO_TEST_CASE(if_statement)
 {
 	char const* text = "contract test {\n"