From 28f10f4783bd4365654191740069a7112be03d92 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 28 Apr 2017 13:09:48 +0200
Subject: Remove error label / invalid jump label.

---
 libsolidity/codegen/CompilerUtils.cpp    | 19 -------------------
 libsolidity/codegen/CompilerUtils.h      |  4 ----
 libsolidity/inlineasm/AsmCodeGen.cpp     |  2 --
 libsolidity/inlineasm/AsmScope.h         |  1 -
 libsolidity/inlineasm/AsmScopeFiller.cpp |  4 ----
 5 files changed, 30 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index dc0b340c..4ae9a09a 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -299,25 +299,6 @@ void CompilerUtils::zeroInitialiseMemoryArray(ArrayType const& _type)
 	m_context << Instruction::SWAP1 << Instruction::POP;
 }
 
-void CompilerUtils::memoryCopyPrecompile()
-{
-	// Stack here: size target source
-
-	m_context.appendInlineAssembly(R"(
-		{
-		let words := div(add(len, 31), 32)
-		let cost := add(15, mul(3, words))
-		jumpi(invalidJumpLabel, iszero(call(cost, $identityContractAddress, 0, src, len, dst, len)))
-		}
-	)",
-		{ "len", "dst", "src" },
-		map<string, string> {
-			{ "$identityContractAddress", toString(identityContractAddress) }
-		}
-	);
-	m_context << Instruction::POP << Instruction::POP << Instruction::POP;
-}
-
 void CompilerUtils::memoryCopy32()
 {
 	// Stack here: size target source
diff --git a/libsolidity/codegen/CompilerUtils.h b/libsolidity/codegen/CompilerUtils.h
index b9ed6757..4140ce8b 100644
--- a/libsolidity/codegen/CompilerUtils.h
+++ b/libsolidity/codegen/CompilerUtils.h
@@ -109,10 +109,6 @@ public:
 	/// Stack post: <updated_memptr>
 	void zeroInitialiseMemoryArray(ArrayType const& _type);
 
-	/// Uses a CALL to the identity contract to perform a memory-to-memory copy.
-	/// Stack pre: <size> <target> <source>
-	/// Stack post:
-	void memoryCopyPrecompile();
 	/// Copies full 32 byte words in memory (regions cannot overlap), i.e. may copy more than length.
 	/// Stack pre: <size> <target> <source>
 	/// Stack post:
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 9ef3e6e7..c19667b4 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -278,8 +278,6 @@ private:
 	{
 		if (_label.id == Scope::Label::unassignedLabelId)
 			_label.id = m_state.newLabelId();
-		else if (_label.id == Scope::Label::errorLabelId)
-			_label.id = size_t(m_state.assembly.errorTag().data());
 	}
 
 
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 37e0f0b8..b70bee67 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -73,7 +73,6 @@ struct Scope
 	struct Label
 	{
 		size_t id = unassignedLabelId;
-		static const size_t errorLabelId = -1;
 		static const size_t unassignedLabelId = 0;
 	};
 
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index de6fbdaa..4a651388 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -39,10 +39,6 @@ using namespace dev::solidity::assembly;
 ScopeFiller::ScopeFiller(ScopeFiller::Scopes& _scopes, ErrorList& _errors):
 	m_scopes(_scopes), m_errors(_errors)
 {
-	// Make the Solidity ErrorTag available to inline assembly
-	Scope::Label errorLabel;
-	errorLabel.id = Scope::Label::errorLabelId;
-	scope(nullptr).identifiers["invalidJumpLabel"] = errorLabel;
 	m_currentScope = &scope(nullptr);
 }
 
-- 
cgit v1.2.3


From d61f9c4d4ee99cf0d540e3a7b6c7f250bab5f7b6 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 1 May 2017 17:40:37 +0100
Subject: Disable labels in Julia

---
 libsolidity/inlineasm/AsmParser.cpp | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index d7f78958..8d54d47a 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -84,6 +84,7 @@ assembly::Statement Parser::parseStatement()
 	}
 	case Token::Return: // opcode
 	case Token::Byte: // opcode
+	case Token::Address: // opcode
 	default:
 		break;
 	}
@@ -119,6 +120,8 @@ assembly::Statement Parser::parseStatement()
 		else
 		{
 			// label
+			if (m_julia)
+				fatalParserError("Labels are not supported.");
 			Label label = createWithLocation<Label>(identifier.location);
 			label.name = identifier.name;
 			return label;
-- 
cgit v1.2.3


From f1f209db4032e7679ab39f0ac1591a43d943b153 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 2 May 2017 09:24:35 +0100
Subject: Do not allow literal pushes in Julia

---
 libsolidity/inlineasm/AsmParser.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 8d54d47a..07483f80 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -128,6 +128,8 @@ assembly::Statement Parser::parseStatement()
 		}
 	}
 	default:
+		if (m_julia)
+			fatalParserError("Call or assignment expected.");
 		break;
 	}
 	return statement;
-- 
cgit v1.2.3


From 804971973d09c97dd12d8a34d50b9c5b556ffee4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 2 May 2017 09:25:12 +0100
Subject: Show better error message for Julia mode

---
 libsolidity/inlineasm/AsmParser.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 07483f80..d9b0b3e0 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -92,7 +92,7 @@ assembly::Statement Parser::parseStatement()
 	// Simple instruction (might turn into functional),
 	// literal,
 	// identifier (might turn into label or functional assignment)
-	Statement statement(parseElementaryOperation());
+	Statement statement(parseElementaryOperation(false));
 	switch (m_scanner->currentToken())
 	{
 	case Token::LParen:
@@ -214,7 +214,11 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		break;
 	}
 	default:
-		fatalParserError("Expected elementary inline assembly operation.");
+		fatalParserError(
+			m_julia ?
+			"Literal or identifier expected." :
+			"Expected elementary inline assembly operation."
+		);
 	}
 	m_scanner->next();
 	return ret;
@@ -322,7 +326,11 @@ assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _in
 		return ret;
 	}
 	else
-		fatalParserError("Assembly instruction or function name required in front of \"(\")");
+		fatalParserError(
+			m_julia ?
+			"Function name expected." :
+			"Assembly instruction or function name required in front of \"(\")"
+		);
 
 	return {};
 }
-- 
cgit v1.2.3


From c423e140eeccaa07ca8c461e86157a4d9dbb1195 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 26 Apr 2017 23:58:08 +0100
Subject: Add flag for JULIA printing

---
 libsolidity/inlineasm/AsmPrinter.h | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index a7a1de0a..038c6d85 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -45,6 +45,8 @@ struct Block;
 class AsmPrinter: public boost::static_visitor<std::string>
 {
 public:
+	explicit AsmPrinter(bool _julia = false): m_julia(_julia) {}
+
 	std::string operator()(assembly::Instruction const& _instruction);
 	std::string operator()(assembly::Literal const& _literal);
 	std::string operator()(assembly::Identifier const& _identifier);
@@ -56,6 +58,9 @@ public:
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
 	std::string operator()(assembly::Block const& _block);
+
+private:
+	bool m_julia = false;
 };
 
 }
-- 
cgit v1.2.3


From 07176e82de05bd4490b22f070cd11e36b84f734a Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 4 May 2017 09:26:59 +0100
Subject: Assert that invalid AST elements are not printed in Julia mode

---
 libsolidity/inlineasm/AsmPrinter.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 252e91f9..4a6f975d 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -21,8 +21,8 @@
  */
 
 #include <libsolidity/inlineasm/AsmPrinter.h>
-
 #include <libsolidity/inlineasm/AsmData.h>
+#include <libsolidity/interface/Utils.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/replace.hpp>
@@ -40,6 +40,7 @@ using namespace dev::solidity::assembly;
 
 string AsmPrinter::operator()(assembly::Instruction const& _instruction)
 {
+	solAssert(!m_julia, "");
 	return boost::to_lower_copy(instructionInfo(_instruction.instruction).name);
 }
 
@@ -83,6 +84,7 @@ string AsmPrinter::operator()(assembly::Identifier const& _identifier)
 
 string AsmPrinter::operator()(assembly::FunctionalInstruction const& _functionalInstruction)
 {
+	solAssert(!m_julia, "");
 	return
 		(*this)(_functionalInstruction.instruction) +
 		"(" +
@@ -94,11 +96,13 @@ string AsmPrinter::operator()(assembly::FunctionalInstruction const& _functional
 
 string AsmPrinter::operator()(assembly::Label const& _label)
 {
+	solAssert(!m_julia, "");
 	return _label.name + ":";
 }
 
 string AsmPrinter::operator()(assembly::Assignment const& _assignment)
 {
+	solAssert(!m_julia, "");
 	return "=: " + (*this)(_assignment.variableName);
 }
 
-- 
cgit v1.2.3


From d6396ee85fd21424568074c41a131e8c52961983 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 26 Apr 2017 23:58:34 +0100
Subject: Parse types in Julia mode

---
 libsolidity/inlineasm/AsmAnalysis.cpp    |  9 +++++----
 libsolidity/inlineasm/AsmCodeGen.cpp     |  2 +-
 libsolidity/inlineasm/AsmData.h          | 17 ++++++++++------
 libsolidity/inlineasm/AsmParser.cpp      | 34 ++++++++++++++++++++++++++------
 libsolidity/inlineasm/AsmParser.h        |  1 +
 libsolidity/inlineasm/AsmPrinter.cpp     | 25 ++++++++++++++++++-----
 libsolidity/inlineasm/AsmPrinter.h       |  2 ++
 libsolidity/inlineasm/AsmScope.cpp       |  8 +++++---
 libsolidity/inlineasm/AsmScope.h         | 17 +++++++++++-----
 libsolidity/inlineasm/AsmScopeFiller.cpp | 16 ++++++++++-----
 libsolidity/inlineasm/AsmScopeFiller.h   |  3 ++-
 11 files changed, 98 insertions(+), 36 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index dad05a78..590f9ad6 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -184,7 +184,7 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	int const stackHeight = m_stackHeight;
 	bool success = boost::apply_visitor(*this, *_varDecl.value);
 	solAssert(m_stackHeight - stackHeight == 1, "Invalid value size.");
-	boost::get<Scope::Variable>(m_currentScope->identifiers.at(_varDecl.name)).active = true;
+	boost::get<Scope::Variable>(m_currentScope->identifiers.at(_varDecl.variable.name)).active = true;
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
 	return success;
 }
@@ -193,7 +193,7 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 {
 	Scope& bodyScope = scope(&_funDef.body);
 	for (auto const& var: _funDef.arguments + _funDef.returns)
-		boost::get<Scope::Variable>(bodyScope.identifiers.at(var)).active = true;
+		boost::get<Scope::Variable>(bodyScope.identifiers.at(var.name)).active = true;
 
 	int const stackHeight = m_stackHeight;
 	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
@@ -232,8 +232,9 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 		},
 		[&](Scope::Function const& _fun)
 		{
-			arguments = _fun.arguments;
-			returns = _fun.returns;
+			/// TODO: compare types too
+			arguments = _fun.arguments.size();
+			returns = _fun.returns.size();
 		}
 	)))
 	{
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index c19667b4..137a70f5 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -204,7 +204,7 @@ public:
 		int height = m_state.assembly.deposit();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height);
-		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.name));
+		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
 		var.stackHeight = height;
 		var.active = true;
 	}
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index d61b5803..363873ab 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -33,12 +33,17 @@ namespace solidity
 namespace assembly
 {
 
+using Type = std::string;
+
+struct TypedName { SourceLocation location; std::string name; Type type; };
+using TypedNameList = std::vector<TypedName>;
+
 /// What follows are the AST nodes for assembly.
 
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
-struct Literal { SourceLocation location; bool isNumber; std::string value; };
+struct Literal { SourceLocation location; bool isNumber; std::string value; Type type; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
@@ -52,18 +57,18 @@ struct FunctionDefinition;
 struct FunctionCall;
 struct Block;
 using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
-/// Functional assignment ("x := mload(20)", expects push-1-expression on the right hand
+/// Functional assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
 struct FunctionalAssignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
-/// Functional instruction, e.g. "mul(mload(20), add(2, x))"
+/// Functional instruction, e.g. "mul(mload(20:u256), add(2:u256, x))"
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
-/// Block-scope variable declaration ("let x := mload(20)"), non-hoisted
-struct VariableDeclaration { SourceLocation location; std::string name; std::shared_ptr<Statement> value; };
+/// Block-scope variable declaration ("let x:u256 := mload(20:u256)"), non-hoisted
+struct VariableDeclaration { SourceLocation location; TypedName variable; std::shared_ptr<Statement> value; };
 /// Block that creates a scope (frees declared stack variables)
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
-struct FunctionDefinition { SourceLocation location; std::string name; std::vector<std::string> arguments; std::vector<std::string> returns; Block body; };
+struct FunctionDefinition { SourceLocation location; std::string name; TypedNameList arguments; TypedNameList returns; Block body; };
 
 struct LocationExtractor: boost::static_visitor<SourceLocation>
 {
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index d9b0b3e0..7ecad5ea 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -201,16 +201,26 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		}
 		else
 			ret = Identifier{location(), literal};
+		m_scanner->next();
 		break;
 	}
 	case Token::StringLiteral:
 	case Token::Number:
 	{
-		ret = Literal{
+		Literal literal{
 			location(),
 			m_scanner->currentToken() == Token::Number,
-			m_scanner->currentLiteral()
+			m_scanner->currentLiteral(),
+			""
 		};
+		m_scanner->next();
+		if (m_julia)
+		{
+			expectToken(Token::Colon);
+			literal.location.end = endPosition();
+			literal.type = expectAsmIdentifier();
+		}
+		ret = std::move(literal);
 		break;
 	}
 	default:
@@ -220,7 +230,6 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 			"Expected elementary inline assembly operation."
 		);
 	}
-	m_scanner->next();
 	return ret;
 }
 
@@ -228,7 +237,7 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 {
 	VariableDeclaration varDecl = createWithLocation<VariableDeclaration>();
 	expectToken(Token::Let);
-	varDecl.name = expectAsmIdentifier();
+	varDecl.variable = parseTypedName();
 	expectToken(Token::Colon);
 	expectToken(Token::Assign);
 	varDecl.value.reset(new Statement(parseExpression()));
@@ -244,7 +253,7 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 	expectToken(Token::LParen);
 	while (m_scanner->currentToken() != Token::RParen)
 	{
-		funDef.arguments.push_back(expectAsmIdentifier());
+		funDef.arguments.emplace_back(parseTypedName());
 		if (m_scanner->currentToken() == Token::RParen)
 			break;
 		expectToken(Token::Comma);
@@ -256,7 +265,7 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 		expectToken(Token::GreaterThan);
 		while (true)
 		{
-			funDef.returns.push_back(expectAsmIdentifier());
+			funDef.returns.emplace_back(parseTypedName());
 			if (m_scanner->currentToken() == Token::LBrace)
 				break;
 			expectToken(Token::Comma);
@@ -335,6 +344,19 @@ assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _in
 	return {};
 }
 
+TypedName Parser::parseTypedName()
+{
+	TypedName typedName = createWithLocation<TypedName>();
+	typedName.name = expectAsmIdentifier();
+	if (m_julia)
+	{
+		expectToken(Token::Colon);
+		typedName.location.end = endPosition();
+		typedName.type = expectAsmIdentifier();
+	}
+	return typedName;
+}
+
 string Parser::expectAsmIdentifier()
 {
 	string name = m_scanner->currentLiteral();
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index c55fd2ac..addc1725 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -69,6 +69,7 @@ protected:
 	VariableDeclaration parseVariableDeclaration();
 	FunctionDefinition parseFunctionDefinition();
 	Statement parseFunctionalInstruction(Statement&& _instruction);
+	TypedName parseTypedName();
 	std::string expectAsmIdentifier();
 
 private:
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 4a6f975d..94829371 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -47,7 +47,7 @@ string AsmPrinter::operator()(assembly::Instruction const& _instruction)
 string AsmPrinter::operator()(assembly::Literal const& _literal)
 {
 	if (_literal.isNumber)
-		return _literal.value;
+		return _literal.value + appendTypeName(_literal.type);
 	string out;
 	for (char c: _literal.value)
 		if (c == '\\')
@@ -74,7 +74,7 @@ string AsmPrinter::operator()(assembly::Literal const& _literal)
 		}
 		else
 			out += c;
-	return "\"" + out + "\"";
+	return "\"" + out + "\"" + appendTypeName(_literal.type);
 }
 
 string AsmPrinter::operator()(assembly::Identifier const& _identifier)
@@ -113,14 +113,22 @@ string AsmPrinter::operator()(assembly::FunctionalAssignment const& _functionalA
 
 string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDeclaration)
 {
-	return "let " + _variableDeclaration.name + " := " + boost::apply_visitor(*this, *_variableDeclaration.value);
+	return "let " + _variableDeclaration.variable.name + appendTypeName(_variableDeclaration.variable.type) + " := " + boost::apply_visitor(*this, *_variableDeclaration.value);
 }
 
 string AsmPrinter::operator()(assembly::FunctionDefinition const& _functionDefinition)
 {
-	string out = "function " + _functionDefinition.name + "(" + boost::algorithm::join(_functionDefinition.arguments, ", ") + ")";
+	string out = "function " + _functionDefinition.name + "(";
+	for (auto const& argument: _functionDefinition.arguments)
+		out += argument.name + appendTypeName(argument.type) + ",";
+	out += ")";
 	if (!_functionDefinition.returns.empty())
-		out += " -> " + boost::algorithm::join(_functionDefinition.returns, ", ");
+	{
+		out += " -> ";
+		for (auto const& argument: _functionDefinition.returns)
+		    out += argument.name + appendTypeName(argument.type) + ",";
+	}
+
 	return out + "\n" + (*this)(_functionDefinition.body);
 }
 
@@ -145,3 +153,10 @@ string AsmPrinter::operator()(Block const& _block)
 	boost::replace_all(body, "\n", "\n    ");
 	return "{\n    " + body + "\n}";
 }
+
+string AsmPrinter::appendTypeName(std::string const& _type)
+{
+	if (m_julia)
+		return ":" + _type;
+	return "";
+}
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 038c6d85..282fd7e3 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -60,6 +60,8 @@ public:
 	std::string operator()(assembly::Block const& _block);
 
 private:
+	std::string appendTypeName(std::string const& _type);
+
 	bool m_julia = false;
 };
 
diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index 609dca16..e3f4615a 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -32,15 +32,17 @@ bool Scope::registerLabel(string const& _name)
 	return true;
 }
 
-bool Scope::registerVariable(string const& _name)
+bool Scope::registerVariable(string const& _name, JuliaType const& _type)
 {
 	if (exists(_name))
 		return false;
-	identifiers[_name] = Variable();
+	Variable variable;
+	variable.type = _type;
+	identifiers[_name] = variable;
 	return true;
 }
 
-bool Scope::registerFunction(string const& _name, size_t _arguments, size_t _returns)
+bool Scope::registerFunction(string const& _name, std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns)
 {
 	if (exists(_name))
 		return false;
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index b70bee67..dd45613d 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -61,6 +61,8 @@ struct GenericVisitor<>: public boost::static_visitor<> {
 
 struct Scope
 {
+	using JuliaType = std::string;
+
 	struct Variable
 	{
 		/// Used during code generation to store the stack height. @todo move there.
@@ -68,6 +70,7 @@ struct Scope
 		/// Used during analysis to check whether we already passed the declaration inside the block.
 		/// @todo move there.
 		bool active = false;
+		JuliaType type;
 	};
 
 	struct Label
@@ -78,18 +81,22 @@ struct Scope
 
 	struct Function
 	{
-		Function(size_t _arguments, size_t _returns): arguments(_arguments), returns(_returns) {}
-		size_t arguments = 0;
-		size_t returns = 0;
+		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
+		std::vector<JuliaType> arguments;
+		std::vector<JuliaType> returns;
 	};
 
 	using Identifier = boost::variant<Variable, Label, Function>;
 	using Visitor = GenericVisitor<Variable const, Label const, Function const>;
 	using NonconstVisitor = GenericVisitor<Variable, Label, Function>;
 
-	bool registerVariable(std::string const& _name);
+	bool registerVariable(std::string const& _name, JuliaType const& _type);
 	bool registerLabel(std::string const& _name);
-	bool registerFunction(std::string const& _name, size_t _arguments, size_t _returns);
+	bool registerFunction(
+		std::string const& _name,
+		std::vector<JuliaType> const& _arguments,
+		std::vector<JuliaType> const& _returns
+	);
 
 	/// Looks up the identifier in this or super scopes and returns a valid pointer if found
 	/// or a nullptr if not found. Variable lookups up across function boundaries will fail, as
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 4a651388..eb10dbb3 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -59,13 +59,19 @@ bool ScopeFiller::operator()(Label const& _item)
 
 bool ScopeFiller::operator()(assembly::VariableDeclaration const& _varDecl)
 {
-	return registerVariable(_varDecl.name, _varDecl.location, *m_currentScope);
+	return registerVariable(_varDecl.variable, _varDecl.location, *m_currentScope);
 }
 
 bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 {
 	bool success = true;
-	if (!m_currentScope->registerFunction(_funDef.name, _funDef.arguments.size(), _funDef.returns.size()))
+	vector<Scope::JuliaType> arguments;
+	for (auto const& _argument: _funDef.arguments)
+		arguments.push_back(_argument.type);
+	vector<Scope::JuliaType> returns;
+	for (auto const& _return: _funDef.returns)
+		returns.push_back(_return.type);
+	if (!m_currentScope->registerFunction(_funDef.name, arguments, returns))
 	{
 		//@TODO secondary location
 		m_errors.push_back(make_shared<Error>(
@@ -102,14 +108,14 @@ bool ScopeFiller::operator()(Block const& _block)
 	return success;
 }
 
-bool ScopeFiller::registerVariable(string const& _name, SourceLocation const& _location, Scope& _scope)
+bool ScopeFiller::registerVariable(TypedName const& _name, SourceLocation const& _location, Scope& _scope)
 {
-	if (!_scope.registerVariable(_name))
+	if (!_scope.registerVariable(_name.name, _name.type))
 	{
 		//@TODO secondary location
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::DeclarationError,
-			"Variable name " + _name + " already taken in this scope.",
+			"Variable name " + _name.name + " already taken in this scope.",
 			_location
 		));
 		return false;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index bb62948b..61428eea 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -34,6 +34,7 @@ namespace solidity
 namespace assembly
 {
 
+struct TypedName;
 struct Literal;
 struct Block;
 struct Label;
@@ -72,7 +73,7 @@ public:
 
 private:
 	bool registerVariable(
-		std::string const& _name,
+		TypedName const& _name,
 		SourceLocation const& _location,
 		Scope& _scope
 	);
-- 
cgit v1.2.3


From 8688b63fa624fbf14982c3c4340ab83c13144f66 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 3 May 2017 19:32:38 +0100
Subject: Use boost range adaptors in AsmPrinter

---
 libsolidity/inlineasm/AsmPrinter.cpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 94829371..f3b66aee 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -119,14 +119,22 @@ string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDecl
 string AsmPrinter::operator()(assembly::FunctionDefinition const& _functionDefinition)
 {
 	string out = "function " + _functionDefinition.name + "(";
-	for (auto const& argument: _functionDefinition.arguments)
-		out += argument.name + appendTypeName(argument.type) + ",";
+	out += boost::algorithm::join(
+		_functionDefinition.arguments | boost::adaptors::transformed(
+			[this](TypedName argument) { return argument.name + appendTypeName(argument.type); }
+		),
+		", "
+	);
 	out += ")";
 	if (!_functionDefinition.returns.empty())
 	{
 		out += " -> ";
-		for (auto const& argument: _functionDefinition.returns)
-		    out += argument.name + appendTypeName(argument.type) + ",";
+		out += boost::algorithm::join(
+			_functionDefinition.returns | boost::adaptors::transformed(
+				[this](TypedName argument) { return argument.name + appendTypeName(argument.type); }
+			),
+			", "
+		);
 	}
 
 	return out + "\n" + (*this)(_functionDefinition.body);
-- 
cgit v1.2.3


From 0489c99870c3b429b6f83af860fd883032124090 Mon Sep 17 00:00:00 2001
From: Erik Quenon Steggall <esteggal@ucsc.edu>
Date: Fri, 5 May 2017 16:49:09 -0700
Subject: Added change to make compile happy on MacOS 10.9.5

---
 libsolidity/analysis/PostTypeChecker.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/PostTypeChecker.h b/libsolidity/analysis/PostTypeChecker.h
index 8774f413..13751c16 100644
--- a/libsolidity/analysis/PostTypeChecker.h
+++ b/libsolidity/analysis/PostTypeChecker.h
@@ -55,7 +55,7 @@ private:
 
 	VariableDeclaration const* findCycle(
 		VariableDeclaration const* _startingFrom,
-		std::set<VariableDeclaration const*> const& _seen = {}
+		std::set<VariableDeclaration const*> const& _seen = std::set<VariableDeclaration const*>{}
 	);
 
 	ErrorList& m_errors;
-- 
cgit v1.2.3


From 5b4b620d8b2a36f5e76ffbca16a2d3d5d7253c45 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Sat, 6 May 2017 17:47:08 +0100
Subject: Do not crash on AST if parsing failed

---
 libsolidity/interface/CompilerStack.cpp | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 9c9c9614..c4e60fd7 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -503,6 +503,9 @@ Scanner const& CompilerStack::scanner(string const& _sourceName) const
 
 SourceUnit const& CompilerStack::ast(string const& _sourceName) const
 {
+	if (m_stackState < ParsingSuccessful)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+
 	return *source(_sourceName).ast;
 }
 
-- 
cgit v1.2.3


From c0f31e4c1b79854bb5960dfe45bcecb907d63f84 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 11 May 2017 08:01:39 +0100
Subject: Ensure proper checks are in CompilerStack

---
 libsolidity/interface/CompilerStack.cpp | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index c4e60fd7..5c836358 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -451,9 +451,6 @@ Json::Value const& CompilerStack::interface(string const& _contractName) const
 
 Json::Value const& CompilerStack::metadata(string const& _contractName, DocumentationType _type) const
 {
-	if (m_stackState < AnalysisSuccessful)
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
-
 	return metadata(contract(_contractName), _type);
 }
 
@@ -491,13 +488,16 @@ Json::Value const& CompilerStack::metadata(Contract const& _contract, Documentat
 string const& CompilerStack::onChainMetadata(string const& _contractName) const
 {
 	if (m_stackState != CompilationSuccessful)
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
 
 	return contract(_contractName).onChainMetadata;
 }
 
 Scanner const& CompilerStack::scanner(string const& _sourceName) const
 {
+	if (m_stackState < ParsingSuccessful)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+
 	return *source(_sourceName).scanner;
 }
 
@@ -511,6 +511,9 @@ SourceUnit const& CompilerStack::ast(string const& _sourceName) const
 
 ContractDefinition const& CompilerStack::contractDefinition(string const& _contractName) const
 {
+	if (m_stackState != CompilationSuccessful)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
+
 	return *contract(_contractName).contract;
 }
 
@@ -739,6 +742,9 @@ void CompilerStack::compileContract(
 
 std::string CompilerStack::defaultContractName() const
 {
+	if (m_stackState != CompilationSuccessful)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
+
 	return contract("").contract->name();
 }
 
-- 
cgit v1.2.3


From dea7b864e6bbd80b913abf44dc4748868c5d6975 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Mon, 20 Mar 2017 19:06:17 +0100
Subject: Compact format for AST-Json with backwards compatibility

---
 libsolidity/ast/AST.h                      |   9 +-
 libsolidity/ast/ASTJsonConverter.cpp       | 812 +++++++++++++++--------------
 libsolidity/ast/ASTJsonConverter.h         |  98 ++--
 libsolidity/ast/Types.cpp                  |   2 +
 libsolidity/interface/StandardCompiler.cpp |   2 +-
 5 files changed, 473 insertions(+), 450 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index 02234ffc..71b81a69 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -583,8 +583,7 @@ public:
 	bool isPayable() const { return m_isPayable; }
 	std::vector<ASTPointer<ModifierInvocation>> const& modifiers() const { return m_functionModifiers; }
 	std::vector<ASTPointer<VariableDeclaration>> const& returnParameters() const { return m_returnParameters->parameters(); }
-	Block const& body() const { return *m_body; }
-
+	Block const& body() const { solAssert(m_body, ""); return *m_body; }
 	virtual bool isVisibleInContract() const override
 	{
 		return Declaration::isVisibleInContract() && !isConstructor() && !name().empty();
@@ -1314,7 +1313,7 @@ private:
 
 /**
  * Tuple, parenthesized expression, or bracketed expression.
- * Examples: (1, 2), (x,), (x), (), [1, 2], 
+ * 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.
@@ -1327,8 +1326,8 @@ public:
 		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;
diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 9ea23687..c6abab54 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -25,6 +25,8 @@
 #include <libdevcore/UTF8.h>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/inlineasm/AsmData.h>
+#include <libsolidity/inlineasm/AsmPrinter.h>
 
 using namespace std;
 
@@ -33,49 +35,86 @@ namespace dev
 namespace solidity
 {
 
-void ASTJsonConverter::addJsonNode(
+ASTJsonConverter::ASTJsonConverter(bool _legacy, map<string, unsigned> _sourceIndices):
+	m_legacy(_legacy),
+	m_sourceIndices(_sourceIndices)
+{
+}
+
+
+void ASTJsonConverter::setJsonNode(
 	ASTNode const& _node,
 	string const& _nodeName,
-	initializer_list<pair<string const, Json::Value const>> _attributes,
-	bool _hasChildren = false
+	initializer_list<pair<string, Json::Value>>&& _attributes
 )
 {
-	ASTJsonConverter::addJsonNode(
+	ASTJsonConverter::setJsonNode(
 		_node,
 		_nodeName,
-		std::vector<pair<string const, Json::Value const>>(_attributes),
-		_hasChildren
+		std::vector<pair<string, Json::Value>>(std::move(_attributes))
 	);
 }
-  
-void ASTJsonConverter::addJsonNode(
+
+void ASTJsonConverter::setJsonNode(
 	ASTNode const& _node,
-	string const& _nodeName,
-	std::vector<pair<string const, Json::Value const>> const& _attributes,
-	bool _hasChildren = false
+	string const& _nodeType,
+	std::vector<pair<string, Json::Value>>&& _attributes
 )
 {
-	Json::Value node;
-
-	node["id"] = Json::UInt64(_node.id());
-	node["src"] = sourceLocationToString(_node.location());
-	node["name"] = _nodeName;
-	if (_attributes.size() != 0)
+	m_currentValue = Json::objectValue;
+	m_currentValue["id"] = nodeId(_node);
+	m_currentValue["src"] = sourceLocationToString(_node.location());
+	if (!m_legacy)
 	{
-		Json::Value attrs;
+		m_currentValue["nodeType"] = _nodeType;
 		for (auto& e: _attributes)
-			attrs[e.first] = e.second;
-		node["attributes"] = attrs;
+			m_currentValue[e.first] = std::move(e.second);
 	}
-
-	m_jsonNodePtrs.top()->append(node);
-
-	if (_hasChildren)
+	else
 	{
-		Json::Value& addedNode = (*m_jsonNodePtrs.top())[m_jsonNodePtrs.top()->size() - 1];
-		Json::Value children(Json::arrayValue);
-		addedNode["children"] = children;
-		m_jsonNodePtrs.push(&addedNode["children"]);
+		m_currentValue["name"] = _nodeType;
+		Json::Value attrs(Json::objectValue);
+		if (
+			//these nodeTypes need to have a children-node even if it is empty
+			(_nodeType == "VariableDeclaration") ||
+			(_nodeType == "ParameterList") ||
+			(_nodeType == "Block") ||
+			(_nodeType == "InlineAssembly") ||
+			(_nodeType == "Throw")
+		)
+		{
+			Json::Value children(Json::arrayValue);
+			m_currentValue["children"] = children;
+		}
+
+		for (auto& e: _attributes)
+		{
+			if (
+				(!e.second.isNull()) &&
+					(
+					(e.second.isObject() && e.second.isMember("name")) ||
+					(e.second.isArray() && e.second[0].isObject() && e.second[0].isMember("name")) ||
+					(e.first == "declarations") // (in the case (_,x)= ... there's a nullpointer at [0]
+					)
+			)
+			{
+				if (e.second.isObject())
+					m_currentValue["children"].append(std::move(e.second));
+				if (e.second.isArray())
+					for (auto& child : e.second)
+						if (!child.isNull())
+							m_currentValue["children"].append(std::move(child));
+			}
+			else
+			{
+				if (e.first == "typeDescriptions")
+					attrs["type"] = Json::Value(e.second["typeString"]);
+				else
+					attrs[e.first] = std::move(e.second);
+			}
+		}
+		if (!attrs.empty())
+			m_currentValue["attributes"] = std::move(attrs);
 	}
 }
 
@@ -90,34 +129,79 @@ string ASTJsonConverter::sourceLocationToString(SourceLocation const& _location)
 	return std::to_string(_location.start) + ":" + std::to_string(length) + ":" + std::to_string(sourceIndex);
 }
 
-ASTJsonConverter::ASTJsonConverter(
-	ASTNode const& _ast,
-	map<string, unsigned> _sourceIndices
-): m_ast(&_ast), m_sourceIndices(_sourceIndices)
+string ASTJsonConverter::namePathToString(std::vector<ASTString> const& _namePath) const
 {
+	return boost::algorithm::join(_namePath, ".");
 }
 
-void ASTJsonConverter::print(ostream& _stream)
+Json::Value ASTJsonConverter::typePointerToJson(TypePointer _tp)
+{
+	Json::Value typeDescriptions(Json::objectValue);
+	typeDescriptions["typeString"] = _tp ? Json::Value(_tp->toString()) : Json::nullValue;
+	typeDescriptions["typeIdentifier"] = _tp ? Json::Value(_tp->identifier()) : Json::nullValue;
+	return typeDescriptions;
+
+}
+Json::Value ASTJsonConverter::typePointerToJson(std::shared_ptr<std::vector<TypePointer>> _tps)
 {
-	process();
-	_stream << m_astJson;
+	if (_tps)
+	{
+		Json::Value arguments(Json::arrayValue);
+		for (auto const& tp : *_tps)
+			arguments.append(typePointerToJson(tp));
+		return arguments;
+	}
+	else
+		return Json::nullValue;
 }
 
-Json::Value const& ASTJsonConverter::json()
+void ASTJsonConverter::appendExpressionAttributes(
+	std::vector<pair<string, Json::Value>> * _attributes,
+	ExpressionAnnotation const& _annotation
+)
 {
-	process();
-	return m_astJson;
+	std::vector<pair<string, Json::Value>> exprAttributes = {
+	make_pair("typeDescriptions", typePointerToJson(_annotation.type)),
+	    make_pair("isConstant", _annotation.isConstant),
+	    make_pair("isPure", _annotation.isPure),
+	    make_pair("isLValue", _annotation.isLValue),
+	    make_pair("lValueRequested", _annotation.lValueRequested),
+	    make_pair("argumentTypes", typePointerToJson(_annotation.argumentTypes))
+	};
+	_attributes->insert(_attributes->end(), exprAttributes.begin(), exprAttributes.end());
 }
 
-bool ASTJsonConverter::visit(SourceUnit const&)
+
+void ASTJsonConverter::print(ostream& _stream, ASTNode const& _node)
 {
-	Json::Value children(Json::arrayValue);
+	_stream << toJson(_node);
+}
 
-	m_astJson["name"] = "SourceUnit";
-	m_astJson["children"] = children;
-	m_jsonNodePtrs.push(&m_astJson["children"]);
+Json::Value ASTJsonConverter::toJson(ASTNode const& _node)
+{
+	_node.accept(*this);
+	return std::move(m_currentValue);
+}
 
-	return true;
+bool ASTJsonConverter::visit(SourceUnit const& _node)
+{
+	Json::Value exportedSymbols = Json::objectValue;
+	for (auto const& sym: _node.annotation().exportedSymbols)
+	{
+		exportedSymbols[sym.first] = Json::arrayValue;
+		for (Declaration const* overload: sym.second)
+			exportedSymbols[sym.first].append(nodeId(*overload));
+	}
+	setJsonNode(
+		_node,
+		"SourceUnit",
+		{
+			make_pair("absolutePath", _node.annotation().path),
+			make_pair("exportedSymbols", move(exportedSymbols)),
+			make_pair("nodes", toJson(_node.nodes()))
+		}
+	);
+	return false;
 }
 
 bool ASTJsonConverter::visit(PragmaDirective const& _node)
@@ -125,313 +209,493 @@ bool ASTJsonConverter::visit(PragmaDirective const& _node)
 	Json::Value literals(Json::arrayValue);
 	for (auto const& literal: _node.literals())
 		literals.append(literal);
-	addJsonNode(_node, "PragmaDirective", { make_pair("literals", literals) });
-	return true;
+	setJsonNode( _node, "PragmaDirective", {
+		make_pair("literals", std::move(literals))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(ImportDirective const& _node)
 {
-	addJsonNode(_node, "ImportDirective", { make_pair("file", _node.path())});
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("file", _node.path()),
+		make_pair("absolutePath", _node.annotation().absolutePath),
+		make_pair("SourceUnit", nodeId(*_node.annotation().sourceUnit)),
+		make_pair("scope", idOrNull(_node.scope()))
+	};
+	attributes.push_back(make_pair("unitAlias", _node.name()));
+	Json::Value symbolAliases(Json::arrayValue);
+	for (auto const& symbolAlias: _node.symbolAliases())
+	{
+		Json::Value tuple(Json::objectValue);
+		solAssert(symbolAlias.first, "");
+		tuple["foreign"] = nodeId(*symbolAlias.first);
+		tuple["local"] =  symbolAlias.second ? Json::Value(*symbolAlias.second) : Json::nullValue;
+		symbolAliases.append(tuple);
+	}
+	attributes.push_back( make_pair("symbolAliases", std::move(symbolAliases)));
+	setJsonNode(_node, "ImportDirective", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(ContractDefinition const& _node)
 {
 	Json::Value linearizedBaseContracts(Json::arrayValue);
 	for (auto const& baseContract: _node.annotation().linearizedBaseContracts)
-		linearizedBaseContracts.append(Json::UInt64(baseContract->id()));
-	addJsonNode(_node, "ContractDefinition", {
+		linearizedBaseContracts.append(nodeId(*baseContract));
+	Json::Value contractDependencies(Json::arrayValue);
+	for (auto const& dependentContract: _node.annotation().contractDependencies)
+		contractDependencies.append(nodeId(*dependentContract));
+	setJsonNode(_node, "ContractDefinition", {
 		make_pair("name", _node.name()),
 		make_pair("isLibrary", _node.isLibrary()),
 		make_pair("fullyImplemented", _node.annotation().isFullyImplemented),
-		make_pair("linearizedBaseContracts", linearizedBaseContracts),
-	}, true);
-	return true;
+		make_pair("linearizedBaseContracts", std::move(linearizedBaseContracts)),
+		make_pair("baseContracts", toJson(_node.baseContracts())),
+		make_pair("contractDependencies", std::move(contractDependencies)),
+		make_pair("nodes", toJson(_node.subNodes())),
+		make_pair("scope", idOrNull(_node.scope()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(InheritanceSpecifier const& _node)
 {
-	addJsonNode(_node, "InheritanceSpecifier", {}, true);
-	return true;
+	setJsonNode(_node, "InheritanceSpecifier", {
+		make_pair("baseName", toJson(_node.name())),
+		make_pair("arguments", toJson(_node.arguments()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(UsingForDirective const& _node)
 {
-	addJsonNode(_node, "UsingForDirective", {}, true);
-	return true;
+	setJsonNode(_node, "UsingForDirective", {
+		make_pair("libraryNames", toJson(_node.libraryName())),
+		make_pair("typeName", _node.typeName() ? toJson(*_node.typeName()) : Json::nullValue)
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(StructDefinition const& _node)
 {
-	addJsonNode(_node, "StructDefinition", { make_pair("name", _node.name()) }, true);
-	return true;
+	setJsonNode(_node, "StructDefinition", {
+		make_pair("name", _node.name()),
+		make_pair("visibility", visibility(_node.visibility())),
+		make_pair("canonicalName", _node.annotation().canonicalName),
+		make_pair("members", toJson(_node.members())),
+		make_pair("scope", idOrNull(_node.scope()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(EnumDefinition const& _node)
 {
-	addJsonNode(_node, "EnumDefinition", { make_pair("name", _node.name()) }, true);
-	return true;
+	setJsonNode(_node, "EnumDefinition", {
+		make_pair("name", _node.name()),
+		make_pair("canonicalName", _node.annotation().canonicalName),
+		make_pair("members", toJson(_node.members()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(EnumValue const& _node)
 {
-	addJsonNode(_node, "EnumValue", { make_pair("name", _node.name()) });
-	return true;
+	setJsonNode(_node, "EnumValue", {
+		make_pair("name", _node.name())
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(ParameterList const& _node)
 {
-	addJsonNode(_node, "ParameterList", {}, true);
-	return true;
+	setJsonNode(_node, "ParameterList", {
+		make_pair("parameters", toJson(_node.parameters()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(FunctionDefinition const& _node)
 {
-	addJsonNode(_node, "FunctionDefinition", {
+	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("name", _node.name()),
 		make_pair("constant", _node.isDeclaredConst()),
 		make_pair("payable", _node.isPayable()),
-		make_pair("visibility", visibility(_node.visibility()))
-	}, true);
-	return true;
+		make_pair("visibility", visibility(_node.visibility())),
+		make_pair("parameters",	toJson(_node.parameterList())),
+		make_pair("isConstructor", _node.isConstructor()),
+		make_pair("returnParameters", toJson((*_node.returnParameterList()))),
+		make_pair("modifiers", toJson(_node.modifiers())),
+		make_pair("body", _node.isImplemented() ? toJson(_node.body()) : Json::nullValue),
+		make_pair("isImplemented", _node.isImplemented()),
+		make_pair("scope", idOrNull(_node.scope()))
+	};
+	setJsonNode(_node, "FunctionDefinition", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(VariableDeclaration const& _node)
 {
-	std::vector<pair<string const, Json::Value const>> attributes = {
+	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("name", _node.name()),
-		make_pair("type", type(_node)),
+		make_pair("typeName", toJsonOrNull(_node.typeName())),
 		make_pair("constant", _node.isConstant()),
 		make_pair("storageLocation", location(_node.referenceLocation())),
-		make_pair("visibility", visibility(_node.visibility()))
-        };
+		make_pair("visibility", visibility(_node.visibility())),
+		make_pair("value", _node.value() ? toJson(*_node.value()) : Json::nullValue),
+		make_pair("scope", idOrNull(_node.scope())),
+		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
+	};
 	if (m_inEvent)
 		attributes.push_back(make_pair("indexed", _node.isIndexed()));
-	addJsonNode(_node, "VariableDeclaration", attributes, true);
-	return true;
-
+	setJsonNode(_node, "VariableDeclaration", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(ModifierDefinition const& _node)
 {
-	addJsonNode(_node, "ModifierDefinition", { make_pair("name", _node.name()) }, true);
-	return true;
+	setJsonNode(_node, "ModifierDefinition", {
+		make_pair("name", _node.name()),
+		make_pair("visibility", visibility(_node.visibility())),
+		make_pair("parameters", toJson(_node.parameterList())),
+		make_pair("body", toJson(_node.body()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(ModifierInvocation const& _node)
 {
-	addJsonNode(_node, "ModifierInvocation", {}, true);
-	return true;
+	setJsonNode(_node, "ModifierInvocation", {
+		make_pair("modifierName", toJson(*_node.name())),
+		make_pair("arguments", toJson(_node.arguments()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(TypeName const&)
 {
-	return true;
+	return false;
 }
 
 bool ASTJsonConverter::visit(EventDefinition const& _node)
 {
 	m_inEvent = true;
-	addJsonNode(_node, "EventDefinition", { make_pair("name", _node.name()) }, true);
-	return true;
+	setJsonNode(_node, "EventDefinition", {
+		make_pair("name", _node.name()),
+		make_pair("parameters", toJson(_node.parameterList())),
+		make_pair("isAnonymous", _node.isAnonymous())
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(ElementaryTypeName const& _node)
 {
-	addJsonNode(_node, "ElementaryTypeName", { make_pair("name", _node.typeName().toString()) });
-	return true;
+	setJsonNode(_node, "ElementaryTypeName", {
+		make_pair("name", _node.typeName().toString()),
+		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(UserDefinedTypeName const& _node)
 {
-	addJsonNode(_node, "UserDefinedTypeName", {
-		make_pair("name", boost::algorithm::join(_node.namePath(), "."))
+	setJsonNode(_node, "UserDefinedTypeName", {
+		make_pair("name", namePathToString(_node.namePath())),
+		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
+		make_pair("contractScope", idOrNull(_node.annotation().contractScope)),
+		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
 	});
-	return true;
+	return false;
 }
 
 bool ASTJsonConverter::visit(FunctionTypeName const& _node)
 {
-	addJsonNode(_node, "FunctionTypeName", {
+	setJsonNode(_node, "FunctionTypeName", {
 		make_pair("payable", _node.isPayable()),
 		make_pair("visibility", visibility(_node.visibility())),
-		make_pair("constant", _node.isDeclaredConst())
-	}, true);
-	return true;
+		make_pair("constant", _node.isDeclaredConst()),
+		make_pair("parameterTypes", toJson(_node.parameterTypes())),
+		make_pair("returnParameterTypes", toJson(_node.returnParameterTypes())),
+		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(Mapping const& _node)
 {
-	addJsonNode(_node, "Mapping", {}, true);
-	return true;
+	setJsonNode(_node, "Mapping", {
+		make_pair("keyType", toJson(_node.keyType())),
+		make_pair("valueType", toJson(_node.valueType())),
+		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(ArrayTypeName const& _node)
 {
-	addJsonNode(_node, "ArrayTypeName", {}, true);
-	return true;
+	setJsonNode(_node, "ArrayTypeName", {
+		make_pair("baseType", toJson(_node.baseType())),
+		make_pair("length", toJsonOrNull(_node.length())),
+		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(InlineAssembly const& _node)
 {
-	addJsonNode(_node, "InlineAssembly", {}, true);
-	return true;
+	std::map<assembly::Identifier const*, Declaration const*>::iterator it;
+	Json::Value externalReferences(Json::arrayValue);
+	for (
+		it = _node.annotation().externalReferences.begin();
+		it != _node.annotation().externalReferences.end();
+		it++
+	)
+	{
+		if (it->first && it->second)
+		{
+			Json::Value tuple(Json::objectValue);
+			tuple[it->first->name] = nodeId(*it->second);
+			externalReferences.append(tuple);
+		}
+	}
+	setJsonNode(_node, "InlineAssembly", {
+		make_pair("operations", Json::Value(assembly::AsmPrinter()(_node.operations()))),
+		make_pair("externalReferences", std::move(externalReferences))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(Block const& _node)
 {
-	addJsonNode(_node, "Block", {}, true);
-	return true;
+	setJsonNode(_node, "Block", {
+		make_pair("statements", toJson(_node.statements()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(PlaceholderStatement const& _node)
 {
-	addJsonNode(_node, "PlaceholderStatement", {});
-	return true;
+	setJsonNode(_node, "PlaceholderStatement", {});
+	return false;
 }
 
 bool ASTJsonConverter::visit(IfStatement const& _node)
 {
-	addJsonNode(_node, "IfStatement", {}, true);
-	return true;
+	setJsonNode(_node, "IfStatement", {
+		make_pair("condition", toJson(_node.condition())),
+		make_pair("trueBody", toJson(_node.trueStatement())),
+		make_pair("falseBody", toJsonOrNull(_node.falseStatement()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(WhileStatement const& _node)
 {
-	addJsonNode(
+	setJsonNode(
 		_node,
 		_node.isDoWhile() ? "DoWhileStatement" : "WhileStatement",
-		{},
-		true);
-	return true;
+		{
+			make_pair("condition", toJson(_node.condition())),
+			make_pair("body", toJson(_node.body()))
+		}
+	);
+	return false;
 }
 
 bool ASTJsonConverter::visit(ForStatement const& _node)
 {
-	addJsonNode(_node, "ForStatement", {}, true);
-	return true;
+	setJsonNode(_node, "ForStatement", {
+		make_pair("initExpression", toJsonOrNull(_node.initializationExpression())),
+		make_pair("condition", toJsonOrNull(_node.condition())),
+		make_pair("loopExpression", toJsonOrNull(_node.loopExpression())),
+		make_pair("body", toJson(_node.body()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(Continue const& _node)
 {
-	addJsonNode(_node, "Continue", {});
-	return true;
+	setJsonNode(_node, "Continue", {});
+	return false;
 }
 
 bool ASTJsonConverter::visit(Break const& _node)
 {
-	addJsonNode(_node, "Break", {});
-	return true;
+	setJsonNode(_node, "Break", {});
+	return false;
 }
 
 bool ASTJsonConverter::visit(Return const& _node)
 {
-	addJsonNode(_node, "Return", {}, true);;
-	return true;
+	setJsonNode(_node, "Return", {
+		make_pair("expression", toJsonOrNull(_node.expression())),
+		make_pair("functionReturnParameters", idOrNull(_node.annotation().functionReturnParameters))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(Throw const& _node)
 {
-	addJsonNode(_node, "Throw", {}, true);;
-	return true;
+	setJsonNode(_node, "Throw", {});;
+	return false;
 }
 
 bool ASTJsonConverter::visit(VariableDeclarationStatement const& _node)
 {
-	addJsonNode(_node, "VariableDeclarationStatement", {}, true);
-	return true;
+	Json::Value varDecs(Json::arrayValue);
+	for (auto const& v: _node.annotation().assignments)
+	{
+		varDecs.append(idOrNull(v));
+	}
+	setJsonNode(_node, "VariableDeclarationStatement", {
+		make_pair("assignments", std::move(varDecs)),
+		make_pair("declarations", toJson(_node.declarations())),
+		make_pair("initialValue", toJsonOrNull(_node.initialValue()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(ExpressionStatement const& _node)
 {
-	addJsonNode(_node, "ExpressionStatement", {}, true);
-	return true;
+	setJsonNode(_node, "ExpressionStatement", {
+		make_pair("expression", toJson(_node.expression()))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(Conditional const& _node)
 {
-	addJsonNode(_node, "Conditional", {}, true);
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("condition", toJson(_node.condition())),
+		make_pair("trueExpression", toJson(_node.trueExpression())),
+		make_pair("falseExpression", toJson(_node.falseExpression()))
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "Conditional", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(Assignment const& _node)
 {
-	addJsonNode(_node, "Assignment",
-				{ make_pair("operator", Token::toString(_node.assignmentOperator())),
-					make_pair("type", type(_node)) },
-				true);
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("operator", Token::toString(_node.assignmentOperator())),
+		make_pair("leftHandSide", toJson(_node.leftHandSide())),
+		make_pair("rightHandSide", toJson(_node.rightHandSide()))
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode( _node, "Assignment", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(TupleExpression const& _node)
 {
-	addJsonNode(_node, "TupleExpression",{}, true);
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("isInlineArray", Json::Value(_node.isInlineArray())),
+		make_pair("components", toJson(_node.components())),
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "TupleExpression", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(UnaryOperation const& _node)
 {
-	addJsonNode(_node, "UnaryOperation",
-				{ make_pair("prefix", _node.isPrefixOperation()),
-					make_pair("operator", Token::toString(_node.getOperator())),
-					make_pair("type", type(_node)) },
-				true);
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("prefix", _node.isPrefixOperation()),
+		make_pair("operator", Token::toString(_node.getOperator())),
+		make_pair("subExpression", toJson(_node.subExpression()))
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "UnaryOperation", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(BinaryOperation const& _node)
 {
-	addJsonNode(_node, "BinaryOperation", {
+	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("operator", Token::toString(_node.getOperator())),
-		make_pair("type", type(_node))
-	}, true);
-	return true;
+		make_pair("leftExpression", toJson(_node.leftExpression())),
+		make_pair("rightExpression", toJson(_node.rightExpression())),
+		make_pair("commonType", typePointerToJson(_node.annotation().commonType)),
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "BinaryOperation", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(FunctionCall const& _node)
 {
-	addJsonNode(_node, "FunctionCall", {
+	Json::Value names(Json::arrayValue);
+	for (auto const& name: _node.names())
+		names.append(Json::Value(*name));
+	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("type_conversion", _node.annotation().isTypeConversion),
-		make_pair("type", type(_node))
-	}, true);
-	return true;
+		make_pair("isStructContstructorCall", _node.annotation().isStructConstructorCall),
+		make_pair("expression", toJson(_node.expression())),
+		make_pair("names", std::move(names)),
+		make_pair("arguments", toJson(_node.arguments()))
+		};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "FunctionCall", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(NewExpression const& _node)
 {
-	addJsonNode(_node, "NewExpression", { make_pair("type", type(_node)) }, true);
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("typeName", toJson(_node.typeName()))
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "NewExpression", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(MemberAccess const& _node)
 {
-	addJsonNode(_node, "MemberAccess", {
+	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("member_name", _node.memberName()),
-		make_pair("type", type(_node))
-	}, true);
-	return true;
+		make_pair("expression", toJson(_node.expression())),
+		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "MemberAccess", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(IndexAccess const& _node)
 {
-	addJsonNode(_node, "IndexAccess", { make_pair("type", type(_node)) }, true);
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("baseExpression", toJson(_node.baseExpression())),
+		make_pair("indexExpression", toJsonOrNull(_node.indexExpression())),
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "IndexAccess", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(Identifier const& _node)
 {
-	addJsonNode(_node, "Identifier",
-				{ make_pair("value", _node.name()), make_pair("type", type(_node)) });
-	return true;
+	Json::Value overloads(Json::arrayValue);
+	for (auto const& dec: _node.annotation().overloadedDeclarations)
+		overloads.append(nodeId(*dec));
+	setJsonNode(_node, "Identifier", {
+		make_pair("value", _node.name()),
+		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
+		make_pair("overloadedDeclarations", overloads),
+		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type)),
+		make_pair("argumentTypes", typePointerToJson(_node.annotation().argumentTypes))
+	});
+	return false;
 }
 
 bool ASTJsonConverter::visit(ElementaryTypeNameExpression const& _node)
 {
-	addJsonNode(_node, "ElementaryTypeNameExpression", {
-		make_pair("value", _node.typeName().toString()),
-		make_pair("type", type(_node))
-	});
-	return true;
+	std::vector<pair<string, Json::Value>> attributes = {
+		make_pair("value", _node.typeName().toString())
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "ElementaryTypeNameExpression", std::move(attributes));
+	return false;
 }
 
 bool ASTJsonConverter::visit(Literal const& _node)
@@ -441,7 +705,7 @@ bool ASTJsonConverter::visit(Literal const& _node)
 	if (!dev::validateUTF8(_node.value()))
 		value = Json::nullValue;
 	Token::Value subdenomination = Token::Value(_node.subDenomination());
-	addJsonNode(_node, "Literal", {
+	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("token", tokenString ? tokenString : Json::Value()),
 		make_pair("value", value),
 		make_pair("hexvalue", toHex(_node.value())),
@@ -450,231 +714,17 @@ bool ASTJsonConverter::visit(Literal const& _node)
 			subdenomination == Token::Illegal ?
 			Json::nullValue :
 			Json::Value{Token::toString(subdenomination)}
-		),
-		make_pair("type", type(_node))
-	});
-	return true;
+		)
+	};
+	appendExpressionAttributes(&attributes, _node.annotation());
+	setJsonNode(_node, "Literal", std::move(attributes));
+	return false;
 }
 
-void ASTJsonConverter::endVisit(SourceUnit const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(PragmaDirective const&)
-{
-}
-
-void ASTJsonConverter::endVisit(ImportDirective const&)
-{
-}
-
-void ASTJsonConverter::endVisit(ContractDefinition const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(InheritanceSpecifier const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(UsingForDirective const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(StructDefinition const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(EnumDefinition const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(EnumValue const&)
-{
-}
-
-void ASTJsonConverter::endVisit(ParameterList const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(FunctionDefinition const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(VariableDeclaration const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(ModifierDefinition const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(ModifierInvocation const&)
-{
-	goUp();
-}
 
 void ASTJsonConverter::endVisit(EventDefinition const&)
 {
 	m_inEvent = false;
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(TypeName const&)
-{
-}
-
-void ASTJsonConverter::endVisit(ElementaryTypeName const&)
-{
-}
-
-void ASTJsonConverter::endVisit(UserDefinedTypeName const&)
-{
-}
-
-void ASTJsonConverter::endVisit(FunctionTypeName const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(Mapping const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(ArrayTypeName const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(InlineAssembly const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(Block const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(PlaceholderStatement const&)
-{
-}
-
-void ASTJsonConverter::endVisit(IfStatement const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(WhileStatement const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(ForStatement const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(Continue const&)
-{
-}
-
-void ASTJsonConverter::endVisit(Break const&)
-{
-}
-
-void ASTJsonConverter::endVisit(Return const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(Throw const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(VariableDeclarationStatement const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(ExpressionStatement const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(Conditional const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(Assignment const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(TupleExpression const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(UnaryOperation const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(BinaryOperation const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(FunctionCall const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(NewExpression const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(MemberAccess const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(IndexAccess const&)
-{
-	goUp();
-}
-
-void ASTJsonConverter::endVisit(Identifier const&)
-{
-}
-
-void ASTJsonConverter::endVisit(ElementaryTypeNameExpression const&)
-{
-}
-
-void ASTJsonConverter::endVisit(Literal const&)
-{
-}
-
-void ASTJsonConverter::process()
-{
-	if (!processed)
-		m_ast->accept(*this);
-	processed = true;
 }
 
 string ASTJsonConverter::visibility(Declaration::Visibility const& _visibility)
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index bd5e6560..eee1086e 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -42,15 +42,23 @@ class ASTJsonConverter: public ASTConstVisitor
 {
 public:
 	/// Create a converter to JSON for the given abstract syntax tree.
+	/// @a _legacy if true, use legacy format
 	/// @a _sourceIndices is used to abbreviate source names in source locations.
 	explicit ASTJsonConverter(
-		ASTNode const& _ast,
+		bool _legacy,
 		std::map<std::string, unsigned> _sourceIndices = std::map<std::string, unsigned>()
 	);
 	/// Output the json representation of the AST to _stream.
-	void print(std::ostream& _stream);
-	Json::Value const& json();
-
+	void print(std::ostream& _stream, ASTNode const& _node);
+	Json::Value toJson(ASTNode const& _node);
+	template <class T>
+	Json::Value toJson(std::vector<ASTPointer<T>> const& _nodes)
+	{
+		Json::Value ret(Json::arrayValue);
+		for (auto const& n: _nodes)
+			ret.append(n ? toJson(*n) : Json::nullValue);
+		return ret;
+	}
 	bool visit(SourceUnit const& _node) override;
 	bool visit(PragmaDirective const& _node) override;
 	bool visit(ImportDirective const& _node) override;
@@ -97,82 +105,46 @@ public:
 	bool visit(ElementaryTypeNameExpression const& _node) override;
 	bool visit(Literal const& _node) override;
 
-	void endVisit(SourceUnit const&) override;
-	void endVisit(PragmaDirective const&) override;
-	void endVisit(ImportDirective const&) override;
-	void endVisit(ContractDefinition const&) override;
-	void endVisit(InheritanceSpecifier const&) override;
-	void endVisit(UsingForDirective const&) override;
-	void endVisit(StructDefinition const&) override;
-	void endVisit(EnumDefinition const&) override;
-	void endVisit(EnumValue const&) override;
-	void endVisit(ParameterList const&) override;
-	void endVisit(FunctionDefinition const&) override;
-	void endVisit(VariableDeclaration const&) override;
-	void endVisit(ModifierDefinition const&) override;
-	void endVisit(ModifierInvocation const&) override;
 	void endVisit(EventDefinition const&) override;
-	void endVisit(TypeName const&) override;
-	void endVisit(ElementaryTypeName const&) override;
-	void endVisit(UserDefinedTypeName const&) override;
-	void endVisit(FunctionTypeName const&) override;
-	void endVisit(Mapping const&) override;
-	void endVisit(ArrayTypeName const&) override;
-	void endVisit(InlineAssembly const&) override;
-	void endVisit(Block const&) override;
-	void endVisit(PlaceholderStatement const&) override;
-	void endVisit(IfStatement 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;
-	void endVisit(Throw const&) override;
-	void endVisit(VariableDeclarationStatement const&) override;
-	void endVisit(ExpressionStatement const&) override;
-	void endVisit(Conditional const&) override;
-	void endVisit(Assignment const&) override;
-	void endVisit(TupleExpression const&) override;
-	void endVisit(UnaryOperation const&) override;
-	void endVisit(BinaryOperation const&) override;
-	void endVisit(FunctionCall const&) override;
-	void endVisit(NewExpression const&) override;
-	void endVisit(MemberAccess const&) override;
-	void endVisit(IndexAccess const&) override;
-	void endVisit(Identifier const&) override;
-	void endVisit(ElementaryTypeNameExpression const&) override;
-	void endVisit(Literal const&) override;
 
 private:
-	void process();
-	void addJsonNode(
+	void setJsonNode(
 		ASTNode const& _node,
 		std::string const& _nodeName,
-		std::initializer_list<std::pair<std::string const, Json::Value const>> _attributes,
-		bool _hasChildren
+		std::initializer_list<std::pair<std::string, Json::Value>>&& _attributes
 	);
-	void addJsonNode(
+	void setJsonNode(
 		ASTNode const& _node,
 		std::string const& _nodeName,
-		std::vector<std::pair<std::string const, Json::Value const>> const& _attributes,
-		bool _hasChildren
+		std::vector<std::pair<std::string, Json::Value>>&& _attributes
 	);
 	std::string sourceLocationToString(SourceLocation const& _location) const;
+	std::string namePathToString(std::vector<ASTString> const& _namePath) const;
+	Json::Value idOrNull(ASTNode const* _pt)
+	{
+		return _pt ? Json::Value(nodeId(*_pt)) : Json::nullValue;
+	}
+	Json::Value toJsonOrNull(ASTNode const* _node)
+	{
+		return _node ? toJson(*_node) : Json::nullValue;
+	}
 	std::string visibility(Declaration::Visibility const& _visibility);
 	std::string location(VariableDeclaration::Location _location);
 	std::string type(Expression const& _expression);
 	std::string type(VariableDeclaration const& _varDecl);
-	inline void goUp()
+	int nodeId(ASTNode const& _node)
 	{
-		solAssert(!m_jsonNodePtrs.empty(), "Uneven json nodes stack. Internal error.");
-		m_jsonNodePtrs.pop();
+		return _node.id();
 	}
-
+	Json::Value typePointerToJson(TypePointer _tp);
+	Json::Value typePointerToJson(std::shared_ptr<std::vector<TypePointer>> _tps);
+	void appendExpressionAttributes(
+		std::vector<std::pair<std::string, Json::Value>> * _attributes,
+		ExpressionAnnotation const& _annotation
+	);
+	bool m_legacy = false; ///< if true, use legacy format
 	bool m_inEvent = false; ///< whether we are currently inside an event or not
-	bool processed = false;
-	Json::Value m_astJson;
-	std::stack<Json::Value*> m_jsonNodePtrs;
-	ASTNode const* m_ast;
+	Json::Value m_currentValue;
 	std::map<std::string, unsigned> m_sourceIndices;
 };
 
diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
index 41ee6498..cfee041e 100644
--- a/libsolidity/ast/Types.cpp
+++ b/libsolidity/ast/Types.cpp
@@ -2183,6 +2183,8 @@ string FunctionType::identifier() const
 	case Kind::ArrayPush: id += "arraypush"; break;
 	case Kind::ByteArrayPush: id += "bytearraypush"; break;
 	case Kind::ObjectCreation: id += "objectcreation"; break;
+	case Kind::Assert: id += "assert"; break;
+	case Kind::Require: id += "require";break;
 	default: solAssert(false, "Unknown function location."); break;
 	}
 	if (isConstant())
diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index 223cc15d..4ca1fd09 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -377,7 +377,7 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 	{
 		Json::Value sourceResult = Json::objectValue;
 		sourceResult["id"] = sourceIndex++;
-		sourceResult["legacyAST"] = ASTJsonConverter(m_compilerStack.ast(source), m_compilerStack.sourceIndices()).json();
+		sourceResult["legacyAST"] = ASTJsonConverter(true, m_compilerStack.sourceIndices()).toJson(m_compilerStack.ast(source));
 		output["sources"][source] = sourceResult;
 	}
 
-- 
cgit v1.2.3


From f2a6331ffbf0fb37bd9d05aed28a625fe366fa4c Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 21 Apr 2017 13:34:26 +0100
Subject: Support the new AST in StandardCompiler

---
 libsolidity/interface/StandardCompiler.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index 4ca1fd09..0afa9ae1 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -377,6 +377,7 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 	{
 		Json::Value sourceResult = Json::objectValue;
 		sourceResult["id"] = sourceIndex++;
+		sourceResult["ast"] = ASTJsonConverter(false, m_compilerStack.sourceIndices()).toJson(m_compilerStack.ast(source));
 		sourceResult["legacyAST"] = ASTJsonConverter(true, m_compilerStack.sourceIndices()).toJson(m_compilerStack.ast(source));
 		output["sources"][source] = sourceResult;
 	}
-- 
cgit v1.2.3


From 487eef18ccb5202461130e91a9b93981bcbf1a5d Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 21 Apr 2017 13:46:53 +0100
Subject: Use different AST node names in legacy and new format

---
 libsolidity/ast/ASTJsonConverter.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index c6abab54..3388d6cc 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -220,7 +220,7 @@ bool ASTJsonConverter::visit(ImportDirective const& _node)
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("file", _node.path()),
 		make_pair("absolutePath", _node.annotation().absolutePath),
-		make_pair("SourceUnit", nodeId(*_node.annotation().sourceUnit)),
+		make_pair(m_legacy ? "SourceUnit" : "sourceUnit", nodeId(*_node.annotation().sourceUnit)),
 		make_pair("scope", idOrNull(_node.scope()))
 	};
 	attributes.push_back(make_pair("unitAlias", _node.name()));
@@ -319,7 +319,7 @@ bool ASTJsonConverter::visit(FunctionDefinition const& _node)
 {
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("name", _node.name()),
-		make_pair("constant", _node.isDeclaredConst()),
+		make_pair(m_legacy ? "constant" : "isDeclaredConst", _node.isDeclaredConst()),
 		make_pair("payable", _node.isPayable()),
 		make_pair("visibility", visibility(_node.visibility())),
 		make_pair("parameters",	toJson(_node.parameterList())),
@@ -339,7 +339,7 @@ bool ASTJsonConverter::visit(VariableDeclaration const& _node)
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("name", _node.name()),
 		make_pair("typeName", toJsonOrNull(_node.typeName())),
-		make_pair("constant", _node.isConstant()),
+		make_pair(m_legacy ? "constant" : "isConstant", _node.isConstant()),
 		make_pair("storageLocation", location(_node.referenceLocation())),
 		make_pair("visibility", visibility(_node.visibility())),
 		make_pair("value", _node.value() ? toJson(*_node.value()) : Json::nullValue),
@@ -413,7 +413,7 @@ bool ASTJsonConverter::visit(FunctionTypeName const& _node)
 	setJsonNode(_node, "FunctionTypeName", {
 		make_pair("payable", _node.isPayable()),
 		make_pair("visibility", visibility(_node.visibility())),
-		make_pair("constant", _node.isDeclaredConst()),
+		make_pair(m_legacy ? "constant" : "isDeclaredConst", _node.isDeclaredConst()),
 		make_pair("parameterTypes", toJson(_node.parameterTypes())),
 		make_pair("returnParameterTypes", toJson(_node.returnParameterTypes())),
 		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
@@ -629,7 +629,7 @@ bool ASTJsonConverter::visit(FunctionCall const& _node)
 	for (auto const& name: _node.names())
 		names.append(Json::Value(*name));
 	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("type_conversion", _node.annotation().isTypeConversion),
+		make_pair(m_legacy ? "type_conversion" : "isTypeConversion", _node.annotation().isTypeConversion),
 		make_pair("isStructContstructorCall", _node.annotation().isStructConstructorCall),
 		make_pair("expression", toJson(_node.expression())),
 		make_pair("names", std::move(names)),
@@ -653,7 +653,7 @@ bool ASTJsonConverter::visit(NewExpression const& _node)
 bool ASTJsonConverter::visit(MemberAccess const& _node)
 {
 	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("member_name", _node.memberName()),
+		make_pair(m_legacy ? "member_name" : "memberName", _node.memberName()),
 		make_pair("expression", toJson(_node.expression())),
 		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
 	};
@@ -679,7 +679,7 @@ bool ASTJsonConverter::visit(Identifier const& _node)
 	for (auto const& dec: _node.annotation().overloadedDeclarations)
 		overloads.append(nodeId(*dec));
 	setJsonNode(_node, "Identifier", {
-		make_pair("value", _node.name()),
+		make_pair(m_legacy ? "value" : "name", _node.name()),
 		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
 		make_pair("overloadedDeclarations", overloads),
 		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type)),
@@ -691,7 +691,7 @@ bool ASTJsonConverter::visit(Identifier const& _node)
 bool ASTJsonConverter::visit(ElementaryTypeNameExpression const& _node)
 {
 	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("value", _node.typeName().toString())
+		make_pair(m_legacy ? "value" : "typeName", _node.typeName().toString())
 	};
 	appendExpressionAttributes(&attributes, _node.annotation());
 	setJsonNode(_node, "ElementaryTypeNameExpression", std::move(attributes));
@@ -708,7 +708,7 @@ bool ASTJsonConverter::visit(Literal const& _node)
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("token", tokenString ? tokenString : Json::Value()),
 		make_pair("value", value),
-		make_pair("hexvalue", toHex(_node.value())),
+		make_pair(m_legacy ? "hexvalue" : "hexValue", toHex(_node.value())),
 		make_pair(
 			"subdenomination",
 			subdenomination == Token::Illegal ?
-- 
cgit v1.2.3


From 2fa7646944451bdb804d842c0dacdbbba960f857 Mon Sep 17 00:00:00 2001
From: djuju <julfaber@gmail.com>
Date: Tue, 25 Apr 2017 18:47:11 +0200
Subject: fixed styletypos, renaming and added helperfunction

---
 libsolidity/ast/ASTJsonConverter.cpp | 63 ++++++++++++++++--------------------
 libsolidity/ast/ASTJsonConverter.h   | 13 +++++++-
 2 files changed, 40 insertions(+), 36 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 3388d6cc..4046073e 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -101,7 +101,7 @@ void ASTJsonConverter::setJsonNode(
 				if (e.second.isObject())
 					m_currentValue["children"].append(std::move(e.second));
 				if (e.second.isArray())
-					for (auto& child : e.second)
+					for (auto& child: e.second)
 						if (!child.isNull())
 							m_currentValue["children"].append(std::move(child));
 			}
@@ -147,7 +147,7 @@ Json::Value ASTJsonConverter::typePointerToJson(std::shared_ptr<std::vector<Type
 	if (_tps)
 	{
 		Json::Value arguments(Json::arrayValue);
-		for (auto const& tp : *_tps)
+		for (auto const& tp: *_tps)
 			arguments.append(typePointerToJson(tp));
 		return arguments;
 	}
@@ -156,19 +156,19 @@ Json::Value ASTJsonConverter::typePointerToJson(std::shared_ptr<std::vector<Type
 }
 
 void ASTJsonConverter::appendExpressionAttributes(
-	std::vector<pair<string, Json::Value>> * _attributes,
+	std::vector<pair<string, Json::Value>> &_attributes,
 	ExpressionAnnotation const& _annotation
 )
 {
 	std::vector<pair<string, Json::Value>> exprAttributes = {
 	make_pair("typeDescriptions", typePointerToJson(_annotation.type)),
-	    make_pair("isConstant", _annotation.isConstant),
-	    make_pair("isPure", _annotation.isPure),
-	    make_pair("isLValue", _annotation.isLValue),
-	    make_pair("lValueRequested", _annotation.lValueRequested),
-	    make_pair("argumentTypes", typePointerToJson(_annotation.argumentTypes))
+		make_pair("isConstant", _annotation.isConstant),
+		make_pair("isPure", _annotation.isPure),
+		make_pair("isLValue", _annotation.isLValue),
+		make_pair("lValueRequested", _annotation.lValueRequested),
+		make_pair("argumentTypes", typePointerToJson(_annotation.argumentTypes))
 	};
-	_attributes->insert(_attributes->end(), exprAttributes.begin(), exprAttributes.end());
+	_attributes.insert(_attributes.end(), exprAttributes.begin(), exprAttributes.end());
 }
 
 
@@ -233,26 +233,20 @@ bool ASTJsonConverter::visit(ImportDirective const& _node)
 		tuple["local"] =  symbolAlias.second ? Json::Value(*symbolAlias.second) : Json::nullValue;
 		symbolAliases.append(tuple);
 	}
-	attributes.push_back( make_pair("symbolAliases", std::move(symbolAliases)));
+	attributes.push_back(make_pair("symbolAliases", std::move(symbolAliases)));
 	setJsonNode(_node, "ImportDirective", std::move(attributes));
 	return false;
 }
 
 bool ASTJsonConverter::visit(ContractDefinition const& _node)
 {
-	Json::Value linearizedBaseContracts(Json::arrayValue);
-	for (auto const& baseContract: _node.annotation().linearizedBaseContracts)
-		linearizedBaseContracts.append(nodeId(*baseContract));
-	Json::Value contractDependencies(Json::arrayValue);
-	for (auto const& dependentContract: _node.annotation().contractDependencies)
-		contractDependencies.append(nodeId(*dependentContract));
 	setJsonNode(_node, "ContractDefinition", {
 		make_pair("name", _node.name()),
 		make_pair("isLibrary", _node.isLibrary()),
 		make_pair("fullyImplemented", _node.annotation().isFullyImplemented),
-		make_pair("linearizedBaseContracts", std::move(linearizedBaseContracts)),
+		make_pair("linearizedBaseContracts", getContainerIds(_node.annotation().linearizedBaseContracts)),
 		make_pair("baseContracts", toJson(_node.baseContracts())),
-		make_pair("contractDependencies", std::move(contractDependencies)),
+		make_pair("contractDependencies", getContainerIds(_node.annotation().contractDependencies)),
 		make_pair("nodes", toJson(_node.subNodes())),
 		make_pair("scope", idOrNull(_node.scope()))
 	});
@@ -322,9 +316,9 @@ bool ASTJsonConverter::visit(FunctionDefinition const& _node)
 		make_pair(m_legacy ? "constant" : "isDeclaredConst", _node.isDeclaredConst()),
 		make_pair("payable", _node.isPayable()),
 		make_pair("visibility", visibility(_node.visibility())),
-		make_pair("parameters",	toJson(_node.parameterList())),
+		make_pair("parameters", toJson(_node.parameterList())),
 		make_pair("isConstructor", _node.isConstructor()),
-		make_pair("returnParameters", toJson((*_node.returnParameterList()))),
+		make_pair("returnParameters", toJson(*_node.returnParameterList())),
 		make_pair("modifiers", toJson(_node.modifiers())),
 		make_pair("body", _node.isImplemented() ? toJson(_node.body()) : Json::nullValue),
 		make_pair("isImplemented", _node.isImplemented()),
@@ -339,7 +333,7 @@ bool ASTJsonConverter::visit(VariableDeclaration const& _node)
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("name", _node.name()),
 		make_pair("typeName", toJsonOrNull(_node.typeName())),
-		make_pair(m_legacy ? "constant" : "isConstant", _node.isConstant()),
+		make_pair("constant", _node.isConstant()),
 		make_pair("storageLocation", location(_node.referenceLocation())),
 		make_pair("visibility", visibility(_node.visibility())),
 		make_pair("value", _node.value() ? toJson(*_node.value()) : Json::nullValue),
@@ -374,6 +368,7 @@ bool ASTJsonConverter::visit(ModifierInvocation const& _node)
 
 bool ASTJsonConverter::visit(TypeName const&)
 {
+	solAssert(false, "AST node of abstract type used.");
 	return false;
 }
 
@@ -383,7 +378,7 @@ bool ASTJsonConverter::visit(EventDefinition const& _node)
 	setJsonNode(_node, "EventDefinition", {
 		make_pair("name", _node.name()),
 		make_pair("parameters", toJson(_node.parameterList())),
-		make_pair("isAnonymous", _node.isAnonymous())
+		make_pair("anonymous", _node.isAnonymous())
 	});
 	return false;
 }
@@ -544,9 +539,7 @@ bool ASTJsonConverter::visit(VariableDeclarationStatement const& _node)
 {
 	Json::Value varDecs(Json::arrayValue);
 	for (auto const& v: _node.annotation().assignments)
-	{
 		varDecs.append(idOrNull(v));
-	}
 	setJsonNode(_node, "VariableDeclarationStatement", {
 		make_pair("assignments", std::move(varDecs)),
 		make_pair("declarations", toJson(_node.declarations())),
@@ -570,7 +563,7 @@ bool ASTJsonConverter::visit(Conditional const& _node)
 		make_pair("trueExpression", toJson(_node.trueExpression())),
 		make_pair("falseExpression", toJson(_node.falseExpression()))
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "Conditional", std::move(attributes));
 	return false;
 }
@@ -582,7 +575,7 @@ bool ASTJsonConverter::visit(Assignment const& _node)
 		make_pair("leftHandSide", toJson(_node.leftHandSide())),
 		make_pair("rightHandSide", toJson(_node.rightHandSide()))
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode( _node, "Assignment", std::move(attributes));
 	return false;
 }
@@ -593,7 +586,7 @@ bool ASTJsonConverter::visit(TupleExpression const& _node)
 		make_pair("isInlineArray", Json::Value(_node.isInlineArray())),
 		make_pair("components", toJson(_node.components())),
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "TupleExpression", std::move(attributes));
 	return false;
 }
@@ -605,7 +598,7 @@ bool ASTJsonConverter::visit(UnaryOperation const& _node)
 		make_pair("operator", Token::toString(_node.getOperator())),
 		make_pair("subExpression", toJson(_node.subExpression()))
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "UnaryOperation", std::move(attributes));
 	return false;
 }
@@ -618,7 +611,7 @@ bool ASTJsonConverter::visit(BinaryOperation const& _node)
 		make_pair("rightExpression", toJson(_node.rightExpression())),
 		make_pair("commonType", typePointerToJson(_node.annotation().commonType)),
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "BinaryOperation", std::move(attributes));
 	return false;
 }
@@ -635,7 +628,7 @@ bool ASTJsonConverter::visit(FunctionCall const& _node)
 		make_pair("names", std::move(names)),
 		make_pair("arguments", toJson(_node.arguments()))
 		};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "FunctionCall", std::move(attributes));
 	return false;
 }
@@ -645,7 +638,7 @@ bool ASTJsonConverter::visit(NewExpression const& _node)
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair("typeName", toJson(_node.typeName()))
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "NewExpression", std::move(attributes));
 	return false;
 }
@@ -657,7 +650,7 @@ bool ASTJsonConverter::visit(MemberAccess const& _node)
 		make_pair("expression", toJson(_node.expression())),
 		make_pair("referencedDeclaration", idOrNull(_node.annotation().referencedDeclaration)),
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "MemberAccess", std::move(attributes));
 	return false;
 }
@@ -668,7 +661,7 @@ bool ASTJsonConverter::visit(IndexAccess const& _node)
 		make_pair("baseExpression", toJson(_node.baseExpression())),
 		make_pair("indexExpression", toJsonOrNull(_node.indexExpression())),
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "IndexAccess", std::move(attributes));
 	return false;
 }
@@ -693,7 +686,7 @@ bool ASTJsonConverter::visit(ElementaryTypeNameExpression const& _node)
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair(m_legacy ? "value" : "typeName", _node.typeName().toString())
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "ElementaryTypeNameExpression", std::move(attributes));
 	return false;
 }
@@ -716,7 +709,7 @@ bool ASTJsonConverter::visit(Literal const& _node)
 			Json::Value{Token::toString(subdenomination)}
 		)
 	};
-	appendExpressionAttributes(&attributes, _node.annotation());
+	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "Literal", std::move(attributes));
 	return false;
 }
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index eee1086e..aab8c124 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -136,10 +136,21 @@ private:
 	{
 		return _node.id();
 	}
+	template<class Container>
+	Json::Value getContainerIds(Container container)
+	{
+		Json::Value tmp(Json::arrayValue);
+		for (auto it = container.begin(); it != container.end(); ++it)
+		{
+			solAssert(*it, "");
+			tmp.append(nodeId(**it));
+		}
+		return tmp;
+	}
 	Json::Value typePointerToJson(TypePointer _tp);
 	Json::Value typePointerToJson(std::shared_ptr<std::vector<TypePointer>> _tps);
 	void appendExpressionAttributes(
-		std::vector<std::pair<std::string, Json::Value>> * _attributes,
+		std::vector<std::pair<std::string, Json::Value>> &_attributes,
 		ExpressionAnnotation const& _annotation
 	);
 	bool m_legacy = false; ///< if true, use legacy format
-- 
cgit v1.2.3


From a4ba5ace8a5d77397715204fe737b0dba4429368 Mon Sep 17 00:00:00 2001
From: djuju <julfaber@gmail.com>
Date: Fri, 5 May 2017 16:15:09 +0200
Subject: prefixChanges and contractKind-field

---
 libsolidity/ast/ASTJsonConverter.cpp | 36 +++++++++++++++++++++++-------------
 libsolidity/ast/ASTJsonConverter.h   |  1 +
 2 files changed, 24 insertions(+), 13 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 4046073e..492429d7 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -242,7 +242,7 @@ bool ASTJsonConverter::visit(ContractDefinition const& _node)
 {
 	setJsonNode(_node, "ContractDefinition", {
 		make_pair("name", _node.name()),
-		make_pair("isLibrary", _node.isLibrary()),
+		make_pair("contractKind", contractKind(_node.contractKind())),
 		make_pair("fullyImplemented", _node.annotation().isFullyImplemented),
 		make_pair("linearizedBaseContracts", getContainerIds(_node.annotation().linearizedBaseContracts)),
 		make_pair("baseContracts", toJson(_node.baseContracts())),
@@ -265,7 +265,7 @@ bool ASTJsonConverter::visit(InheritanceSpecifier const& _node)
 bool ASTJsonConverter::visit(UsingForDirective const& _node)
 {
 	setJsonNode(_node, "UsingForDirective", {
-		make_pair("libraryNames", toJson(_node.libraryName())),
+		make_pair("libraryName", toJson(_node.libraryName())),
 		make_pair("typeName", _node.typeName() ? toJson(*_node.typeName()) : Json::nullValue)
 	});
 	return false;
@@ -321,7 +321,7 @@ bool ASTJsonConverter::visit(FunctionDefinition const& _node)
 		make_pair("returnParameters", toJson(*_node.returnParameterList())),
 		make_pair("modifiers", toJson(_node.modifiers())),
 		make_pair("body", _node.isImplemented() ? toJson(_node.body()) : Json::nullValue),
-		make_pair("isImplemented", _node.isImplemented()),
+		make_pair("implemented", _node.isImplemented()),
 		make_pair("scope", idOrNull(_node.scope()))
 	};
 	setJsonNode(_node, "FunctionDefinition", std::move(attributes));
@@ -438,18 +438,13 @@ bool ASTJsonConverter::visit(ArrayTypeName const& _node)
 
 bool ASTJsonConverter::visit(InlineAssembly const& _node)
 {
-	std::map<assembly::Identifier const*, Declaration const*>::iterator it;
 	Json::Value externalReferences(Json::arrayValue);
-	for (
-		it = _node.annotation().externalReferences.begin();
-		it != _node.annotation().externalReferences.end();
-		it++
-	)
+	for (auto const& it : _node.annotation().externalReferences)
 	{
-		if (it->first && it->second)
+		if (it.first && it.second)
 		{
 			Json::Value tuple(Json::objectValue);
-			tuple[it->first->name] = nodeId(*it->second);
+			tuple[it.first->name] = nodeId(*it.second);
 			externalReferences.append(tuple);
 		}
 	}
@@ -500,7 +495,7 @@ bool ASTJsonConverter::visit(WhileStatement const& _node)
 bool ASTJsonConverter::visit(ForStatement const& _node)
 {
 	setJsonNode(_node, "ForStatement", {
-		make_pair("initExpression", toJsonOrNull(_node.initializationExpression())),
+		make_pair("initializationExpression", toJsonOrNull(_node.initializationExpression())),
 		make_pair("condition", toJsonOrNull(_node.condition())),
 		make_pair("loopExpression", toJsonOrNull(_node.loopExpression())),
 		make_pair("body", toJson(_node.body()))
@@ -623,7 +618,7 @@ bool ASTJsonConverter::visit(FunctionCall const& _node)
 		names.append(Json::Value(*name));
 	std::vector<pair<string, Json::Value>> attributes = {
 		make_pair(m_legacy ? "type_conversion" : "isTypeConversion", _node.annotation().isTypeConversion),
-		make_pair("isStructContstructorCall", _node.annotation().isStructConstructorCall),
+		make_pair("isStructConstructorCall", _node.annotation().isStructConstructorCall),
 		make_pair("expression", toJson(_node.expression())),
 		make_pair("names", std::move(names)),
 		make_pair("arguments", toJson(_node.arguments()))
@@ -752,6 +747,21 @@ string ASTJsonConverter::location(VariableDeclaration::Location _location)
 	}
 }
 
+string ASTJsonConverter::contractKind(ContractDefinition::ContractKind _kind)
+{
+	switch (_kind)
+	{
+	case ContractDefinition::ContractKind::Interface:
+		return "interface";
+	case ContractDefinition::ContractKind::Contract:
+		return "contract";
+	case ContractDefinition::ContractKind::Library:
+		return "library";
+	default:
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown contract kind."));
+	}
+}
+
 string ASTJsonConverter::type(Expression const& _expression)
 {
 	return _expression.annotation().type ? _expression.annotation().type->toString() : "Unknown";
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index aab8c124..1499c3b8 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -130,6 +130,7 @@ private:
 	}
 	std::string visibility(Declaration::Visibility const& _visibility);
 	std::string location(VariableDeclaration::Location _location);
+	std::string contractKind(ContractDefinition::ContractKind _kind);
 	std::string type(Expression const& _expression);
 	std::string type(VariableDeclaration const& _varDecl);
 	int nodeId(ASTNode const& _node)
-- 
cgit v1.2.3


From e3583d04f79c5e9ada9914f43711d3b90242dfdc Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Wed, 17 May 2017 15:52:45 +0200
Subject: include new InlineAssemblyInformation into JSON

---
 libsolidity/ast/ASTJsonConverter.cpp | 14 ++++++++++++--
 libsolidity/ast/ASTJsonConverter.h   |  1 +
 2 files changed, 13 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 492429d7..3c3ceae8 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -171,6 +171,16 @@ void ASTJsonConverter::appendExpressionAttributes(
 	_attributes.insert(_attributes.end(), exprAttributes.begin(), exprAttributes.end());
 }
 
+Json::Value ASTJsonConverter::inlineAssemblyIdentifierToJson(pair<assembly::Identifier const* ,InlineAssemblyAnnotation::ExternalIdentifierInfo> _info)
+{
+	Json::Value tuple(Json::objectValue);
+	tuple["src"] = sourceLocationToString(_info.first->location);
+	tuple["declaration"] = idOrNull(_info.second.declaration);
+	tuple["isSlot"] = Json::Value(_info.second.isSlot);
+	tuple["isOffset"] = Json::Value(_info.second.isOffset);
+	tuple["valueSize"] = _info.second.valueSize;
+	return tuple;
+}
 
 void ASTJsonConverter::print(ostream& _stream, ASTNode const& _node)
 {
@@ -441,10 +451,10 @@ bool ASTJsonConverter::visit(InlineAssembly const& _node)
 	Json::Value externalReferences(Json::arrayValue);
 	for (auto const& it : _node.annotation().externalReferences)
 	{
-		if (it.first && it.second)
+		if (it.first)
 		{
 			Json::Value tuple(Json::objectValue);
-			tuple[it.first->name] = nodeId(*it.second);
+			tuple[it.first->name] = inlineAssemblyIdentifierToJson(it);
 			externalReferences.append(tuple);
 		}
 	}
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index 1499c3b8..cf62e5f5 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -128,6 +128,7 @@ private:
 	{
 		return _node ? toJson(*_node) : Json::nullValue;
 	}
+	Json::Value inlineAssemblyIdentifierToJson(std::pair<assembly::Identifier const* , InlineAssemblyAnnotation::ExternalIdentifierInfo> _info);
 	std::string visibility(Declaration::Visibility const& _visibility);
 	std::string location(VariableDeclaration::Location _location);
 	std::string contractKind(ContractDefinition::ContractKind _kind);
-- 
cgit v1.2.3


From 6316a76ab915e03e02825ce391d3812098c6b682 Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Wed, 17 May 2017 18:22:39 +0200
Subject: testsuite adjustment

---
 libsolidity/ast/ASTJsonConverter.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index cf62e5f5..3d6035a4 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -139,13 +139,13 @@ private:
 		return _node.id();
 	}
 	template<class Container>
-	Json::Value getContainerIds(Container container)
+	Json::Value getContainerIds(Container const& container)
 	{
 		Json::Value tmp(Json::arrayValue);
-		for (auto it = container.begin(); it != container.end(); ++it)
+		for (auto const& element: container)
 		{
-			solAssert(*it, "");
-			tmp.append(nodeId(**it));
+			solAssert(element, "");
+			tmp.append(nodeId(*element));
 		}
 		return tmp;
 	}
-- 
cgit v1.2.3


From edd0afa3c35475990bacd8ffe64d15b3be40a036 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 2 May 2017 18:26:33 +0100
Subject: Support true/false literals in inline assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp |  2 +-
 libsolidity/inlineasm/AsmCodeGen.cpp  |  9 ++++++++-
 libsolidity/inlineasm/AsmData.h       |  3 ++-
 libsolidity/inlineasm/AsmParser.cpp   | 23 ++++++++++++++++++++++-
 libsolidity/inlineasm/AsmPrinter.cpp  | 10 +++++++++-
 5 files changed, 42 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 590f9ad6..e03eea2e 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -72,7 +72,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 {
 	++m_stackHeight;
-	if (!_literal.isNumber && _literal.value.size() > 32)
+	if (_literal.kind == assembly::LiteralKind::String && _literal.value.size() > 32)
 	{
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::TypeError,
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 137a70f5..44e12b3e 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -118,8 +118,15 @@ public:
 	void operator()(assembly::Literal const& _literal)
 	{
 		m_state.assembly.setSourceLocation(_literal.location);
-		if (_literal.isNumber)
+		if (_literal.kind == assembly::LiteralKind::Number)
 			m_state.assembly.append(u256(_literal.value));
+		else if (_literal.kind == assembly::LiteralKind::Boolean)
+		{
+			if (_literal.value == "true")
+				m_state.assembly.append(u256(1));
+			else
+				m_state.assembly.append(u256(0));
+		}
 		else
 		{
 			solAssert(_literal.value.size() <= 32, "");
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 363873ab..8efe1f07 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -43,7 +43,8 @@ using TypedNameList = std::vector<TypedName>;
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
-struct Literal { SourceLocation location; bool isNumber; std::string value; Type type; };
+enum class LiteralKind { Number, Boolean, String };
+struct Literal { SourceLocation location; LiteralKind kind; std::string value; Type type; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 7ecad5ea..079b9352 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -206,10 +206,29 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 	}
 	case Token::StringLiteral:
 	case Token::Number:
+	case Token::TrueLiteral:
+	case Token::FalseLiteral:
 	{
+		LiteralKind kind = LiteralKind::Number;
+		switch (m_scanner->currentToken())
+		{
+		case Token::StringLiteral:
+			kind = LiteralKind::String;
+			break;
+		case Token::Number:
+			kind = LiteralKind::Number;
+			break;
+		case Token::TrueLiteral:
+		case Token::FalseLiteral:
+			kind = LiteralKind::Boolean;
+			break;
+		default:
+			break;
+		}
+
 		Literal literal{
 			location(),
-			m_scanner->currentToken() == Token::Number,
+			kind,
 			m_scanner->currentLiteral(),
 			""
 		};
@@ -220,6 +239,8 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 			literal.location.end = endPosition();
 			literal.type = expectAsmIdentifier();
 		}
+		else if (kind == LiteralKind::Boolean)
+			fatalParserError("True and false are not valid literals.");
 		ret = std::move(literal);
 		break;
 	}
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index f3b66aee..636e61b8 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -46,8 +46,16 @@ string AsmPrinter::operator()(assembly::Instruction const& _instruction)
 
 string AsmPrinter::operator()(assembly::Literal const& _literal)
 {
-	if (_literal.isNumber)
+	switch (_literal.kind)
+	{
+	case LiteralKind::Number:
 		return _literal.value + appendTypeName(_literal.type);
+	case LiteralKind::Boolean:
+		return ((_literal.value == "true") ? "true" : "false") + appendTypeName(_literal.type);
+	case LiteralKind::String:
+		break;
+	}
+
 	string out;
 	for (char c: _literal.value)
 		if (c == '\\')
-- 
cgit v1.2.3


From ebcb27e5c14549d114c116889c730c3a8cd82a86 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 17 May 2017 13:33:05 +0100
Subject: Accept bool as a type in Julia mode

---
 libsolidity/inlineasm/AsmParser.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 079b9352..a96984f5 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -381,7 +381,15 @@ TypedName Parser::parseTypedName()
 string Parser::expectAsmIdentifier()
 {
 	string name = m_scanner->currentLiteral();
-	if (!m_julia && instructions().count(name))
+	if (m_julia)
+	{
+		if (m_scanner->currentToken() == Token::Bool)
+		{
+			m_scanner->next();
+			return name;
+		}
+	}
+	else if (instructions().count(name))
 		fatalParserError("Cannot use instruction names for identifier names.");
 	expectToken(Token::Identifier);
 	return name;
-- 
cgit v1.2.3


From 1d22233a43453a21d9fde6e4ba91e26d651045bd Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Fri, 19 May 2017 15:45:01 +0200
Subject: refactoring functionCallAnnotation

---
 libsolidity/analysis/TypeChecker.cpp       | 15 ++++++++-----
 libsolidity/ast/ASTAnnotations.h           | 13 +++++++----
 libsolidity/ast/ASTJsonConverter.cpp       | 35 ++++++++++++++++++++++++------
 libsolidity/ast/ASTJsonConverter.h         |  1 +
 libsolidity/codegen/ExpressionCompiler.cpp |  6 ++---
 libsolidity/formal/Why3Translator.cpp      |  2 +-
 6 files changed, 51 insertions(+), 21 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 38cdc1f8..b8221a2c 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -1238,13 +1238,16 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 
 	if (auto const* typeType = dynamic_cast<TypeType const*>(expressionType.get()))
 	{
-		_functionCall.annotation().isStructConstructorCall = (typeType->actualType()->category() == Type::Category::Struct);
-		_functionCall.annotation().isTypeConversion = !_functionCall.annotation().isStructConstructorCall;
+		if (typeType->actualType()->category() == Type::Category::Struct)
+			_functionCall.annotation().kind = FunctionCallKind::StructConstructorCall;
+		else
+			_functionCall.annotation().kind = FunctionCallKind::TypeConversion;
+
 	}
 	else
-		_functionCall.annotation().isStructConstructorCall = _functionCall.annotation().isTypeConversion = false;
+		_functionCall.annotation().kind = FunctionCallKind::FunctionCall;
 
-	if (_functionCall.annotation().isTypeConversion)
+	if (_functionCall.annotation().kind == FunctionCallKind::TypeConversion)
 	{
 		TypeType const& t = dynamic_cast<TypeType const&>(*expressionType);
 		TypePointer resultType = t.actualType();
@@ -1274,7 +1277,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 
 	/// For error message: Struct members that were removed during conversion to memory.
 	set<string> membersRemovedForStructConstructor;
-	if (_functionCall.annotation().isStructConstructorCall)
+	if (_functionCall.annotation().kind == FunctionCallKind::StructConstructorCall)
 	{
 		TypeType const& t = dynamic_cast<TypeType const&>(*expressionType);
 		auto const& structType = dynamic_cast<StructType const&>(*t.actualType());
@@ -1312,7 +1315,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			toString(parameterTypes.size()) +
 			".";
 		// Extend error message in case we try to construct a struct with mapping member.
-		if (_functionCall.annotation().isStructConstructorCall && !membersRemovedForStructConstructor.empty())
+		if (_functionCall.annotation().kind == FunctionCallKind::StructConstructorCall && !membersRemovedForStructConstructor.empty())
 		{
 			msg += " Members that have to be skipped in memory:";
 			for (auto const& member: membersRemovedForStructConstructor)
diff --git a/libsolidity/ast/ASTAnnotations.h b/libsolidity/ast/ASTAnnotations.h
index a7d89248..45a6dd1a 100644
--- a/libsolidity/ast/ASTAnnotations.h
+++ b/libsolidity/ast/ASTAnnotations.h
@@ -200,12 +200,17 @@ struct BinaryOperationAnnotation: ExpressionAnnotation
 	TypePointer commonType;
 };
 
+enum class FunctionCallKind
+{
+	Unset,
+	FunctionCall,
+	TypeConversion,
+	StructConstructorCall
+};
+
 struct FunctionCallAnnotation: ExpressionAnnotation
 {
-	/// Whether this is an explicit type conversion.
-	bool isTypeConversion = false;
-	/// Whether this is a struct constructor call.
-	bool isStructConstructorCall = false;
+	FunctionCallKind kind = FunctionCallKind::Unset;
 };
 
 }
diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 3c3ceae8..81996678 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -156,19 +156,19 @@ Json::Value ASTJsonConverter::typePointerToJson(std::shared_ptr<std::vector<Type
 }
 
 void ASTJsonConverter::appendExpressionAttributes(
-	std::vector<pair<string, Json::Value>> &_attributes,
+	std::vector<pair<string, Json::Value>>& _attributes,
 	ExpressionAnnotation const& _annotation
 )
 {
 	std::vector<pair<string, Json::Value>> exprAttributes = {
-	make_pair("typeDescriptions", typePointerToJson(_annotation.type)),
+		make_pair("typeDescriptions", typePointerToJson(_annotation.type)),
 		make_pair("isConstant", _annotation.isConstant),
 		make_pair("isPure", _annotation.isPure),
 		make_pair("isLValue", _annotation.isLValue),
 		make_pair("lValueRequested", _annotation.lValueRequested),
 		make_pair("argumentTypes", typePointerToJson(_annotation.argumentTypes))
 	};
-	_attributes.insert(_attributes.end(), exprAttributes.begin(), exprAttributes.end());
+	_attributes += exprAttributes;
 }
 
 Json::Value ASTJsonConverter::inlineAssemblyIdentifierToJson(pair<assembly::Identifier const* ,InlineAssemblyAnnotation::ExternalIdentifierInfo> _info)
@@ -344,6 +344,7 @@ bool ASTJsonConverter::visit(VariableDeclaration const& _node)
 		make_pair("name", _node.name()),
 		make_pair("typeName", toJsonOrNull(_node.typeName())),
 		make_pair("constant", _node.isConstant()),
+		make_pair("stateVariable", _node.isStateVariable()),
 		make_pair("storageLocation", location(_node.referenceLocation())),
 		make_pair("visibility", visibility(_node.visibility())),
 		make_pair("value", _node.value() ? toJson(*_node.value()) : Json::nullValue),
@@ -627,12 +628,17 @@ bool ASTJsonConverter::visit(FunctionCall const& _node)
 	for (auto const& name: _node.names())
 		names.append(Json::Value(*name));
 	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair(m_legacy ? "type_conversion" : "isTypeConversion", _node.annotation().isTypeConversion),
-		make_pair("isStructConstructorCall", _node.annotation().isStructConstructorCall),
 		make_pair("expression", toJson(_node.expression())),
 		make_pair("names", std::move(names)),
 		make_pair("arguments", toJson(_node.arguments()))
-		};
+	};
+	if (m_legacy)
+	{
+		attributes.push_back(make_pair("isStructConstructorCall", functionCallKind(_node.annotation().kind)));
+		attributes.push_back(make_pair("type_conversion", _node.annotation().kind == FunctionCallKind::TypeConversion));
+	}
+	else
+		attributes.push_back(make_pair("kind", functionCallKind(_node.annotation().kind)));
 	appendExpressionAttributes(attributes, _node.annotation());
 	setJsonNode(_node, "FunctionCall", std::move(attributes));
 	return false;
@@ -768,7 +774,22 @@ string ASTJsonConverter::contractKind(ContractDefinition::ContractKind _kind)
 	case ContractDefinition::ContractKind::Library:
 		return "library";
 	default:
-		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown contract kind."));
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of contract."));
+	}
+}
+
+string ASTJsonConverter::functionCallKind(FunctionCallKind _kind)
+{
+	switch (_kind)
+	{
+	case FunctionCallKind::FunctionCall:
+		return "functionCall";
+	case FunctionCallKind::TypeConversion:
+		return "typeConversion";
+	case FunctionCallKind::StructConstructorCall:
+		return "structConstructorCall";
+	default:
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of function call ."));
 	}
 }
 
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index 3d6035a4..5ee40536 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -132,6 +132,7 @@ private:
 	std::string visibility(Declaration::Visibility const& _visibility);
 	std::string location(VariableDeclaration::Location _location);
 	std::string contractKind(ContractDefinition::ContractKind _kind);
+	std::string functionCallKind(FunctionCallKind _kind);
 	std::string type(Expression const& _expression);
 	std::string type(VariableDeclaration const& _varDecl);
 	int nodeId(ASTNode const& _node)
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index f018b311..0aa82ea8 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -434,7 +434,7 @@ bool ExpressionCompiler::visit(BinaryOperation const& _binaryOperation)
 bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 {
 	CompilerContext::LocationSetter locationSetter(m_context, _functionCall);
-	if (_functionCall.annotation().isTypeConversion)
+	if (_functionCall.annotation().kind == FunctionCallKind::TypeConversion)
 	{
 		solAssert(_functionCall.arguments().size() == 1, "");
 		solAssert(_functionCall.names().empty(), "");
@@ -445,7 +445,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 	}
 
 	FunctionTypePointer functionType;
-	if (_functionCall.annotation().isStructConstructorCall)
+	if (_functionCall.annotation().kind == FunctionCallKind::StructConstructorCall)
 	{
 		auto const& type = dynamic_cast<TypeType const&>(*_functionCall.expression().annotation().type);
 		auto const& structType = dynamic_cast<StructType const&>(*type.actualType());
@@ -476,7 +476,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			solAssert(found, "");
 		}
 
-	if (_functionCall.annotation().isStructConstructorCall)
+	if (_functionCall.annotation().kind == FunctionCallKind::StructConstructorCall)
 	{
 		TypeType const& type = dynamic_cast<TypeType const&>(*_functionCall.expression().annotation().type);
 		auto const& structType = dynamic_cast<StructType const&>(*type.actualType());
diff --git a/libsolidity/formal/Why3Translator.cpp b/libsolidity/formal/Why3Translator.cpp
index b6f17907..77d3c217 100644
--- a/libsolidity/formal/Why3Translator.cpp
+++ b/libsolidity/formal/Why3Translator.cpp
@@ -582,7 +582,7 @@ bool Why3Translator::visit(BinaryOperation const& _binaryOperation)
 
 bool Why3Translator::visit(FunctionCall const& _node)
 {
-	if (_node.annotation().isTypeConversion || _node.annotation().isStructConstructorCall)
+	if (_node.annotation().kind == FunctionCallKind::TypeConversion || _node.annotation().kind == FunctionCallKind::StructConstructorCall)
 	{
 		error(_node, "Only ordinary function calls supported.");
 		return true;
-- 
cgit v1.2.3


From 8169e149c98b14861cc6467f9f796010f617c521 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Sat, 6 May 2017 17:59:16 +0100
Subject: Rename CompilerStack.interface to CompilerStack.contractABI

---
 libsolidity/interface/CompilerStack.cpp | 2 +-
 libsolidity/interface/CompilerStack.h   | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 5c836358..7887a2cb 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -444,7 +444,7 @@ map<string, unsigned> CompilerStack::sourceIndices() const
 	return indices;
 }
 
-Json::Value const& CompilerStack::interface(string const& _contractName) const
+Json::Value const& CompilerStack::contractABI(string const& _contractName) const
 {
 	return metadata(_contractName, DocumentationType::ABIInterface);
 }
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index c1d344ca..e98c3b82 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -173,9 +173,9 @@ public:
 	/// @returns a mapping assigning each source name its index inside the vector returned
 	/// by sourceNames().
 	std::map<std::string, unsigned> sourceIndices() const;
-	/// @returns a JSON representing the contract interface.
+	/// @returns a JSON representing the contract ABI.
 	/// Prerequisite: Successful call to parse or compile.
-	Json::Value const& interface(std::string const& _contractName = "") const;
+	Json::Value const& contractABI(std::string const& _contractName = "") const;
 	/// @returns a JSON representing the contract's documentation.
 	/// Prerequisite: Successful call to parse or compile.
 	/// @param type The type of the documentation to get.
-- 
cgit v1.2.3


From 4bf3cbb09a42131dba27b080a4917f30284959d3 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Sat, 6 May 2017 18:02:56 +0100
Subject: Use CompilerStack.contractABI directly

---
 libsolidity/interface/CompilerStack.cpp    | 7 ++++++-
 libsolidity/interface/StandardCompiler.cpp | 2 +-
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 7887a2cb..1f235656 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -449,6 +449,11 @@ Json::Value const& CompilerStack::contractABI(string const& _contractName) const
 	return metadata(_contractName, DocumentationType::ABIInterface);
 }
 
+Json::Value const& CompilerStack::contractABI(Contract const& _contract) const
+{
+	return metadata(_contract, DocumentationType::ABIInterface);
+}
+
 Json::Value const& CompilerStack::metadata(string const& _contractName, DocumentationType _type) const
 {
 	return metadata(contract(_contractName), _type);
@@ -830,7 +835,7 @@ string CompilerStack::createOnChainMetadata(Contract const& _contract) const
 	for (auto const& library: m_libraries)
 		meta["settings"]["libraries"][library.first] = "0x" + toHex(library.second.asBytes());
 
-	meta["output"]["abi"] = metadata(_contract, DocumentationType::ABIInterface);
+	meta["output"]["abi"] = contractABI(_contract);
 	meta["output"]["userdoc"] = metadata(_contract, DocumentationType::NatspecUser);
 	meta["output"]["devdoc"] = metadata(_contract, DocumentationType::NatspecDev);
 
diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index 223cc15d..4eb52fc2 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -391,7 +391,7 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 
 		// ABI, documentation and metadata
 		Json::Value contractData(Json::objectValue);
-		contractData["abi"] = m_compilerStack.metadata(contractName, DocumentationType::ABIInterface);
+		contractData["abi"] = m_compilerStack.contractABI(contractName);
 		contractData["metadata"] = m_compilerStack.onChainMetadata(contractName);
 		contractData["userdoc"] = m_compilerStack.metadata(contractName, DocumentationType::NatspecUser);
 		contractData["devdoc"] = m_compilerStack.metadata(contractName, DocumentationType::NatspecDev);
-- 
cgit v1.2.3


From 12328b784875bad30156a2c66912652f89fa8222 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 10 May 2017 10:54:23 +0100
Subject: Split ABI out of InterfaceHandler

---
 libsolidity/interface/ABI.cpp              | 116 +++++++++++++++++++++++++++++
 libsolidity/interface/ABI.h                |  56 ++++++++++++++
 libsolidity/interface/CompilerStack.cpp    |  17 +++--
 libsolidity/interface/CompilerStack.h      |   6 +-
 libsolidity/interface/InterfaceHandler.cpp | 115 ++++++----------------------
 libsolidity/interface/InterfaceHandler.h   |   7 +-
 6 files changed, 212 insertions(+), 105 deletions(-)
 create mode 100644 libsolidity/interface/ABI.cpp
 create mode 100644 libsolidity/interface/ABI.h

(limited to 'libsolidity')

diff --git a/libsolidity/interface/ABI.cpp b/libsolidity/interface/ABI.cpp
new file mode 100644
index 00000000..12f958fc
--- /dev/null
+++ b/libsolidity/interface/ABI.cpp
@@ -0,0 +1,116 @@
+/*
+        This file is part of solidity.
+
+        solidity is free software: you can redistribute it and/or modify
+        it under the terms of the GNU General Public License as published by
+        the Free Software Foundation, either version 3 of the License, or
+        (at your option) any later version.
+
+        solidity is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+        GNU General Public License for more details.
+
+        You should have received a copy of the GNU General Public License
+        along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Utilities to handle the Contract ABI (https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI)
+ */
+
+#include <libsolidity/interface/ABI.h>
+#include <boost/range/irange.hpp>
+#include <libsolidity/ast/AST.h>
+
+using namespace std;
+using namespace dev;
+using namespace dev::solidity;
+
+Json::Value ABI::generate(ContractDefinition const& _contractDef)
+{
+	Json::Value abi(Json::arrayValue);
+
+	for (auto it: _contractDef.interfaceFunctions())
+	{
+		auto externalFunctionType = it.second->interfaceFunctionType();
+		Json::Value method;
+		method["type"] = "function";
+		method["name"] = it.second->declaration().name();
+		method["constant"] = it.second->isConstant();
+		method["payable"] = it.second->isPayable();
+		method["inputs"] = formatTypeList(
+			externalFunctionType->parameterNames(),
+			externalFunctionType->parameterTypes(),
+			_contractDef.isLibrary()
+		);
+		method["outputs"] = formatTypeList(
+			externalFunctionType->returnParameterNames(),
+			externalFunctionType->returnParameterTypes(),
+			_contractDef.isLibrary()
+		);
+		abi.append(method);
+	}
+	if (_contractDef.constructor())
+	{
+		Json::Value method;
+		method["type"] = "constructor";
+		auto externalFunction = FunctionType(*_contractDef.constructor(), false).interfaceFunctionType();
+		solAssert(!!externalFunction, "");
+		method["payable"] = externalFunction->isPayable();
+		method["inputs"] = formatTypeList(
+			externalFunction->parameterNames(),
+			externalFunction->parameterTypes(),
+			_contractDef.isLibrary()
+		);
+		abi.append(method);
+	}
+	if (_contractDef.fallbackFunction())
+	{
+		auto externalFunctionType = FunctionType(*_contractDef.fallbackFunction(), false).interfaceFunctionType();
+		solAssert(!!externalFunctionType, "");
+		Json::Value method;
+		method["type"] = "fallback";
+		method["payable"] = externalFunctionType->isPayable();
+		abi.append(method);
+	}
+	for (auto const& it: _contractDef.interfaceEvents())
+	{
+		Json::Value event;
+		event["type"] = "event";
+		event["name"] = it->name();
+		event["anonymous"] = it->isAnonymous();
+		Json::Value params(Json::arrayValue);
+		for (auto const& p: it->parameters())
+		{
+			solAssert(!!p->annotation().type->interfaceType(false), "");
+			Json::Value input;
+			input["name"] = p->name();
+			input["type"] = p->annotation().type->interfaceType(false)->canonicalName(false);
+			input["indexed"] = p->isIndexed();
+			params.append(input);
+		}
+		event["inputs"] = params;
+		abi.append(event);
+	}
+
+	return abi;
+}
+
+Json::Value ABI::formatTypeList(
+	vector<string> const& _names,
+	vector<TypePointer> const& _types,
+	bool _forLibrary
+)
+{
+	Json::Value params(Json::arrayValue);
+	solAssert(_names.size() == _types.size(), "Names and types vector size does not match");
+	for (unsigned i = 0; i < _names.size(); ++i)
+	{
+		solAssert(_types[i], "");
+		Json::Value param;
+		param["name"] = _names[i];
+		param["type"] = _types[i]->canonicalName(_forLibrary);
+		params.append(param);
+	}
+	return params;
+}
diff --git a/libsolidity/interface/ABI.h b/libsolidity/interface/ABI.h
new file mode 100644
index 00000000..95b162a9
--- /dev/null
+++ b/libsolidity/interface/ABI.h
@@ -0,0 +1,56 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Utilities to handle the Contract ABI (https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI)
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+#include <json/json.h>
+
+namespace dev
+{
+namespace solidity
+{
+
+// Forward declarations
+class ContractDefinition;
+class Type;
+using TypePointer = std::shared_ptr<Type const>;
+
+class ABI
+{
+public:
+	/// Get the ABI Interface of the contract
+	/// @param _contractDef The contract definition
+	/// @return             A JSONrepresentation of the contract's ABI Interface
+	static Json::Value generate(ContractDefinition const& _contractDef);
+private:
+	/// @returns a json value suitable for a list of types in function input or output
+	/// parameters or other places. If @a _forLibrary is true, complex types are referenced
+	/// by name, otherwise they are anonymously expanded.
+	static Json::Value formatTypeList(
+		std::vector<std::string> const& _names,
+		std::vector<TypePointer> const& _types,
+		bool _forLibrary
+	);
+};
+
+}
+}
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 1f235656..4b57b34c 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -37,6 +37,7 @@
 #include <libsolidity/analysis/PostTypeChecker.h>
 #include <libsolidity/analysis/SyntaxChecker.h>
 #include <libsolidity/codegen/Compiler.h>
+#include <libsolidity/interface/ABI.h>
 #include <libsolidity/interface/InterfaceHandler.h>
 #include <libsolidity/interface/GasEstimator.h>
 #include <libsolidity/formal/Why3Translator.h>
@@ -446,12 +447,21 @@ map<string, unsigned> CompilerStack::sourceIndices() const
 
 Json::Value const& CompilerStack::contractABI(string const& _contractName) const
 {
-	return metadata(_contractName, DocumentationType::ABIInterface);
+	return contractABI(contract(_contractName));
 }
 
 Json::Value const& CompilerStack::contractABI(Contract const& _contract) const
 {
-	return metadata(_contract, DocumentationType::ABIInterface);
+	if (m_stackState < AnalysisSuccessful)
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+
+	solAssert(_contract.contract, "");
+
+	// caches the result
+	if (!_contract.abi)
+		_contract.abi.reset(new Json::Value(ABI::generate(*_contract.contract)));
+
+	return *_contract.abi;
 }
 
 Json::Value const& CompilerStack::metadata(string const& _contractName, DocumentationType _type) const
@@ -476,9 +486,6 @@ Json::Value const& CompilerStack::metadata(Contract const& _contract, Documentat
 	case DocumentationType::NatspecDev:
 		doc = &_contract.devDocumentation;
 		break;
-	case DocumentationType::ABIInterface:
-		doc = &_contract.interface;
-		break;
 	default:
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Illegal documentation type."));
 	}
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index e98c3b82..dd8d671e 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -66,8 +66,7 @@ class DeclarationContainer;
 enum class DocumentationType: uint8_t
 {
 	NatspecUser = 1,
-	NatspecDev,
-	ABIInterface
+	NatspecDev
 };
 
 /**
@@ -230,7 +229,7 @@ private:
 		eth::LinkerObject runtimeObject;
 		eth::LinkerObject cloneObject;
 		std::string onChainMetadata; ///< The metadata json that will be hashed into the chain.
-		mutable std::unique_ptr<Json::Value const> interface;
+		mutable std::unique_ptr<Json::Value const> abi;
 		mutable std::unique_ptr<Json::Value const> userDocumentation;
 		mutable std::unique_ptr<Json::Value const> devDocumentation;
 		mutable std::unique_ptr<std::string const> sourceMapping;
@@ -267,6 +266,7 @@ private:
 
 	std::string createOnChainMetadata(Contract const& _contract) const;
 	std::string computeSourceMapping(eth::AssemblyItems const& _items) const;
+	Json::Value const& contractABI(Contract const&) const;
 	Json::Value const& metadata(Contract const&, DocumentationType _type) const;
 
 	struct Remapping
diff --git a/libsolidity/interface/InterfaceHandler.cpp b/libsolidity/interface/InterfaceHandler.cpp
index 6c1bb0c4..b73cf46e 100644
--- a/libsolidity/interface/InterfaceHandler.cpp
+++ b/libsolidity/interface/InterfaceHandler.cpp
@@ -1,3 +1,27 @@
+/*
+        This file is part of solidity.
+
+        solidity is free software: you can redistribute it and/or modify
+        it under the terms of the GNU General Public License as published by
+        the Free Software Foundation, either version 3 of the License, or
+        (at your option) any later version.
+
+        solidity is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+        GNU General Public License for more details.
+
+        You should have received a copy of the GNU General Public License
+        along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Lefteris <lefteris@ethdev.com>
+ * @date 2014
+ * Takes the parsed AST and produces the Natspec documentation:
+ * https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format
+ *
+ * Can generally deal with JSON files
+ */
 
 #include <libsolidity/interface/InterfaceHandler.h>
 #include <boost/range/irange.hpp>
@@ -19,83 +43,11 @@ Json::Value InterfaceHandler::documentation(
 		return userDocumentation(_contractDef);
 	case DocumentationType::NatspecDev:
 		return devDocumentation(_contractDef);
-	case DocumentationType::ABIInterface:
-		return abiInterface(_contractDef);
 	}
 
 	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation type"));
 }
 
-Json::Value InterfaceHandler::abiInterface(ContractDefinition const& _contractDef)
-{
-	Json::Value abi(Json::arrayValue);
-
-	for (auto it: _contractDef.interfaceFunctions())
-	{
-		auto externalFunctionType = it.second->interfaceFunctionType();
-		Json::Value method;
-		method["type"] = "function";
-		method["name"] = it.second->declaration().name();
-		method["constant"] = it.second->isConstant();
-		method["payable"] = it.second->isPayable();
-		method["inputs"] = formatTypeList(
-			externalFunctionType->parameterNames(),
-			externalFunctionType->parameterTypes(),
-			_contractDef.isLibrary()
-		);
-		method["outputs"] = formatTypeList(
-			externalFunctionType->returnParameterNames(),
-			externalFunctionType->returnParameterTypes(),
-			_contractDef.isLibrary()
-		);
-		abi.append(method);
-	}
-	if (_contractDef.constructor())
-	{
-		Json::Value method;
-		method["type"] = "constructor";
-		auto externalFunction = FunctionType(*_contractDef.constructor(), false).interfaceFunctionType();
-		solAssert(!!externalFunction, "");
-		method["payable"] = externalFunction->isPayable();
-		method["inputs"] = formatTypeList(
-			externalFunction->parameterNames(),
-			externalFunction->parameterTypes(),
-			_contractDef.isLibrary()
-		);
-		abi.append(method);
-	}
-	if (_contractDef.fallbackFunction())
-	{
-		auto externalFunctionType = FunctionType(*_contractDef.fallbackFunction(), false).interfaceFunctionType();
-		solAssert(!!externalFunctionType, "");
-		Json::Value method;
-		method["type"] = "fallback";
-		method["payable"] = externalFunctionType->isPayable();
-		abi.append(method);
-	}
-	for (auto const& it: _contractDef.interfaceEvents())
-	{
-		Json::Value event;
-		event["type"] = "event";
-		event["name"] = it->name();
-		event["anonymous"] = it->isAnonymous();
-		Json::Value params(Json::arrayValue);
-		for (auto const& p: it->parameters())
-		{
-			solAssert(!!p->annotation().type->interfaceType(false), "");
-			Json::Value input;
-			input["name"] = p->name();
-			input["type"] = p->annotation().type->interfaceType(false)->canonicalName(false);
-			input["indexed"] = p->isIndexed();
-			params.append(input);
-		}
-		event["inputs"] = params;
-		abi.append(event);
-	}
-
-	return abi;
-}
-
 Json::Value InterfaceHandler::userDocumentation(ContractDefinition const& _contractDef)
 {
 	Json::Value doc;
@@ -168,25 +120,6 @@ Json::Value InterfaceHandler::devDocumentation(ContractDefinition const& _contra
 	return doc;
 }
 
-Json::Value InterfaceHandler::formatTypeList(
-	vector<string> const& _names,
-	vector<TypePointer> const& _types,
-	bool _forLibrary
-)
-{
-	Json::Value params(Json::arrayValue);
-	solAssert(_names.size() == _types.size(), "Names and types vector size does not match");
-	for (unsigned i = 0; i < _names.size(); ++i)
-	{
-		solAssert(_types[i], "");
-		Json::Value param;
-		param["name"] = _names[i];
-		param["type"] = _types[i]->canonicalName(_forLibrary);
-		params.append(param);
-	}
-	return params;
-}
-
 string InterfaceHandler::extractDoc(multimap<string, DocTag> const& _tags, string const& _name)
 {
 	string value;
diff --git a/libsolidity/interface/InterfaceHandler.h b/libsolidity/interface/InterfaceHandler.h
index 56927d44..883ef3b9 100644
--- a/libsolidity/interface/InterfaceHandler.h
+++ b/libsolidity/interface/InterfaceHandler.h
@@ -17,8 +17,7 @@
 /**
  * @author Lefteris <lefteris@ethdev.com>
  * @date 2014
- * Takes the parsed AST and produces the Natspec
- * documentation and the ABI interface
+ * Takes the parsed AST and produces the Natspec documentation:
  * https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format
  *
  * Can generally deal with JSON files
@@ -71,10 +70,6 @@ public:
 		ContractDefinition const& _contractDef,
 		DocumentationType _type
 	);
-	/// Get the ABI Interface of the contract
-	/// @param _contractDef The contract definition
-	/// @return             A JSONrepresentation of the contract's ABI Interface
-	static Json::Value abiInterface(ContractDefinition const& _contractDef);
 	/// Get the User documentation of the contract
 	/// @param _contractDef The contract definition
 	/// @return             A JSON representation of the contract's user documentation
-- 
cgit v1.2.3


From 81877cc59441f43a33ad7e7a09b92d3ea06b5f03 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 10 May 2017 10:56:21 +0100
Subject: Rename InterfaceHandler to Natspec

---
 libsolidity/interface/CompilerStack.cpp    |   8 +-
 libsolidity/interface/CompilerStack.h      |   2 +-
 libsolidity/interface/InterfaceHandler.cpp | 130 -----------------------------
 libsolidity/interface/InterfaceHandler.h   |  97 ---------------------
 libsolidity/interface/Natspec.cpp          | 130 +++++++++++++++++++++++++++++
 libsolidity/interface/Natspec.h            |  97 +++++++++++++++++++++
 libsolidity/parsing/Parser.cpp             |   1 -
 7 files changed, 232 insertions(+), 233 deletions(-)
 delete mode 100644 libsolidity/interface/InterfaceHandler.cpp
 delete mode 100644 libsolidity/interface/InterfaceHandler.h
 create mode 100644 libsolidity/interface/Natspec.cpp
 create mode 100644 libsolidity/interface/Natspec.h

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 4b57b34c..7125adec 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -38,7 +38,7 @@
 #include <libsolidity/analysis/SyntaxChecker.h>
 #include <libsolidity/codegen/Compiler.h>
 #include <libsolidity/interface/ABI.h>
-#include <libsolidity/interface/InterfaceHandler.h>
+#include <libsolidity/interface/Natspec.h>
 #include <libsolidity/interface/GasEstimator.h>
 #include <libsolidity/formal/Why3Translator.h>
 
@@ -220,8 +220,8 @@ bool CompilerStack::analyze()
 				TypeChecker typeChecker(m_errors);
 				if (typeChecker.checkTypeRequirements(*contract))
 				{
-					contract->setDevDocumentation(InterfaceHandler::devDocumentation(*contract));
-					contract->setUserDocumentation(InterfaceHandler::userDocumentation(*contract));
+					contract->setDevDocumentation(Natspec::devDocumentation(*contract));
+					contract->setUserDocumentation(Natspec::userDocumentation(*contract));
 				}
 				else
 					noErrors = false;
@@ -492,7 +492,7 @@ Json::Value const& CompilerStack::metadata(Contract const& _contract, Documentat
 
 	// caches the result
 	if (!*doc)
-		doc->reset(new Json::Value(InterfaceHandler::documentation(*_contract.contract, _type)));
+		doc->reset(new Json::Value(Natspec::documentation(*_contract.contract, _type)));
 
 	return *(*doc);
 }
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index dd8d671e..cc5ba64c 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -59,7 +59,7 @@ class FunctionDefinition;
 class SourceUnit;
 class Compiler;
 class GlobalContext;
-class InterfaceHandler;
+class Natspec;
 class Error;
 class DeclarationContainer;
 
diff --git a/libsolidity/interface/InterfaceHandler.cpp b/libsolidity/interface/InterfaceHandler.cpp
deleted file mode 100644
index b73cf46e..00000000
--- a/libsolidity/interface/InterfaceHandler.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-        This file is part of solidity.
-
-        solidity is free software: you can redistribute it and/or modify
-        it under the terms of the GNU General Public License as published by
-        the Free Software Foundation, either version 3 of the License, or
-        (at your option) any later version.
-
-        solidity is distributed in the hope that it will be useful,
-        but WITHOUT ANY WARRANTY; without even the implied warranty of
-        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-        GNU General Public License for more details.
-
-        You should have received a copy of the GNU General Public License
-        along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Lefteris <lefteris@ethdev.com>
- * @date 2014
- * Takes the parsed AST and produces the Natspec documentation:
- * https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format
- *
- * Can generally deal with JSON files
- */
-
-#include <libsolidity/interface/InterfaceHandler.h>
-#include <boost/range/irange.hpp>
-#include <libsolidity/ast/AST.h>
-#include <libsolidity/interface/CompilerStack.h>
-
-using namespace std;
-using namespace dev;
-using namespace dev::solidity;
-
-Json::Value InterfaceHandler::documentation(
-	ContractDefinition const& _contractDef,
-	DocumentationType _type
-)
-{
-	switch(_type)
-	{
-	case DocumentationType::NatspecUser:
-		return userDocumentation(_contractDef);
-	case DocumentationType::NatspecDev:
-		return devDocumentation(_contractDef);
-	}
-
-	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation type"));
-}
-
-Json::Value InterfaceHandler::userDocumentation(ContractDefinition const& _contractDef)
-{
-	Json::Value doc;
-	Json::Value methods(Json::objectValue);
-
-	for (auto const& it: _contractDef.interfaceFunctions())
-		if (it.second->hasDeclaration())
-			if (auto const* f = dynamic_cast<FunctionDefinition const*>(&it.second->declaration()))
-			{
-				string value = extractDoc(f->annotation().docTags, "notice");
-				if (!value.empty())
-				{
-					Json::Value user;
-					// since @notice is the only user tag if missing function should not appear
-					user["notice"] = Json::Value(value);
-					methods[it.second->externalSignature()] = user;
-				}
-			}
-	doc["methods"] = methods;
-
-	return doc;
-}
-
-Json::Value InterfaceHandler::devDocumentation(ContractDefinition const& _contractDef)
-{
-	Json::Value doc;
-	Json::Value methods(Json::objectValue);
-
-	auto author = extractDoc(_contractDef.annotation().docTags, "author");
-	if (!author.empty())
-		doc["author"] = author;
-	auto title = extractDoc(_contractDef.annotation().docTags, "title");
-	if (!title.empty())
-		doc["title"] = title;
-
-	for (auto const& it: _contractDef.interfaceFunctions())
-	{
-		if (!it.second->hasDeclaration())
-			continue;
-		Json::Value method;
-		if (auto fun = dynamic_cast<FunctionDefinition const*>(&it.second->declaration()))
-		{
-			auto dev = extractDoc(fun->annotation().docTags, "dev");
-			if (!dev.empty())
-				method["details"] = Json::Value(dev);
-
-			auto author = extractDoc(fun->annotation().docTags, "author");
-			if (!author.empty())
-				method["author"] = author;
-
-			auto ret = extractDoc(fun->annotation().docTags, "return");
-			if (!ret.empty())
-				method["return"] = ret;
-
-			Json::Value params(Json::objectValue);
-			auto paramRange = fun->annotation().docTags.equal_range("param");
-			for (auto i = paramRange.first; i != paramRange.second; ++i)
-				params[i->second.paramName] = Json::Value(i->second.content);
-
-			if (!params.empty())
-				method["params"] = params;
-
-			if (!method.empty())
-				// add the function, only if we have any documentation to add
-				methods[it.second->externalSignature()] = method;
-		}
-	}
-	doc["methods"] = methods;
-
-	return doc;
-}
-
-string InterfaceHandler::extractDoc(multimap<string, DocTag> const& _tags, string const& _name)
-{
-	string value;
-	auto range = _tags.equal_range(_name);
-	for (auto i = range.first; i != range.second; i++)
-		value += i->second.content;
-	return value;
-}
diff --git a/libsolidity/interface/InterfaceHandler.h b/libsolidity/interface/InterfaceHandler.h
deleted file mode 100644
index 883ef3b9..00000000
--- a/libsolidity/interface/InterfaceHandler.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Lefteris <lefteris@ethdev.com>
- * @date 2014
- * Takes the parsed AST and produces the Natspec documentation:
- * https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format
- *
- * Can generally deal with JSON files
- */
-
-#pragma once
-
-#include <string>
-#include <memory>
-#include <json/json.h>
-
-namespace dev
-{
-namespace solidity
-{
-
-// Forward declarations
-class ContractDefinition;
-class Type;
-using TypePointer = std::shared_ptr<Type const>;
-struct DocTag;
-enum class DocumentationType: uint8_t;
-
-enum class DocTagType: uint8_t
-{
-	None = 0,
-	Dev,
-	Notice,
-	Param,
-	Return,
-	Author,
-	Title
-};
-
-enum class CommentOwner
-{
-	Contract,
-	Function
-};
-
-class InterfaceHandler
-{
-public:
-	/// Get the given type of documentation
-	/// @param _contractDef The contract definition
-	/// @param _type        The type of the documentation. Can be one of the
-	///                     types provided by @c DocumentationType
-	/// @return             A JSON representation of provided type
-	static Json::Value documentation(
-		ContractDefinition const& _contractDef,
-		DocumentationType _type
-	);
-	/// Get the User documentation of the contract
-	/// @param _contractDef The contract definition
-	/// @return             A JSON representation of the contract's user documentation
-	static Json::Value userDocumentation(ContractDefinition const& _contractDef);
-	/// Genereates the Developer's documentation of the contract
-	/// @param _contractDef The contract definition
-	/// @return             A JSON representation
-	///                     of the contract's developer documentation
-	static Json::Value devDocumentation(ContractDefinition const& _contractDef);
-
-private:
-	/// @returns a json value suitable for a list of types in function input or output
-	/// parameters or other places. If @a _forLibrary is true, complex types are referenced
-	/// by name, otherwise they are anonymously expanded.
-	static Json::Value formatTypeList(
-		std::vector<std::string> const& _names,
-		std::vector<TypePointer> const& _types,
-		bool _forLibrary
-	);
-	/// @returns concatenation of all content under the given tag name.
-	static std::string extractDoc(std::multimap<std::string, DocTag> const& _tags, std::string const& _name);
-};
-
-} //solidity NS
-} // dev NS
diff --git a/libsolidity/interface/Natspec.cpp b/libsolidity/interface/Natspec.cpp
new file mode 100644
index 00000000..70486e23
--- /dev/null
+++ b/libsolidity/interface/Natspec.cpp
@@ -0,0 +1,130 @@
+/*
+        This file is part of solidity.
+
+        solidity is free software: you can redistribute it and/or modify
+        it under the terms of the GNU General Public License as published by
+        the Free Software Foundation, either version 3 of the License, or
+        (at your option) any later version.
+
+        solidity is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+        GNU General Public License for more details.
+
+        You should have received a copy of the GNU General Public License
+        along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Lefteris <lefteris@ethdev.com>
+ * @date 2014
+ * Takes the parsed AST and produces the Natspec documentation:
+ * https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format
+ *
+ * Can generally deal with JSON files
+ */
+
+#include <libsolidity/interface/Natspec.h>
+#include <boost/range/irange.hpp>
+#include <libsolidity/ast/AST.h>
+#include <libsolidity/interface/CompilerStack.h>
+
+using namespace std;
+using namespace dev;
+using namespace dev::solidity;
+
+Json::Value Natspec::documentation(
+	ContractDefinition const& _contractDef,
+	DocumentationType _type
+)
+{
+	switch(_type)
+	{
+	case DocumentationType::NatspecUser:
+		return userDocumentation(_contractDef);
+	case DocumentationType::NatspecDev:
+		return devDocumentation(_contractDef);
+	}
+
+	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation type"));
+}
+
+Json::Value Natspec::userDocumentation(ContractDefinition const& _contractDef)
+{
+	Json::Value doc;
+	Json::Value methods(Json::objectValue);
+
+	for (auto const& it: _contractDef.interfaceFunctions())
+		if (it.second->hasDeclaration())
+			if (auto const* f = dynamic_cast<FunctionDefinition const*>(&it.second->declaration()))
+			{
+				string value = extractDoc(f->annotation().docTags, "notice");
+				if (!value.empty())
+				{
+					Json::Value user;
+					// since @notice is the only user tag if missing function should not appear
+					user["notice"] = Json::Value(value);
+					methods[it.second->externalSignature()] = user;
+				}
+			}
+	doc["methods"] = methods;
+
+	return doc;
+}
+
+Json::Value Natspec::devDocumentation(ContractDefinition const& _contractDef)
+{
+	Json::Value doc;
+	Json::Value methods(Json::objectValue);
+
+	auto author = extractDoc(_contractDef.annotation().docTags, "author");
+	if (!author.empty())
+		doc["author"] = author;
+	auto title = extractDoc(_contractDef.annotation().docTags, "title");
+	if (!title.empty())
+		doc["title"] = title;
+
+	for (auto const& it: _contractDef.interfaceFunctions())
+	{
+		if (!it.second->hasDeclaration())
+			continue;
+		Json::Value method;
+		if (auto fun = dynamic_cast<FunctionDefinition const*>(&it.second->declaration()))
+		{
+			auto dev = extractDoc(fun->annotation().docTags, "dev");
+			if (!dev.empty())
+				method["details"] = Json::Value(dev);
+
+			auto author = extractDoc(fun->annotation().docTags, "author");
+			if (!author.empty())
+				method["author"] = author;
+
+			auto ret = extractDoc(fun->annotation().docTags, "return");
+			if (!ret.empty())
+				method["return"] = ret;
+
+			Json::Value params(Json::objectValue);
+			auto paramRange = fun->annotation().docTags.equal_range("param");
+			for (auto i = paramRange.first; i != paramRange.second; ++i)
+				params[i->second.paramName] = Json::Value(i->second.content);
+
+			if (!params.empty())
+				method["params"] = params;
+
+			if (!method.empty())
+				// add the function, only if we have any documentation to add
+				methods[it.second->externalSignature()] = method;
+		}
+	}
+	doc["methods"] = methods;
+
+	return doc;
+}
+
+string Natspec::extractDoc(multimap<string, DocTag> const& _tags, string const& _name)
+{
+	string value;
+	auto range = _tags.equal_range(_name);
+	for (auto i = range.first; i != range.second; i++)
+		value += i->second.content;
+	return value;
+}
diff --git a/libsolidity/interface/Natspec.h b/libsolidity/interface/Natspec.h
new file mode 100644
index 00000000..bec9acd2
--- /dev/null
+++ b/libsolidity/interface/Natspec.h
@@ -0,0 +1,97 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Lefteris <lefteris@ethdev.com>
+ * @date 2014
+ * Takes the parsed AST and produces the Natspec documentation:
+ * https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format
+ *
+ * Can generally deal with JSON files
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+#include <json/json.h>
+
+namespace dev
+{
+namespace solidity
+{
+
+// Forward declarations
+class ContractDefinition;
+class Type;
+using TypePointer = std::shared_ptr<Type const>;
+struct DocTag;
+enum class DocumentationType: uint8_t;
+
+enum class DocTagType: uint8_t
+{
+	None = 0,
+	Dev,
+	Notice,
+	Param,
+	Return,
+	Author,
+	Title
+};
+
+enum class CommentOwner
+{
+	Contract,
+	Function
+};
+
+class Natspec
+{
+public:
+	/// Get the given type of documentation
+	/// @param _contractDef The contract definition
+	/// @param _type        The type of the documentation. Can be one of the
+	///                     types provided by @c DocumentationType
+	/// @return             A JSON representation of provided type
+	static Json::Value documentation(
+		ContractDefinition const& _contractDef,
+		DocumentationType _type
+	);
+	/// Get the User documentation of the contract
+	/// @param _contractDef The contract definition
+	/// @return             A JSON representation of the contract's user documentation
+	static Json::Value userDocumentation(ContractDefinition const& _contractDef);
+	/// Genereates the Developer's documentation of the contract
+	/// @param _contractDef The contract definition
+	/// @return             A JSON representation
+	///                     of the contract's developer documentation
+	static Json::Value devDocumentation(ContractDefinition const& _contractDef);
+
+private:
+	/// @returns a json value suitable for a list of types in function input or output
+	/// parameters or other places. If @a _forLibrary is true, complex types are referenced
+	/// by name, otherwise they are anonymously expanded.
+	static Json::Value formatTypeList(
+		std::vector<std::string> const& _names,
+		std::vector<TypePointer> const& _types,
+		bool _forLibrary
+	);
+	/// @returns concatenation of all content under the given tag name.
+	static std::string extractDoc(std::multimap<std::string, DocTag> const& _tags, std::string const& _name);
+};
+
+} //solidity NS
+} // dev NS
diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index b5130c8a..72150a3e 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -27,7 +27,6 @@
 #include <libsolidity/parsing/Scanner.h>
 #include <libsolidity/inlineasm/AsmParser.h>
 #include <libsolidity/interface/Exceptions.h>
-#include <libsolidity/interface/InterfaceHandler.h>
 
 using namespace std;
 
-- 
cgit v1.2.3


From cd5d93da2aef3b9617cbf02d0d1341ce071789c2 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 10 May 2017 11:04:52 +0100
Subject: Rename CompilerStack.metadata to CompilerStack.natspec

---
 libsolidity/interface/CompilerStack.cpp    | 10 +++++-----
 libsolidity/interface/CompilerStack.h      |  4 ++--
 libsolidity/interface/StandardCompiler.cpp |  4 ++--
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 7125adec..72712298 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -464,12 +464,12 @@ Json::Value const& CompilerStack::contractABI(Contract const& _contract) const
 	return *_contract.abi;
 }
 
-Json::Value const& CompilerStack::metadata(string const& _contractName, DocumentationType _type) const
+Json::Value const& CompilerStack::natspec(string const& _contractName, DocumentationType _type) const
 {
-	return metadata(contract(_contractName), _type);
+	return natspec(contract(_contractName), _type);
 }
 
-Json::Value const& CompilerStack::metadata(Contract const& _contract, DocumentationType _type) const
+Json::Value const& CompilerStack::natspec(Contract const& _contract, DocumentationType _type) const
 {
 	if (m_stackState < AnalysisSuccessful)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
@@ -843,8 +843,8 @@ string CompilerStack::createOnChainMetadata(Contract const& _contract) const
 		meta["settings"]["libraries"][library.first] = "0x" + toHex(library.second.asBytes());
 
 	meta["output"]["abi"] = contractABI(_contract);
-	meta["output"]["userdoc"] = metadata(_contract, DocumentationType::NatspecUser);
-	meta["output"]["devdoc"] = metadata(_contract, DocumentationType::NatspecDev);
+	meta["output"]["userdoc"] = natspec(_contract, DocumentationType::NatspecUser);
+	meta["output"]["devdoc"] = natspec(_contract, DocumentationType::NatspecDev);
 
 	return jsonCompactPrint(meta);
 }
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index cc5ba64c..84d15d70 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -179,7 +179,7 @@ public:
 	/// Prerequisite: Successful call to parse or compile.
 	/// @param type The type of the documentation to get.
 	/// Can be one of 4 types defined at @c DocumentationType
-	Json::Value const& metadata(std::string const& _contractName, DocumentationType _type) const;
+	Json::Value const& natspec(std::string const& _contractName, DocumentationType _type) const;
 	std::string const& onChainMetadata(std::string const& _contractName) const;
 	void useMetadataLiteralSources(bool _metadataLiteralSources) { m_metadataLiteralSources = _metadataLiteralSources; }
 
@@ -267,7 +267,7 @@ private:
 	std::string createOnChainMetadata(Contract const& _contract) const;
 	std::string computeSourceMapping(eth::AssemblyItems const& _items) const;
 	Json::Value const& contractABI(Contract const&) const;
-	Json::Value const& metadata(Contract const&, DocumentationType _type) const;
+	Json::Value const& natspec(Contract const&, DocumentationType _type) const;
 
 	struct Remapping
 	{
diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index 4eb52fc2..503be57b 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -393,8 +393,8 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 		Json::Value contractData(Json::objectValue);
 		contractData["abi"] = m_compilerStack.contractABI(contractName);
 		contractData["metadata"] = m_compilerStack.onChainMetadata(contractName);
-		contractData["userdoc"] = m_compilerStack.metadata(contractName, DocumentationType::NatspecUser);
-		contractData["devdoc"] = m_compilerStack.metadata(contractName, DocumentationType::NatspecDev);
+		contractData["userdoc"] = m_compilerStack.natspec(contractName, DocumentationType::NatspecUser);
+		contractData["devdoc"] = m_compilerStack.natspec(contractName, DocumentationType::NatspecDev);
 
 		// EVM
 		Json::Value evmData(Json::objectValue);
-- 
cgit v1.2.3


From e2b21e1c9611fd94f8e7b91b0ecbb0ec39145758 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 28 Apr 2017 18:15:18 +0200
Subject: Refactor to abstract assembly to JULIA.

---
 libsolidity/codegen/CompilerContext.cpp  |  16 ++--
 libsolidity/codegen/ContractCompiler.cpp |  36 ++++----
 libsolidity/inlineasm/AsmCodeGen.cpp     | 143 ++++++++++++++++++++-----------
 libsolidity/inlineasm/AsmScope.h         |   4 +-
 libsolidity/inlineasm/AsmStack.h         |   4 +-
 5 files changed, 127 insertions(+), 76 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 51dd9fd2..5c4f88c4 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -264,7 +264,7 @@ void CompilerContext::appendInlineAssembly(
 		assembly = &replacedAssembly;
 	}
 
-	unsigned startStackHeight = stackHeight();
+	int startStackHeight = stackHeight();
 
 	assembly::ExternalIdentifierAccess identifierAccess;
 	identifierAccess.resolve = [&](
@@ -278,26 +278,26 @@ void CompilerContext::appendInlineAssembly(
 	identifierAccess.generateCode = [&](
 		assembly::Identifier const& _identifier,
 		assembly::IdentifierContext _context,
-		eth::Assembly& _assembly
+		julia::AbstractAssembly& _assembly
 	)
 	{
 		auto it = std::find(_localVariables.begin(), _localVariables.end(), _identifier.name);
 		solAssert(it != _localVariables.end(), "");
-		unsigned stackDepth = _localVariables.end() - it;
-		int stackDiff = _assembly.deposit() - startStackHeight + stackDepth;
+		int stackDepth = _localVariables.end() - it;
+		int stackDiff = _assembly.stackHeight() - startStackHeight + stackDepth;
 		if (_context == assembly::IdentifierContext::LValue)
 			stackDiff -= 1;
 		if (stackDiff < 1 || stackDiff > 16)
 			BOOST_THROW_EXCEPTION(
 				CompilerError() <<
-				errinfo_comment("Stack too deep, try removing local variables.")
+				errinfo_comment("Stack too deep (" + to_string(stackDiff) + "), try removing local variables.")
 			);
 		if (_context == assembly::IdentifierContext::RValue)
-			_assembly.append(dupInstruction(stackDiff));
+			_assembly.appendInstruction(dupInstruction(stackDiff));
 		else
 		{
-			_assembly.append(swapInstruction(stackDiff));
-			_assembly.append(Instruction::POP);
+			_assembly.appendInstruction(swapInstruction(stackDiff));
+			_assembly.appendInstruction(Instruction::POP);
 		}
 	};
 
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index 34ef13c0..41940e1a 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -530,7 +530,7 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 			return size_t(-1);
 		return ref->second.valueSize;
 	};
-	identifierAccess.generateCode = [&](assembly::Identifier const& _identifier, assembly::IdentifierContext _context, eth::Assembly& _assembly)
+	identifierAccess.generateCode = [&](assembly::Identifier const& _identifier, assembly::IdentifierContext _context, julia::AbstractAssembly& _assembly)
 	{
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
 		solAssert(ref != _inlineAssembly.annotation().externalReferences.end(), "");
@@ -538,21 +538,25 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 		solAssert(!!decl, "");
 		if (_context == assembly::IdentifierContext::RValue)
 		{
-			int const depositBefore = _assembly.deposit();
+			int const depositBefore = _assembly.stackHeight();
 			solAssert(!!decl->type(), "Type of declaration required but not yet determined.");
 			if (FunctionDefinition const* functionDef = dynamic_cast<FunctionDefinition const*>(decl))
 			{
 				solAssert(!ref->second.isOffset && !ref->second.isSlot, "");
 				functionDef = &m_context.resolveVirtualFunction(*functionDef);
-				_assembly.append(m_context.functionEntryLabel(*functionDef).pushTag());
+				auto functionEntryLabel = m_context.functionEntryLabel(*functionDef).pushTag();
+				solAssert(functionEntryLabel.data() <= std::numeric_limits<size_t>::max(), "");
+				_assembly.appendLabelReference(size_t(functionEntryLabel.data()));
 				// If there is a runtime context, we have to merge both labels into the same
 				// stack slot in case we store it in storage.
 				if (CompilerContext* rtc = m_context.runtimeContext())
 				{
-					_assembly.append(u256(1) << 32);
-					_assembly.append(Instruction::MUL);
-					_assembly.append(rtc->functionEntryLabel(*functionDef).toSubAssemblyTag(m_context.runtimeSub()));
-					_assembly.append(Instruction::OR);
+					_assembly.appendConstant(u256(1) << 32);
+					_assembly.appendInstruction(Instruction::MUL);
+					auto runtimeEntryLabel = rtc->functionEntryLabel(*functionDef).toSubAssemblyTag(m_context.runtimeSub());
+					solAssert(runtimeEntryLabel.data() <= std::numeric_limits<size_t>::max(), "");
+					_assembly.appendLabelReference(size_t(runtimeEntryLabel.data()));
+					_assembly.appendInstruction(Instruction::OR);
 				}
 			}
 			else if (auto variable = dynamic_cast<VariableDeclaration const*>(decl))
@@ -570,7 +574,7 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 				}
 				else if (m_context.isLocalVariable(decl))
 				{
-					int stackDiff = _assembly.deposit() - m_context.baseStackOffsetOfVariable(*variable);
+					int stackDiff = _assembly.stackHeight() - m_context.baseStackOffsetOfVariable(*variable);
 					if (ref->second.isSlot || ref->second.isOffset)
 					{
 						solAssert(variable->type()->dataStoredIn(DataLocation::Storage), "");
@@ -587,7 +591,7 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 							// only slot, offset is zero
 							if (ref->second.isOffset)
 							{
-								_assembly.append(u256(0));
+								_assembly.appendConstant(u256(0));
 								return;
 							}
 						}
@@ -601,7 +605,7 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 							errinfo_comment("Stack too deep, try removing local variables.")
 						);
 					solAssert(variable->type()->sizeOnStack() == 1, "");
-					_assembly.append(dupInstruction(stackDiff));
+					_assembly.appendInstruction(dupInstruction(stackDiff));
 				}
 				else
 					solAssert(false, "");
@@ -610,11 +614,11 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 			{
 				solAssert(!ref->second.isOffset && !ref->second.isSlot, "");
 				solAssert(contract->isLibrary(), "");
-				_assembly.appendLibraryAddress(contract->fullyQualifiedName());
+				_assembly.appendLinkerSymbol(contract->fullyQualifiedName());
 			}
 			else
 				solAssert(false, "Invalid declaration type.");
-			solAssert(_assembly.deposit() - depositBefore == int(ref->second.valueSize), "");
+			solAssert(_assembly.stackHeight() - depositBefore == int(ref->second.valueSize), "");
 		}
 		else
 		{
@@ -626,15 +630,15 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 				"Can only assign to stack variables in inline assembly."
 			);
 			solAssert(variable->type()->sizeOnStack() == 1, "");
-			int stackDiff = _assembly.deposit() - m_context.baseStackOffsetOfVariable(*variable) - 1;
+			int stackDiff = _assembly.stackHeight() - m_context.baseStackOffsetOfVariable(*variable) - 1;
 			if (stackDiff > 16 || stackDiff < 1)
 				BOOST_THROW_EXCEPTION(
 					CompilerError() <<
 					errinfo_sourceLocation(_inlineAssembly.location()) <<
-					errinfo_comment("Stack too deep, try removing local variables.")
+					errinfo_comment("Stack too deep(" + to_string(stackDiff) + "), try removing local variables.")
 				);
-			_assembly.append(swapInstruction(stackDiff));
-			_assembly.append(Instruction::POP);
+			_assembly.appendInstruction(swapInstruction(stackDiff));
+			_assembly.appendInstruction(Instruction::POP);
 		}
 	};
 	solAssert(_inlineAssembly.annotation().analysisInfo, "");
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 44e12b3e..a6d7e76b 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -32,6 +32,8 @@
 #include <libevmasm/SourceLocation.h>
 #include <libevmasm/Instruction.h>
 
+#include <libjulia/backends/AbstractAssembly.h>
+
 #include <libdevcore/CommonIO.h>
 
 #include <boost/range/adaptor/reversed.hpp>
@@ -48,24 +50,61 @@ using namespace dev::solidity::assembly;
 
 struct GeneratorState
 {
-	GeneratorState(ErrorList& _errors, AsmAnalysisInfo& _analysisInfo, eth::Assembly& _assembly):
-		errors(_errors), info(_analysisInfo), assembly(_assembly) {}
+	GeneratorState(ErrorList& _errors, AsmAnalysisInfo& _analysisInfo):
+		errors(_errors), info(_analysisInfo) {}
+
+	ErrorList& errors;
+	AsmAnalysisInfo info;
+};
 
-	size_t newLabelId()
+class EthAssemblyAdapter: public julia::AbstractAssembly
+{
+public:
+	EthAssemblyAdapter(eth::Assembly& _assembly):
+		m_assembly(_assembly)
+	{
+	}
+	virtual void setSourceLocation(SourceLocation const& _location) override
+	{
+		m_assembly.setSourceLocation(_location);
+	}
+	virtual int stackHeight() const override { return m_assembly.deposit(); }
+	virtual void appendInstruction(solidity::Instruction _instruction) override
+	{
+		m_assembly.append(_instruction);
+	}
+	virtual void appendConstant(u256 const& _constant) override
+	{
+		m_assembly.append(_constant);
+	}
+	/// Append a label.
+	virtual void appendLabel(size_t _labelId) override
+	{
+		m_assembly.append(eth::AssemblyItem(eth::Tag, _labelId));
+	}
+	/// Append a label reference.
+	virtual void appendLabelReference(size_t _labelId) override
+	{
+		m_assembly.append(eth::AssemblyItem(eth::PushTag, _labelId));
+	}
+	virtual size_t newLabel() override
+	{
+		return assemblyTagToIdentifier(m_assembly.newTag());
+	}
+	virtual void appendLinkerSymbol(std::string const& _linkerSymbol) override
 	{
-		return assemblyTagToIdentifier(assembly.newTag());
+		m_assembly.appendLibraryAddress(_linkerSymbol);
 	}
 
-	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
+private:
+	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag)
 	{
 		u256 id = _tag.data();
 		solAssert(id <= std::numeric_limits<size_t>::max(), "Tag id too large.");
 		return size_t(id);
 	}
 
-	ErrorList& errors;
-	AsmAnalysisInfo info;
-	eth::Assembly& assembly;
+	eth::Assembly& m_assembly;
 };
 
 class CodeTransform: public boost::static_visitor<>
@@ -76,81 +115,84 @@ public:
 	/// @param _identifierAccess used to resolve identifiers external to the inline assembly
 	explicit CodeTransform(
 		GeneratorState& _state,
+		julia::AbstractAssembly& _assembly,
 		assembly::Block const& _block,
 		assembly::ExternalIdentifierAccess const& _identifierAccess = assembly::ExternalIdentifierAccess()
-	): CodeTransform(_state, _block, _identifierAccess, _state.assembly.deposit())
+	): CodeTransform(_state, _assembly, _block, _identifierAccess, _assembly.stackHeight())
 	{
 	}
 
 private:
 	CodeTransform(
 		GeneratorState& _state,
+		julia::AbstractAssembly& _assembly,
 		assembly::Block const& _block,
 		assembly::ExternalIdentifierAccess const& _identifierAccess,
-		int _initialDeposit
+		int _initialStackHeight
 	):
 		m_state(_state),
+		m_assembly(_assembly),
 		m_scope(*m_state.info.scopes.at(&_block)),
 		m_identifierAccess(_identifierAccess),
-		m_initialDeposit(_initialDeposit)
+		m_initialStackHeight(_initialStackHeight)
 	{
-		int blockStartDeposit = m_state.assembly.deposit();
+		int blockStartStackHeight = m_assembly.stackHeight();
 		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
 
-		m_state.assembly.setSourceLocation(_block.location);
+		m_assembly.setSourceLocation(_block.location);
 
 		// pop variables
 		for (auto const& identifier: m_scope.identifiers)
 			if (identifier.second.type() == typeid(Scope::Variable))
-				m_state.assembly.append(solidity::Instruction::POP);
+				m_assembly.appendInstruction(solidity::Instruction::POP);
 
-		int deposit = m_state.assembly.deposit() - blockStartDeposit;
+		int deposit = m_assembly.stackHeight() - blockStartStackHeight;
 		solAssert(deposit == 0, "Invalid stack height at end of block.");
 	}
 
 public:
 	void operator()(assembly::Instruction const& _instruction)
 	{
-		m_state.assembly.setSourceLocation(_instruction.location);
-		m_state.assembly.append(_instruction.instruction);
+		m_assembly.setSourceLocation(_instruction.location);
+		m_assembly.appendInstruction(_instruction.instruction);
 		checkStackHeight(&_instruction);
 	}
 	void operator()(assembly::Literal const& _literal)
 	{
-		m_state.assembly.setSourceLocation(_literal.location);
+		m_assembly.setSourceLocation(_literal.location);
 		if (_literal.kind == assembly::LiteralKind::Number)
-			m_state.assembly.append(u256(_literal.value));
+			m_assembly.appendConstant(u256(_literal.value));
 		else if (_literal.kind == assembly::LiteralKind::Boolean)
 		{
 			if (_literal.value == "true")
-				m_state.assembly.append(u256(1));
+				m_assembly.appendConstant(u256(1));
 			else
-				m_state.assembly.append(u256(0));
+				m_assembly.appendConstant(u256(0));
 		}
 		else
 		{
 			solAssert(_literal.value.size() <= 32, "");
-			m_state.assembly.append(u256(h256(_literal.value, h256::FromBinary, h256::AlignLeft)));
+			m_assembly.appendConstant(u256(h256(_literal.value, h256::FromBinary, h256::AlignLeft)));
 		}
 		checkStackHeight(&_literal);
 	}
 	void operator()(assembly::Identifier const& _identifier)
 	{
-		m_state.assembly.setSourceLocation(_identifier.location);
+		m_assembly.setSourceLocation(_identifier.location);
 		// First search internals, then externals.
 		if (m_scope.lookup(_identifier.name, Scope::NonconstVisitor(
 			[=](Scope::Variable& _var)
 			{
 				if (int heightDiff = variableHeightDiff(_var, _identifier.location, false))
-					m_state.assembly.append(solidity::dupInstruction(heightDiff));
+					m_assembly.appendInstruction(solidity::dupInstruction(heightDiff));
 				else
 					// Store something to balance the stack
-					m_state.assembly.append(u256(0));
+					m_assembly.appendConstant(u256(0));
 			},
 			[=](Scope::Label& _label)
 			{
 				assignLabelIdIfUnset(_label);
-				m_state.assembly.append(eth::AssemblyItem(eth::PushTag, _label.id));
+				m_assembly.appendLabelReference(*_label.id);
 			},
 			[=](Scope::Function&)
 			{
@@ -164,14 +206,14 @@ public:
 			m_identifierAccess.generateCode,
 			"Identifier not found and no external access available."
 		);
-		m_identifierAccess.generateCode(_identifier, IdentifierContext::RValue, m_state.assembly);
+		m_identifierAccess.generateCode(_identifier, IdentifierContext::RValue, m_assembly);
 		checkStackHeight(&_identifier);
 	}
 	void operator()(FunctionalInstruction const& _instr)
 	{
 		for (auto it = _instr.arguments.rbegin(); it != _instr.arguments.rend(); ++it)
 		{
-			int height = m_state.assembly.deposit();
+			int height = m_assembly.stackHeight();
 			boost::apply_visitor(*this, *it);
 			expectDeposit(1, height);
 		}
@@ -184,31 +226,31 @@ public:
 	}
 	void operator()(Label const& _label)
 	{
-		m_state.assembly.setSourceLocation(_label.location);
+		m_assembly.setSourceLocation(_label.location);
 		solAssert(m_scope.identifiers.count(_label.name), "");
 		Scope::Label& label = boost::get<Scope::Label>(m_scope.identifiers.at(_label.name));
 		assignLabelIdIfUnset(label);
-		m_state.assembly.append(eth::AssemblyItem(eth::Tag, label.id));
+		m_assembly.appendLabel(*label.id);
 		checkStackHeight(&_label);
 	}
 	void operator()(assembly::Assignment const& _assignment)
 	{
-		m_state.assembly.setSourceLocation(_assignment.location);
+		m_assembly.setSourceLocation(_assignment.location);
 		generateAssignment(_assignment.variableName, _assignment.location);
 		checkStackHeight(&_assignment);
 	}
 	void operator()(FunctionalAssignment const& _assignment)
 	{
-		int height = m_state.assembly.deposit();
+		size_t height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_assignment.value);
 		expectDeposit(1, height);
-		m_state.assembly.setSourceLocation(_assignment.location);
+		m_assembly.setSourceLocation(_assignment.location);
 		generateAssignment(_assignment.variableName, _assignment.location);
 		checkStackHeight(&_assignment);
 	}
 	void operator()(assembly::VariableDeclaration const& _varDecl)
 	{
-		int height = m_state.assembly.deposit();
+		size_t height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height);
 		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
@@ -217,7 +259,7 @@ public:
 	}
 	void operator()(assembly::Block const& _block)
 	{
-		CodeTransform(m_state, _block, m_identifierAccess, m_initialDeposit);
+		CodeTransform(m_state, m_assembly, _block, m_identifierAccess, m_initialStackHeight);
 		checkStackHeight(&_block);
 	}
 	void operator()(assembly::FunctionDefinition const&)
@@ -233,8 +275,8 @@ private:
 		{
 			Scope::Variable const& _var = boost::get<Scope::Variable>(*var);
 			if (int heightDiff = variableHeightDiff(_var, _location, true))
-				m_state.assembly.append(solidity::swapInstruction(heightDiff - 1));
-			m_state.assembly.append(solidity::Instruction::POP);
+				m_assembly.appendInstruction(solidity::swapInstruction(heightDiff - 1));
+			m_assembly.appendInstruction(solidity::Instruction::POP);
 		}
 		else
 		{
@@ -242,16 +284,16 @@ private:
 				m_identifierAccess.generateCode,
 				"Identifier not found and no external access available."
 			);
-			m_identifierAccess.generateCode(_variableName, IdentifierContext::LValue, m_state.assembly);
+			m_identifierAccess.generateCode(_variableName, IdentifierContext::LValue, m_assembly);
 		}
 	}
 
 	/// Determines the stack height difference to the given variables. Automatically generates
 	/// errors if it is not yet in scope or the height difference is too large. Returns 0 on
 	/// errors and the (positive) stack height difference otherwise.
-	int variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
+	size_t variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
 	{
-		int heightDiff = m_state.assembly.deposit() - _var.stackHeight;
+		size_t heightDiff = m_assembly.stackHeight() - _var.stackHeight;
 		if (heightDiff <= (_forSwap ? 1 : 0) || heightDiff > (_forSwap ? 17 : 16))
 		{
 			//@TODO move this to analysis phase.
@@ -268,14 +310,14 @@ private:
 
 	void expectDeposit(int _deposit, int _oldHeight)
 	{
-		solAssert(m_state.assembly.deposit() == _oldHeight + _deposit, "Invalid stack deposit.");
+		solAssert(m_assembly.stackHeight() == _oldHeight + _deposit, "Invalid stack deposit.");
 	}
 
 	void checkStackHeight(void const* _astElement)
 	{
 		solAssert(m_state.info.stackHeightInfo.count(_astElement), "Stack height for AST element not found.");
 		solAssert(
-			m_state.info.stackHeightInfo.at(_astElement) == m_state.assembly.deposit() - m_initialDeposit,
+			m_state.info.stackHeightInfo.at(_astElement) == m_assembly.stackHeight() - m_initialStackHeight,
 			"Stack height mismatch between analysis and code generation phase."
 		);
 	}
@@ -283,15 +325,16 @@ private:
 	/// Assigns the label's id to a value taken from eth::Assembly if it has not yet been set.
 	void assignLabelIdIfUnset(Scope::Label& _label)
 	{
-		if (_label.id == Scope::Label::unassignedLabelId)
-			_label.id = m_state.newLabelId();
+		if (!_label.id)
+			_label.id.reset(m_assembly.newLabel());
 	}
 
 
 	GeneratorState& m_state;
+	julia::AbstractAssembly& m_assembly;
 	Scope& m_scope;
 	ExternalIdentifierAccess m_identifierAccess;
-	int const m_initialDeposit;
+	int const m_initialStackHeight;
 };
 
 eth::Assembly assembly::CodeGenerator::assemble(
@@ -301,8 +344,9 @@ eth::Assembly assembly::CodeGenerator::assemble(
 )
 {
 	eth::Assembly assembly;
-	GeneratorState state(m_errors, _analysisInfo, assembly);
-	CodeTransform(state, _parsedData, _identifierAccess);
+	GeneratorState state(m_errors, _analysisInfo);
+	EthAssemblyAdapter assemblyAdapter(assembly);
+	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
 	return assembly;
 }
 
@@ -313,6 +357,7 @@ void assembly::CodeGenerator::assemble(
 	ExternalIdentifierAccess const& _identifierAccess
 )
 {
-	GeneratorState state(m_errors, _analysisInfo, _assembly);
-	CodeTransform(state, _parsedData, _identifierAccess);
+	GeneratorState state(m_errors, _analysisInfo);
+	EthAssemblyAdapter assemblyAdapter(_assembly);
+	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
 }
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index dd45613d..70786dce 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -23,6 +23,7 @@
 #include <libsolidity/interface/Exceptions.h>
 
 #include <boost/variant.hpp>
+#include <boost/optional.hpp>
 
 #include <functional>
 #include <memory>
@@ -75,8 +76,7 @@ struct Scope
 
 	struct Label
 	{
-		size_t id = unassignedLabelId;
-		static const size_t unassignedLabelId = 0;
+		boost::optional<size_t> id;
 	};
 
 	struct Function
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
index 77a7e02a..e223ccc9 100644
--- a/libsolidity/inlineasm/AsmStack.h
+++ b/libsolidity/inlineasm/AsmStack.h
@@ -24,6 +24,8 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
+#include <libjulia/backends/AbstractAssembly.h>
+
 #include <string>
 #include <functional>
 
@@ -51,7 +53,7 @@ struct ExternalIdentifierAccess
 	/// Resolve a an external reference given by the identifier in the given context.
 	/// @returns the size of the value (number of stack slots) or size_t(-1) if not found.
 	Resolver resolve;
-	using CodeGenerator = std::function<void(assembly::Identifier const&, IdentifierContext, eth::Assembly&)>;
+	using CodeGenerator = std::function<void(assembly::Identifier const&, IdentifierContext, julia::AbstractAssembly&)>;
 	/// Generate code for retrieving the value (rvalue context) or storing the value (lvalue context)
 	/// of an identifier. The code should be appended to the assembly. In rvalue context, the value is supposed
 	/// to be put onto the stack, in lvalue context, the value is assumed to be at the top of the stack.
-- 
cgit v1.2.3


From 69413ae32a07ebe51adf3eca295cef4dfcd513b4 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 19 May 2017 20:12:12 +0200
Subject: Review changes.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index a6d7e76b..3591ba97 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -87,7 +87,7 @@ public:
 	{
 		m_assembly.append(eth::AssemblyItem(eth::PushTag, _labelId));
 	}
-	virtual size_t newLabel() override
+	virtual size_t newLabelId() override
 	{
 		return assemblyTagToIdentifier(m_assembly.newTag());
 	}
@@ -241,7 +241,7 @@ public:
 	}
 	void operator()(FunctionalAssignment const& _assignment)
 	{
-		size_t height = m_assembly.stackHeight();
+		int height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_assignment.value);
 		expectDeposit(1, height);
 		m_assembly.setSourceLocation(_assignment.location);
@@ -250,7 +250,7 @@ public:
 	}
 	void operator()(assembly::VariableDeclaration const& _varDecl)
 	{
-		size_t height = m_assembly.stackHeight();
+		int height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(1, height);
 		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
@@ -291,9 +291,9 @@ private:
 	/// Determines the stack height difference to the given variables. Automatically generates
 	/// errors if it is not yet in scope or the height difference is too large. Returns 0 on
 	/// errors and the (positive) stack height difference otherwise.
-	size_t variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
+	int variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
 	{
-		size_t heightDiff = m_assembly.stackHeight() - _var.stackHeight;
+		int heightDiff = m_assembly.stackHeight() - _var.stackHeight;
 		if (heightDiff <= (_forSwap ? 1 : 0) || heightDiff > (_forSwap ? 17 : 16))
 		{
 			//@TODO move this to analysis phase.
@@ -326,7 +326,7 @@ private:
 	void assignLabelIdIfUnset(Scope::Label& _label)
 	{
 		if (!_label.id)
-			_label.id.reset(m_assembly.newLabel());
+			_label.id.reset(m_assembly.newLabelId());
 	}
 
 
-- 
cgit v1.2.3


From 7f5601fd4b63e90313f1a9c1a53e08ba9757b452 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 19 May 2017 20:15:28 +0200
Subject: Add const

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 3591ba97..b8af9dc6 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -97,7 +97,7 @@ public:
 	}
 
 private:
-	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag)
+	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
 	{
 		u256 id = _tag.data();
 		solAssert(id <= std::numeric_limits<size_t>::max(), "Tag id too large.");
-- 
cgit v1.2.3


From 621c3fa22fc5830517ad3174f7ebe2ca67f1f700 Mon Sep 17 00:00:00 2001
From: Rhett Aultman <roadriverrail@gmail.com>
Date: Thu, 11 May 2017 07:57:34 -0700
Subject: Analyze InlineAssembly for variable use

The unused variable checker in StaticAnalyzer did not conssider
InlineAssembly objects.  This commit introduces that missing feature.
---
 libsolidity/analysis/StaticAnalyzer.cpp | 25 +++++++++++++++++++++++--
 libsolidity/analysis/StaticAnalyzer.h   |  1 +
 2 files changed, 24 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/StaticAnalyzer.cpp b/libsolidity/analysis/StaticAnalyzer.cpp
index 369376fa..d273b26e 100644
--- a/libsolidity/analysis/StaticAnalyzer.cpp
+++ b/libsolidity/analysis/StaticAnalyzer.cpp
@@ -21,14 +21,16 @@
  */
 
 #include <libsolidity/analysis/StaticAnalyzer.h>
-#include <memory>
 #include <libsolidity/ast/AST.h>
+#include <libsolidity/inlineasm/AsmAnalysis.h>
+#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
+#include <libsolidity/inlineasm/AsmData.h>
+#include <memory>
 
 using namespace std;
 using namespace dev;
 using namespace dev::solidity;
 
-
 bool StaticAnalyzer::analyze(SourceUnit const& _sourceUnit)
 {
 	_sourceUnit.accept(*this);
@@ -128,3 +130,22 @@ void StaticAnalyzer::warning(SourceLocation const& _location, string const& _des
 
 	m_errors.push_back(err);
 }
+
+bool StaticAnalyzer::visit(InlineAssembly const& _inlineAssembly)
+{
+	if (!m_currentFunction)
+		return true;
+
+	for (auto const& ref: _inlineAssembly.annotation().externalReferences)
+	{
+		if (auto var = dynamic_cast<VariableDeclaration const*>(ref.second.declaration))
+		{
+			solAssert(!var->name().empty(), "");
+			if (var->isLocalVariable())
+				m_localVarUseCount[var] += 1;
+		}
+	}
+
+	return true;
+}
+
diff --git a/libsolidity/analysis/StaticAnalyzer.h b/libsolidity/analysis/StaticAnalyzer.h
index ab72e7d9..458bab2a 100644
--- a/libsolidity/analysis/StaticAnalyzer.h
+++ b/libsolidity/analysis/StaticAnalyzer.h
@@ -65,6 +65,7 @@ private:
 	virtual bool visit(Identifier const& _identifier) override;
 	virtual bool visit(Return const& _return) override;
 	virtual bool visit(MemberAccess const& _memberAccess) override;
+	virtual bool visit(InlineAssembly const& _inlineAssembly) override;
 
 	ErrorList& m_errors;
 
-- 
cgit v1.2.3


From e82df073d15237455b1e53e35ef544aea72a69f9 Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Mon, 22 May 2017 11:51:45 +0200
Subject: minor fixes and changelog update

---
 libsolidity/analysis/TypeChecker.cpp | 1 +
 libsolidity/ast/ASTJsonConverter.cpp | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index b8221a2c..8161a3a1 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -1246,6 +1246,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 	}
 	else
 		_functionCall.annotation().kind = FunctionCallKind::FunctionCall;
+	solAssert(_functionCall.annotation().kind != FunctionCallKind::Unset, "");
 
 	if (_functionCall.annotation().kind == FunctionCallKind::TypeConversion)
 	{
diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 81996678..40c552a3 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -634,7 +634,7 @@ bool ASTJsonConverter::visit(FunctionCall const& _node)
 	};
 	if (m_legacy)
 	{
-		attributes.push_back(make_pair("isStructConstructorCall", functionCallKind(_node.annotation().kind)));
+		attributes.push_back(make_pair("isStructConstructorCall", _node.annotation().kind == FunctionCallKind::StructConstructorCall));
 		attributes.push_back(make_pair("type_conversion", _node.annotation().kind == FunctionCallKind::TypeConversion));
 	}
 	else
-- 
cgit v1.2.3


From 15b4d4def23bcf0feb93c67dccc137baa59d5102 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 5 May 2017 18:35:40 +0100
Subject: Support multiple variables in a variable declaration in inline
 assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 28 ++++++++++++++++++++++++----
 libsolidity/inlineasm/AsmCodeGen.cpp     | 15 ++++++++++-----
 libsolidity/inlineasm/AsmData.h          |  2 +-
 libsolidity/inlineasm/AsmParser.cpp      | 20 +++++++++++++++++---
 libsolidity/inlineasm/AsmPrinter.cpp     | 16 +++++++++++++++-
 libsolidity/inlineasm/AsmScopeFiller.cpp |  5 ++++-
 6 files changed, 71 insertions(+), 15 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index e03eea2e..8d3d1fd2 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -181,12 +181,32 @@ bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
 
 bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 {
+	// The number of variable names and values must match. One exception
+	// is a single value, where a tuple assignment is assumed from a function.
+	if (_varDecl.variables.size() != _varDecl.values.size())
+	{
+		if (_varDecl.values.size() != 1)
+		{
+			m_errors.push_back(make_shared<Error>(
+				Error::Type::DeclarationError,
+				"Variable declaration name and value count mismatch.",
+				_varDecl.location
+			));
+			return false;
+		}
+	}
+
+	int const expectedItems = _varDecl.variables.size();
 	int const stackHeight = m_stackHeight;
-	bool success = boost::apply_visitor(*this, *_varDecl.value);
-	solAssert(m_stackHeight - stackHeight == 1, "Invalid value size.");
-	boost::get<Scope::Variable>(m_currentScope->identifiers.at(_varDecl.variable.name)).active = true;
+	for (auto const& value: _varDecl.values)
+		if (!boost::apply_visitor(*this, value))
+			return false;
+	solAssert(m_stackHeight - stackHeight == expectedItems, "Invalid value size.");
+
+	for (auto const& variable: _varDecl.variables)
+		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
-	return success;
+	return true;
 }
 
 bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index b8af9dc6..1063d552 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -251,11 +251,16 @@ public:
 	void operator()(assembly::VariableDeclaration const& _varDecl)
 	{
 		int height = m_assembly.stackHeight();
-		boost::apply_visitor(*this, *_varDecl.value);
-		expectDeposit(1, height);
-		auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(_varDecl.variable.name));
-		var.stackHeight = height;
-		var.active = true;
+		int expectedItems = _varDecl.variables.size();
+		for (auto const& value: _varDecl.values)
+			boost::apply_visitor(*this, value);
+		expectDeposit(expectedItems, height);
+		for (auto const& variable: _varDecl.variables)
+		{
+			auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(variable.name));
+			var.stackHeight = height++;
+			var.active = true;
+		}
 	}
 	void operator()(assembly::Block const& _block)
 	{
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 8efe1f07..bf21ba00 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -65,7 +65,7 @@ struct FunctionalAssignment { SourceLocation location; Identifier variableName;
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
 /// Block-scope variable declaration ("let x:u256 := mload(20:u256)"), non-hoisted
-struct VariableDeclaration { SourceLocation location; TypedName variable; std::shared_ptr<Statement> value; };
+struct VariableDeclaration { SourceLocation location; TypedNameList variables; std::vector<Statement> values; };
 /// Block that creates a scope (frees declared stack variables)
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index a96984f5..53954a49 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -258,11 +258,25 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 {
 	VariableDeclaration varDecl = createWithLocation<VariableDeclaration>();
 	expectToken(Token::Let);
-	varDecl.variable = parseTypedName();
+	while (true)
+	{
+		varDecl.variables.push_back(parseTypedName());
+		if (m_scanner->currentToken() == Token::Comma)
+			expectToken(Token::Comma);
+		else
+			break;
+	}
 	expectToken(Token::Colon);
 	expectToken(Token::Assign);
-	varDecl.value.reset(new Statement(parseExpression()));
-	varDecl.location.end = locationOf(*varDecl.value).end;
+	while (true)
+	{
+		varDecl.values.emplace_back(new Statement(parseExpression()));
+		if (m_scanner->currentToken() == Token::Comma)
+			expectToken(Token::Comma);
+		else
+			break;
+	}
+	varDecl.location.end = locationOf(varDecl.values.back()).end;
 	return varDecl;
 }
 
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 636e61b8..845aefb9 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -121,7 +121,21 @@ string AsmPrinter::operator()(assembly::FunctionalAssignment const& _functionalA
 
 string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDeclaration)
 {
-	return "let " + _variableDeclaration.variable.name + appendTypeName(_variableDeclaration.variable.type) + " := " + boost::apply_visitor(*this, *_variableDeclaration.value);
+	string out = "let ";
+	out += boost::algorithm::join(
+		_variableDeclaration.variables | boost::adaptors::transformed(
+			[this](TypedName variable) { return variable.name + appendTypeName(variable.type); }
+		),
+		", "
+	);
+	out += " := ";
+	out += boost::algorithm::join(
+		_variableDeclaration.values | boost::adaptors::transformed(
+			[this](Statement statement) { return boost::apply_visitor(*this, statement); }
+		),
+		", "
+	);
+	return out;
 }
 
 string AsmPrinter::operator()(assembly::FunctionDefinition const& _functionDefinition)
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index eb10dbb3..05b1b211 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -59,7 +59,10 @@ bool ScopeFiller::operator()(Label const& _item)
 
 bool ScopeFiller::operator()(assembly::VariableDeclaration const& _varDecl)
 {
-	return registerVariable(_varDecl.variable, _varDecl.location, *m_currentScope);
+	for (auto const& variable: _varDecl.variables)
+		if (!registerVariable(variable, _varDecl.location, *m_currentScope))
+			return false;
+	return true;
 }
 
 bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
-- 
cgit v1.2.3


From cb4966046d9871b63084ddcf0ff6fac8a4c322aa Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 5 May 2017 18:56:29 +0100
Subject: Enable a single right hand item on let

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 21 ++-------------------
 libsolidity/inlineasm/AsmCodeGen.cpp  |  3 +--
 libsolidity/inlineasm/AsmData.h       |  2 +-
 libsolidity/inlineasm/AsmParser.cpp   | 11 ++---------
 libsolidity/inlineasm/AsmPrinter.cpp  |  7 +------
 5 files changed, 7 insertions(+), 37 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 8d3d1fd2..5062fcf4 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -181,32 +181,15 @@ bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
 
 bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 {
-	// The number of variable names and values must match. One exception
-	// is a single value, where a tuple assignment is assumed from a function.
-	if (_varDecl.variables.size() != _varDecl.values.size())
-	{
-		if (_varDecl.values.size() != 1)
-		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Variable declaration name and value count mismatch.",
-				_varDecl.location
-			));
-			return false;
-		}
-	}
-
 	int const expectedItems = _varDecl.variables.size();
 	int const stackHeight = m_stackHeight;
-	for (auto const& value: _varDecl.values)
-		if (!boost::apply_visitor(*this, value))
-			return false;
+	bool success = boost::apply_visitor(*this, *_varDecl.value);
 	solAssert(m_stackHeight - stackHeight == expectedItems, "Invalid value size.");
 
 	for (auto const& variable: _varDecl.variables)
 		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
-	return true;
+	return success;
 }
 
 bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 1063d552..02d5ced0 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -252,8 +252,7 @@ public:
 	{
 		int height = m_assembly.stackHeight();
 		int expectedItems = _varDecl.variables.size();
-		for (auto const& value: _varDecl.values)
-			boost::apply_visitor(*this, value);
+		boost::apply_visitor(*this, *_varDecl.value);
 		expectDeposit(expectedItems, height);
 		for (auto const& variable: _varDecl.variables)
 		{
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index bf21ba00..65dfbadf 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -65,7 +65,7 @@ struct FunctionalAssignment { SourceLocation location; Identifier variableName;
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
 /// Block-scope variable declaration ("let x:u256 := mload(20:u256)"), non-hoisted
-struct VariableDeclaration { SourceLocation location; TypedNameList variables; std::vector<Statement> values; };
+struct VariableDeclaration { SourceLocation location; TypedNameList variables; std::shared_ptr<Statement> value; };
 /// Block that creates a scope (frees declared stack variables)
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 53954a49..73f70e3f 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -268,15 +268,8 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 	}
 	expectToken(Token::Colon);
 	expectToken(Token::Assign);
-	while (true)
-	{
-		varDecl.values.emplace_back(new Statement(parseExpression()));
-		if (m_scanner->currentToken() == Token::Comma)
-			expectToken(Token::Comma);
-		else
-			break;
-	}
-	varDecl.location.end = locationOf(varDecl.values.back()).end;
+	varDecl.value.reset(new Statement(parseExpression()));
+	varDecl.location.end = locationOf(*varDecl.value).end;
 	return varDecl;
 }
 
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 845aefb9..219a57ad 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -129,12 +129,7 @@ string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDecl
 		", "
 	);
 	out += " := ";
-	out += boost::algorithm::join(
-		_variableDeclaration.values | boost::adaptors::transformed(
-			[this](Statement statement) { return boost::apply_visitor(*this, statement); }
-		),
-		", "
-	);
+	out += boost::apply_visitor(*this, *_variableDeclaration.value);
 	return out;
 }
 
-- 
cgit v1.2.3


From 3451a30e5cd6d8bceedba70bf9c5012f263b3ec8 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 5 May 2017 21:10:05 +0100
Subject: Display actual error message and not assertion in analysis

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 5062fcf4..9e0ade2a 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -184,7 +184,15 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	int const expectedItems = _varDecl.variables.size();
 	int const stackHeight = m_stackHeight;
 	bool success = boost::apply_visitor(*this, *_varDecl.value);
-	solAssert(m_stackHeight - stackHeight == expectedItems, "Invalid value size.");
+	if ((m_stackHeight - stackHeight) != expectedItems)
+	{
+		m_errors.push_back(make_shared<Error>(
+			Error::Type::DeclarationError,
+			"Variable count mismatch.",
+			_varDecl.location
+		));
+		return false;
+	}
 
 	for (auto const& variable: _varDecl.variables)
 		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
-- 
cgit v1.2.3


From f735207732ed25dcff155a683525890f0231077a Mon Sep 17 00:00:00 2001
From: Rhett Aultman <roadriverrail@gmail.com>
Date: Tue, 23 May 2017 06:38:17 -0700
Subject: Drop the inline asm includes from StaticAnalyzer

---
 libsolidity/analysis/StaticAnalyzer.cpp | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/StaticAnalyzer.cpp b/libsolidity/analysis/StaticAnalyzer.cpp
index d273b26e..cfc863e0 100644
--- a/libsolidity/analysis/StaticAnalyzer.cpp
+++ b/libsolidity/analysis/StaticAnalyzer.cpp
@@ -22,9 +22,6 @@
 
 #include <libsolidity/analysis/StaticAnalyzer.h>
 #include <libsolidity/ast/AST.h>
-#include <libsolidity/inlineasm/AsmAnalysis.h>
-#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
-#include <libsolidity/inlineasm/AsmData.h>
 #include <memory>
 
 using namespace std;
-- 
cgit v1.2.3


From 604d254e8c930a48aeeb1b68264a7b113e916b0f Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 22 May 2017 19:36:41 +0100
Subject: Fix AST JSON converter type lookup

---
 libsolidity/ast/ASTJsonConverter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 40c552a3..a7b61c4e 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -178,7 +178,7 @@ Json::Value ASTJsonConverter::inlineAssemblyIdentifierToJson(pair<assembly::Iden
 	tuple["declaration"] = idOrNull(_info.second.declaration);
 	tuple["isSlot"] = Json::Value(_info.second.isSlot);
 	tuple["isOffset"] = Json::Value(_info.second.isOffset);
-	tuple["valueSize"] = _info.second.valueSize;
+	tuple["valueSize"] = Json::Value(Json::LargestUInt(_info.second.valueSize));
 	return tuple;
 }
 
-- 
cgit v1.2.3


From f15d6ea45fd9470ba7ec1fcdc57796b268c0e7a5 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:02:11 +0100
Subject: Rename Assignment to StackAssignment

---
 libsolidity/inlineasm/AsmAnalysis.cpp   | 2 +-
 libsolidity/inlineasm/AsmAnalysis.h     | 4 ++--
 libsolidity/inlineasm/AsmAnalysisInfo.h | 4 ++--
 libsolidity/inlineasm/AsmCodeGen.cpp    | 2 +-
 libsolidity/inlineasm/AsmData.h         | 6 +++---
 libsolidity/inlineasm/AsmParser.cpp     | 2 +-
 libsolidity/inlineasm/AsmPrinter.cpp    | 2 +-
 libsolidity/inlineasm/AsmPrinter.h      | 4 ++--
 libsolidity/inlineasm/AsmScopeFiller.h  | 4 ++--
 9 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 9e0ade2a..ed0211d4 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -160,7 +160,7 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	return success;
 }
 
-bool AsmAnalyzer::operator()(assembly::Assignment const& _assignment)
+bool AsmAnalyzer::operator()(assembly::StackAssignment const& _assignment)
 {
 	bool success = checkAssignment(_assignment.variableName, size_t(-1));
 	m_info.stackHeightInfo[&_assignment] = m_stackHeight;
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 426ee0d2..4f2a9d9e 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -44,7 +44,7 @@ struct FunctionalAssignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
-struct Assignment;
+struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 
@@ -73,7 +73,7 @@ public:
 	bool operator()(assembly::Identifier const&);
 	bool operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	bool operator()(assembly::Label const& _label);
-	bool operator()(assembly::Assignment const&);
+	bool operator()(assembly::StackAssignment const&);
 	bool operator()(assembly::FunctionalAssignment const& _functionalAssignment);
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index e21eb2c5..6f5b1159 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -40,13 +40,13 @@ struct FunctionalAssignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
-struct Assignment;
+struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 02d5ced0..708073e1 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -233,7 +233,7 @@ public:
 		m_assembly.appendLabel(*label.id);
 		checkStackHeight(&_label);
 	}
-	void operator()(assembly::Assignment const& _assignment)
+	void operator()(assembly::StackAssignment const& _assignment)
 	{
 		m_assembly.setSourceLocation(_assignment.location);
 		generateAssignment(_assignment.variableName, _assignment.location);
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 65dfbadf..9d8610cf 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -50,14 +50,14 @@ struct Identifier { SourceLocation location; std::string name; };
 struct FunctionalInstruction;
 /// Jump label ("name:")
 struct Label { SourceLocation location; std::string name; };
-/// Assignemnt (":= x", moves stack top into x, potentially multiple slots)
-struct Assignment { SourceLocation location; Identifier variableName; };
+/// Assignment from stack (":= x", moves stack top into x, potentially multiple slots)
+struct StackAssignment { SourceLocation location; Identifier variableName; };
 struct FunctionalAssignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Block;
-using Statement = boost::variant<Instruction, Literal, Label, Assignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 /// Functional assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
 struct FunctionalAssignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 73f70e3f..7c23e6b4 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -71,7 +71,7 @@ assembly::Statement Parser::parseStatement()
 	{
 		if (m_julia)
 			break;
-		assembly::Assignment assignment = createWithLocation<assembly::Assignment>();
+		assembly::StackAssignment assignment = createWithLocation<assembly::StackAssignment>();
 		m_scanner->next();
 		expectToken(Token::Colon);
 		assignment.variableName.location = location();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 219a57ad..8001f361 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -108,7 +108,7 @@ string AsmPrinter::operator()(assembly::Label const& _label)
 	return _label.name + ":";
 }
 
-string AsmPrinter::operator()(assembly::Assignment const& _assignment)
+string AsmPrinter::operator()(assembly::StackAssignment const& _assignment)
 {
 	solAssert(!m_julia, "");
 	return "=: " + (*this)(_assignment.variableName);
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 282fd7e3..c608f8cb 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -35,7 +35,7 @@ struct Literal;
 struct Identifier;
 struct FunctionalInstruction;
 struct Label;
-struct Assignment;
+struct StackAssignment;
 struct FunctionalAssignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
@@ -52,7 +52,7 @@ public:
 	std::string operator()(assembly::Identifier const& _identifier);
 	std::string operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	std::string operator()(assembly::Label const& _label);
-	std::string operator()(assembly::Assignment const& _assignment);
+	std::string operator()(assembly::StackAssignment const& _assignment);
 	std::string operator()(assembly::FunctionalAssignment const& _functionalAssignment);
 	std::string operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 61428eea..8aa96208 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -43,7 +43,7 @@ struct FunctionalAssignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
-struct Assignment;
+struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 
@@ -64,7 +64,7 @@ public:
 	bool operator()(assembly::Identifier const&) { return true; }
 	bool operator()(assembly::FunctionalInstruction const&) { return true; }
 	bool operator()(assembly::Label const& _label);
-	bool operator()(assembly::Assignment const&) { return true; }
+	bool operator()(assembly::StackAssignment const&) { return true; }
 	bool operator()(assembly::FunctionalAssignment const&) { return true; }
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
-- 
cgit v1.2.3


From 187fa5075105008578fa2af467eda44bfa444144 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:07:00 +0100
Subject: Rename FunctionalAssignment to Assignment

---
 libsolidity/inlineasm/AsmAnalysis.cpp   |  2 +-
 libsolidity/inlineasm/AsmAnalysis.h     |  4 ++--
 libsolidity/inlineasm/AsmAnalysisInfo.h |  4 ++--
 libsolidity/inlineasm/AsmCodeGen.cpp    |  2 +-
 libsolidity/inlineasm/AsmData.h         |  8 ++++----
 libsolidity/inlineasm/AsmParser.cpp     | 11 +++++------
 libsolidity/inlineasm/AsmPrinter.cpp    |  4 ++--
 libsolidity/inlineasm/AsmPrinter.h      |  4 ++--
 libsolidity/inlineasm/AsmScopeFiller.h  |  4 ++--
 9 files changed, 21 insertions(+), 22 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index ed0211d4..babb93b4 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -168,7 +168,7 @@ bool AsmAnalyzer::operator()(assembly::StackAssignment const& _assignment)
 }
 
 
-bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
+bool AsmAnalyzer::operator()(assembly::Assignment const& _assignment)
 {
 	int const stackHeight = m_stackHeight;
 	bool success = boost::apply_visitor(*this, *_assignment.value);
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 4f2a9d9e..f09e4b59 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -40,7 +40,7 @@ struct Literal;
 struct Block;
 struct Label;
 struct FunctionalInstruction;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
@@ -74,7 +74,7 @@ public:
 	bool operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	bool operator()(assembly::Label const& _label);
 	bool operator()(assembly::StackAssignment const&);
-	bool operator()(assembly::FunctionalAssignment const& _functionalAssignment);
+	bool operator()(assembly::Assignment const& _assignment);
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const& _functionCall);
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index 6f5b1159..d2253c78 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -36,7 +36,7 @@ struct Literal;
 struct Block;
 struct Label;
 struct FunctionalInstruction;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
@@ -46,7 +46,7 @@ struct FunctionCall;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 708073e1..53eafc96 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -239,7 +239,7 @@ public:
 		generateAssignment(_assignment.variableName, _assignment.location);
 		checkStackHeight(&_assignment);
 	}
-	void operator()(FunctionalAssignment const& _assignment)
+	void operator()(assembly::Assignment const& _assignment)
 	{
 		int height = m_assembly.stackHeight();
 		boost::apply_visitor(*this, *_assignment.value);
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 9d8610cf..3d2c8cad 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -52,15 +52,15 @@ struct FunctionalInstruction;
 struct Label { SourceLocation location; std::string name; };
 /// Assignment from stack (":= x", moves stack top into x, potentially multiple slots)
 struct StackAssignment { SourceLocation location; Identifier variableName; };
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Block;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, FunctionalAssignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
-/// Functional assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+/// Assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
-struct FunctionalAssignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
+struct Assignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
 /// Functional instruction, e.g. "mul(mload(20:u256), add(2:u256, x))"
 struct FunctionalInstruction { SourceLocation location; Instruction instruction; std::vector<Statement> arguments; };
 struct FunctionCall { SourceLocation location; Identifier functionName; std::vector<Statement> arguments; };
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 7c23e6b4..ffd9f6e2 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -107,15 +107,14 @@ assembly::Statement Parser::parseStatement()
 		// while identifier:= (being followed by a non-colon) as identifier := (assignment).
 		if (m_scanner->currentToken() == Token::Assign && m_scanner->peekNextToken() != Token::Colon)
 		{
-			// functional assignment
-			FunctionalAssignment funAss = createWithLocation<FunctionalAssignment>(identifier.location);
+			assembly::Assignment assignment = createWithLocation<assembly::Assignment>(identifier.location);
 			if (!m_julia && instructions().count(identifier.name))
 				fatalParserError("Cannot use instruction names for identifier names.");
 			m_scanner->next();
-			funAss.variableName = identifier;
-			funAss.value.reset(new Statement(parseExpression()));
-			funAss.location.end = locationOf(*funAss.value).end;
-			return funAss;
+			assignment.variableName = identifier;
+			assignment.value.reset(new Statement(parseExpression()));
+			assignment.location.end = locationOf(*assignment.value).end;
+			return assignment;
 		}
 		else
 		{
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 8001f361..92b12423 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -114,9 +114,9 @@ string AsmPrinter::operator()(assembly::StackAssignment const& _assignment)
 	return "=: " + (*this)(_assignment.variableName);
 }
 
-string AsmPrinter::operator()(assembly::FunctionalAssignment const& _functionalAssignment)
+string AsmPrinter::operator()(assembly::Assignment const& _assignment)
 {
-	return (*this)(_functionalAssignment.variableName) + " := " + boost::apply_visitor(*this, *_functionalAssignment.value);
+	return (*this)(_assignment.variableName) + " := " + boost::apply_visitor(*this, *_assignment.value);
 }
 
 string AsmPrinter::operator()(assembly::VariableDeclaration const& _variableDeclaration)
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index c608f8cb..423eeefa 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -36,7 +36,7 @@ struct Identifier;
 struct FunctionalInstruction;
 struct Label;
 struct StackAssignment;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
@@ -53,7 +53,7 @@ public:
 	std::string operator()(assembly::FunctionalInstruction const& _functionalInstruction);
 	std::string operator()(assembly::Label const& _label);
 	std::string operator()(assembly::StackAssignment const& _assignment);
-	std::string operator()(assembly::FunctionalAssignment const& _functionalAssignment);
+	std::string operator()(assembly::Assignment const& _assignment);
 	std::string operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 8aa96208..b1b0833b 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -39,7 +39,7 @@ struct Literal;
 struct Block;
 struct Label;
 struct FunctionalInstruction;
-struct FunctionalAssignment;
+struct Assignment;
 struct VariableDeclaration;
 struct Instruction;
 struct Identifier;
@@ -65,7 +65,7 @@ public:
 	bool operator()(assembly::FunctionalInstruction const&) { return true; }
 	bool operator()(assembly::Label const& _label);
 	bool operator()(assembly::StackAssignment const&) { return true; }
-	bool operator()(assembly::FunctionalAssignment const&) { return true; }
+	bool operator()(assembly::Assignment const&) { return true; }
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
-- 
cgit v1.2.3


From 4f738ff1c0975202f064900549eca4661d2f51a6 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:14:06 +0100
Subject: Reorder AsmData for readability

---
 libsolidity/inlineasm/AsmData.h | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 3d2c8cad..3b4048c3 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -40,6 +40,20 @@ using TypedNameList = std::vector<TypedName>;
 
 /// What follows are the AST nodes for assembly.
 
+struct Instruction;
+struct Literal;
+struct Label;
+struct StackAssignment;
+struct Identifier;
+struct Assignment;
+struct VariableDeclaration;
+struct FunctionalInstruction;
+struct FunctionDefinition;
+struct FunctionCall;
+struct Block;
+
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
@@ -47,17 +61,10 @@ enum class LiteralKind { Number, Boolean, String };
 struct Literal { SourceLocation location; LiteralKind kind; std::string value; Type type; };
 /// External / internal identifier or label reference
 struct Identifier { SourceLocation location; std::string name; };
-struct FunctionalInstruction;
 /// Jump label ("name:")
 struct Label { SourceLocation location; std::string name; };
 /// Assignment from stack (":= x", moves stack top into x, potentially multiple slots)
 struct StackAssignment { SourceLocation location; Identifier variableName; };
-struct Assignment;
-struct VariableDeclaration;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Block;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
 /// Assignment ("x := mload(20:u256)", expects push-1-expression on the right hand
 /// side and requires x to occupy exactly one stack slot.
 struct Assignment { SourceLocation location; Identifier variableName; std::shared_ptr<Statement> value; };
-- 
cgit v1.2.3


From b77b11781d174712bd141d0fd82e823cd2727aec Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 01:26:17 +0100
Subject: Rename parseFunctionalInstruction to parseCall

---
 libsolidity/inlineasm/AsmParser.cpp | 6 +++---
 libsolidity/inlineasm/AsmParser.h   | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index ffd9f6e2..85ae9424 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -96,7 +96,7 @@ assembly::Statement Parser::parseStatement()
 	switch (m_scanner->currentToken())
 	{
 	case Token::LParen:
-		return parseFunctionalInstruction(std::move(statement));
+		return parseCall(std::move(statement));
 	case Token::Colon:
 	{
 		if (statement.type() != typeid(assembly::Identifier))
@@ -138,7 +138,7 @@ assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
 	if (m_scanner->currentToken() == Token::LParen)
-		return parseFunctionalInstruction(std::move(operation));
+		return parseCall(std::move(operation));
 	else
 		return operation;
 }
@@ -303,7 +303,7 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 	return funDef;
 }
 
-assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _instruction)
+assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 {
 	if (_instruction.type() == typeid(Instruction))
 	{
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index addc1725..812762a6 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -68,7 +68,7 @@ protected:
 	Statement parseElementaryOperation(bool _onlySinglePusher = false);
 	VariableDeclaration parseVariableDeclaration();
 	FunctionDefinition parseFunctionDefinition();
-	Statement parseFunctionalInstruction(Statement&& _instruction);
+	Statement parseCall(Statement&& _instruction);
 	TypedName parseTypedName();
 	std::string expectAsmIdentifier();
 
-- 
cgit v1.2.3


From 74d41ad25fa53d3ac2e34bb082b467cb7dc56b99 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 23 May 2017 22:58:37 +0100
Subject: Fix scope assert in AsmAnalyzer

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index babb93b4..65b935f2 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -406,6 +406,7 @@ bool AsmAnalyzer::expectDeposit(int const _deposit, int const _oldHeight, Source
 
 Scope& AsmAnalyzer::scope(Block const* _block)
 {
+	solAssert(m_info.scopes.count(_block) == 1, "Scope requested but not present.");
 	auto scopePtr = m_info.scopes.at(_block);
 	solAssert(scopePtr, "Scope requested but not present.");
 	return *scopePtr;
-- 
cgit v1.2.3


From 26abd61d9b3523fbc81ad33b8826bb06005b95c6 Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Wed, 24 May 2017 13:52:16 +0200
Subject: insert ParameterList-node in FunctionType-json

---
 libsolidity/ast/AST.h                | 2 ++
 libsolidity/ast/ASTJsonConverter.cpp | 4 ++--
 2 files changed, 4 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index 71b81a69..ba1d0589 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -873,6 +873,8 @@ public:
 
 	std::vector<ASTPointer<VariableDeclaration>> const& parameterTypes() const { return m_parameterTypes->parameters(); }
 	std::vector<ASTPointer<VariableDeclaration>> const& returnParameterTypes() const { return m_returnTypes->parameters(); }
+	ASTPointer<ParameterList> const& parameterTypeList() const { return m_parameterTypes; }
+	ASTPointer<ParameterList> const& returnParameterTypeList() const { return m_returnTypes; }
 
 	Declaration::Visibility visibility() const
 	{
diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 40c552a3..5a411dd8 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -420,8 +420,8 @@ bool ASTJsonConverter::visit(FunctionTypeName const& _node)
 		make_pair("payable", _node.isPayable()),
 		make_pair("visibility", visibility(_node.visibility())),
 		make_pair(m_legacy ? "constant" : "isDeclaredConst", _node.isDeclaredConst()),
-		make_pair("parameterTypes", toJson(_node.parameterTypes())),
-		make_pair("returnParameterTypes", toJson(_node.returnParameterTypes())),
+		make_pair("parameterTypes", toJson(*_node.parameterTypeList())),
+		make_pair("returnParameterTypes", toJson(*_node.returnParameterTypeList())),
 		make_pair("typeDescriptions", typePointerToJson(_node.annotation().type))
 	});
 	return false;
-- 
cgit v1.2.3


From 56fe3a6ab93116438ea52634e891c71b995d7c3f Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 13:13:05 +0100
Subject: Better error messages during parsing functional instructions

---
 libsolidity/inlineasm/AsmParser.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 85ae9424..519bfa2e 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -321,6 +321,15 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		unsigned args = unsigned(instrInfo.args);
 		for (unsigned i = 0; i < args; ++i)
 		{
+			/// check for premature closing parentheses
+			if (m_scanner->currentToken() == Token::RParen)
+				fatalParserError(string(
+					"Expected " +
+					boost::lexical_cast<string>(args) +
+					" arguments, but received " +
+					boost::lexical_cast<string>(i)
+				));
+
 			ret.arguments.emplace_back(parseExpression());
 			if (i != args - 1)
 			{
-- 
cgit v1.2.3


From 338202ea96e0af8822dde3acc27aa45f79c8780b Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 13:27:58 +0100
Subject: Uniform error messages

---
 libsolidity/inlineasm/AsmParser.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 519bfa2e..530cd726 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -324,10 +324,11 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			/// check for premature closing parentheses
 			if (m_scanner->currentToken() == Token::RParen)
 				fatalParserError(string(
-					"Expected " +
+					"Expected expression (" +
+					instrInfo.name +
+					" expects " +
 					boost::lexical_cast<string>(args) +
-					" arguments, but received " +
-					boost::lexical_cast<string>(i)
+					" arguments)"
 				));
 
 			ret.arguments.emplace_back(parseExpression());
-- 
cgit v1.2.3


From 8c3ec16132e77084c8a08b79b90922b82ec8e1cd Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 22:45:10 +0100
Subject: Scanner requires only the SourcesSet state

---
 libsolidity/interface/CompilerStack.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 72712298..be0d060e 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -507,7 +507,7 @@ string const& CompilerStack::onChainMetadata(string const& _contractName) const
 
 Scanner const& CompilerStack::scanner(string const& _sourceName) const
 {
-	if (m_stackState < ParsingSuccessful)
+	if (m_stackState < SourcesSet)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
 
 	return *source(_sourceName).scanner;
-- 
cgit v1.2.3


From b5080860d5f2d141b8fccceaa635378a86c996a8 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 28 Apr 2017 14:27:56 +0100
Subject: Implement switch statement in the assembly parser/printer

---
 libsolidity/inlineasm/AsmAnalysis.cpp   | 32 ++++++++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmAnalysis.h     |  2 ++
 libsolidity/inlineasm/AsmAnalysisInfo.h |  3 ++-
 libsolidity/inlineasm/AsmCodeGen.cpp    |  4 ++++
 libsolidity/inlineasm/AsmData.h         |  7 ++++++-
 libsolidity/inlineasm/AsmParser.cpp     | 30 ++++++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmParser.h       |  1 +
 libsolidity/inlineasm/AsmPrinter.cpp    | 14 ++++++++++++++
 libsolidity/inlineasm/AsmPrinter.h      |  2 ++
 libsolidity/inlineasm/AsmScopeFiller.h  |  2 ++
 10 files changed, 95 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 65b935f2..ecc63372 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -285,6 +285,38 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 	return success;
 }
 
+bool AsmAnalyzer::operator()(Switch const& _switch)
+{
+	int const initialStackHeight = m_stackHeight;
+	if (!boost::apply_visitor(*this, *_switch.expression))
+		return false;
+	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
+
+	map<string, bool> caseNames;
+	for (auto const& _case: _switch.cases)
+	{
+		/// Note: the parser ensures there is only one default case
+		if (caseNames[_case.name])
+		{
+			m_errors.push_back(make_shared<Error>(
+				Error::Type::DeclarationError,
+				"Duplicate case defined: " + _case.name,
+				_case.location
+			));
+			return false;
+		}
+		else
+			caseNames[_case.name] = true;
+
+		if (!(*this)(_case.body))
+			return false;
+	}
+
+	m_stackHeight--;
+
+	return true;
+}
+
 bool AsmAnalyzer::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index f09e4b59..9f022b12 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -47,6 +47,7 @@ struct Identifier;
 struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 
 struct Scope;
 
@@ -78,6 +79,7 @@ public:
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const& _functionCall);
+	bool operator()(assembly::Switch const& _switch);
 	bool operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index d2253c78..18382db0 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -43,10 +43,11 @@ struct Identifier;
 struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 53eafc96..5c66b125 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -266,6 +266,10 @@ public:
 		CodeTransform(m_state, m_assembly, _block, m_identifierAccess, m_initialStackHeight);
 		checkStackHeight(&_block);
 	}
+	void operator()(assembly::Switch const&)
+	{
+		solAssert(false, "Switch not removed during desugaring phase.");
+	}
 	void operator()(assembly::FunctionDefinition const&)
 	{
 		solAssert(false, "Function definition not removed during desugaring phase.");
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 3b4048c3..92ff1c5a 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -50,9 +50,10 @@ struct VariableDeclaration;
 struct FunctionalInstruction;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 struct Block;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
 
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
@@ -77,6 +78,10 @@ struct VariableDeclaration { SourceLocation location; TypedNameList variables; s
 struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
 struct FunctionDefinition { SourceLocation location; std::string name; TypedNameList arguments; TypedNameList returns; Block body; };
+/// Switch case or default case
+struct Case { SourceLocation location; std::string name; Block body; };
+/// Switch statement
+struct Switch { SourceLocation location; std::shared_ptr<Statement> expression; std::vector<Case> cases; };
 
 struct LocationExtractor: boost::static_visitor<SourceLocation>
 {
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 530cd726..a3a25a42 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -67,6 +67,20 @@ assembly::Statement Parser::parseStatement()
 		return parseFunctionDefinition();
 	case Token::LBrace:
 		return parseBlock();
+	case Token::Switch:
+	{
+		assembly::Switch _switch = createWithLocation<assembly::Switch>();
+		m_scanner->next();
+		_switch.expression = make_shared<Statement>(parseExpression());
+		while (m_scanner->currentToken() == Token::Case)
+			_switch.cases.emplace_back(parseCase());
+		if (m_scanner->currentToken() == Token::Default)
+			_switch.cases.emplace_back(parseCase(true));
+		if (_switch.cases.size() == 0)
+			fatalParserError("Switch statement without any cases.");
+		_switch.location.end = _switch.cases.back().body.location.end;
+		return _switch;
+	}
 	case Token::Assign:
 	{
 		if (m_julia)
@@ -134,6 +148,22 @@ assembly::Statement Parser::parseStatement()
 	return statement;
 }
 
+assembly::Case Parser::parseCase(bool _defaultCase)
+{
+	assembly::Case _case = createWithLocation<assembly::Case>();
+	if (_defaultCase)
+		expectToken(Token::Default);
+	else
+	{
+		expectToken(Token::Case);
+		_case.name = expectAsmIdentifier();
+	}
+	expectToken(Token::Colon);
+	_case.body = parseBlock();
+	_case.location.end = _case.body.location.end;
+	return _case;
+}
+
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index 812762a6..d1d0c1cc 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -62,6 +62,7 @@ protected:
 
 	Block parseBlock();
 	Statement parseStatement();
+	Case parseCase(bool _defaultCase = false);
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
 	std::map<std::string, dev::solidity::Instruction> const& instructions();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 92b12423..92200f84 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -167,6 +167,20 @@ string AsmPrinter::operator()(assembly::FunctionCall const& _functionCall)
 		")";
 }
 
+string AsmPrinter::operator()(Switch const& _switch)
+{
+	string out = "switch " + boost::apply_visitor(*this, *_switch.expression);
+	for (auto const& _case: _switch.cases)
+	{
+		if (_case.name.empty())
+			out += "\ndefault: ";
+		else
+			out += "\ncase " + _case.name + ": ";
+		out += (*this)(_case.body);
+	}
+	return out;
+}
+
 string AsmPrinter::operator()(Block const& _block)
 {
 	if (_block.statements.empty())
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 423eeefa..b0d7fc09 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -40,6 +40,7 @@ struct Assignment;
 struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 struct Block;
 
 class AsmPrinter: public boost::static_visitor<std::string>
@@ -57,6 +58,7 @@ public:
 	std::string operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
+	std::string operator()(assembly::Switch const& _switch);
 	std::string operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index b1b0833b..0f5a5dd6 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -46,6 +46,7 @@ struct Identifier;
 struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
+struct Switch;
 
 struct Scope;
 
@@ -69,6 +70,7 @@ public:
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
+	bool operator()(assembly::Switch const&) { return true; };
 	bool operator()(assembly::Block const& _block);
 
 private:
-- 
cgit v1.2.3


From 66eab1caf63f9221a279abf71de953524fe9c2ad Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 17 May 2017 11:21:37 +0100
Subject: Change switch case string to Literal

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 30 +++++++++++++++++++-----------
 libsolidity/inlineasm/AsmData.h       |  2 +-
 libsolidity/inlineasm/AsmParser.cpp   |  5 ++++-
 libsolidity/inlineasm/AsmPrinter.cpp  |  4 ++--
 4 files changed, 26 insertions(+), 15 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index ecc63372..a83a93a8 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -292,21 +292,29 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 		return false;
 	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
 
-	map<string, bool> caseNames;
+	set<tuple<LiteralKind, string>> cases;
 	for (auto const& _case: _switch.cases)
 	{
-		/// Note: the parser ensures there is only one default case
-		if (caseNames[_case.name])
+		if (_case.value)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Duplicate case defined: " + _case.name,
-				_case.location
-			));
-			return false;
+			int const initialStackHeight = m_stackHeight;
+			if (!(*this)(*_case.value))
+				return false;
+			expectDeposit(1, initialStackHeight, _case.value->location);
+			m_stackHeight--;
+
+			/// Note: the parser ensures there is only one default case
+			auto val = make_tuple(_case.value->kind, _case.value->value);
+			if (!cases.insert(val).second)
+			{
+				m_errors.push_back(make_shared<Error>(
+					Error::Type::DeclarationError,
+					"Duplicate case defined",
+					_case.location
+				));
+				return false;
+			}
 		}
-		else
-			caseNames[_case.name] = true;
 
 		if (!(*this)(_case.body))
 			return false;
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 92ff1c5a..72afeef1 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -79,7 +79,7 @@ struct Block { SourceLocation location; std::vector<Statement> statements; };
 /// Function definition ("function f(a, b) -> (d, e) { ... }")
 struct FunctionDefinition { SourceLocation location; std::string name; TypedNameList arguments; TypedNameList returns; Block body; };
 /// Switch case or default case
-struct Case { SourceLocation location; std::string name; Block body; };
+struct Case { SourceLocation location; std::shared_ptr<Literal> value; Block body; };
 /// Switch statement
 struct Switch { SourceLocation location; std::shared_ptr<Statement> expression; std::vector<Case> cases; };
 
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index a3a25a42..11b33218 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -156,7 +156,10 @@ assembly::Case Parser::parseCase(bool _defaultCase)
 	else
 	{
 		expectToken(Token::Case);
-		_case.name = expectAsmIdentifier();
+		assembly::Statement statement = parseElementaryOperation();
+		if (statement.type() != typeid(assembly::Literal))
+			fatalParserError("Literal expected.");
+		_case.value = make_shared<Literal>(std::move(boost::get<assembly::Literal>(statement)));
 	}
 	expectToken(Token::Colon);
 	_case.body = parseBlock();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 92200f84..1ef9d071 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -172,10 +172,10 @@ string AsmPrinter::operator()(Switch const& _switch)
 	string out = "switch " + boost::apply_visitor(*this, *_switch.expression);
 	for (auto const& _case: _switch.cases)
 	{
-		if (_case.name.empty())
+		if (!_case.value)
 			out += "\ndefault: ";
 		else
-			out += "\ncase " + _case.name + ": ";
+			out += "\ncase " + (*this)(*_case.value) + ": ";
 		out += (*this)(_case.body);
 	}
 	return out;
-- 
cgit v1.2.3


From db3d9e0416e7ac69ddf13eb6e2fd4e0a35dd1a63 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 19 May 2017 17:54:55 +0100
Subject: Switch cases are not followed by colon

---
 libsolidity/inlineasm/AsmParser.cpp  | 1 -
 libsolidity/inlineasm/AsmPrinter.cpp | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 11b33218..63c08b15 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -161,7 +161,6 @@ assembly::Case Parser::parseCase(bool _defaultCase)
 			fatalParserError("Literal expected.");
 		_case.value = make_shared<Literal>(std::move(boost::get<assembly::Literal>(statement)));
 	}
-	expectToken(Token::Colon);
 	_case.body = parseBlock();
 	_case.location.end = _case.body.location.end;
 	return _case;
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 1ef9d071..e282e5e8 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -173,9 +173,9 @@ string AsmPrinter::operator()(Switch const& _switch)
 	for (auto const& _case: _switch.cases)
 	{
 		if (!_case.value)
-			out += "\ndefault: ";
+			out += "\ndefault ";
 		else
-			out += "\ncase " + (*this)(*_case.value) + ": ";
+			out += "\ncase " + (*this)(*_case.value) + " ";
 		out += (*this)(_case.body);
 	}
 	return out;
-- 
cgit v1.2.3


From e48e84ca2bfdf863a798c88c329796284b2a87cb Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 19 May 2017 18:04:40 +0100
Subject: Check token within parseCase

---
 libsolidity/inlineasm/AsmParser.cpp | 14 ++++++++------
 libsolidity/inlineasm/AsmParser.h   |  2 +-
 2 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 63c08b15..537a39a1 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -75,7 +75,7 @@ assembly::Statement Parser::parseStatement()
 		while (m_scanner->currentToken() == Token::Case)
 			_switch.cases.emplace_back(parseCase());
 		if (m_scanner->currentToken() == Token::Default)
-			_switch.cases.emplace_back(parseCase(true));
+			_switch.cases.emplace_back(parseCase());
 		if (_switch.cases.size() == 0)
 			fatalParserError("Switch statement without any cases.");
 		_switch.location.end = _switch.cases.back().body.location.end;
@@ -148,19 +148,21 @@ assembly::Statement Parser::parseStatement()
 	return statement;
 }
 
-assembly::Case Parser::parseCase(bool _defaultCase)
+assembly::Case Parser::parseCase()
 {
 	assembly::Case _case = createWithLocation<assembly::Case>();
-	if (_defaultCase)
-		expectToken(Token::Default);
-	else
+	if (m_scanner->currentToken() == Token::Default)
+		m_scanner->next();
+	else if (m_scanner->currentToken() == Token::Case)
 	{
-		expectToken(Token::Case);
+		m_scanner->next();
 		assembly::Statement statement = parseElementaryOperation();
 		if (statement.type() != typeid(assembly::Literal))
 			fatalParserError("Literal expected.");
 		_case.value = make_shared<Literal>(std::move(boost::get<assembly::Literal>(statement)));
 	}
+	else
+		fatalParserError("Case or default case expected.");
 	_case.body = parseBlock();
 	_case.location.end = _case.body.location.end;
 	return _case;
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index d1d0c1cc..138af337 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -62,7 +62,7 @@ protected:
 
 	Block parseBlock();
 	Statement parseStatement();
-	Case parseCase(bool _defaultCase = false);
+	Case parseCase();
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
 	std::map<std::string, dev::solidity::Instruction> const& instructions();
-- 
cgit v1.2.3


From ba8a79c600e45618a5cd0bbfc044edbeab1e551c Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 19 May 2017 18:33:25 +0100
Subject: Do not stop on first switch error

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index a83a93a8..d022ecf6 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -287,9 +287,11 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 
 bool AsmAnalyzer::operator()(Switch const& _switch)
 {
+	bool success = true;
+
 	int const initialStackHeight = m_stackHeight;
 	if (!boost::apply_visitor(*this, *_switch.expression))
-		return false;
+		success = false;
 	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
 
 	set<tuple<LiteralKind, string>> cases;
@@ -299,7 +301,7 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 		{
 			int const initialStackHeight = m_stackHeight;
 			if (!(*this)(*_case.value))
-				return false;
+				success = false;
 			expectDeposit(1, initialStackHeight, _case.value->location);
 			m_stackHeight--;
 
@@ -312,17 +314,17 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 					"Duplicate case defined",
 					_case.location
 				));
-				return false;
+				success = false;
 			}
 		}
 
 		if (!(*this)(_case.body))
-			return false;
+			success = false;
 	}
 
 	m_stackHeight--;
 
-	return true;
+	return success;
 }
 
 bool AsmAnalyzer::operator()(Block const& _block)
-- 
cgit v1.2.3


From d745dd6542d488432453035763211fdad78c3a06 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 23 May 2017 20:51:33 +0100
Subject: Visit case bodies in scope filler

---
 libsolidity/inlineasm/AsmScopeFiller.cpp | 9 +++++++++
 libsolidity/inlineasm/AsmScopeFiller.h   | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 05b1b211..7eb6a9ed 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -97,6 +97,15 @@ bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 	return success;
 }
 
+bool ScopeFiller::operator()(Switch const& _switch)
+{
+	bool success = true;
+	for (auto const& _case: _switch.cases)
+		if (!(*this)(_case.body))
+			success = false;
+	return success;
+}
+
 bool ScopeFiller::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 0f5a5dd6..c7179b3b 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -70,7 +70,7 @@ public:
 	bool operator()(assembly::VariableDeclaration const& _variableDeclaration);
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
-	bool operator()(assembly::Switch const&) { return true; };
+	bool operator()(assembly::Switch const& _switch);
 	bool operator()(assembly::Block const& _block);
 
 private:
-- 
cgit v1.2.3


From c64bd3378427b46b0ae37e5d39e8ca6586d697c2 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 14:33:10 +0100
Subject: Disallow instructions as a switch expression

---
 libsolidity/inlineasm/AsmParser.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 537a39a1..847735f4 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -72,6 +72,8 @@ assembly::Statement Parser::parseStatement()
 		assembly::Switch _switch = createWithLocation<assembly::Switch>();
 		m_scanner->next();
 		_switch.expression = make_shared<Statement>(parseExpression());
+		if (_switch.expression->type() == typeid(assembly::Instruction))
+			fatalParserError("Instructions are not supported as expressions for switch.");
 		while (m_scanner->currentToken() == Token::Case)
 			_switch.cases.emplace_back(parseCase());
 		if (m_scanner->currentToken() == Token::Default)
-- 
cgit v1.2.3


From 05fcf1989ca619d197d22d3acab79b25ef7aa695 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 01:49:32 +0100
Subject: Better error messages for invalid switch cases

---
 libsolidity/inlineasm/AsmParser.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 847735f4..ccc735f7 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -78,6 +78,10 @@ assembly::Statement Parser::parseStatement()
 			_switch.cases.emplace_back(parseCase());
 		if (m_scanner->currentToken() == Token::Default)
 			_switch.cases.emplace_back(parseCase());
+		if (m_scanner->currentToken() == Token::Default)
+			fatalParserError("Only one default case allowed.");
+		else if (m_scanner->currentToken() == Token::Case)
+			fatalParserError("Case not allowed after default case.");
 		if (_switch.cases.size() == 0)
 			fatalParserError("Switch statement without any cases.");
 		_switch.location.end = _switch.cases.back().body.location.end;
-- 
cgit v1.2.3


From e410cec19ace7ae489c2c58f6d44519234a44ed7 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 09:41:53 +0100
Subject: Better error message for elementary operations

---
 libsolidity/inlineasm/AsmParser.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 530cd726..79e67af3 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -82,9 +82,6 @@ assembly::Statement Parser::parseStatement()
 		expectToken(Token::Identifier);
 		return assignment;
 	}
-	case Token::Return: // opcode
-	case Token::Byte: // opcode
-	case Token::Address: // opcode
 	default:
 		break;
 	}
@@ -247,7 +244,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		fatalParserError(
 			m_julia ?
 			"Literal or identifier expected." :
-			"Expected elementary inline assembly operation."
+			"Literal, identifier or instruction expected."
 		);
 	}
 	return ret;
@@ -259,7 +256,7 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 	expectToken(Token::Let);
 	while (true)
 	{
-		varDecl.variables.push_back(parseTypedName());
+		varDecl.variables.emplace_back(parseTypedName());
 		if (m_scanner->currentToken() == Token::Comma)
 			expectToken(Token::Comma);
 		else
-- 
cgit v1.2.3


From 40d5d5a956ab8ace804597e7af29397f477eaf40 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 26 May 2017 11:13:32 +0200
Subject: Also change error message.

---
 libsolidity/interface/CompilerStack.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index be0d060e..328df91f 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -508,7 +508,7 @@ string const& CompilerStack::onChainMetadata(string const& _contractName) const
 Scanner const& CompilerStack::scanner(string const& _sourceName) const
 {
 	if (m_stackState < SourcesSet)
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
+		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("No sources set."));
 
 	return *source(_sourceName).scanner;
 }
-- 
cgit v1.2.3


From eaa13d42a09155200127418762940ca652b050c5 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 23 May 2017 18:57:06 +0200
Subject: Support multiple assembly front and backends.

---
 .../interface/MultiBackendAssemblyStack.cpp        | 85 ++++++++++++++++++++++
 libsolidity/interface/MultiBackendAssemblyStack.h  | 85 ++++++++++++++++++++++
 2 files changed, 170 insertions(+)
 create mode 100644 libsolidity/interface/MultiBackendAssemblyStack.cpp
 create mode 100644 libsolidity/interface/MultiBackendAssemblyStack.h

(limited to 'libsolidity')

diff --git a/libsolidity/interface/MultiBackendAssemblyStack.cpp b/libsolidity/interface/MultiBackendAssemblyStack.cpp
new file mode 100644
index 00000000..cf16b627
--- /dev/null
+++ b/libsolidity/interface/MultiBackendAssemblyStack.cpp
@@ -0,0 +1,85 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
+ * eWasm as output.
+ */
+
+
+#include <libsolidity/interface/MultiBackendAssemblyStack.h>
+
+#include <libsolidity/parsing/Scanner.h>
+#include <libsolidity/inlineasm/AsmPrinter.h>
+#include <libsolidity/inlineasm/AsmParser.h>
+#include <libsolidity/inlineasm/AsmAnalysis.h>
+#include <libsolidity/inlineasm/AsmCodeGen.h>
+
+#include <libevmasm/Assembly.h>
+
+using namespace std;
+using namespace dev;
+using namespace dev::solidity;
+
+
+Scanner const& MultiBackendAssemblyStack::scanner() const
+{
+	solAssert(m_scanner, "");
+	return *m_scanner;
+}
+
+bool MultiBackendAssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string const& _source)
+{
+	m_analysisSuccessful = false;
+	m_scanner = make_shared<Scanner>(CharStream(_source), _sourceName);
+	m_parserResult = assembly::Parser(m_errors, m_input == Input::JULIA).parse(m_scanner);
+	if (!m_errors.empty())
+		return false;
+	solAssert(m_parserResult, "");
+
+	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
+	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errors);
+	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
+	return m_analysisSuccessful;
+}
+
+eth::LinkerObject MultiBackendAssemblyStack::assemble()
+{
+	solAssert(m_analysisSuccessful, "");
+	solAssert(m_parserResult, "");
+	solAssert(m_analysisInfo, "");
+
+	switch (m_targetMachine)
+	{
+	case Machine::EVM:
+	{
+		auto assembly = assembly::CodeGenerator(m_errors).assemble(*m_parserResult, *m_analysisInfo);
+		return assembly.assemble();
+	}
+	case Machine::EVM15:
+		solUnimplemented("EVM 1.5 backend is not yet implemented.");
+	case Machine::eWasm:
+		solUnimplemented("eWasm backend is not yet implemented.");
+	}
+	// unreachable
+	return eth::LinkerObject();
+}
+
+string MultiBackendAssemblyStack::print()
+{
+	solAssert(m_parserResult, "");
+	return assembly::AsmPrinter(m_input == Input::JULIA)(*m_parserResult);
+}
diff --git a/libsolidity/interface/MultiBackendAssemblyStack.h b/libsolidity/interface/MultiBackendAssemblyStack.h
new file mode 100644
index 00000000..fed9e8f9
--- /dev/null
+++ b/libsolidity/interface/MultiBackendAssemblyStack.h
@@ -0,0 +1,85 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
+ * eWasm as output.
+ */
+
+#pragma once
+
+#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
+#include <libevmasm/LinkerObject.h>
+
+#include <string>
+#include <memory>
+
+namespace dev
+{
+namespace solidity
+{
+class Scanner;
+namespace assembly
+{
+struct AsmAnalysisInfo;
+struct Block;
+}
+
+/*
+ * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
+ * eWasm as output.
+ */
+class MultiBackendAssemblyStack
+{
+public:
+	enum class Input { JULIA, Assembly };
+	enum class Machine { EVM, EVM15, eWasm };
+
+	MultiBackendAssemblyStack(Input _input = Input::Assembly, Machine _targetMachine = Machine::EVM):
+		m_input(_input),
+		m_targetMachine(_targetMachine)
+	{}
+
+	/// @returns the scanner used during parsing
+	Scanner const& scanner() const;
+
+	/// Runs parsing and analysis steps, returns false if input cannot be assembled.
+	bool parseAndAnalyze(std::string const& _sourceName, std::string const& _source);
+
+	/// Run the assembly step (should only be called after parseAndAnalyze).
+	eth::LinkerObject assemble();
+
+	ErrorList const& errors() const { return m_errors; }
+
+	/// Pretty-print the input after having parsed it.
+	std::string print();
+
+private:
+
+	Input m_input = Input::Assembly;
+	Machine m_targetMachine = Machine::EVM;
+
+	std::shared_ptr<Scanner> m_scanner;
+
+	bool m_analysisSuccessful = false;
+	std::shared_ptr<assembly::Block> m_parserResult;
+	std::shared_ptr<assembly::AsmAnalysisInfo> m_analysisInfo;
+	ErrorList m_errors;
+};
+
+}
+}
-- 
cgit v1.2.3


From 71b923cc36d33bf3e173f2210b33895df49fcbba Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 23 May 2017 19:11:14 +0200
Subject: Move EVM codegen to libjulia.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 238 -----------------------------------
 1 file changed, 238 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 5c66b125..ce2d8a1d 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -107,244 +107,6 @@ private:
 	eth::Assembly& m_assembly;
 };
 
-class CodeTransform: public boost::static_visitor<>
-{
-public:
-	/// Create the code transformer which appends assembly to _state.assembly when called
-	/// with parsed assembly data.
-	/// @param _identifierAccess used to resolve identifiers external to the inline assembly
-	explicit CodeTransform(
-		GeneratorState& _state,
-		julia::AbstractAssembly& _assembly,
-		assembly::Block const& _block,
-		assembly::ExternalIdentifierAccess const& _identifierAccess = assembly::ExternalIdentifierAccess()
-	): CodeTransform(_state, _assembly, _block, _identifierAccess, _assembly.stackHeight())
-	{
-	}
-
-private:
-	CodeTransform(
-		GeneratorState& _state,
-		julia::AbstractAssembly& _assembly,
-		assembly::Block const& _block,
-		assembly::ExternalIdentifierAccess const& _identifierAccess,
-		int _initialStackHeight
-	):
-		m_state(_state),
-		m_assembly(_assembly),
-		m_scope(*m_state.info.scopes.at(&_block)),
-		m_identifierAccess(_identifierAccess),
-		m_initialStackHeight(_initialStackHeight)
-	{
-		int blockStartStackHeight = m_assembly.stackHeight();
-		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
-
-		m_assembly.setSourceLocation(_block.location);
-
-		// pop variables
-		for (auto const& identifier: m_scope.identifiers)
-			if (identifier.second.type() == typeid(Scope::Variable))
-				m_assembly.appendInstruction(solidity::Instruction::POP);
-
-		int deposit = m_assembly.stackHeight() - blockStartStackHeight;
-		solAssert(deposit == 0, "Invalid stack height at end of block.");
-	}
-
-public:
-	void operator()(assembly::Instruction const& _instruction)
-	{
-		m_assembly.setSourceLocation(_instruction.location);
-		m_assembly.appendInstruction(_instruction.instruction);
-		checkStackHeight(&_instruction);
-	}
-	void operator()(assembly::Literal const& _literal)
-	{
-		m_assembly.setSourceLocation(_literal.location);
-		if (_literal.kind == assembly::LiteralKind::Number)
-			m_assembly.appendConstant(u256(_literal.value));
-		else if (_literal.kind == assembly::LiteralKind::Boolean)
-		{
-			if (_literal.value == "true")
-				m_assembly.appendConstant(u256(1));
-			else
-				m_assembly.appendConstant(u256(0));
-		}
-		else
-		{
-			solAssert(_literal.value.size() <= 32, "");
-			m_assembly.appendConstant(u256(h256(_literal.value, h256::FromBinary, h256::AlignLeft)));
-		}
-		checkStackHeight(&_literal);
-	}
-	void operator()(assembly::Identifier const& _identifier)
-	{
-		m_assembly.setSourceLocation(_identifier.location);
-		// First search internals, then externals.
-		if (m_scope.lookup(_identifier.name, Scope::NonconstVisitor(
-			[=](Scope::Variable& _var)
-			{
-				if (int heightDiff = variableHeightDiff(_var, _identifier.location, false))
-					m_assembly.appendInstruction(solidity::dupInstruction(heightDiff));
-				else
-					// Store something to balance the stack
-					m_assembly.appendConstant(u256(0));
-			},
-			[=](Scope::Label& _label)
-			{
-				assignLabelIdIfUnset(_label);
-				m_assembly.appendLabelReference(*_label.id);
-			},
-			[=](Scope::Function&)
-			{
-				solAssert(false, "Function not removed during desugaring.");
-			}
-		)))
-		{
-			return;
-		}
-		solAssert(
-			m_identifierAccess.generateCode,
-			"Identifier not found and no external access available."
-		);
-		m_identifierAccess.generateCode(_identifier, IdentifierContext::RValue, m_assembly);
-		checkStackHeight(&_identifier);
-	}
-	void operator()(FunctionalInstruction const& _instr)
-	{
-		for (auto it = _instr.arguments.rbegin(); it != _instr.arguments.rend(); ++it)
-		{
-			int height = m_assembly.stackHeight();
-			boost::apply_visitor(*this, *it);
-			expectDeposit(1, height);
-		}
-		(*this)(_instr.instruction);
-		checkStackHeight(&_instr);
-	}
-	void operator()(assembly::FunctionCall const&)
-	{
-		solAssert(false, "Function call not removed during desugaring phase.");
-	}
-	void operator()(Label const& _label)
-	{
-		m_assembly.setSourceLocation(_label.location);
-		solAssert(m_scope.identifiers.count(_label.name), "");
-		Scope::Label& label = boost::get<Scope::Label>(m_scope.identifiers.at(_label.name));
-		assignLabelIdIfUnset(label);
-		m_assembly.appendLabel(*label.id);
-		checkStackHeight(&_label);
-	}
-	void operator()(assembly::StackAssignment const& _assignment)
-	{
-		m_assembly.setSourceLocation(_assignment.location);
-		generateAssignment(_assignment.variableName, _assignment.location);
-		checkStackHeight(&_assignment);
-	}
-	void operator()(assembly::Assignment const& _assignment)
-	{
-		int height = m_assembly.stackHeight();
-		boost::apply_visitor(*this, *_assignment.value);
-		expectDeposit(1, height);
-		m_assembly.setSourceLocation(_assignment.location);
-		generateAssignment(_assignment.variableName, _assignment.location);
-		checkStackHeight(&_assignment);
-	}
-	void operator()(assembly::VariableDeclaration const& _varDecl)
-	{
-		int height = m_assembly.stackHeight();
-		int expectedItems = _varDecl.variables.size();
-		boost::apply_visitor(*this, *_varDecl.value);
-		expectDeposit(expectedItems, height);
-		for (auto const& variable: _varDecl.variables)
-		{
-			auto& var = boost::get<Scope::Variable>(m_scope.identifiers.at(variable.name));
-			var.stackHeight = height++;
-			var.active = true;
-		}
-	}
-	void operator()(assembly::Block const& _block)
-	{
-		CodeTransform(m_state, m_assembly, _block, m_identifierAccess, m_initialStackHeight);
-		checkStackHeight(&_block);
-	}
-	void operator()(assembly::Switch const&)
-	{
-		solAssert(false, "Switch not removed during desugaring phase.");
-	}
-	void operator()(assembly::FunctionDefinition const&)
-	{
-		solAssert(false, "Function definition not removed during desugaring phase.");
-	}
-
-private:
-	void generateAssignment(assembly::Identifier const& _variableName, SourceLocation const& _location)
-	{
-		auto var = m_scope.lookup(_variableName.name);
-		if (var)
-		{
-			Scope::Variable const& _var = boost::get<Scope::Variable>(*var);
-			if (int heightDiff = variableHeightDiff(_var, _location, true))
-				m_assembly.appendInstruction(solidity::swapInstruction(heightDiff - 1));
-			m_assembly.appendInstruction(solidity::Instruction::POP);
-		}
-		else
-		{
-			solAssert(
-				m_identifierAccess.generateCode,
-				"Identifier not found and no external access available."
-			);
-			m_identifierAccess.generateCode(_variableName, IdentifierContext::LValue, m_assembly);
-		}
-	}
-
-	/// Determines the stack height difference to the given variables. Automatically generates
-	/// errors if it is not yet in scope or the height difference is too large. Returns 0 on
-	/// errors and the (positive) stack height difference otherwise.
-	int variableHeightDiff(Scope::Variable const& _var, SourceLocation const& _location, bool _forSwap)
-	{
-		int heightDiff = m_assembly.stackHeight() - _var.stackHeight;
-		if (heightDiff <= (_forSwap ? 1 : 0) || heightDiff > (_forSwap ? 17 : 16))
-		{
-			//@TODO move this to analysis phase.
-			m_state.errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Variable inaccessible, too deep inside stack (" + boost::lexical_cast<string>(heightDiff) + ")",
-				_location
-			));
-			return 0;
-		}
-		else
-			return heightDiff;
-	}
-
-	void expectDeposit(int _deposit, int _oldHeight)
-	{
-		solAssert(m_assembly.stackHeight() == _oldHeight + _deposit, "Invalid stack deposit.");
-	}
-
-	void checkStackHeight(void const* _astElement)
-	{
-		solAssert(m_state.info.stackHeightInfo.count(_astElement), "Stack height for AST element not found.");
-		solAssert(
-			m_state.info.stackHeightInfo.at(_astElement) == m_assembly.stackHeight() - m_initialStackHeight,
-			"Stack height mismatch between analysis and code generation phase."
-		);
-	}
-
-	/// Assigns the label's id to a value taken from eth::Assembly if it has not yet been set.
-	void assignLabelIdIfUnset(Scope::Label& _label)
-	{
-		if (!_label.id)
-			_label.id.reset(m_assembly.newLabelId());
-	}
-
-
-	GeneratorState& m_state;
-	julia::AbstractAssembly& m_assembly;
-	Scope& m_scope;
-	ExternalIdentifierAccess m_identifierAccess;
-	int const m_initialStackHeight;
-};
-
 eth::Assembly assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
-- 
cgit v1.2.3


From 261731f7eea48902983c55163d377e26bbca07da Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 23 May 2017 19:21:14 +0200
Subject: Adapt EVM codegen to new namespace.

---
 libsolidity/CMakeLists.txt                         |  4 +-
 libsolidity/analysis/ReferencesResolver.cpp        |  4 +-
 libsolidity/analysis/TypeChecker.cpp               | 10 +--
 libsolidity/codegen/CompilerContext.cpp            | 10 +--
 libsolidity/codegen/ContractCompiler.cpp           |  8 +-
 libsolidity/inlineasm/AsmAnalysis.cpp              |  6 +-
 libsolidity/inlineasm/AsmAnalysis.h                |  4 +-
 libsolidity/inlineasm/AsmCodeGen.cpp               | 22 ++----
 libsolidity/inlineasm/AsmCodeGen.h                 |  4 +-
 libsolidity/inlineasm/AsmStack.cpp                 |  4 +-
 libsolidity/inlineasm/AsmStack.h                   | 23 +-----
 libsolidity/interface/AssemblyStack.cpp            | 85 ++++++++++++++++++++++
 libsolidity/interface/AssemblyStack.h              | 83 +++++++++++++++++++++
 .../interface/MultiBackendAssemblyStack.cpp        | 85 ----------------------
 libsolidity/interface/MultiBackendAssemblyStack.h  | 85 ----------------------
 15 files changed, 205 insertions(+), 232 deletions(-)
 create mode 100644 libsolidity/interface/AssemblyStack.cpp
 create mode 100644 libsolidity/interface/AssemblyStack.h
 delete mode 100644 libsolidity/interface/MultiBackendAssemblyStack.cpp
 delete mode 100644 libsolidity/interface/MultiBackendAssemblyStack.h

(limited to 'libsolidity')

diff --git a/libsolidity/CMakeLists.txt b/libsolidity/CMakeLists.txt
index bcc47e5a..2342f0f9 100644
--- a/libsolidity/CMakeLists.txt
+++ b/libsolidity/CMakeLists.txt
@@ -7,10 +7,12 @@ aux_source_directory(formal SRC_LIST)
 aux_source_directory(interface SRC_LIST)
 aux_source_directory(parsing SRC_LIST)
 aux_source_directory(inlineasm SRC_LIST)
+# Until we have a clear separation, libjulia has to be included here
+aux_source_directory(../libjulia SRC_LIST)
 
 set(EXECUTABLE solidity)
 
-file(GLOB HEADERS "*/*.h") 
+file(GLOB HEADERS "*/*.h" "../libjulia/backends/evm/*")
 
 include_directories(BEFORE ..)
 add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS})
diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp
index 9433976a..83ea17c7 100644
--- a/libsolidity/analysis/ReferencesResolver.cpp
+++ b/libsolidity/analysis/ReferencesResolver.cpp
@@ -166,8 +166,8 @@ bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 	// The only purpose of this step is to fill the inline assembly annotation with
 	// external references.
 	ErrorList errorsIgnored;
-	assembly::ExternalIdentifierAccess::Resolver resolver =
-	[&](assembly::Identifier const& _identifier, assembly::IdentifierContext) {
+	julia::ExternalIdentifierAccess::Resolver resolver =
+	[&](assembly::Identifier const& _identifier, julia::IdentifierContext) {
 		auto declarations = m_resolver.nameFromCurrentScope(_identifier.name);
 		bool isSlot = boost::algorithm::ends_with(_identifier.name, "_slot");
 		bool isOffset = boost::algorithm::ends_with(_identifier.name, "_offset");
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 8161a3a1..ad22cc66 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -631,9 +631,9 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 {
 	// External references have already been resolved in a prior stage and stored in the annotation.
 	// We run the resolve step again regardless.
-	assembly::ExternalIdentifierAccess::Resolver identifierAccess = [&](
+	julia::ExternalIdentifierAccess::Resolver identifierAccess = [&](
 		assembly::Identifier const& _identifier,
-		assembly::IdentifierContext _context
+		julia::IdentifierContext _context
 	)
 	{
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
@@ -650,7 +650,7 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 					typeError(_identifier.location, "The suffixes _offset and _slot can only be used on storage variables.");
 					return size_t(-1);
 				}
-				else if (_context != assembly::IdentifierContext::RValue)
+				else if (_context != julia::IdentifierContext::RValue)
 				{
 					typeError(_identifier.location, "Storage variables cannot be assigned to.");
 					return size_t(-1);
@@ -677,13 +677,13 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 				return size_t(-1);
 			}
 		}
-		else if (_context == assembly::IdentifierContext::LValue)
+		else if (_context == julia::IdentifierContext::LValue)
 		{
 			typeError(_identifier.location, "Only local variables can be assigned to in inline assembly.");
 			return size_t(-1);
 		}
 
-		if (_context == assembly::IdentifierContext::RValue)
+		if (_context == julia::IdentifierContext::RValue)
 		{
 			solAssert(!!declaration->type(), "Type of declaration required but not yet determined.");
 			if (dynamic_cast<FunctionDefinition const*>(declaration))
diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 5c4f88c4..404a3af6 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -266,10 +266,10 @@ void CompilerContext::appendInlineAssembly(
 
 	int startStackHeight = stackHeight();
 
-	assembly::ExternalIdentifierAccess identifierAccess;
+	julia::ExternalIdentifierAccess identifierAccess;
 	identifierAccess.resolve = [&](
 		assembly::Identifier const& _identifier,
-		assembly::IdentifierContext
+		julia::IdentifierContext
 	)
 	{
 		auto it = std::find(_localVariables.begin(), _localVariables.end(), _identifier.name);
@@ -277,7 +277,7 @@ void CompilerContext::appendInlineAssembly(
 	};
 	identifierAccess.generateCode = [&](
 		assembly::Identifier const& _identifier,
-		assembly::IdentifierContext _context,
+		julia::IdentifierContext _context,
 		julia::AbstractAssembly& _assembly
 	)
 	{
@@ -285,14 +285,14 @@ void CompilerContext::appendInlineAssembly(
 		solAssert(it != _localVariables.end(), "");
 		int stackDepth = _localVariables.end() - it;
 		int stackDiff = _assembly.stackHeight() - startStackHeight + stackDepth;
-		if (_context == assembly::IdentifierContext::LValue)
+		if (_context == julia::IdentifierContext::LValue)
 			stackDiff -= 1;
 		if (stackDiff < 1 || stackDiff > 16)
 			BOOST_THROW_EXCEPTION(
 				CompilerError() <<
 				errinfo_comment("Stack too deep (" + to_string(stackDiff) + "), try removing local variables.")
 			);
-		if (_context == assembly::IdentifierContext::RValue)
+		if (_context == julia::IdentifierContext::RValue)
 			_assembly.appendInstruction(dupInstruction(stackDiff));
 		else
 		{
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index 41940e1a..e79bb6dc 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -522,21 +522,21 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 	ErrorList errors;
 	assembly::CodeGenerator codeGen(errors);
 	unsigned startStackHeight = m_context.stackHeight();
-	assembly::ExternalIdentifierAccess identifierAccess;
-	identifierAccess.resolve = [&](assembly::Identifier const& _identifier, assembly::IdentifierContext)
+	julia::ExternalIdentifierAccess identifierAccess;
+	identifierAccess.resolve = [&](assembly::Identifier const& _identifier, julia::IdentifierContext)
 	{
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
 		if (ref == _inlineAssembly.annotation().externalReferences.end())
 			return size_t(-1);
 		return ref->second.valueSize;
 	};
-	identifierAccess.generateCode = [&](assembly::Identifier const& _identifier, assembly::IdentifierContext _context, julia::AbstractAssembly& _assembly)
+	identifierAccess.generateCode = [&](assembly::Identifier const& _identifier, julia::IdentifierContext _context, julia::AbstractAssembly& _assembly)
 	{
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
 		solAssert(ref != _inlineAssembly.annotation().externalReferences.end(), "");
 		Declaration const* decl = ref->second.declaration;
 		solAssert(!!decl, "");
-		if (_context == assembly::IdentifierContext::RValue)
+		if (_context == julia::IdentifierContext::RValue)
 		{
 			int const depositBefore = _assembly.stackHeight();
 			solAssert(!!decl->type(), "Type of declaration required but not yet determined.");
diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index d022ecf6..60caaa1d 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -41,7 +41,7 @@ using namespace dev::solidity::assembly;
 AsmAnalyzer::AsmAnalyzer(
 	AsmAnalysisInfo& _analysisInfo,
 	ErrorList& _errors,
-	ExternalIdentifierAccess::Resolver const& _resolver
+	julia::ExternalIdentifierAccess::Resolver const& _resolver
 ):
 	m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors)
 {
@@ -123,7 +123,7 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 	{
 		size_t stackSize(-1);
 		if (m_resolver)
-			stackSize = m_resolver(_identifier, IdentifierContext::RValue);
+			stackSize = m_resolver(_identifier, julia::IdentifierContext::RValue);
 		if (stackSize == size_t(-1))
 		{
 			// Only add an error message if the callback did not do it.
@@ -393,7 +393,7 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 		variableSize = 1;
 	}
 	else if (m_resolver)
-		variableSize = m_resolver(_variable, IdentifierContext::LValue);
+		variableSize = m_resolver(_variable, julia::IdentifierContext::LValue);
 	if (variableSize == size_t(-1))
 	{
 		// Only add message if the callback did not.
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 9f022b12..613abf38 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -64,7 +64,7 @@ public:
 	AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
 		ErrorList& _errors,
-		ExternalIdentifierAccess::Resolver const& _resolver = ExternalIdentifierAccess::Resolver()
+		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
 	);
 
 	bool analyze(assembly::Block const& _block);
@@ -94,7 +94,7 @@ private:
 	/// we enter the block.
 	int m_virtualVariablesInNextBlock = 0;
 	int m_stackHeight = 0;
-	ExternalIdentifierAccess::Resolver const& m_resolver;
+	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
 	ErrorList& m_errors;
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index ce2d8a1d..6a44faac 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -32,7 +32,8 @@
 #include <libevmasm/SourceLocation.h>
 #include <libevmasm/Instruction.h>
 
-#include <libjulia/backends/AbstractAssembly.h>
+#include <libjulia/backends/evm/AbstractAssembly.h>
+#include <libjulia/backends/evm/EVMCodeTransform.h>
 
 #include <libdevcore/CommonIO.h>
 
@@ -48,15 +49,6 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-struct GeneratorState
-{
-	GeneratorState(ErrorList& _errors, AsmAnalysisInfo& _analysisInfo):
-		errors(_errors), info(_analysisInfo) {}
-
-	ErrorList& errors;
-	AsmAnalysisInfo info;
-};
-
 class EthAssemblyAdapter: public julia::AbstractAssembly
 {
 public:
@@ -110,13 +102,12 @@ private:
 eth::Assembly assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
-	ExternalIdentifierAccess const& _identifierAccess
+	julia::ExternalIdentifierAccess const& _identifierAccess
 )
 {
 	eth::Assembly assembly;
-	GeneratorState state(m_errors, _analysisInfo);
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
+	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 	return assembly;
 }
 
@@ -124,10 +115,9 @@ void assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
 	eth::Assembly& _assembly,
-	ExternalIdentifierAccess const& _identifierAccess
+	julia::ExternalIdentifierAccess const& _identifierAccess
 )
 {
-	GeneratorState state(m_errors, _analysisInfo);
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	CodeTransform(state, assemblyAdapter, _parsedData, _identifierAccess);
+	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index e830e047..1b43d2f6 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -48,14 +48,14 @@ public:
 	eth::Assembly assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
-		ExternalIdentifierAccess const& _identifierAccess = ExternalIdentifierAccess()
+		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 	/// Performs code generation and appends generated to to _assembly.
 	void assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
 		eth::Assembly& _assembly,
-		ExternalIdentifierAccess const& _identifierAccess = ExternalIdentifierAccess()
+		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 
 private:
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index c2a7d8ea..2e63465f 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -42,7 +42,7 @@ using namespace dev::solidity::assembly;
 
 bool InlineAssemblyStack::parse(
 	shared_ptr<Scanner> const& _scanner,
-	ExternalIdentifierAccess::Resolver const& _resolver
+	julia::ExternalIdentifierAccess::Resolver const& _resolver
 )
 {
 	m_parserResult = make_shared<Block>();
@@ -73,7 +73,7 @@ eth::Assembly InlineAssemblyStack::assemble()
 bool InlineAssemblyStack::parseAndAssemble(
 	string const& _input,
 	eth::Assembly& _assembly,
-	ExternalIdentifierAccess const& _identifierAccess
+	julia::ExternalIdentifierAccess const& _identifierAccess
 )
 {
 	ErrorList errors;
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
index e223ccc9..23072a88 100644
--- a/libsolidity/inlineasm/AsmStack.h
+++ b/libsolidity/inlineasm/AsmStack.h
@@ -24,7 +24,7 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
-#include <libjulia/backends/AbstractAssembly.h>
+#include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <string>
 #include <functional>
@@ -43,23 +43,6 @@ namespace assembly
 struct Block;
 struct Identifier;
 
-enum class IdentifierContext { LValue, RValue };
-
-/// Object that is used to resolve references and generate code for access to identifiers external
-/// to inline assembly (not used in standalone assembly mode).
-struct ExternalIdentifierAccess
-{
-	using Resolver = std::function<size_t(assembly::Identifier const&, IdentifierContext)>;
-	/// Resolve a an external reference given by the identifier in the given context.
-	/// @returns the size of the value (number of stack slots) or size_t(-1) if not found.
-	Resolver resolve;
-	using CodeGenerator = std::function<void(assembly::Identifier const&, IdentifierContext, julia::AbstractAssembly&)>;
-	/// Generate code for retrieving the value (rvalue context) or storing the value (lvalue context)
-	/// of an identifier. The code should be appended to the assembly. In rvalue context, the value is supposed
-	/// to be put onto the stack, in lvalue context, the value is assumed to be at the top of the stack.
-	CodeGenerator generateCode;
-};
-
 class InlineAssemblyStack
 {
 public:
@@ -67,7 +50,7 @@ public:
 	/// @return false or error.
 	bool parse(
 		std::shared_ptr<Scanner> const& _scanner,
-		ExternalIdentifierAccess::Resolver const& _externalIdentifierResolver = ExternalIdentifierAccess::Resolver()
+		julia::ExternalIdentifierAccess::Resolver const& _externalIdentifierResolver = julia::ExternalIdentifierAccess::Resolver()
 	);
 	/// Converts the parser result back into a string form (not necessarily the same form
 	/// as the source form, but it should parse into the same parsed form again).
@@ -79,7 +62,7 @@ public:
 	bool parseAndAssemble(
 		std::string const& _input,
 		eth::Assembly& _assembly,
-		ExternalIdentifierAccess const& _identifierAccess = ExternalIdentifierAccess()
+		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 
 	ErrorList const& errors() const { return m_errors; }
diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
new file mode 100644
index 00000000..c4bd63c4
--- /dev/null
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -0,0 +1,85 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
+ * eWasm as output.
+ */
+
+
+#include <libsolidity/interface/AssemblyStack.h>
+
+#include <libsolidity/parsing/Scanner.h>
+#include <libsolidity/inlineasm/AsmPrinter.h>
+#include <libsolidity/inlineasm/AsmParser.h>
+#include <libsolidity/inlineasm/AsmAnalysis.h>
+#include <libsolidity/inlineasm/AsmCodeGen.h>
+
+#include <libevmasm/Assembly.h>
+
+using namespace std;
+using namespace dev;
+using namespace dev::solidity;
+
+
+Scanner const& AssemblyStack::scanner() const
+{
+	solAssert(m_scanner, "");
+	return *m_scanner;
+}
+
+bool AssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string const& _source)
+{
+	m_analysisSuccessful = false;
+	m_scanner = make_shared<Scanner>(CharStream(_source), _sourceName);
+	m_parserResult = assembly::Parser(m_errors, m_language == Language::JULIA).parse(m_scanner);
+	if (!m_errors.empty())
+		return false;
+	solAssert(m_parserResult, "");
+
+	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
+	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errors);
+	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
+	return m_analysisSuccessful;
+}
+
+eth::LinkerObject AssemblyStack::assemble(Machine _machine)
+{
+	solAssert(m_analysisSuccessful, "");
+	solAssert(m_parserResult, "");
+	solAssert(m_analysisInfo, "");
+
+	switch (_machine)
+	{
+	case Machine::EVM:
+	{
+		auto assembly = assembly::CodeGenerator(m_errors).assemble(*m_parserResult, *m_analysisInfo);
+		return assembly.assemble();
+	}
+	case Machine::EVM15:
+		solUnimplemented("EVM 1.5 backend is not yet implemented.");
+	case Machine::eWasm:
+		solUnimplemented("eWasm backend is not yet implemented.");
+	}
+	// unreachable
+	return eth::LinkerObject();
+}
+
+string AssemblyStack::print()
+{
+	solAssert(m_parserResult, "");
+	return assembly::AsmPrinter(m_language == Language::JULIA)(*m_parserResult);
+}
diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
new file mode 100644
index 00000000..4aba4846
--- /dev/null
+++ b/libsolidity/interface/AssemblyStack.h
@@ -0,0 +1,83 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
+ * eWasm as output.
+ */
+
+#pragma once
+
+#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
+#include <libevmasm/LinkerObject.h>
+
+#include <string>
+#include <memory>
+
+namespace dev
+{
+namespace solidity
+{
+class Scanner;
+namespace assembly
+{
+struct AsmAnalysisInfo;
+struct Block;
+}
+
+/*
+ * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
+ * eWasm as output.
+ */
+class AssemblyStack
+{
+public:
+	enum class Language { JULIA, Assembly };
+	enum class Machine { EVM, EVM15, eWasm };
+
+	explicit AssemblyStack(Language _language = Language::Assembly):
+		m_language(_language)
+	{}
+
+	/// @returns the scanner used during parsing
+	Scanner const& scanner() const;
+
+	/// Runs parsing and analysis steps, returns false if input cannot be assembled.
+	bool parseAndAnalyze(std::string const& _sourceName, std::string const& _source);
+
+	/// Run the assembly step (should only be called after parseAndAnalyze).
+	eth::LinkerObject assemble(Machine _machine);
+
+	ErrorList const& errors() const { return m_errors; }
+
+	/// Pretty-print the input after having parsed it.
+	std::string print();
+
+private:
+
+	Language m_language = Language::Assembly;
+
+	std::shared_ptr<Scanner> m_scanner;
+
+	bool m_analysisSuccessful = false;
+	std::shared_ptr<assembly::Block> m_parserResult;
+	std::shared_ptr<assembly::AsmAnalysisInfo> m_analysisInfo;
+	ErrorList m_errors;
+};
+
+}
+}
diff --git a/libsolidity/interface/MultiBackendAssemblyStack.cpp b/libsolidity/interface/MultiBackendAssemblyStack.cpp
deleted file mode 100644
index cf16b627..00000000
--- a/libsolidity/interface/MultiBackendAssemblyStack.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
- * eWasm as output.
- */
-
-
-#include <libsolidity/interface/MultiBackendAssemblyStack.h>
-
-#include <libsolidity/parsing/Scanner.h>
-#include <libsolidity/inlineasm/AsmPrinter.h>
-#include <libsolidity/inlineasm/AsmParser.h>
-#include <libsolidity/inlineasm/AsmAnalysis.h>
-#include <libsolidity/inlineasm/AsmCodeGen.h>
-
-#include <libevmasm/Assembly.h>
-
-using namespace std;
-using namespace dev;
-using namespace dev::solidity;
-
-
-Scanner const& MultiBackendAssemblyStack::scanner() const
-{
-	solAssert(m_scanner, "");
-	return *m_scanner;
-}
-
-bool MultiBackendAssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string const& _source)
-{
-	m_analysisSuccessful = false;
-	m_scanner = make_shared<Scanner>(CharStream(_source), _sourceName);
-	m_parserResult = assembly::Parser(m_errors, m_input == Input::JULIA).parse(m_scanner);
-	if (!m_errors.empty())
-		return false;
-	solAssert(m_parserResult, "");
-
-	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
-	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errors);
-	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
-	return m_analysisSuccessful;
-}
-
-eth::LinkerObject MultiBackendAssemblyStack::assemble()
-{
-	solAssert(m_analysisSuccessful, "");
-	solAssert(m_parserResult, "");
-	solAssert(m_analysisInfo, "");
-
-	switch (m_targetMachine)
-	{
-	case Machine::EVM:
-	{
-		auto assembly = assembly::CodeGenerator(m_errors).assemble(*m_parserResult, *m_analysisInfo);
-		return assembly.assemble();
-	}
-	case Machine::EVM15:
-		solUnimplemented("EVM 1.5 backend is not yet implemented.");
-	case Machine::eWasm:
-		solUnimplemented("eWasm backend is not yet implemented.");
-	}
-	// unreachable
-	return eth::LinkerObject();
-}
-
-string MultiBackendAssemblyStack::print()
-{
-	solAssert(m_parserResult, "");
-	return assembly::AsmPrinter(m_input == Input::JULIA)(*m_parserResult);
-}
diff --git a/libsolidity/interface/MultiBackendAssemblyStack.h b/libsolidity/interface/MultiBackendAssemblyStack.h
deleted file mode 100644
index fed9e8f9..00000000
--- a/libsolidity/interface/MultiBackendAssemblyStack.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
- * eWasm as output.
- */
-
-#pragma once
-
-#include <libsolidity/interface/Exceptions.h>
-#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
-#include <libevmasm/LinkerObject.h>
-
-#include <string>
-#include <memory>
-
-namespace dev
-{
-namespace solidity
-{
-class Scanner;
-namespace assembly
-{
-struct AsmAnalysisInfo;
-struct Block;
-}
-
-/*
- * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
- * eWasm as output.
- */
-class MultiBackendAssemblyStack
-{
-public:
-	enum class Input { JULIA, Assembly };
-	enum class Machine { EVM, EVM15, eWasm };
-
-	MultiBackendAssemblyStack(Input _input = Input::Assembly, Machine _targetMachine = Machine::EVM):
-		m_input(_input),
-		m_targetMachine(_targetMachine)
-	{}
-
-	/// @returns the scanner used during parsing
-	Scanner const& scanner() const;
-
-	/// Runs parsing and analysis steps, returns false if input cannot be assembled.
-	bool parseAndAnalyze(std::string const& _sourceName, std::string const& _source);
-
-	/// Run the assembly step (should only be called after parseAndAnalyze).
-	eth::LinkerObject assemble();
-
-	ErrorList const& errors() const { return m_errors; }
-
-	/// Pretty-print the input after having parsed it.
-	std::string print();
-
-private:
-
-	Input m_input = Input::Assembly;
-	Machine m_targetMachine = Machine::EVM;
-
-	std::shared_ptr<Scanner> m_scanner;
-
-	bool m_analysisSuccessful = false;
-	std::shared_ptr<assembly::Block> m_parserResult;
-	std::shared_ptr<assembly::AsmAnalysisInfo> m_analysisInfo;
-	ErrorList m_errors;
-};
-
-}
-}
-- 
cgit v1.2.3


From fe32531a16322c9528c34cfbd32924b4c24a1f13 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 26 May 2017 14:59:41 +0200
Subject: More comments for assembly

---
 libsolidity/interface/AssemblyStack.h | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
index 4aba4846..40662ac3 100644
--- a/libsolidity/interface/AssemblyStack.h
+++ b/libsolidity/interface/AssemblyStack.h
@@ -57,11 +57,13 @@ public:
 	Scanner const& scanner() const;
 
 	/// Runs parsing and analysis steps, returns false if input cannot be assembled.
+	/// Multiple calls overwrite the previous state.
 	bool parseAndAnalyze(std::string const& _sourceName, std::string const& _source);
 
 	/// Run the assembly step (should only be called after parseAndAnalyze).
 	eth::LinkerObject assemble(Machine _machine);
 
+	/// @returns the errors generated during parsing, analysis (and potentially assembly).
 	ErrorList const& errors() const { return m_errors; }
 
 	/// Pretty-print the input after having parsed it.
-- 
cgit v1.2.3


From dda497ca027f5dcd47c6e2b8d624b327c4478adc Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 00:19:11 +0100
Subject: Move constructor to AsmAnalyzer header

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 9 ---------
 libsolidity/inlineasm/AsmAnalysis.h   | 4 ++--
 2 files changed, 2 insertions(+), 11 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 60caaa1d..742d2c1a 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -38,15 +38,6 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-AsmAnalyzer::AsmAnalyzer(
-	AsmAnalysisInfo& _analysisInfo,
-	ErrorList& _errors,
-	julia::ExternalIdentifierAccess::Resolver const& _resolver
-):
-	m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors)
-{
-}
-
 bool AsmAnalyzer::analyze(Block const& _block)
 {
 	if (!(ScopeFiller(m_info.scopes, m_errors))(_block))
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 613abf38..da4b7608 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -61,11 +61,11 @@ struct AsmAnalysisInfo;
 class AsmAnalyzer: public boost::static_visitor<bool>
 {
 public:
-	AsmAnalyzer(
+	explicit AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
 		ErrorList& _errors,
 		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
-	);
+	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors) {}
 
 	bool analyze(assembly::Block const& _block);
 
-- 
cgit v1.2.3


From 3b75c5b45fdb1bfb49b4e157e031154c57b475f3 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 00:27:48 +0100
Subject: Validate that only basic types are used in Julia

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 20 ++++++++++++++++++++
 libsolidity/inlineasm/AsmAnalysis.h   |  1 +
 2 files changed, 21 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 742d2c1a..ca50fdbe 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -62,6 +62,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 
 bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 {
+	expectValidType(_literal.type, _literal.location);
 	++m_stackHeight;
 	if (_literal.kind == assembly::LiteralKind::String && _literal.value.size() > 32)
 	{
@@ -186,7 +187,10 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	}
 
 	for (auto const& variable: _varDecl.variables)
+	{
+		expectValidType(variable.type, variable.location);
 		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
+	}
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
 	return success;
 }
@@ -195,7 +199,10 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 {
 	Scope& bodyScope = scope(&_funDef.body);
 	for (auto const& var: _funDef.arguments + _funDef.returns)
+	{
+		expectValidType(var.type, var.location);
 		boost::get<Scope::Variable>(bodyScope.identifiers.at(var.name)).active = true;
+	}
 
 	int const stackHeight = m_stackHeight;
 	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
@@ -444,3 +451,16 @@ Scope& AsmAnalyzer::scope(Block const* _block)
 	solAssert(scopePtr, "Scope requested but not present.");
 	return *scopePtr;
 }
+
+void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _location)
+{
+//	if (!m_julia)
+//		return;
+
+	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
+		m_errors.push_back(make_shared<Error>(
+			Error::Type::TypeError,
+			"User defined types (\"" + type + "\") are not supported yet.",
+			_location
+		));
+}
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index da4b7608..8244df84 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -88,6 +88,7 @@ private:
 	bool checkAssignment(assembly::Identifier const& _assignment, size_t _valueSize = size_t(-1));
 	bool expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location);
 	Scope& scope(assembly::Block const* _block);
+	void expectValidType(std::string const& type, SourceLocation const& _location);
 
 	/// This is used when we enter the body of a function definition. There, the parameters
 	/// and return parameters appear as variables which are already on the stack before
-- 
cgit v1.2.3


From 8fe79fe706fd64146ffbf345e0241b7c4357ce43 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 01:59:57 +0100
Subject: Introduce Julia mode in AsmAnalyzer

---
 libsolidity/analysis/ReferencesResolver.cpp | 2 +-
 libsolidity/analysis/TypeChecker.cpp        | 1 +
 libsolidity/inlineasm/AsmAnalysis.cpp       | 9 ++++++---
 libsolidity/inlineasm/AsmAnalysis.h         | 4 +++-
 libsolidity/inlineasm/AsmStack.cpp          | 4 ++--
 5 files changed, 13 insertions(+), 7 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp
index 83ea17c7..f5fffb57 100644
--- a/libsolidity/analysis/ReferencesResolver.cpp
+++ b/libsolidity/analysis/ReferencesResolver.cpp
@@ -194,7 +194,7 @@ bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 
 	// Will be re-generated later with correct information
 	assembly::AsmAnalysisInfo analysisInfo;
-	assembly::AsmAnalyzer(analysisInfo, errorsIgnored, resolver).analyze(_inlineAssembly.operations());
+	assembly::AsmAnalyzer(analysisInfo, errorsIgnored, false, resolver).analyze(_inlineAssembly.operations());
 	return false;
 }
 
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index ad22cc66..528a23da 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -711,6 +711,7 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 	assembly::AsmAnalyzer analyzer(
 		*_inlineAssembly.annotation().analysisInfo,
 		m_errors,
+		false,
 		identifierAccess
 	);
 	if (!analyzer.analyze(_inlineAssembly.operations()))
diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index ca50fdbe..eb6f8bc0 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -48,12 +48,14 @@ bool AsmAnalyzer::analyze(Block const& _block)
 
 bool AsmAnalyzer::operator()(Label const& _label)
 {
+	solAssert(!m_julia, "");
 	m_info.stackHeightInfo[&_label] = m_stackHeight;
 	return true;
 }
 
 bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 {
+	solAssert(!m_julia, "");
 	auto const& info = instructionInfo(_instruction.instruction);
 	m_stackHeight += info.ret - info.args;
 	m_info.stackHeightInfo[&_instruction] = m_stackHeight;
@@ -135,6 +137,7 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 
 bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 {
+	solAssert(!m_julia, "");
 	bool success = true;
 	for (auto const& arg: _instr.arguments | boost::adaptors::reversed)
 	{
@@ -154,12 +157,12 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 
 bool AsmAnalyzer::operator()(assembly::StackAssignment const& _assignment)
 {
+	solAssert(!m_julia, "");
 	bool success = checkAssignment(_assignment.variableName, size_t(-1));
 	m_info.stackHeightInfo[&_assignment] = m_stackHeight;
 	return success;
 }
 
-
 bool AsmAnalyzer::operator()(assembly::Assignment const& _assignment)
 {
 	int const stackHeight = m_stackHeight;
@@ -454,8 +457,8 @@ Scope& AsmAnalyzer::scope(Block const* _block)
 
 void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _location)
 {
-//	if (!m_julia)
-//		return;
+	if (!m_julia)
+		return;
 
 	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
 		m_errors.push_back(make_shared<Error>(
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 8244df84..87d41e11 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -64,8 +64,9 @@ public:
 	explicit AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
 		ErrorList& _errors,
+		bool _julia = false,
 		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
-	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors) {}
+	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors), m_julia(_julia) {}
 
 	bool analyze(assembly::Block const& _block);
 
@@ -99,6 +100,7 @@ private:
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
 	ErrorList& m_errors;
+	bool m_julia = false;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index 2e63465f..fe443c08 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -53,7 +53,7 @@ bool InlineAssemblyStack::parse(
 
 	*m_parserResult = std::move(*result);
 	AsmAnalysisInfo analysisInfo;
-	return (AsmAnalyzer(analysisInfo, m_errors, _resolver)).analyze(*m_parserResult);
+	return (AsmAnalyzer(analysisInfo, m_errors, false, _resolver)).analyze(*m_parserResult);
 }
 
 string InlineAssemblyStack::toString()
@@ -84,7 +84,7 @@ bool InlineAssemblyStack::parseAndAssemble(
 	solAssert(parserResult, "");
 
 	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, errors, _identifierAccess.resolve);
+	AsmAnalyzer analyzer(analysisInfo, errors, false, _identifierAccess.resolve);
 	solAssert(analyzer.analyze(*parserResult), "");
 	CodeGenerator(errors).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
 
-- 
cgit v1.2.3


From efadf7e41f73b83f3a7793562cc26f3e92b0211d Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 20:42:17 +0100
Subject: Change error message for invalid type

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index eb6f8bc0..24eddf05 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -463,7 +463,7 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::TypeError,
-			"User defined types (\"" + type + "\") are not supported yet.",
+			"\"" + type + "\" is not a valid type (user defined types are not yet supported).",
 			_location
 		));
 }
-- 
cgit v1.2.3


From 2a50e869d060bd42faae9003fa563398ba8b79c1 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 20:43:28 +0100
Subject: Move builtin type list to the top

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 24eddf05..eeb7d0a6 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -38,6 +38,12 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
+namespace {
+
+set<string> const builtinTypes{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"};
+
+}
+
 bool AsmAnalyzer::analyze(Block const& _block)
 {
 	if (!(ScopeFiller(m_info.scopes, m_errors))(_block))
@@ -460,7 +466,7 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 	if (!m_julia)
 		return;
 
-	if (!(set<string>{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "u128", "s128", "u256", "s256"}).count(type))
+	if (!builtinTypes.count(type))
 		m_errors.push_back(make_shared<Error>(
 			Error::Type::TypeError,
 			"\"" + type + "\" is not a valid type (user defined types are not yet supported).",
-- 
cgit v1.2.3


From 2fefe3b5497172a16094014b66e148b707bc7492 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 22:55:29 +0100
Subject: Move Solidity specific methods from ParserBase to the Solidity Parser

---
 libsolidity/parsing/Parser.cpp     | 56 ++++++++++++++++++++++++++++++++++++++
 libsolidity/parsing/Parser.h       |  4 +++
 libsolidity/parsing/ParserBase.cpp | 56 --------------------------------------
 libsolidity/parsing/ParserBase.h   |  4 ---
 4 files changed, 60 insertions(+), 60 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 72150a3e..470586cf 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -1437,5 +1437,61 @@ ASTPointer<ParameterList> Parser::createEmptyParameterList()
 	return nodeFactory.createNode<ParameterList>(vector<ASTPointer<VariableDeclaration>>());
 }
 
+Token::Value Parser::expectAssignmentOperator()
+{
+	Token::Value op = m_scanner->currentToken();
+	if (!Token::isAssignmentOp(op))
+	{
+		if (Token::isElementaryTypeName(op)) //for the sake of accuracy in reporting
+		{
+			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
+			fatalParserError(
+				string("Expected assignment operator,  got '") +
+				elemTypeName.toString() +
+				string("'")
+			);
+		}
+		else
+			fatalParserError(
+				string("Expected assignment operator,  got '") +
+				string(Token::name(m_scanner->currentToken())) +
+				string("'")
+			);
+	}
+	m_scanner->next();
+	return op;
+}
+
+ASTPointer<ASTString> Parser::expectIdentifierToken()
+{
+	Token::Value id = m_scanner->currentToken();
+	if (id != Token::Identifier)
+	{
+		if (Token::isElementaryTypeName(id)) //for the sake of accuracy in reporting
+		{
+			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
+			fatalParserError(
+				string("Expected identifier, got '") +
+				elemTypeName.toString() +
+				string("'")
+			);
+		}
+		else
+			fatalParserError(
+				string("Expected identifier, got '") +
+				string(Token::name(id)) +
+				string("'")
+			);
+	}
+	return getLiteralAndAdvance();
+}
+
+ASTPointer<ASTString> Parser::getLiteralAndAdvance()
+{
+	ASTPointer<ASTString> identifier = make_shared<ASTString>(m_scanner->currentLiteral());
+	m_scanner->next();
+	return identifier;
+}
+
 }
 }
diff --git a/libsolidity/parsing/Parser.h b/libsolidity/parsing/Parser.h
index 282617ab..05e99566 100644
--- a/libsolidity/parsing/Parser.h
+++ b/libsolidity/parsing/Parser.h
@@ -154,6 +154,10 @@ private:
 		std::vector<ASTPointer<PrimaryExpression>> const& _path,
 		std::vector<std::pair<ASTPointer<Expression>, SourceLocation>> const& _indices
 	);
+
+	Token::Value expectAssignmentOperator();
+	ASTPointer<ASTString> expectIdentifierToken();
+	ASTPointer<ASTString> getLiteralAndAdvance();
 	///@}
 
 	/// Creates an empty ParameterList at the current location (used if parameters can be omitted).
diff --git a/libsolidity/parsing/ParserBase.cpp b/libsolidity/parsing/ParserBase.cpp
index 87d47f4b..ac103bda 100644
--- a/libsolidity/parsing/ParserBase.cpp
+++ b/libsolidity/parsing/ParserBase.cpp
@@ -80,62 +80,6 @@ void ParserBase::expectToken(Token::Value _value)
 	m_scanner->next();
 }
 
-Token::Value ParserBase::expectAssignmentOperator()
-{
-	Token::Value op = m_scanner->currentToken();
-	if (!Token::isAssignmentOp(op))
-	{
-		if (Token::isElementaryTypeName(op)) //for the sake of accuracy in reporting
-		{
-			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
-			fatalParserError(
-				string("Expected assignment operator,  got '") +
-				elemTypeName.toString() +
-				string("'")
-			);
-		}
-		else
-			fatalParserError(
-				string("Expected assignment operator,  got '") +
-				string(Token::name(m_scanner->currentToken())) +
-				string("'")
-			);
-	}
-	m_scanner->next();
-	return op;
-}
-
-ASTPointer<ASTString> ParserBase::expectIdentifierToken()
-{
-	Token::Value id = m_scanner->currentToken();
-	if (id != Token::Identifier)
-	{
-		if (Token::isElementaryTypeName(id)) //for the sake of accuracy in reporting
-		{
-			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
-			fatalParserError(
-				string("Expected identifier, got '") +
-				elemTypeName.toString() +
-				string("'")
-			);
-		}
-		else
-			fatalParserError(
-				string("Expected identifier, got '") +
-				string(Token::name(id)) +
-				string("'")
-			);
-	}
-	return getLiteralAndAdvance();
-}
-
-ASTPointer<ASTString> ParserBase::getLiteralAndAdvance()
-{
-	ASTPointer<ASTString> identifier = make_shared<ASTString>(m_scanner->currentLiteral());
-	m_scanner->next();
-	return identifier;
-}
-
 void ParserBase::parserError(string const& _description)
 {
 	auto err = make_shared<Error>(Error::Type::ParserError);
diff --git a/libsolidity/parsing/ParserBase.h b/libsolidity/parsing/ParserBase.h
index dfb7cab7..768b3bbf 100644
--- a/libsolidity/parsing/ParserBase.h
+++ b/libsolidity/parsing/ParserBase.h
@@ -25,7 +25,6 @@
 #include <memory>
 #include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/parsing/Token.h>
-#include <libsolidity/ast/ASTForward.h>
 
 namespace dev
 {
@@ -52,9 +51,6 @@ protected:
 	///@name Helper functions
 	/// If current token value is not _value, throw exception otherwise advance token.
 	void expectToken(Token::Value _value);
-	Token::Value expectAssignmentOperator();
-	ASTPointer<ASTString> expectIdentifierToken();
-	ASTPointer<ASTString> getLiteralAndAdvance();
 	///@}
 
 	/// Creates a @ref ParserError and annotates it with the current position and the
-- 
cgit v1.2.3


From 3459052ae83ac08082855d41e21c297ac5f852b5 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 23:03:15 +0100
Subject: Add scanner helpers to ParserBase

---
 libsolidity/parsing/ParserBase.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/ParserBase.h b/libsolidity/parsing/ParserBase.h
index 768b3bbf..18b39a5e 100644
--- a/libsolidity/parsing/ParserBase.h
+++ b/libsolidity/parsing/ParserBase.h
@@ -24,6 +24,7 @@
 
 #include <memory>
 #include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/parsing/Scanner.h>
 #include <libsolidity/parsing/Token.h>
 
 namespace dev
@@ -46,11 +47,14 @@ protected:
 	/// End position of the current token
 	int endPosition() const;
 
-
 	///@{
 	///@name Helper functions
 	/// If current token value is not _value, throw exception otherwise advance token.
 	void expectToken(Token::Value _value);
+	Token::Value currentToken() const { return m_scanner->currentToken(); }
+	Token::Value peekNextToken() const { return m_scanner->peekNextToken(); }
+	std::string currentLiteral() const { return m_scanner->currentLiteral(); }
+	Token::Value advance() { return m_scanner->next(); }
 	///@}
 
 	/// Creates a @ref ParserError and annotates it with the current position and the
-- 
cgit v1.2.3


From 9337003d5e623cd52c55001222b629543c859cd7 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 25 May 2017 00:13:51 +0100
Subject: Use the new ParserBase API in AsmParser

---
 libsolidity/inlineasm/AsmParser.cpp | 66 ++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 605d27be..80409c63 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -50,16 +50,16 @@ assembly::Block Parser::parseBlock()
 {
 	assembly::Block block = createWithLocation<Block>();
 	expectToken(Token::LBrace);
-	while (m_scanner->currentToken() != Token::RBrace)
+	while (currentToken() != Token::RBrace)
 		block.statements.emplace_back(parseStatement());
 	block.location.end = endPosition();
-	m_scanner->next();
+	advance();
 	return block;
 }
 
 assembly::Statement Parser::parseStatement()
 {
-	switch (m_scanner->currentToken())
+	switch (currentToken())
 	{
 	case Token::Let:
 		return parseVariableDeclaration();
@@ -92,10 +92,10 @@ assembly::Statement Parser::parseStatement()
 		if (m_julia)
 			break;
 		assembly::StackAssignment assignment = createWithLocation<assembly::StackAssignment>();
-		m_scanner->next();
+		advance();
 		expectToken(Token::Colon);
 		assignment.variableName.location = location();
-		assignment.variableName.name = m_scanner->currentLiteral();
+		assignment.variableName.name = currentLiteral();
 		if (!m_julia && instructions().count(assignment.variableName.name))
 			fatalParserError("Identifier expected, got instruction name.");
 		assignment.location.end = endPosition();
@@ -110,7 +110,7 @@ assembly::Statement Parser::parseStatement()
 	// literal,
 	// identifier (might turn into label or functional assignment)
 	Statement statement(parseElementaryOperation(false));
-	switch (m_scanner->currentToken())
+	switch (currentToken())
 	{
 	case Token::LParen:
 		return parseCall(std::move(statement));
@@ -119,15 +119,15 @@ assembly::Statement Parser::parseStatement()
 		if (statement.type() != typeid(assembly::Identifier))
 			fatalParserError("Label name / variable name must precede \":\".");
 		assembly::Identifier const& identifier = boost::get<assembly::Identifier>(statement);
-		m_scanner->next();
+		advance();
 		// identifier:=: should be parsed as identifier: =: (i.e. a label),
 		// while identifier:= (being followed by a non-colon) as identifier := (assignment).
-		if (m_scanner->currentToken() == Token::Assign && m_scanner->peekNextToken() != Token::Colon)
+		if (currentToken() == Token::Assign && peekNextToken() != Token::Colon)
 		{
 			assembly::Assignment assignment = createWithLocation<assembly::Assignment>(identifier.location);
 			if (!m_julia && instructions().count(identifier.name))
 				fatalParserError("Cannot use instruction names for identifier names.");
-			m_scanner->next();
+			advance();
 			assignment.variableName = identifier;
 			assignment.value.reset(new Statement(parseExpression()));
 			assignment.location.end = locationOf(*assignment.value).end;
@@ -174,7 +174,7 @@ assembly::Case Parser::parseCase()
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
-	if (m_scanner->currentToken() == Token::LParen)
+	if (currentToken() == Token::LParen)
 		return parseCall(std::move(operation));
 	else
 		return operation;
@@ -207,7 +207,7 @@ std::map<string, dev::solidity::Instruction> const& Parser::instructions()
 assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 {
 	Statement ret;
-	switch (m_scanner->currentToken())
+	switch (currentToken())
 	{
 	case Token::Identifier:
 	case Token::Return:
@@ -215,14 +215,14 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 	case Token::Address:
 	{
 		string literal;
-		if (m_scanner->currentToken() == Token::Return)
+		if (currentToken() == Token::Return)
 			literal = "return";
-		else if (m_scanner->currentToken() == Token::Byte)
+		else if (currentToken() == Token::Byte)
 			literal = "byte";
-		else if (m_scanner->currentToken() == Token::Address)
+		else if (currentToken() == Token::Address)
 			literal = "address";
 		else
-			literal = m_scanner->currentLiteral();
+			literal = currentLiteral();
 		// first search the set of instructions.
 		if (!m_julia && instructions().count(literal))
 		{
@@ -237,7 +237,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		}
 		else
 			ret = Identifier{location(), literal};
-		m_scanner->next();
+		advance();
 		break;
 	}
 	case Token::StringLiteral:
@@ -246,7 +246,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 	case Token::FalseLiteral:
 	{
 		LiteralKind kind = LiteralKind::Number;
-		switch (m_scanner->currentToken())
+		switch (currentToken())
 		{
 		case Token::StringLiteral:
 			kind = LiteralKind::String;
@@ -265,10 +265,10 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 		Literal literal{
 			location(),
 			kind,
-			m_scanner->currentLiteral(),
+			currentLiteral(),
 			""
 		};
-		m_scanner->next();
+		advance();
 		if (m_julia)
 		{
 			expectToken(Token::Colon);
@@ -297,7 +297,7 @@ assembly::VariableDeclaration Parser::parseVariableDeclaration()
 	while (true)
 	{
 		varDecl.variables.emplace_back(parseTypedName());
-		if (m_scanner->currentToken() == Token::Comma)
+		if (currentToken() == Token::Comma)
 			expectToken(Token::Comma);
 		else
 			break;
@@ -315,22 +315,22 @@ assembly::FunctionDefinition Parser::parseFunctionDefinition()
 	expectToken(Token::Function);
 	funDef.name = expectAsmIdentifier();
 	expectToken(Token::LParen);
-	while (m_scanner->currentToken() != Token::RParen)
+	while (currentToken() != Token::RParen)
 	{
 		funDef.arguments.emplace_back(parseTypedName());
-		if (m_scanner->currentToken() == Token::RParen)
+		if (currentToken() == Token::RParen)
 			break;
 		expectToken(Token::Comma);
 	}
 	expectToken(Token::RParen);
-	if (m_scanner->currentToken() == Token::Sub)
+	if (currentToken() == Token::Sub)
 	{
 		expectToken(Token::Sub);
 		expectToken(Token::GreaterThan);
 		while (true)
 		{
 			funDef.returns.emplace_back(parseTypedName());
-			if (m_scanner->currentToken() == Token::LBrace)
+			if (currentToken() == Token::LBrace)
 				break;
 			expectToken(Token::Comma);
 		}
@@ -359,7 +359,7 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		for (unsigned i = 0; i < args; ++i)
 		{
 			/// check for premature closing parentheses
-			if (m_scanner->currentToken() == Token::RParen)
+			if (currentToken() == Token::RParen)
 				fatalParserError(string(
 					"Expected expression (" +
 					instrInfo.name +
@@ -371,7 +371,7 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			ret.arguments.emplace_back(parseExpression());
 			if (i != args - 1)
 			{
-				if (m_scanner->currentToken() != Token::Comma)
+				if (currentToken() != Token::Comma)
 					fatalParserError(string(
 						"Expected comma (" +
 						instrInfo.name +
@@ -380,11 +380,11 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 						" arguments)"
 					));
 				else
-					m_scanner->next();
+					advance();
 			}
 		}
 		ret.location.end = endPosition();
-		if (m_scanner->currentToken() == Token::Comma)
+		if (currentToken() == Token::Comma)
 			fatalParserError(
 				string("Expected ')' (" + instrInfo.name + " expects " + boost::lexical_cast<string>(args) + " arguments)")
 			);
@@ -397,10 +397,10 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		ret.functionName = std::move(boost::get<Identifier>(_instruction));
 		ret.location = ret.functionName.location;
 		expectToken(Token::LParen);
-		while (m_scanner->currentToken() != Token::RParen)
+		while (currentToken() != Token::RParen)
 		{
 			ret.arguments.emplace_back(parseExpression());
-			if (m_scanner->currentToken() == Token::RParen)
+			if (currentToken() == Token::RParen)
 				break;
 			expectToken(Token::Comma);
 		}
@@ -433,12 +433,12 @@ TypedName Parser::parseTypedName()
 
 string Parser::expectAsmIdentifier()
 {
-	string name = m_scanner->currentLiteral();
+	string name = currentLiteral();
 	if (m_julia)
 	{
-		if (m_scanner->currentToken() == Token::Bool)
+		if (currentToken() == Token::Bool)
 		{
-			m_scanner->next();
+			advance();
 			return name;
 		}
 	}
-- 
cgit v1.2.3


From 48f58aa3f9b4d8962b2c6f1bd7967b119893a889 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 21:00:08 +0100
Subject: Remove duplicate code

---
 libsolidity/parsing/Parser.cpp | 38 ++++++++++++++++++--------------------
 1 file changed, 18 insertions(+), 20 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 470586cf..dca49360 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -1442,21 +1442,20 @@ Token::Value Parser::expectAssignmentOperator()
 	Token::Value op = m_scanner->currentToken();
 	if (!Token::isAssignmentOp(op))
 	{
+		string tokenName;
 		if (Token::isElementaryTypeName(op)) //for the sake of accuracy in reporting
 		{
 			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
-			fatalParserError(
-				string("Expected assignment operator,  got '") +
-				elemTypeName.toString() +
-				string("'")
-			);
+			tokenName = elemTypeName.toString();
 		}
 		else
-			fatalParserError(
-				string("Expected assignment operator,  got '") +
-				string(Token::name(m_scanner->currentToken())) +
-				string("'")
-			);
+			tokenName = Token::name(m_scanner->currentToken());
+
+		fatalParserError(
+			string("Expected assignment operator,  got '") +
+			tokenName +
+			string("'")
+		);
 	}
 	m_scanner->next();
 	return op;
@@ -1467,21 +1466,20 @@ ASTPointer<ASTString> Parser::expectIdentifierToken()
 	Token::Value id = m_scanner->currentToken();
 	if (id != Token::Identifier)
 	{
+		string tokenName;
 		if (Token::isElementaryTypeName(id)) //for the sake of accuracy in reporting
 		{
 			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
-			fatalParserError(
-				string("Expected identifier, got '") +
-				elemTypeName.toString() +
-				string("'")
-			);
+			tokenName = elemTypeName.toString();
 		}
 		else
-			fatalParserError(
-				string("Expected identifier, got '") +
-				string(Token::name(id)) +
-				string("'")
-			);
+			tokenName = Token::name(id);
+
+		fatalParserError(
+			string("Expected identifier, got '") +
+			tokenName +
+			string("'")
+		);
 	}
 	return getLiteralAndAdvance();
 }
-- 
cgit v1.2.3


From 751c97ca19ed0bb69e67222a1edd61e7d227b30f Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 26 May 2017 21:02:24 +0100
Subject: Pull out common code to a helper

---
 libsolidity/parsing/Parser.cpp | 38 ++++++++++++++------------------------
 libsolidity/parsing/Parser.h   |  1 +
 2 files changed, 15 insertions(+), 24 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index dca49360..5b318b2b 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -1437,26 +1437,27 @@ ASTPointer<ParameterList> Parser::createEmptyParameterList()
 	return nodeFactory.createNode<ParameterList>(vector<ASTPointer<VariableDeclaration>>());
 }
 
+string Parser::currentTokenName()
+{
+	Token::Value token = m_scanner->currentToken();
+	if (Token::isElementaryTypeName(token)) //for the sake of accuracy in reporting
+	{
+		ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
+		return elemTypeName.toString();
+	}
+	else
+		return Token::name(token);
+}
+
 Token::Value Parser::expectAssignmentOperator()
 {
 	Token::Value op = m_scanner->currentToken();
 	if (!Token::isAssignmentOp(op))
-	{
-		string tokenName;
-		if (Token::isElementaryTypeName(op)) //for the sake of accuracy in reporting
-		{
-			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
-			tokenName = elemTypeName.toString();
-		}
-		else
-			tokenName = Token::name(m_scanner->currentToken());
-
 		fatalParserError(
 			string("Expected assignment operator,  got '") +
-			tokenName +
+			currentTokenName() +
 			string("'")
 		);
-	}
 	m_scanner->next();
 	return op;
 }
@@ -1465,22 +1466,11 @@ ASTPointer<ASTString> Parser::expectIdentifierToken()
 {
 	Token::Value id = m_scanner->currentToken();
 	if (id != Token::Identifier)
-	{
-		string tokenName;
-		if (Token::isElementaryTypeName(id)) //for the sake of accuracy in reporting
-		{
-			ElementaryTypeNameToken elemTypeName = m_scanner->currentElementaryTypeNameToken();
-			tokenName = elemTypeName.toString();
-		}
-		else
-			tokenName = Token::name(id);
-
 		fatalParserError(
 			string("Expected identifier, got '") +
-			tokenName +
+			currentTokenName() +
 			string("'")
 		);
-	}
 	return getLiteralAndAdvance();
 }
 
diff --git a/libsolidity/parsing/Parser.h b/libsolidity/parsing/Parser.h
index 05e99566..5ec3dbed 100644
--- a/libsolidity/parsing/Parser.h
+++ b/libsolidity/parsing/Parser.h
@@ -155,6 +155,7 @@ private:
 		std::vector<std::pair<ASTPointer<Expression>, SourceLocation>> const& _indices
 	);
 
+	std::string currentTokenName();
 	Token::Value expectAssignmentOperator();
 	ASTPointer<ASTString> expectIdentifierToken();
 	ASTPointer<ASTString> getLiteralAndAdvance();
-- 
cgit v1.2.3


From 9adff68ecc9fe725670c3752429d18d15379644b Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 24 May 2017 18:34:19 +0200
Subject: Introduce LabelID typedef.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 4 ++--
 libsolidity/inlineasm/AsmScope.h     | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 6a44faac..af3547fd 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -70,12 +70,12 @@ public:
 		m_assembly.append(_constant);
 	}
 	/// Append a label.
-	virtual void appendLabel(size_t _labelId) override
+	virtual void appendLabel(LabelID _labelId) override
 	{
 		m_assembly.append(eth::AssemblyItem(eth::Tag, _labelId));
 	}
 	/// Append a label reference.
-	virtual void appendLabelReference(size_t _labelId) override
+	virtual void appendLabelReference(LabelID _labelId) override
 	{
 		m_assembly.append(eth::AssemblyItem(eth::PushTag, _labelId));
 	}
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 70786dce..498218b4 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -63,6 +63,7 @@ struct GenericVisitor<>: public boost::static_visitor<> {
 struct Scope
 {
 	using JuliaType = std::string;
+	using LabelID = size_t;
 
 	struct Variable
 	{
@@ -76,7 +77,7 @@ struct Scope
 
 	struct Label
 	{
-		boost::optional<size_t> id;
+		boost::optional<LabelID> id;
 	};
 
 	struct Function
-- 
cgit v1.2.3


From 4af55c78ebcacb5cfda1b573253cac6e6824d67a Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 26 May 2017 21:46:02 +0200
Subject: Introduce virtual blocks for function arguments.

---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 15 ++++++++-------
 libsolidity/inlineasm/AsmAnalysis.h      |  4 ----
 libsolidity/inlineasm/AsmAnalysisInfo.h  |  3 +++
 libsolidity/inlineasm/AsmScopeFiller.cpp | 21 ++++++++++++++-------
 libsolidity/inlineasm/AsmScopeFiller.h   |  6 +++---
 5 files changed, 28 insertions(+), 21 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index eeb7d0a6..9f512f87 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -46,7 +46,7 @@ set<string> const builtinTypes{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "
 
 bool AsmAnalyzer::analyze(Block const& _block)
 {
-	if (!(ScopeFiller(m_info.scopes, m_errors))(_block))
+	if (!(ScopeFiller(m_info, m_errors))(_block))
 		return false;
 
 	return (*this)(_block);
@@ -206,16 +206,17 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 
 bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 {
-	Scope& bodyScope = scope(&_funDef.body);
+	Block const* virtualBlock = m_info.virtualBlocks.at(&_funDef).get();
+	solAssert(virtualBlock, "");
+	Scope& varScope = scope(virtualBlock);
 	for (auto const& var: _funDef.arguments + _funDef.returns)
 	{
 		expectValidType(var.type, var.location);
-		boost::get<Scope::Variable>(bodyScope.identifiers.at(var.name)).active = true;
+		boost::get<Scope::Variable>(varScope.identifiers.at(var.name)).active = true;
 	}
 
 	int const stackHeight = m_stackHeight;
 	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
-	m_virtualVariablesInNextBlock = m_stackHeight;
 
 	bool success = (*this)(_funDef.body);
 
@@ -337,10 +338,10 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 bool AsmAnalyzer::operator()(Block const& _block)
 {
 	bool success = true;
+	auto previousScope = m_currentScope;
 	m_currentScope = &scope(&_block);
 
-	int const initialStackHeight = m_stackHeight - m_virtualVariablesInNextBlock;
-	m_virtualVariablesInNextBlock = 0;
+	int const initialStackHeight = m_stackHeight;
 
 	for (auto const& s: _block.statements)
 		if (!boost::apply_visitor(*this, s))
@@ -366,8 +367,8 @@ bool AsmAnalyzer::operator()(Block const& _block)
 		success = false;
 	}
 
-	m_currentScope = m_currentScope->superScope;
 	m_info.stackHeightInfo[&_block] = m_stackHeight;
+	m_currentScope = previousScope;
 	return success;
 }
 
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 87d41e11..14b18c4a 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -91,10 +91,6 @@ private:
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
 
-	/// This is used when we enter the body of a function definition. There, the parameters
-	/// and return parameters appear as variables which are already on the stack before
-	/// we enter the block.
-	int m_virtualVariablesInNextBlock = 0;
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
 	Scope* m_currentScope = nullptr;
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index 18382db0..78c1fbe0 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -24,6 +24,7 @@
 
 #include <map>
 #include <memory>
+#include <vector>
 
 namespace dev
 {
@@ -55,6 +56,8 @@ struct AsmAnalysisInfo
 	using Scopes = std::map<assembly::Block const*, std::shared_ptr<Scope>>;
 	Scopes scopes;
 	StackHeightInfo stackHeightInfo;
+	/// Virtual blocks which will be used for scopes for function arguments and return values.
+	std::map<FunctionDefinition const*, std::shared_ptr<assembly::Block const>> virtualBlocks;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 7eb6a9ed..3fade842 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -22,6 +22,7 @@
 
 #include <libsolidity/inlineasm/AsmData.h>
 #include <libsolidity/inlineasm/AsmScope.h>
+#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
 #include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/interface/Utils.h>
@@ -36,8 +37,8 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-ScopeFiller::ScopeFiller(ScopeFiller::Scopes& _scopes, ErrorList& _errors):
-	m_scopes(_scopes), m_errors(_errors)
+ScopeFiller::ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors):
+	m_info(_info), m_errors(_errors)
 {
 	m_currentScope = &scope(nullptr);
 }
@@ -84,16 +85,22 @@ bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 		));
 		success = false;
 	}
-	Scope& body = scope(&_funDef.body);
-	body.superScope = m_currentScope;
-	body.functionScope = true;
+
+	auto virtualBlock = m_info.virtualBlocks[&_funDef] = make_shared<Block>();
+	Scope& varScope = scope(virtualBlock.get());
+	varScope.superScope = m_currentScope;
+	m_currentScope = &varScope;
+	varScope.functionScope = true;
 	for (auto const& var: _funDef.arguments + _funDef.returns)
-		if (!registerVariable(var, _funDef.location, body))
+		if (!registerVariable(var, _funDef.location, varScope))
 			success = false;
 
 	if (!(*this)(_funDef.body))
 		success = false;
 
+	solAssert(m_currentScope == &varScope, "");
+	m_currentScope = m_currentScope->superScope;
+
 	return success;
 }
 
@@ -137,7 +144,7 @@ bool ScopeFiller::registerVariable(TypedName const& _name, SourceLocation const&
 
 Scope& ScopeFiller::scope(Block const* _block)
 {
-	auto& scope = m_scopes[_block];
+	auto& scope = m_info.scopes[_block];
 	if (!scope)
 		scope = make_shared<Scope>();
 	return *scope;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index c7179b3b..42e80141 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -49,6 +49,7 @@ struct FunctionCall;
 struct Switch;
 
 struct Scope;
+struct AsmAnalysisInfo;
 
 /**
  * Fills scopes with identifiers and checks for name clashes.
@@ -57,8 +58,7 @@ struct Scope;
 class ScopeFiller: public boost::static_visitor<bool>
 {
 public:
-	using Scopes = std::map<assembly::Block const*, std::shared_ptr<Scope>>;
-	ScopeFiller(Scopes& _scopes, ErrorList& _errors);
+	ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors);
 
 	bool operator()(assembly::Instruction const&) { return true; }
 	bool operator()(assembly::Literal const&) { return true; }
@@ -83,7 +83,7 @@ private:
 	Scope& scope(assembly::Block const* _block);
 
 	Scope* m_currentScope = nullptr;
-	Scopes& m_scopes;
+	AsmAnalysisInfo& m_info;
 	ErrorList& m_errors;
 };
 
-- 
cgit v1.2.3


From 0c8beac35785a3c688c48c7f607832c30509c907 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 10 May 2017 08:48:00 +0100
Subject: Rename the SHA3 assembly instruction to KECCAK256

---
 libsolidity/codegen/ArrayUtils.cpp         | 4 ++--
 libsolidity/codegen/CompilerUtils.cpp      | 2 +-
 libsolidity/codegen/CompilerUtils.h        | 2 +-
 libsolidity/codegen/ExpressionCompiler.cpp | 8 ++++----
 4 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/ArrayUtils.cpp b/libsolidity/codegen/ArrayUtils.cpp
index bdd29abd..6a641b02 100644
--- a/libsolidity/codegen/ArrayUtils.cpp
+++ b/libsolidity/codegen/ArrayUtils.cpp
@@ -449,7 +449,7 @@ void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWord
 		m_context << Instruction::DUP3 << Instruction::ADD << Instruction::SWAP2;
 		if (_sourceType.isDynamicallySized())
 		{
-			// actual array data is stored at SHA3(storage_offset)
+			// actual array data is stored at KECCAK256(storage_offset)
 			m_context << Instruction::SWAP1;
 			utils.computeHashStatic();
 			m_context << Instruction::SWAP1;
@@ -731,7 +731,7 @@ void ArrayUtils::resizeDynamicArray(ArrayType const& _typeIn) const
 				_context << Instruction::POP;
 			}
 
-			// Change of length for a regular array (i.e. length at location, data at sha3(location)).
+			// Change of length for a regular array (i.e. length at location, data at KECCAK256(location)).
 			// stack: ref new_length old_length
 			// store new length
 			_context << Instruction::DUP2;
diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 4ae9a09a..3baaaddf 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -934,7 +934,7 @@ unsigned CompilerUtils::sizeOnStack(vector<shared_ptr<Type const>> const& _varia
 void CompilerUtils::computeHashStatic()
 {
 	storeInMemory(0);
-	m_context << u256(32) << u256(0) << Instruction::SHA3;
+	m_context << u256(32) << u256(0) << Instruction::KECCAK256;
 }
 
 void CompilerUtils::storeStringData(bytesConstRef _data)
diff --git a/libsolidity/codegen/CompilerUtils.h b/libsolidity/codegen/CompilerUtils.h
index 4140ce8b..a88951bc 100644
--- a/libsolidity/codegen/CompilerUtils.h
+++ b/libsolidity/codegen/CompilerUtils.h
@@ -166,7 +166,7 @@ public:
 	static unsigned sizeOnStack(std::vector<T> const& _variables);
 	static unsigned sizeOnStack(std::vector<std::shared_ptr<Type const>> const& _variableTypes);
 
-	/// Appends code that computes tha SHA3 hash of the topmost stack element of 32 byte type.
+	/// Appends code that computes tha Keccak-256 hash of the topmost stack element of 32 byte type.
 	void computeHashStatic();
 
 	/// Bytes we need to the start of call data.
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index 0aa82ea8..25154bc0 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -110,7 +110,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
 			// move key to memory.
 			utils().copyToStackTop(paramTypes.size() - i, 1);
 			utils().storeInMemory(0);
-			m_context << u256(64) << u256(0) << Instruction::SHA3;
+			m_context << u256(64) << u256(0) << Instruction::KECCAK256;
 			// push offset
 			m_context << u256(0);
 			returnType = mappingType->valueType();
@@ -674,7 +674,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			utils().fetchFreeMemoryPointer();
 			utils().encodeToMemory(argumentTypes, TypePointers(), function.padArguments(), true);
 			utils().toSizeAfterFreeMemoryPointer();
-			m_context << Instruction::SHA3;
+			m_context << Instruction::KECCAK256;
 			break;
 		}
 		case FunctionType::Kind::Log0:
@@ -721,7 +721,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 							true
 						);
 						utils().toSizeAfterFreeMemoryPointer();
-						m_context << Instruction::SHA3;
+						m_context << Instruction::KECCAK256;
 					}
 					else
 						utils().convertType(
@@ -1214,7 +1214,7 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 			utils().storeInMemoryDynamic(IntegerType(256));
 			m_context << u256(0);
 		}
-		m_context << Instruction::SHA3;
+		m_context << Instruction::KECCAK256;
 		m_context << u256(0);
 		setLValueToStorageItem(_indexAccess);
 	}
-- 
cgit v1.2.3


From 75e4a2be1b920ad88c34a261a84cef5f4635eb68 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 11 May 2017 09:58:45 +0100
Subject: Alias sha3 to keccak256 in inline assembly

---
 libsolidity/inlineasm/AsmParser.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 80409c63..f891ddc9 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -200,6 +200,8 @@ std::map<string, dev::solidity::Instruction> const& Parser::instructions()
 
 		// add alias for suicide
 		s_instructions["suicide"] = solidity::Instruction::SELFDESTRUCT;
+		// add alis for sha3
+		s_instructions["sha3"] = solidity::Instruction::KECCAK256;
 	}
 	return s_instructions;
 }
-- 
cgit v1.2.3


From 89b60ffbd4c2dde26fa5e9f1d750729b5c89373e Mon Sep 17 00:00:00 2001
From: Rhett Aultman <roadriverrail@gmail.com>
Date: Thu, 11 May 2017 06:26:35 -0700
Subject: Refactor error reporting

This commit introduces ErrorReporter, a utility class which consolidates
all of the error logging functionality into a common set of functions.
It also replaces all direct interactions with an ErrorList with calls to
an ErrorReporter.

This commit resolves issue #2209
---
 libsolidity/analysis/DocStringAnalyser.cpp   |   7 +-
 libsolidity/analysis/DocStringAnalyser.h     |   6 +-
 libsolidity/analysis/NameAndTypeResolver.cpp | 131 ++---------
 libsolidity/analysis/NameAndTypeResolver.h   |  40 +---
 libsolidity/analysis/PostTypeChecker.cpp     |  19 +-
 libsolidity/analysis/PostTypeChecker.h       |   6 +-
 libsolidity/analysis/ReferencesResolver.cpp  |  24 +-
 libsolidity/analysis/ReferencesResolver.h    |  12 +-
 libsolidity/analysis/StaticAnalyzer.cpp      |  27 +--
 libsolidity/analysis/StaticAnalyzer.h        |   6 +-
 libsolidity/analysis/SyntaxChecker.cpp       |  41 +---
 libsolidity/analysis/SyntaxChecker.h         |   7 +-
 libsolidity/analysis/TypeChecker.cpp         | 330 ++++++++++++---------------
 libsolidity/analysis/TypeChecker.h           |  14 +-
 libsolidity/codegen/ContractCompiler.cpp     |   5 +-
 libsolidity/formal/Why3Translator.cpp        |  30 ++-
 libsolidity/formal/Why3Translator.h          |  16 +-
 libsolidity/inlineasm/AsmAnalysis.cpp        | 153 +++++--------
 libsolidity/inlineasm/AsmAnalysis.h          |   9 +-
 libsolidity/inlineasm/AsmCodeGen.cpp         |   4 +-
 libsolidity/inlineasm/AsmCodeGen.h           |   8 +-
 libsolidity/inlineasm/AsmParser.cpp          |   6 +-
 libsolidity/inlineasm/AsmParser.h            |   2 +-
 libsolidity/inlineasm/AsmScopeFiller.cpp     |  33 ++-
 libsolidity/inlineasm/AsmScopeFiller.h       |   8 +-
 libsolidity/inlineasm/AsmStack.cpp           |  19 +-
 libsolidity/inlineasm/AsmStack.h             |  10 +-
 libsolidity/interface/AssemblyStack.cpp      |   8 +-
 libsolidity/interface/AssemblyStack.h        |   5 +-
 libsolidity/interface/CompilerStack.cpp      |  48 ++--
 libsolidity/interface/CompilerStack.h        |  14 +-
 libsolidity/interface/ErrorReporter.cpp      | 186 +++++++++++++++
 libsolidity/interface/ErrorReporter.h        | 106 +++++++++
 libsolidity/parsing/DocStringParser.cpp      |   9 +-
 libsolidity/parsing/DocStringParser.h        |   7 +-
 libsolidity/parsing/Parser.cpp               |   6 +-
 libsolidity/parsing/Parser.h                 |   2 +-
 libsolidity/parsing/ParserBase.cpp           |  11 +-
 libsolidity/parsing/ParserBase.h             |   6 +-
 39 files changed, 718 insertions(+), 663 deletions(-)
 create mode 100644 libsolidity/interface/ErrorReporter.cpp
 create mode 100644 libsolidity/interface/ErrorReporter.h

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/DocStringAnalyser.cpp b/libsolidity/analysis/DocStringAnalyser.cpp
index 58261144..6a8fa08e 100644
--- a/libsolidity/analysis/DocStringAnalyser.cpp
+++ b/libsolidity/analysis/DocStringAnalyser.cpp
@@ -23,6 +23,7 @@
 
 #include <libsolidity/analysis/DocStringAnalyser.h>
 #include <libsolidity/ast/AST.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/parsing/DocStringParser.h>
 
 using namespace std;
@@ -110,7 +111,7 @@ void DocStringAnalyser::parseDocStrings(
 	DocStringParser parser;
 	if (_node.documentation() && !_node.documentation()->empty())
 	{
-		if (!parser.parse(*_node.documentation(), m_errors))
+		if (!parser.parse(*_node.documentation(), m_errorReporter))
 			m_errorOccured = true;
 		_annotation.docTags = parser.tags();
 	}
@@ -121,8 +122,6 @@ void DocStringAnalyser::parseDocStrings(
 
 void DocStringAnalyser::appendError(string const& _description)
 {
-	auto err = make_shared<Error>(Error::Type::DocstringParsingError);
-	*err << errinfo_comment(_description);
-	m_errors.push_back(err);
 	m_errorOccured = true;
+	m_errorReporter.docstringParsingError(_description);
 }
diff --git a/libsolidity/analysis/DocStringAnalyser.h b/libsolidity/analysis/DocStringAnalyser.h
index bfc8befc..e871cb60 100644
--- a/libsolidity/analysis/DocStringAnalyser.h
+++ b/libsolidity/analysis/DocStringAnalyser.h
@@ -30,6 +30,8 @@ namespace dev
 namespace solidity
 {
 
+class ErrorReporter;
+
 /**
  * Parses and analyses the doc strings.
  * Stores the parsing results in the AST annotations and reports errors.
@@ -37,7 +39,7 @@ namespace solidity
 class DocStringAnalyser: private ASTConstVisitor
 {
 public:
-	DocStringAnalyser(ErrorList& _errors): m_errors(_errors) {}
+	DocStringAnalyser(ErrorReporter& _errorReporter): m_errorReporter(_errorReporter) {}
 	bool analyseDocStrings(SourceUnit const& _sourceUnit);
 
 private:
@@ -64,7 +66,7 @@ private:
 	void appendError(std::string const& _description);
 
 	bool m_errorOccured = false;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/analysis/NameAndTypeResolver.cpp b/libsolidity/analysis/NameAndTypeResolver.cpp
index 336dc894..2742dcf2 100644
--- a/libsolidity/analysis/NameAndTypeResolver.cpp
+++ b/libsolidity/analysis/NameAndTypeResolver.cpp
@@ -24,7 +24,7 @@
 
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/analysis/TypeChecker.h>
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 
 using namespace std;
 
@@ -36,10 +36,10 @@ namespace solidity
 NameAndTypeResolver::NameAndTypeResolver(
 	vector<Declaration const*> const& _globals,
 	map<ASTNode const*, shared_ptr<DeclarationContainer>>& _scopes,
-	ErrorList& _errors
+	ErrorReporter& _errorReporter
 ) :
 	m_scopes(_scopes),
-	m_errors(_errors)
+	m_errorReporter(_errorReporter)
 {
 	if (!m_scopes[nullptr])
 		m_scopes[nullptr].reset(new DeclarationContainer());
@@ -52,11 +52,11 @@ bool NameAndTypeResolver::registerDeclarations(ASTNode& _sourceUnit, ASTNode con
 	// The helper registers all declarations in m_scopes as a side-effect of its construction.
 	try
 	{
-		DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errors, _currentScope);
+		DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errorReporter, _currentScope);
 	}
 	catch (FatalError const&)
 	{
-		if (m_errors.empty())
+		if (m_errorReporter.errors().empty())
 			throw; // Something is weird here, rather throw again.
 		return false;
 	}
@@ -73,7 +73,7 @@ bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, So
 			string const& path = imp->annotation().absolutePath;
 			if (!_sourceUnits.count(path))
 			{
-				reportDeclarationError(
+				m_errorReporter.declarationError(
 					imp->location(),
 					"Import \"" + path + "\" (referenced as \"" + imp->path() + "\") not found."
 				);
@@ -88,7 +88,7 @@ bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, So
 					auto declarations = scope->second->resolveName(alias.first->name(), false);
 					if (declarations.empty())
 					{
-						reportDeclarationError(
+						m_errorReporter.declarationError(
 							imp->location(),
 							"Declaration \"" +
 							alias.first->name() +
@@ -106,7 +106,7 @@ bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, So
 							ASTString const* name = alias.second ? alias.second.get() : &declaration->name();
 							if (!target.registerDeclaration(*declaration, name))
 							{
-								reportDeclarationError(
+								m_errorReporter.declarationError(
 									imp->location(),
 									"Identifier \"" + *name + "\" already declared."
 								);
@@ -119,7 +119,7 @@ bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, So
 					for (auto const& declaration: nameAndDeclaration.second)
 						if (!target.registerDeclaration(*declaration, &nameAndDeclaration.first))
 						{
-							reportDeclarationError(
+							m_errorReporter.declarationError(
 								imp->location(),
 								"Identifier \"" + nameAndDeclaration.first + "\" already declared."
 							);
@@ -137,7 +137,7 @@ bool NameAndTypeResolver::resolveNamesAndTypes(ASTNode& _node, bool _resolveInsi
 	}
 	catch (FatalError const&)
 	{
-		if (m_errors.empty())
+		if (m_errorReporter.errors().empty())
 			throw; // Something is weird here, rather throw again.
 		return false;
 	}
@@ -152,7 +152,7 @@ bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
 	}
 	catch (FatalError const&)
 	{
-		if (m_errors.empty())
+		if (m_errorReporter.errors().empty())
 			throw; // Something is weird here, rather throw again.
 		return false;
 	}
@@ -214,7 +214,7 @@ vector<Declaration const*> NameAndTypeResolver::cleanedDeclarations(
 
 		for (auto parameter: functionType->parameterTypes() + functionType->returnParameterTypes())
 			if (!parameter)
-				reportFatalDeclarationError(_identifier.location(), "Function type can not be used in this context.");
+				m_errorReporter.fatalDeclarationError(_identifier.location(), "Function type can not be used in this context.");
 
 		if (uniqueFunctions.end() == find_if(
 			uniqueFunctions.begin(),
@@ -290,7 +290,7 @@ bool NameAndTypeResolver::resolveNamesAndTypesInternal(ASTNode& _node, bool _res
 	{
 		if (m_scopes.count(&_node))
 			m_currentScope = m_scopes[&_node].get();
-		return ReferencesResolver(m_errors, *this, _resolveInsideCode).resolve(_node);
+		return ReferencesResolver(m_errorReporter, *this, _resolveInsideCode).resolve(_node);
 	}
 }
 
@@ -328,11 +328,10 @@ void NameAndTypeResolver::importInheritedScope(ContractDefinition const& _base)
 						secondDeclarationLocation = declaration->location();
 					}
 
-					reportDeclarationError(
+					m_errorReporter.declarationError(
 						secondDeclarationLocation,
-						"Identifier already declared.",
-						firstDeclarationLocation,
-						"The previous declaration is here:"
+						SecondarySourceLocation().append("The previous declaration is here:", firstDeclarationLocation),
+						"Identifier already declared."
 					);
 				}
 }
@@ -347,19 +346,19 @@ void NameAndTypeResolver::linearizeBaseContracts(ContractDefinition& _contract)
 		UserDefinedTypeName const& baseName = baseSpecifier->name();
 		auto base = dynamic_cast<ContractDefinition const*>(baseName.annotation().referencedDeclaration);
 		if (!base)
-			reportFatalTypeError(baseName.createTypeError("Contract expected."));
+			m_errorReporter.fatalTypeError(baseName.location(), "Contract expected.");
 		// "push_front" has the effect that bases mentioned later can overwrite members of bases
 		// mentioned earlier
 		input.back().push_front(base);
 		vector<ContractDefinition const*> const& basesBases = base->annotation().linearizedBaseContracts;
 		if (basesBases.empty())
-			reportFatalTypeError(baseName.createTypeError("Definition of base has to precede definition of derived contract"));
+			m_errorReporter.fatalTypeError(baseName.location(), "Definition of base has to precede definition of derived contract");
 		input.push_front(list<ContractDefinition const*>(basesBases.begin(), basesBases.end()));
 	}
 	input.back().push_front(&_contract);
 	vector<ContractDefinition const*> result = cThreeMerge(input);
 	if (result.empty())
-		reportFatalTypeError(_contract.createTypeError("Linearization of inheritance graph impossible"));
+		m_errorReporter.fatalTypeError(_contract.location(), "Linearization of inheritance graph impossible");
 	_contract.annotation().linearizedBaseContracts = result;
 	_contract.annotation().contractDependencies.insert(result.begin() + 1, result.end());
 }
@@ -415,61 +414,15 @@ vector<_T const*> NameAndTypeResolver::cThreeMerge(list<list<_T const*>>& _toMer
 	return result;
 }
 
-void NameAndTypeResolver::reportDeclarationError(
-	SourceLocation _sourceLoction,
-	string const& _description,
-	SourceLocation _secondarySourceLocation,
-	string const& _secondaryDescription
-)
-{
-	auto err = make_shared<Error>(Error::Type::DeclarationError); // todo remove Error?
-	*err <<
-		errinfo_sourceLocation(_sourceLoction) <<
-		errinfo_comment(_description) <<
-		errinfo_secondarySourceLocation(
-			SecondarySourceLocation().append(_secondaryDescription, _secondarySourceLocation)
-		);
-
-	m_errors.push_back(err);
-}
-
-void NameAndTypeResolver::reportDeclarationError(SourceLocation _sourceLocation, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::DeclarationError); // todo remove Error?
-	*err <<	errinfo_sourceLocation(_sourceLocation) << errinfo_comment(_description);
-
-	m_errors.push_back(err);
-}
-
-void NameAndTypeResolver::reportFatalDeclarationError(
-	SourceLocation _sourceLocation,
-	string const& _description
-)
-{
-	reportDeclarationError(_sourceLocation, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
-}
-
-void NameAndTypeResolver::reportTypeError(Error const& _e)
-{
-	m_errors.push_back(make_shared<Error>(_e));
-}
-
-void NameAndTypeResolver::reportFatalTypeError(Error const& _e)
-{
-	reportTypeError(_e);
-	BOOST_THROW_EXCEPTION(FatalError());
-}
-
 DeclarationRegistrationHelper::DeclarationRegistrationHelper(
 	map<ASTNode const*, shared_ptr<DeclarationContainer>>& _scopes,
 	ASTNode& _astRoot,
-	ErrorList& _errors,
+	ErrorReporter& _errorReporter,
 	ASTNode const* _currentScope
 ):
 	m_scopes(_scopes),
 	m_currentScope(_currentScope),
-	m_errors(_errors)
+	m_errorReporter(_errorReporter)
 {
 	_astRoot.accept(*this);
 	solAssert(m_currentScope == _currentScope, "Scopes not correctly closed.");
@@ -633,11 +586,10 @@ void DeclarationRegistrationHelper::registerDeclaration(Declaration& _declaratio
 			secondDeclarationLocation = _declaration.location();
 		}
 
-		declarationError(
+		m_errorReporter.declarationError(
 			secondDeclarationLocation,
-			"Identifier already declared.",
-			firstDeclarationLocation,
-			"The previous declaration is here:"
+			SecondarySourceLocation().append("The previous declaration is here:", firstDeclarationLocation),
+			"Identifier already declared."
 		);
 	}
 
@@ -665,40 +617,5 @@ string DeclarationRegistrationHelper::currentCanonicalName() const
 	return ret;
 }
 
-void DeclarationRegistrationHelper::declarationError(
-	SourceLocation _sourceLocation,
-	string const& _description,
-	SourceLocation _secondarySourceLocation,
-	string const& _secondaryDescription
-)
-{
-	auto err = make_shared<Error>(Error::Type::DeclarationError);
-	*err <<
-		errinfo_sourceLocation(_sourceLocation) <<
-		errinfo_comment(_description) <<
-		errinfo_secondarySourceLocation(
-			SecondarySourceLocation().append(_secondaryDescription, _secondarySourceLocation)
-		);
-
-	m_errors.push_back(err);
-}
-
-void DeclarationRegistrationHelper::declarationError(SourceLocation _sourceLocation, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::DeclarationError);
-	*err <<	errinfo_sourceLocation(_sourceLocation) << errinfo_comment(_description);
-
-	m_errors.push_back(err);
-}
-
-void DeclarationRegistrationHelper::fatalDeclarationError(
-	SourceLocation _sourceLocation,
-	string const& _description
-)
-{
-	declarationError(_sourceLocation, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
-}
-
 }
 }
diff --git a/libsolidity/analysis/NameAndTypeResolver.h b/libsolidity/analysis/NameAndTypeResolver.h
index 038a887b..0441867d 100644
--- a/libsolidity/analysis/NameAndTypeResolver.h
+++ b/libsolidity/analysis/NameAndTypeResolver.h
@@ -35,6 +35,8 @@ namespace dev
 namespace solidity
 {
 
+class ErrorReporter;
+
 /**
  * Resolves name references, typenames and sets the (explicitly given) types for all variable
  * declarations.
@@ -48,7 +50,7 @@ public:
 	NameAndTypeResolver(
 		std::vector<Declaration const*> const& _globals,
 		std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& _scopes,
-		ErrorList& _errors
+		ErrorReporter& _errorReporter
 	);
 	/// Registers all declarations found in the AST node, usually a source unit.
 	/// @returns false in case of error.
@@ -103,24 +105,6 @@ private:
 	template <class _T>
 	static std::vector<_T const*> cThreeMerge(std::list<std::list<_T const*>>& _toMerge);
 
-	// creates the Declaration error and adds it in the errors list
-	void reportDeclarationError(
-		SourceLocation _sourceLoction,
-		std::string const& _description,
-		SourceLocation _secondarySourceLocation,
-		std::string const& _secondaryDescription
-	);
-	// creates the Declaration error and adds it in the errors list
-	void reportDeclarationError(SourceLocation _sourceLocation, std::string const& _description);
-	// creates the Declaration error and adds it in the errors list and throws FatalError
-	void reportFatalDeclarationError(SourceLocation _sourceLocation, std::string const& _description);
-
-	// creates the Declaration error and adds it in the errors list
-	void reportTypeError(Error const& _e);
-	// creates the Declaration error and adds it in the errors list and throws FatalError
-	void reportFatalTypeError(Error const& _e);
-
-
 	/// Maps nodes declaring a scope to scopes, i.e. ContractDefinition and FunctionDeclaration,
 	/// where nullptr denotes the global scope. Note that structs are not scope since they do
 	/// not contain code.
@@ -128,7 +112,7 @@ private:
 	std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& m_scopes;
 
 	DeclarationContainer* m_currentScope = nullptr;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 /**
@@ -145,7 +129,7 @@ public:
 	DeclarationRegistrationHelper(
 		std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& _scopes,
 		ASTNode& _astRoot,
-		ErrorList& _errors,
+		ErrorReporter& _errorReporter,
 		ASTNode const* _currentScope = nullptr
 	);
 
@@ -175,23 +159,11 @@ private:
 
 	/// @returns the canonical name of the current scope.
 	std::string currentCanonicalName() const;
-	// creates the Declaration error and adds it in the errors list
-	void declarationError(
-		SourceLocation _sourceLocation,
-		std::string const& _description,
-		SourceLocation _secondarySourceLocation,
-		std::string const& _secondaryDescription
-	);
-
-	// creates the Declaration error and adds it in the errors list
-	void declarationError(SourceLocation _sourceLocation, std::string const& _description);
-	// creates the Declaration error and adds it in the errors list and throws FatalError
-	void fatalDeclarationError(SourceLocation _sourceLocation, std::string const& _description);
 
 	std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& m_scopes;
 	ASTNode const* m_currentScope = nullptr;
 	VariableScope* m_currentFunction = nullptr;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/analysis/PostTypeChecker.cpp b/libsolidity/analysis/PostTypeChecker.cpp
index e8da3ca4..fbc72e52 100644
--- a/libsolidity/analysis/PostTypeChecker.cpp
+++ b/libsolidity/analysis/PostTypeChecker.cpp
@@ -18,6 +18,7 @@
 #include <libsolidity/analysis/PostTypeChecker.h>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/analysis/SemVerHandler.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Version.h>
 
 #include <boost/range/adaptor/map.hpp>
@@ -32,17 +33,7 @@ using namespace dev::solidity;
 bool PostTypeChecker::check(ASTNode const& _astRoot)
 {
 	_astRoot.accept(*this);
-	return Error::containsOnlyWarnings(m_errors);
-}
-
-void PostTypeChecker::typeError(SourceLocation const& _location, std::string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::TypeError);
-	*err <<
-		errinfo_sourceLocation(_location) <<
-		errinfo_comment(_description);
-
-	m_errors.push_back(err);
+	return Error::containsOnlyWarnings(m_errorReporter.errors());
 }
 
 bool PostTypeChecker::visit(ContractDefinition const&)
@@ -57,7 +48,11 @@ void PostTypeChecker::endVisit(ContractDefinition const&)
 	solAssert(!m_currentConstVariable, "");
 	for (auto declaration: m_constVariables)
 		if (auto identifier = findCycle(declaration))
-			typeError(declaration->location(), "The value of the constant " + declaration->name() + " has a cyclic dependency via " + identifier->name() + ".");
+			m_errorReporter.typeError(
+				declaration->location(),
+				"The value of the constant " + declaration->name() +
+				" has a cyclic dependency via " + identifier->name() + "."
+			);
 
 	m_constVariables.clear();
 	m_constVariableDependencies.clear();
diff --git a/libsolidity/analysis/PostTypeChecker.h b/libsolidity/analysis/PostTypeChecker.h
index 13751c16..dbdf50e0 100644
--- a/libsolidity/analysis/PostTypeChecker.h
+++ b/libsolidity/analysis/PostTypeChecker.h
@@ -28,6 +28,8 @@ namespace dev
 namespace solidity
 {
 
+class ErrorReporter;
+
 /**
  * This module performs analyses on the AST that are done after type checking and assignments of types:
  *  - whether there are circular references in constant state variables
@@ -37,7 +39,7 @@ class PostTypeChecker: private ASTConstVisitor
 {
 public:
 	/// @param _errors the reference to the list of errors and warnings to add them found during type checking.
-	PostTypeChecker(ErrorList& _errors): m_errors(_errors) {}
+	PostTypeChecker(ErrorReporter& _errorReporter): m_errorReporter(_errorReporter) {}
 
 	bool check(ASTNode const& _astRoot);
 
@@ -58,7 +60,7 @@ private:
 		std::set<VariableDeclaration const*> const& _seen = std::set<VariableDeclaration const*>{}
 	);
 
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 
 	VariableDeclaration const* m_currentConstVariable = nullptr;
 	std::vector<VariableDeclaration const*> m_constVariables; ///< Required for determinism.
diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp
index f5fffb57..b70b0f0e 100644
--- a/libsolidity/analysis/ReferencesResolver.cpp
+++ b/libsolidity/analysis/ReferencesResolver.cpp
@@ -28,6 +28,7 @@
 #include <libsolidity/inlineasm/AsmAnalysis.h>
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 #include <libsolidity/inlineasm/AsmData.h>
+#include <libsolidity/interface/ErrorReporter.h>
 
 #include <boost/algorithm/string.hpp>
 
@@ -111,7 +112,7 @@ void ReferencesResolver::endVisit(FunctionTypeName const& _typeName)
 	case VariableDeclaration::Visibility::External:
 		break;
 	default:
-		typeError(_typeName.location(), "Invalid visibility, can only be \"external\" or \"internal\".");
+		fatalTypeError(_typeName.location(), "Invalid visibility, can only be \"external\" or \"internal\".");
 	}
 
 	if (_typeName.isPayable() && _typeName.visibility() != VariableDeclaration::Visibility::External)
@@ -165,7 +166,8 @@ bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 	// the type and size of external identifiers, which would result in false errors.
 	// The only purpose of this step is to fill the inline assembly annotation with
 	// external references.
-	ErrorList errorsIgnored;
+	ErrorList errors;
+	ErrorReporter errorsIgnored(errors);
 	julia::ExternalIdentifierAccess::Resolver resolver =
 	[&](assembly::Identifier const& _identifier, julia::IdentifierContext) {
 		auto declarations = m_resolver.nameFromCurrentScope(_identifier.name);
@@ -303,29 +305,19 @@ void ReferencesResolver::endVisit(VariableDeclaration const& _variable)
 
 void ReferencesResolver::typeError(SourceLocation const& _location, string const& _description)
 {
-	auto err = make_shared<Error>(Error::Type::TypeError);
-	*err <<	errinfo_sourceLocation(_location) << errinfo_comment(_description);
 	m_errorOccurred = true;
-	m_errors.push_back(err);
+	m_errorReporter.typeError(_location, _description);
 }
 
 void ReferencesResolver::fatalTypeError(SourceLocation const& _location, string const& _description)
 {
-	typeError(_location, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
-}
-
-void ReferencesResolver::declarationError(SourceLocation const& _location, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::DeclarationError);
-	*err <<	errinfo_sourceLocation(_location) << errinfo_comment(_description);
 	m_errorOccurred = true;
-	m_errors.push_back(err);
+	m_errorReporter.fatalTypeError(_location, _description);
 }
 
 void ReferencesResolver::fatalDeclarationError(SourceLocation const& _location, string const& _description)
 {
-	declarationError(_location, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
+	m_errorOccurred = true;
+	m_errorReporter.fatalDeclarationError(_location, _description);
 }
 
diff --git a/libsolidity/analysis/ReferencesResolver.h b/libsolidity/analysis/ReferencesResolver.h
index dce343d3..bbde19f9 100644
--- a/libsolidity/analysis/ReferencesResolver.h
+++ b/libsolidity/analysis/ReferencesResolver.h
@@ -33,6 +33,7 @@ namespace dev
 namespace solidity
 {
 
+class ErrorReporter;
 class NameAndTypeResolver;
 
 /**
@@ -43,11 +44,11 @@ class ReferencesResolver: private ASTConstVisitor
 {
 public:
 	ReferencesResolver(
-		ErrorList& _errors,
+		ErrorReporter& _errorReporter,
 		NameAndTypeResolver& _resolver,
 		bool _resolveInsideCode = false
 	):
-		m_errors(_errors),
+		m_errorReporter(_errorReporter),
 		m_resolver(_resolver),
 		m_resolveInsideCode(_resolveInsideCode)
 	{}
@@ -77,13 +78,10 @@ private:
 	/// Adds a new error to the list of errors and throws to abort type checking.
 	void fatalTypeError(SourceLocation const& _location, std::string const& _description);
 
-	/// Adds a new error to the list of errors.
-	void declarationError(const SourceLocation& _location, std::string const& _description);
-
 	/// Adds a new error to the list of errors and throws to abort type checking.
-	void fatalDeclarationError(const SourceLocation& _location, std::string const& _description);
+	void fatalDeclarationError(SourceLocation const& _location, std::string const& _description);
 
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 	NameAndTypeResolver& m_resolver;
 	/// Stack of return parameters.
 	std::vector<ParameterList const*> m_returnParameters;
diff --git a/libsolidity/analysis/StaticAnalyzer.cpp b/libsolidity/analysis/StaticAnalyzer.cpp
index cfc863e0..375e9bde 100644
--- a/libsolidity/analysis/StaticAnalyzer.cpp
+++ b/libsolidity/analysis/StaticAnalyzer.cpp
@@ -22,6 +22,7 @@
 
 #include <libsolidity/analysis/StaticAnalyzer.h>
 #include <libsolidity/ast/AST.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <memory>
 
 using namespace std;
@@ -31,7 +32,7 @@ using namespace dev::solidity;
 bool StaticAnalyzer::analyze(SourceUnit const& _sourceUnit)
 {
 	_sourceUnit.accept(*this);
-	return Error::containsOnlyWarnings(m_errors);
+	return Error::containsOnlyWarnings(m_errorReporter.errors());
 }
 
 bool StaticAnalyzer::visit(ContractDefinition const& _contract)
@@ -62,7 +63,7 @@ void StaticAnalyzer::endVisit(FunctionDefinition const&)
 	m_nonPayablePublic = false;
 	for (auto const& var: m_localVarUseCount)
 		if (var.second == 0)
-			warning(var.first->location(), "Unused local variable");
+			m_errorReporter.warning(var.first->location(), "Unused local variable");
 	m_localVarUseCount.clear();
 }
 
@@ -104,7 +105,11 @@ bool StaticAnalyzer::visit(Return const& _return)
 bool StaticAnalyzer::visit(ExpressionStatement const& _statement)
 {
 	if (_statement.expression().annotation().isPure)
-		warning(_statement.location(), "Statement has no effect.");
+		m_errorReporter.warning(
+			_statement.location(),
+			"Statement has no effect."
+		);
+
 	return true;
 }
 
@@ -113,21 +118,14 @@ bool StaticAnalyzer::visit(MemberAccess const& _memberAccess)
 	if (m_nonPayablePublic && !m_library)
 		if (MagicType const* type = dynamic_cast<MagicType const*>(_memberAccess.expression().annotation().type.get()))
 			if (type->kind() == MagicType::Kind::Message && _memberAccess.memberName() == "value")
-				warning(_memberAccess.location(), "\"msg.value\" used in non-payable function. Do you want to add the \"payable\" modifier to this function?");
+				m_errorReporter.warning(
+					_memberAccess.location(),
+					"\"msg.value\" used in non-payable function. Do you want to add the \"payable\" modifier to this function?"
+				);
 
 	return true;
 }
 
-void StaticAnalyzer::warning(SourceLocation const& _location, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::Warning);
-	*err <<
-		errinfo_sourceLocation(_location) <<
-		errinfo_comment(_description);
-
-	m_errors.push_back(err);
-}
-
 bool StaticAnalyzer::visit(InlineAssembly const& _inlineAssembly)
 {
 	if (!m_currentFunction)
@@ -145,4 +143,3 @@ bool StaticAnalyzer::visit(InlineAssembly const& _inlineAssembly)
 
 	return true;
 }
-
diff --git a/libsolidity/analysis/StaticAnalyzer.h b/libsolidity/analysis/StaticAnalyzer.h
index 458bab2a..cd6913b5 100644
--- a/libsolidity/analysis/StaticAnalyzer.h
+++ b/libsolidity/analysis/StaticAnalyzer.h
@@ -44,15 +44,13 @@ class StaticAnalyzer: private ASTConstVisitor
 {
 public:
 	/// @param _errors the reference to the list of errors and warnings to add them found during static analysis.
-	explicit StaticAnalyzer(ErrorList& _errors): m_errors(_errors) {}
+	explicit StaticAnalyzer(ErrorReporter& _errorReporter): m_errorReporter(_errorReporter) {}
 
 	/// Performs static analysis on the given source unit and all of its sub-nodes.
 	/// @returns true iff all checks passed. Note even if all checks passed, errors() can still contain warnings
 	bool analyze(SourceUnit const& _sourceUnit);
 
 private:
-	/// Adds a new warning to the list of errors.
-	void warning(SourceLocation const& _location, std::string const& _description);
 
 	virtual bool visit(ContractDefinition const& _contract) override;
 	virtual void endVisit(ContractDefinition const& _contract) override;
@@ -67,7 +65,7 @@ private:
 	virtual bool visit(MemberAccess const& _memberAccess) override;
 	virtual bool visit(InlineAssembly const& _inlineAssembly) override;
 
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 
 	/// Flag that indicates whether the current contract definition is a library.
 	bool m_library = false;
diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp
index 94e82a87..35d71d85 100644
--- a/libsolidity/analysis/SyntaxChecker.cpp
+++ b/libsolidity/analysis/SyntaxChecker.cpp
@@ -19,6 +19,7 @@
 #include <memory>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/analysis/SemVerHandler.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Version.h>
 
 using namespace std;
@@ -29,27 +30,7 @@ using namespace dev::solidity;
 bool SyntaxChecker::checkSyntax(ASTNode const& _astRoot)
 {
 	_astRoot.accept(*this);
-	return Error::containsOnlyWarnings(m_errors);
-}
-
-void SyntaxChecker::warning(SourceLocation const& _location, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::Warning);
-	*err <<
-		errinfo_sourceLocation(_location) <<
-		errinfo_comment(_description);
-
-	m_errors.push_back(err);
-}
-
-void SyntaxChecker::syntaxError(SourceLocation const& _location, std::string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::SyntaxError);
-	*err <<
-		errinfo_sourceLocation(_location) <<
-		errinfo_comment(_description);
-
-	m_errors.push_back(err);
+	return Error::containsOnlyWarnings(m_errorReporter.errors());
 }
 
 bool SyntaxChecker::visit(SourceUnit const&)
@@ -74,11 +55,7 @@ void SyntaxChecker::endVisit(SourceUnit const& _sourceUnit)
 				to_string(recommendedVersion.patch());
 				string(";\"");
 
-		auto err = make_shared<Error>(Error::Type::Warning);
-		*err <<
-			errinfo_sourceLocation(_sourceUnit.location()) <<
-			errinfo_comment(errorString);
-		m_errors.push_back(err);
+		m_errorReporter.warning(_sourceUnit.location(), errorString);
 	}
 }
 
@@ -87,7 +64,7 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 	solAssert(!_pragma.tokens().empty(), "");
 	solAssert(_pragma.tokens().size() == _pragma.literals().size(), "");
 	if (_pragma.tokens()[0] != Token::Identifier || _pragma.literals()[0] != "solidity")
-		syntaxError(_pragma.location(), "Unknown pragma \"" + _pragma.literals()[0] + "\"");
+		m_errorReporter.syntaxError(_pragma.location(), "Unknown pragma \"" + _pragma.literals()[0] + "\"");
 	else
 	{
 		vector<Token::Value> tokens(_pragma.tokens().begin() + 1, _pragma.tokens().end());
@@ -96,7 +73,7 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 		auto matchExpression = parser.parse();
 		SemVerVersion currentVersion{string(VersionString)};
 		if (!matchExpression.matches(currentVersion))
-			syntaxError(
+			m_errorReporter.syntaxError(
 				_pragma.location(),
 				"Source file requires different compiler version (current compiler is " +
 				string(VersionString) + " - note that nightly builds are considered to be "
@@ -116,7 +93,7 @@ bool SyntaxChecker::visit(ModifierDefinition const&)
 void SyntaxChecker::endVisit(ModifierDefinition const& _modifier)
 {
 	if (!m_placeholderFound)
-		syntaxError(_modifier.body().location(), "Modifier body does not contain '_'.");
+		m_errorReporter.syntaxError(_modifier.body().location(), "Modifier body does not contain '_'.");
 	m_placeholderFound = false;
 }
 
@@ -146,7 +123,7 @@ bool SyntaxChecker::visit(Continue const& _continueStatement)
 {
 	if (m_inLoopDepth <= 0)
 		// we're not in a for/while loop, report syntax error
-		syntaxError(_continueStatement.location(), "\"continue\" has to be in a \"for\" or \"while\" loop.");
+		m_errorReporter.syntaxError(_continueStatement.location(), "\"continue\" has to be in a \"for\" or \"while\" loop.");
 	return true;
 }
 
@@ -154,14 +131,14 @@ bool SyntaxChecker::visit(Break const& _breakStatement)
 {
 	if (m_inLoopDepth <= 0)
 		// we're not in a for/while loop, report syntax error
-		syntaxError(_breakStatement.location(), "\"break\" has to be in a \"for\" or \"while\" loop.");
+		m_errorReporter.syntaxError(_breakStatement.location(), "\"break\" has to be in a \"for\" or \"while\" loop.");
 	return true;
 }
 
 bool SyntaxChecker::visit(UnaryOperation const& _operation)
 {
 	if (_operation.getOperator() == Token::Add)
-		warning(_operation.location(), "Use of unary + is deprecated.");
+		m_errorReporter.warning(_operation.location(), "Use of unary + is deprecated.");
 	return true;
 }
 
diff --git a/libsolidity/analysis/SyntaxChecker.h b/libsolidity/analysis/SyntaxChecker.h
index 8d7dcdd3..b1857aa5 100644
--- a/libsolidity/analysis/SyntaxChecker.h
+++ b/libsolidity/analysis/SyntaxChecker.h
@@ -38,14 +38,11 @@ class SyntaxChecker: private ASTConstVisitor
 {
 public:
 	/// @param _errors the reference to the list of errors and warnings to add them found during type checking.
-	SyntaxChecker(ErrorList& _errors): m_errors(_errors) {}
+	SyntaxChecker(ErrorReporter& _errorReporter): m_errorReporter(_errorReporter) {}
 
 	bool checkSyntax(ASTNode const& _astRoot);
 
 private:
-	/// Adds a new error to the list of errors.
-	void warning(SourceLocation const& _location, std::string const& _description);
-	void syntaxError(SourceLocation const& _location, std::string const& _description);
 
 	virtual bool visit(SourceUnit const& _sourceUnit) override;
 	virtual void endVisit(SourceUnit const& _sourceUnit) override;
@@ -66,7 +63,7 @@ private:
 
 	virtual bool visit(PlaceholderStatement const& _placeholderStatement) override;
 
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 
 	/// Flag that indicates whether a function modifier actually contains '_'.
 	bool m_placeholderFound = false;
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 528a23da..0fb0d212 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -27,6 +27,7 @@
 #include <libsolidity/inlineasm/AsmAnalysis.h>
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 #include <libsolidity/inlineasm/AsmData.h>
+#include <libsolidity/interface/ErrorReporter.h>
 
 using namespace std;
 using namespace dev;
@@ -43,10 +44,10 @@ bool TypeChecker::checkTypeRequirements(ASTNode const& _contract)
 	{
 		// We got a fatal error which required to stop further type checking, but we can
 		// continue normally from here.
-		if (m_errors.empty())
+		if (m_errorReporter.errors().empty())
 			throw; // Something is weird here, rather throw again.
 	}
-	return Error::containsOnlyWarnings(m_errors);
+	return Error::containsOnlyWarnings(m_errorReporter.errors());
 }
 
 TypePointer const& TypeChecker::type(Expression const& _expression) const
@@ -81,11 +82,11 @@ bool TypeChecker::visit(ContractDefinition const& _contract)
 	if (function)
 	{
 		if (!function->returnParameters().empty())
-			typeError(function->returnParameterList()->location(), "Non-empty \"returns\" directive for constructor.");
+			m_errorReporter.typeError(function->returnParameterList()->location(), "Non-empty \"returns\" directive for constructor.");
 		if (function->isDeclaredConst())
-			typeError(function->location(), "Constructor cannot be defined as constant.");
+			m_errorReporter.typeError(function->location(), "Constructor cannot be defined as constant.");
 		if (function->visibility() != FunctionDefinition::Visibility::Public && function->visibility() != FunctionDefinition::Visibility::Internal)
-			typeError(function->location(), "Constructor must be public or internal.");
+			m_errorReporter.typeError(function->location(), "Constructor must be public or internal.");
 	}
 
 	FunctionDefinition const* fallbackFunction = nullptr;
@@ -95,21 +96,19 @@ bool TypeChecker::visit(ContractDefinition const& _contract)
 		{
 			if (fallbackFunction)
 			{
-				auto err = make_shared<Error>(Error::Type::DeclarationError);
-				*err << errinfo_comment("Only one fallback function is allowed.");
-				m_errors.push_back(err);
+				m_errorReporter.declarationError(function->location(), "Only one fallback function is allowed.");
 			}
 			else
 			{
 				fallbackFunction = function;
 				if (_contract.isLibrary())
-					typeError(fallbackFunction->location(), "Libraries cannot have fallback functions.");
+					m_errorReporter.typeError(fallbackFunction->location(), "Libraries cannot have fallback functions.");
 				if (fallbackFunction->isDeclaredConst())
-					typeError(fallbackFunction->location(), "Fallback function cannot be declared constant.");
+					m_errorReporter.typeError(fallbackFunction->location(), "Fallback function cannot be declared constant.");
 				if (!fallbackFunction->parameters().empty())
-					typeError(fallbackFunction->parameterList().location(), "Fallback function cannot take parameters.");
+					m_errorReporter.typeError(fallbackFunction->parameterList().location(), "Fallback function cannot take parameters.");
 				if (!fallbackFunction->returnParameters().empty())
-					typeError(fallbackFunction->returnParameterList()->location(), "Fallback function cannot return values.");
+					m_errorReporter.typeError(fallbackFunction->returnParameterList()->location(), "Fallback function cannot return values.");
 			}
 		}
 		if (!function->isImplemented())
@@ -127,7 +126,7 @@ bool TypeChecker::visit(ContractDefinition const& _contract)
 	{
 		FixedHash<4> const& hash = it.first;
 		if (hashes.count(hash))
-			typeError(
+			m_errorReporter.typeError(
 				_contract.location(),
 				string("Function signature hash collision for ") + it.second->externalSignature()
 			);
@@ -156,12 +155,11 @@ void TypeChecker::checkContractDuplicateFunctions(ContractDefinition const& _con
 		for (; it != functions[_contract.name()].end(); ++it)
 			ssl.append("Another declaration is here:", (*it)->location());
 
-		auto err = make_shared<Error>(Error(Error::Type::DeclarationError));
-		*err <<
-			errinfo_sourceLocation(functions[_contract.name()].front()->location()) <<
-			errinfo_comment("More than one constructor defined.") <<
-			errinfo_secondarySourceLocation(ssl);
-		m_errors.push_back(err);
+		m_errorReporter.declarationError(
+			functions[_contract.name()].front()->location(),
+			ssl,
+			"More than one constructor defined."
+		);
 	}
 	for (auto const& it: functions)
 	{
@@ -170,13 +168,14 @@ void TypeChecker::checkContractDuplicateFunctions(ContractDefinition const& _con
 			for (size_t j = i + 1; j < overloads.size(); ++j)
 				if (FunctionType(*overloads[i]).hasEqualArgumentTypes(FunctionType(*overloads[j])))
 				{
-					auto err = make_shared<Error>(Error(Error::Type::DeclarationError));
-					*err <<
-						errinfo_sourceLocation(overloads[j]->location()) <<
-						errinfo_comment("Function with same name and arguments defined twice.") <<
-						errinfo_secondarySourceLocation(SecondarySourceLocation().append(
-							"Other declaration is here:", overloads[i]->location()));
-					m_errors.push_back(err);
+					m_errorReporter.declarationError(
+						overloads[j]->location(),
+						SecondarySourceLocation().append(
+							"Other declaration is here:",
+							overloads[i]->location()
+						),
+						"Function with same name and arguments defined twice."
+					);
 				}
 	}
 }
@@ -213,7 +212,7 @@ void TypeChecker::checkContractAbstractFunctions(ContractDefinition const& _cont
 			else if (it->second)
 			{
 				if (!function->isImplemented())
-					typeError(function->location(), "Redeclaring an already implemented function as abstract");
+					m_errorReporter.typeError(function->location(), "Redeclaring an already implemented function as abstract");
 			}
 			else if (function->isImplemented())
 				it->second = true;
@@ -285,7 +284,7 @@ void TypeChecker::checkContractIllegalOverrides(ContractDefinition const& _contr
 				continue; // constructors can neither be overridden nor override anything
 			string const& name = function->name();
 			if (modifiers.count(name))
-				typeError(modifiers[name]->location(), "Override changes function to modifier.");
+				m_errorReporter.typeError(modifiers[name]->location(), "Override changes function to modifier.");
 			FunctionType functionType(*function);
 			// function should not change the return type
 			for (FunctionDefinition const* overriding: functions[name])
@@ -299,7 +298,7 @@ void TypeChecker::checkContractIllegalOverrides(ContractDefinition const& _contr
 					overriding->isPayable() != function->isPayable() ||
 					overridingType != functionType
 				)
-					typeError(overriding->location(), "Override changes extended function signature.");
+					m_errorReporter.typeError(overriding->location(), "Override changes extended function signature.");
 			}
 			functions[name].push_back(function);
 		}
@@ -310,9 +309,9 @@ void TypeChecker::checkContractIllegalOverrides(ContractDefinition const& _contr
 			if (!override)
 				override = modifier;
 			else if (ModifierType(*override) != ModifierType(*modifier))
-				typeError(override->location(), "Override changes modifier signature.");
+				m_errorReporter.typeError(override->location(), "Override changes modifier signature.");
 			if (!functions[name].empty())
-				typeError(override->location(), "Override changes modifier to function.");
+				m_errorReporter.typeError(override->location(), "Override changes modifier to function.");
 		}
 	}
 }
@@ -347,7 +346,7 @@ void TypeChecker::checkContractExternalTypeClashes(ContractDefinition const& _co
 		for (size_t i = 0; i < it.second.size(); ++i)
 			for (size_t j = i + 1; j < it.second.size(); ++j)
 				if (!it.second[i].second->hasEqualArgumentTypes(*it.second[j].second))
-					typeError(
+					m_errorReporter.typeError(
 						it.second[j].first->location(),
 						"Function overload clash during conversion to external types for arguments."
 					);
@@ -357,11 +356,11 @@ void TypeChecker::checkLibraryRequirements(ContractDefinition const& _contract)
 {
 	solAssert(_contract.isLibrary(), "");
 	if (!_contract.baseContracts().empty())
-		typeError(_contract.location(), "Library is not allowed to inherit.");
+		m_errorReporter.typeError(_contract.location(), "Library is not allowed to inherit.");
 
 	for (auto const& var: _contract.stateVariables())
 		if (!var->isConstant())
-			typeError(var->location(), "Library cannot have non-constant state variables");
+			m_errorReporter.typeError(var->location(), "Library cannot have non-constant state variables");
 }
 
 void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
@@ -370,16 +369,16 @@ void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
 	solAssert(base, "Base contract not available.");
 
 	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
-		typeError(_inheritance.location(), "Interfaces cannot inherit.");
+		m_errorReporter.typeError(_inheritance.location(), "Interfaces cannot inherit.");
 
 	if (base->isLibrary())
-		typeError(_inheritance.location(), "Libraries cannot be inherited from.");
+		m_errorReporter.typeError(_inheritance.location(), "Libraries cannot be inherited from.");
 
 	auto const& arguments = _inheritance.arguments();
 	TypePointers parameterTypes = ContractType(*base).newExpressionType()->parameterTypes();
 	if (!arguments.empty() && parameterTypes.size() != arguments.size())
 	{
-		typeError(
+		m_errorReporter.typeError(
 			_inheritance.location(),
 			"Wrong argument count for constructor call: " +
 			toString(arguments.size()) +
@@ -392,7 +391,7 @@ void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
 
 	for (size_t i = 0; i < arguments.size(); ++i)
 		if (!type(*arguments[i])->isImplicitlyConvertibleTo(*parameterTypes[i]))
-			typeError(
+			m_errorReporter.typeError(
 				arguments[i]->location(),
 				"Invalid type for argument in constructor call. "
 				"Invalid implicit conversion from " +
@@ -409,17 +408,17 @@ void TypeChecker::endVisit(UsingForDirective const& _usingFor)
 		_usingFor.libraryName().annotation().referencedDeclaration
 	);
 	if (!library || !library->isLibrary())
-		typeError(_usingFor.libraryName().location(), "Library name expected.");
+		m_errorReporter.typeError(_usingFor.libraryName().location(), "Library name expected.");
 }
 
 bool TypeChecker::visit(StructDefinition const& _struct)
 {
 	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
-		typeError(_struct.location(), "Structs cannot be defined in interfaces.");
+		m_errorReporter.typeError(_struct.location(), "Structs cannot be defined in interfaces.");
 
 	for (ASTPointer<VariableDeclaration> const& member: _struct.members())
 		if (!type(*member)->canBeStored())
-			typeError(member->location(), "Type cannot be used in struct.");
+			m_errorReporter.typeError(member->location(), "Type cannot be used in struct.");
 
 	// Check recursion, fatal error if detected.
 	using StructPointer = StructDefinition const*;
@@ -427,7 +426,7 @@ bool TypeChecker::visit(StructDefinition const& _struct)
 	function<void(StructPointer,StructPointersSet const&)> check = [&](StructPointer _struct, StructPointersSet const& _parents)
 	{
 		if (_parents.count(_struct))
-			fatalTypeError(_struct->location(), "Recursive struct definition.");
+			m_errorReporter.fatalTypeError(_struct->location(), "Recursive struct definition.");
 		StructPointersSet parents = _parents;
 		parents.insert(_struct);
 		for (ASTPointer<VariableDeclaration> const& member: _struct->members())
@@ -452,18 +451,18 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 	if (_function.isPayable())
 	{
 		if (isLibraryFunction)
-			typeError(_function.location(), "Library functions cannot be payable.");
+			m_errorReporter.typeError(_function.location(), "Library functions cannot be payable.");
 		if (!_function.isConstructor() && !_function.name().empty() && !_function.isPartOfExternalInterface())
-			typeError(_function.location(), "Internal functions cannot be payable.");
+			m_errorReporter.typeError(_function.location(), "Internal functions cannot be payable.");
 		if (_function.isDeclaredConst())
-			typeError(_function.location(), "Functions cannot be constant and payable at the same time.");
+			m_errorReporter.typeError(_function.location(), "Functions cannot be constant and payable at the same time.");
 	}
 	for (ASTPointer<VariableDeclaration> const& var: _function.parameters() + _function.returnParameters())
 	{
 		if (!type(*var)->canLiveOutsideStorage())
-			typeError(var->location(), "Type is required to live outside storage.");
+			m_errorReporter.typeError(var->location(), "Type is required to live outside storage.");
 		if (_function.visibility() >= FunctionDefinition::Visibility::Public && !(type(*var)->interfaceType(isLibraryFunction)))
-			fatalTypeError(var->location(), "Internal type is not allowed for public or external functions.");
+			m_errorReporter.fatalTypeError(var->location(), "Internal type is not allowed for public or external functions.");
 	}
 	for (ASTPointer<ModifierInvocation> const& modifier: _function.modifiers())
 		visitManually(
@@ -475,11 +474,11 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
 	{
 		if (_function.isImplemented())
-			typeError(_function.location(), "Functions in interfaces cannot have an implementation.");
+			m_errorReporter.typeError(_function.location(), "Functions in interfaces cannot have an implementation.");
 		if (_function.visibility() < FunctionDefinition::Visibility::Public)
-			typeError(_function.location(), "Functions in interfaces cannot be internal or private.");
+			m_errorReporter.typeError(_function.location(), "Functions in interfaces cannot be internal or private.");
 		if (_function.isConstructor())
-			typeError(_function.location(), "Constructor cannot be defined in interfaces.");
+			m_errorReporter.typeError(_function.location(), "Constructor cannot be defined in interfaces.");
 	}
 	if (_function.isImplemented())
 		_function.body().accept(*this);
@@ -489,7 +488,7 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 bool TypeChecker::visit(VariableDeclaration const& _variable)
 {
 	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
-		typeError(_variable.location(), "Variables cannot be declared in interfaces.");
+		m_errorReporter.typeError(_variable.location(), "Variables cannot be declared in interfaces.");
 
 	// Variables can be declared without type (with "var"), in which case the first assignment
 	// sets the type.
@@ -505,19 +504,19 @@ bool TypeChecker::visit(VariableDeclaration const& _variable)
 	if (_variable.isConstant())
 	{
 		if (!_variable.isStateVariable())
-			typeError(_variable.location(), "Illegal use of \"constant\" specifier.");
+			m_errorReporter.typeError(_variable.location(), "Illegal use of \"constant\" specifier.");
 		if (!_variable.type()->isValueType())
 		{
 			bool allowed = false;
 			if (auto arrayType = dynamic_cast<ArrayType const*>(_variable.type().get()))
 				allowed = arrayType->isString();
 			if (!allowed)
-				typeError(_variable.location(), "Constants of non-value type not yet implemented.");
+				m_errorReporter.typeError(_variable.location(), "Constants of non-value type not yet implemented.");
 		}
 		if (!_variable.value())
-			typeError(_variable.location(), "Uninitialized \"constant\" variable.");
+			m_errorReporter.typeError(_variable.location(), "Uninitialized \"constant\" variable.");
 		else if (!_variable.value()->annotation().isPure)
-			warning(
+			m_errorReporter.warning(
 				_variable.value()->location(),
 				"Initial value for constant variable has to be compile-time constant. "
 				"This will fail to compile with the next breaking version change."
@@ -527,20 +526,20 @@ bool TypeChecker::visit(VariableDeclaration const& _variable)
 	{
 		if (varType->dataStoredIn(DataLocation::Memory) || varType->dataStoredIn(DataLocation::CallData))
 			if (!varType->canLiveOutsideStorage())
-				typeError(_variable.location(), "Type " + varType->toString() + " is only valid in storage.");
+				m_errorReporter.typeError(_variable.location(), "Type " + varType->toString() + " is only valid in storage.");
 	}
 	else if (
 		_variable.visibility() >= VariableDeclaration::Visibility::Public &&
 		!FunctionType(_variable).interfaceFunctionType()
 	)
-		typeError(_variable.location(), "Internal type is not allowed for public state variables.");
+		m_errorReporter.typeError(_variable.location(), "Internal type is not allowed for public state variables.");
 	return false;
 }
 
 bool TypeChecker::visit(EnumDefinition const& _enum)
 {
 	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
-		typeError(_enum.location(), "Enumerable cannot be declared in interfaces.");
+		m_errorReporter.typeError(_enum.location(), "Enumerable cannot be declared in interfaces.");
 	return false;
 }
 
@@ -572,12 +571,12 @@ void TypeChecker::visitManually(
 			}
 	if (!parameters)
 	{
-		typeError(_modifier.location(), "Referenced declaration is neither modifier nor base class.");
+		m_errorReporter.typeError(_modifier.location(), "Referenced declaration is neither modifier nor base class.");
 		return;
 	}
 	if (parameters->size() != arguments.size())
 	{
-		typeError(
+		m_errorReporter.typeError(
 			_modifier.location(),
 			"Wrong argument count for modifier invocation: " +
 			toString(arguments.size()) +
@@ -589,7 +588,7 @@ void TypeChecker::visitManually(
 	}
 	for (size_t i = 0; i < _modifier.arguments().size(); ++i)
 		if (!type(*arguments[i])->isImplicitlyConvertibleTo(*type(*(*parameters)[i])))
-			typeError(
+			m_errorReporter.typeError(
 				arguments[i]->location(),
 				"Invalid type for argument in modifier invocation. "
 				"Invalid implicit conversion from " +
@@ -608,13 +607,13 @@ bool TypeChecker::visit(EventDefinition const& _eventDef)
 		if (var->isIndexed())
 			numIndexed++;
 		if (_eventDef.isAnonymous() && numIndexed > 4)
-			typeError(_eventDef.location(), "More than 4 indexed arguments for anonymous event.");
+			m_errorReporter.typeError(_eventDef.location(), "More than 4 indexed arguments for anonymous event.");
 		else if (!_eventDef.isAnonymous() && numIndexed > 3)
-			typeError(_eventDef.location(), "More than 3 indexed arguments for event.");
+			m_errorReporter.typeError(_eventDef.location(), "More than 3 indexed arguments for event.");
 		if (!type(*var)->canLiveOutsideStorage())
-			typeError(var->location(), "Type is required to live outside storage.");
+			m_errorReporter.typeError(var->location(), "Type is required to live outside storage.");
 		if (!type(*var)->interfaceType(false))
-			typeError(var->location(), "Internal type is not allowed as event parameter type.");
+			m_errorReporter.typeError(var->location(), "Internal type is not allowed as event parameter type.");
 	}
 	return false;
 }
@@ -624,7 +623,7 @@ void TypeChecker::endVisit(FunctionTypeName const& _funType)
 	FunctionType const& fun = dynamic_cast<FunctionType const&>(*_funType.annotation().type);
 	if (fun.kind() == FunctionType::Kind::External)
 		if (!fun.canBeUsedExternally(false))
-			typeError(_funType.location(), "External function type uses internal types.");
+			m_errorReporter.typeError(_funType.location(), "External function type uses internal types.");
 }
 
 bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
@@ -647,39 +646,39 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 			{
 				if (!var->isStateVariable() && !var->type()->dataStoredIn(DataLocation::Storage))
 				{
-					typeError(_identifier.location, "The suffixes _offset and _slot can only be used on storage variables.");
+					m_errorReporter.typeError(_identifier.location, "The suffixes _offset and _slot can only be used on storage variables.");
 					return size_t(-1);
 				}
 				else if (_context != julia::IdentifierContext::RValue)
 				{
-					typeError(_identifier.location, "Storage variables cannot be assigned to.");
+					m_errorReporter.typeError(_identifier.location, "Storage variables cannot be assigned to.");
 					return size_t(-1);
 				}
 			}
 			else if (var->isConstant())
 			{
-				typeError(_identifier.location, "Constant variables not supported by inline assembly.");
+				m_errorReporter.typeError(_identifier.location, "Constant variables not supported by inline assembly.");
 				return size_t(-1);
 			}
 			else if (!var->isLocalVariable())
 			{
-				typeError(_identifier.location, "Only local variables are supported. To access storage variables, use the _slot and _offset suffixes.");
+				m_errorReporter.typeError(_identifier.location, "Only local variables are supported. To access storage variables, use the _slot and _offset suffixes.");
 				return size_t(-1);
 			}
 			else if (var->type()->dataStoredIn(DataLocation::Storage))
 			{
-				typeError(_identifier.location, "You have to use the _slot or _offset prefix to access storage reference variables.");
+				m_errorReporter.typeError(_identifier.location, "You have to use the _slot or _offset prefix to access storage reference variables.");
 				return size_t(-1);
 			}
 			else if (var->type()->sizeOnStack() != 1)
 			{
-				typeError(_identifier.location, "Only types that use one stack slot are supported.");
+				m_errorReporter.typeError(_identifier.location, "Only types that use one stack slot are supported.");
 				return size_t(-1);
 			}
 		}
 		else if (_context == julia::IdentifierContext::LValue)
 		{
-			typeError(_identifier.location, "Only local variables can be assigned to in inline assembly.");
+			m_errorReporter.typeError(_identifier.location, "Only local variables can be assigned to in inline assembly.");
 			return size_t(-1);
 		}
 
@@ -696,7 +695,7 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 			{
 				if (!contract->isLibrary())
 				{
-					typeError(_identifier.location, "Expected a library.");
+					m_errorReporter.typeError(_identifier.location, "Expected a library.");
 					return size_t(-1);
 				}
 			}
@@ -710,7 +709,7 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 	_inlineAssembly.annotation().analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
 	assembly::AsmAnalyzer analyzer(
 		*_inlineAssembly.annotation().analysisInfo,
-		m_errors,
+		m_errorReporter,
 		false,
 		identifierAccess
 	);
@@ -754,7 +753,7 @@ void TypeChecker::endVisit(Return const& _return)
 	ParameterList const* params = _return.annotation().functionReturnParameters;
 	if (!params)
 	{
-		typeError(_return.location(), "Return arguments not allowed.");
+		m_errorReporter.typeError(_return.location(), "Return arguments not allowed.");
 		return;
 	}
 	TypePointers returnTypes;
@@ -763,9 +762,9 @@ void TypeChecker::endVisit(Return const& _return)
 	if (auto tupleType = dynamic_cast<TupleType const*>(type(*_return.expression()).get()))
 	{
 		if (tupleType->components().size() != params->parameters().size())
-			typeError(_return.location(), "Different number of arguments in return statement than in returns declaration.");
+			m_errorReporter.typeError(_return.location(), "Different number of arguments in return statement than in returns declaration.");
 		else if (!tupleType->isImplicitlyConvertibleTo(TupleType(returnTypes)))
-			typeError(
+			m_errorReporter.typeError(
 				_return.expression()->location(),
 				"Return argument type " +
 				type(*_return.expression())->toString() +
@@ -775,12 +774,12 @@ void TypeChecker::endVisit(Return const& _return)
 			);
 	}
 	else if (params->parameters().size() != 1)
-		typeError(_return.location(), "Different number of arguments in return statement than in returns declaration.");
+		m_errorReporter.typeError(_return.location(), "Different number of arguments in return statement than in returns declaration.");
 	else
 	{
 		TypePointer const& expected = type(*params->parameters().front());
 		if (!type(*_return.expression())->isImplicitlyConvertibleTo(*expected))
-			typeError(
+			m_errorReporter.typeError(
 				_return.expression()->location(),
 				"Return argument type " +
 				type(*_return.expression())->toString() +
@@ -797,20 +796,20 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 	{
 		// No initial value is only permitted for single variables with specified type.
 		if (_statement.declarations().size() != 1 || !_statement.declarations().front())
-			fatalTypeError(_statement.location(), "Assignment necessary for type detection.");
+			m_errorReporter.fatalTypeError(_statement.location(), "Assignment necessary for type detection.");
 		VariableDeclaration const& varDecl = *_statement.declarations().front();
 		if (!varDecl.annotation().type)
-			fatalTypeError(_statement.location(), "Assignment necessary for type detection.");
+			m_errorReporter.fatalTypeError(_statement.location(), "Assignment necessary for type detection.");
 		if (auto ref = dynamic_cast<ReferenceType const*>(type(varDecl).get()))
 		{
 			if (ref->dataStoredIn(DataLocation::Storage))
-				warning(
+				m_errorReporter.warning(
 					varDecl.location(),
 					"Uninitialized storage pointer. Did you mean '<type> memory " + varDecl.name() + "'?"
 				);
 		}
 		else if (dynamic_cast<MappingType const*>(type(varDecl).get()))
-			typeError(
+			m_errorReporter.typeError(
 				varDecl.location(),
 				"Uninitialized mapping. Mappings cannot be created dynamically, you have to assign them from a state variable."
 			);
@@ -836,7 +835,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 	if (variables.empty())
 	{
 		if (!valueTypes.empty())
-			fatalTypeError(
+			m_errorReporter.fatalTypeError(
 				_statement.location(),
 				"Too many components (" +
 				toString(valueTypes.size()) +
@@ -844,7 +843,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 			);
 	}
 	else if (valueTypes.size() != variables.size() && !variables.front() && !variables.back())
-		fatalTypeError(
+		m_errorReporter.fatalTypeError(
 			_statement.location(),
 			"Wildcard both at beginning and end of variable declaration list is only allowed "
 			"if the number of components is equal."
@@ -853,7 +852,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 	if (!variables.empty() && (!variables.back() || !variables.front()))
 		--minNumValues;
 	if (valueTypes.size() < minNumValues)
-		fatalTypeError(
+		m_errorReporter.fatalTypeError(
 			_statement.location(),
 			"Not enough components (" +
 			toString(valueTypes.size()) +
@@ -861,7 +860,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 			toString(minNumValues) + ")."
 		);
 	if (valueTypes.size() > variables.size() && variables.front() && variables.back())
-		fatalTypeError(
+		m_errorReporter.fatalTypeError(
 			_statement.location(),
 			"Too many components (" +
 			toString(valueTypes.size()) +
@@ -892,7 +891,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 			if (!var.annotation().type)
 			{
 				if (valueComponentType->category() == Type::Category::RationalNumber)
-					fatalTypeError(
+					m_errorReporter.fatalTypeError(
 						_statement.initialValue()->location(),
 						"Invalid rational " +
 						valueComponentType->toString() +
@@ -902,7 +901,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 					solAssert(false, "");
 			}
 			else if (*var.annotation().type == TupleType())
-				typeError(
+				m_errorReporter.typeError(
 					var.location(),
 					"Cannot declare variable with void (empty tuple) type."
 				);
@@ -918,7 +917,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 					dynamic_cast<RationalNumberType const&>(*valueComponentType).isFractional() &&
 					valueComponentType->mobileType()
 				)
-					typeError(
+					m_errorReporter.typeError(
 						_statement.location(),
 						"Type " +
 						valueComponentType->toString() +
@@ -929,7 +928,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 						" or use an explicit conversion." 
 					);
 				else
-					typeError(
+					m_errorReporter.typeError(
 						_statement.location(),
 						"Type " +
 						valueComponentType->toString() +
@@ -947,7 +946,7 @@ void TypeChecker::endVisit(ExpressionStatement const& _statement)
 {
 	if (type(_statement.expression())->category() == Type::Category::RationalNumber)
 		if (!dynamic_cast<RationalNumberType const&>(*type(_statement.expression())).mobileType())
-			typeError(_statement.expression().location(), "Invalid rational number.");
+			m_errorReporter.typeError(_statement.expression().location(), "Invalid rational number.");
 
 	if (auto call = dynamic_cast<FunctionCall const*>(&_statement.expression()))
 	{
@@ -959,9 +958,9 @@ void TypeChecker::endVisit(ExpressionStatement const& _statement)
 				kind == FunctionType::Kind::BareCallCode ||
 				kind == FunctionType::Kind::BareDelegateCall
 			)
-				warning(_statement.location(), "Return value of low-level calls not used.");
+				m_errorReporter.warning(_statement.location(), "Return value of low-level calls not used.");
 			else if (kind == FunctionType::Kind::Send)
-				warning(_statement.location(), "Failure condition of 'send' ignored. Consider using 'transfer' instead.");
+				m_errorReporter.warning(_statement.location(), "Failure condition of 'send' ignored. Consider using 'transfer' instead.");
 		}
 	}
 }
@@ -976,14 +975,14 @@ bool TypeChecker::visit(Conditional const& _conditional)
 	TypePointer trueType = type(_conditional.trueExpression())->mobileType();
 	TypePointer falseType = type(_conditional.falseExpression())->mobileType();
 	if (!trueType)
-		fatalTypeError(_conditional.trueExpression().location(), "Invalid mobile type.");
+		m_errorReporter.fatalTypeError(_conditional.trueExpression().location(), "Invalid mobile type.");
 	if (!falseType)
-		fatalTypeError(_conditional.falseExpression().location(), "Invalid mobile type.");
+		m_errorReporter.fatalTypeError(_conditional.falseExpression().location(), "Invalid mobile type.");
 
 	TypePointer commonType = Type::commonType(trueType, falseType);
 	if (!commonType)
 	{
-		typeError(
+		m_errorReporter.typeError(
 				_conditional.location(),
 				"True expression's type " +
 				trueType->toString() +
@@ -1003,7 +1002,7 @@ bool TypeChecker::visit(Conditional const& _conditional)
 		_conditional.falseExpression().annotation().isPure;
 
 	if (_conditional.annotation().lValueRequested)
-		typeError(
+		m_errorReporter.typeError(
 				_conditional.location(),
 				"Conditional expression as left value is not supported yet."
 		);
@@ -1019,7 +1018,7 @@ bool TypeChecker::visit(Assignment const& _assignment)
 	if (TupleType const* tupleType = dynamic_cast<TupleType const*>(t.get()))
 	{
 		if (_assignment.assignmentOperator() != Token::Assign)
-			typeError(
+			m_errorReporter.typeError(
 				_assignment.location(),
 				"Compound assignment is not allowed for tuple types."
 			);
@@ -1029,7 +1028,7 @@ bool TypeChecker::visit(Assignment const& _assignment)
 	}
 	else if (t->category() == Type::Category::Mapping)
 	{
-		typeError(_assignment.location(), "Mappings cannot be assigned to.");
+		m_errorReporter.typeError(_assignment.location(), "Mappings cannot be assigned to.");
 		_assignment.rightHandSide().accept(*this);
 	}
 	else if (_assignment.assignmentOperator() == Token::Assign)
@@ -1043,7 +1042,7 @@ bool TypeChecker::visit(Assignment const& _assignment)
 			type(_assignment.rightHandSide())
 		);
 		if (!resultType || *resultType != *t)
-			typeError(
+			m_errorReporter.typeError(
 				_assignment.location(),
 				"Operator " +
 				string(Token::toString(_assignment.assignmentOperator())) +
@@ -1064,7 +1063,7 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 	if (_tuple.annotation().lValueRequested)
 	{
 		if (_tuple.isInlineArray())
-			fatalTypeError(_tuple.location(), "Inline array type cannot be declared as LValue.");
+			m_errorReporter.fatalTypeError(_tuple.location(), "Inline array type cannot be declared as LValue.");
 		for (auto const& component: components)
 			if (component)
 			{
@@ -1088,7 +1087,7 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 		{
 			// Outside of an lvalue-context, the only situation where a component can be empty is (x,).
 			if (!components[i] && !(i == 1 && components.size() == 2))
-				fatalTypeError(_tuple.location(), "Tuple component cannot be empty.");
+				m_errorReporter.fatalTypeError(_tuple.location(), "Tuple component cannot be empty.");
 			else if (components[i])
 			{
 				components[i]->accept(*this);
@@ -1098,7 +1097,7 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 				if (_tuple.isInlineArray())
 				{
 					if ((i == 0 || inlineArrayType) && !types[i]->mobileType())
-						fatalTypeError(components[i]->location(), "Invalid mobile type.");
+						m_errorReporter.fatalTypeError(components[i]->location(), "Invalid mobile type.");
 
 					if (i == 0)
 						inlineArrayType = types[i]->mobileType();
@@ -1115,7 +1114,7 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 		if (_tuple.isInlineArray())
 		{
 			if (!inlineArrayType) 
-				fatalTypeError(_tuple.location(), "Unable to deduce common type for array elements.");
+				m_errorReporter.fatalTypeError(_tuple.location(), "Unable to deduce common type for array elements.");
 			_tuple.annotation().type = make_shared<ArrayType>(DataLocation::Memory, inlineArrayType, types.size());
 		}
 		else
@@ -1147,7 +1146,7 @@ bool TypeChecker::visit(UnaryOperation const& _operation)
 	TypePointer t = type(_operation.subExpression())->unaryOperatorResult(op);
 	if (!t)
 	{
-		typeError(
+		m_errorReporter.typeError(
 			_operation.location(),
 			"Unary operator " +
 			string(Token::toString(op)) +
@@ -1168,7 +1167,7 @@ void TypeChecker::endVisit(BinaryOperation const& _operation)
 	TypePointer commonType = leftType->binaryOperatorResult(_operation.getOperator(), rightType);
 	if (!commonType)
 	{
-		typeError(
+		m_errorReporter.typeError(
 			_operation.location(),
 			"Operator " +
 			string(Token::toString(_operation.getOperator())) +
@@ -1201,7 +1200,7 @@ void TypeChecker::endVisit(BinaryOperation const& _operation)
 				commonType->category() == Type::Category::FixedPoint &&
 				dynamic_cast<FixedPointType const&>(*commonType).numBits() != 256
 			))
-				warning(
+				m_errorReporter.warning(
 					_operation.location(),
 					"Result of exponentiation has type " + commonType->toString() + " and thus "
 					"might overflow. Silence this warning by converting the literal to the "
@@ -1254,9 +1253,9 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		TypeType const& t = dynamic_cast<TypeType const&>(*expressionType);
 		TypePointer resultType = t.actualType();
 		if (arguments.size() != 1)
-			typeError(_functionCall.location(), "Exactly one argument expected for explicit type conversion.");
+			m_errorReporter.typeError(_functionCall.location(), "Exactly one argument expected for explicit type conversion.");
 		else if (!isPositionalCall)
-			typeError(_functionCall.location(), "Type conversion cannot allow named arguments.");
+			m_errorReporter.typeError(_functionCall.location(), "Type conversion cannot allow named arguments.");
 		else
 		{
 			TypePointer const& argType = type(*arguments.front());
@@ -1265,7 +1264,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 				// (data location cannot yet be specified for type conversions)
 				resultType = ReferenceType::copyForLocationIfReference(argRefType->location(), resultType);
 			if (!argType->isExplicitlyConvertibleTo(*resultType))
-				typeError(_functionCall.location(), "Explicit type conversion not allowed.");
+				m_errorReporter.typeError(_functionCall.location(), "Explicit type conversion not allowed.");
 		}
 		_functionCall.annotation().type = resultType;
 		_functionCall.annotation().isPure = isPure;
@@ -1298,7 +1297,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 
 	if (!functionType)
 	{
-		typeError(_functionCall.location(), "Type is not callable");
+		m_errorReporter.typeError(_functionCall.location(), "Type is not callable");
 		_functionCall.annotation().type = make_shared<TupleType>();
 		return false;
 	}
@@ -1323,7 +1322,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			for (auto const& member: membersRemovedForStructConstructor)
 				msg += " " + member;
 		}
-		typeError(_functionCall.location(), msg);
+		m_errorReporter.typeError(_functionCall.location(), msg);
 	}
 	else if (isPositionalCall)
 	{
@@ -1335,10 +1334,10 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			{
 				if (auto t = dynamic_cast<RationalNumberType const*>(argType.get()))
 					if (!t->mobileType())
-						typeError(arguments[i]->location(), "Invalid rational number (too large or division by zero).");
+						m_errorReporter.typeError(arguments[i]->location(), "Invalid rational number (too large or division by zero).");
 			}
 			else if (!type(*arguments[i])->isImplicitlyConvertibleTo(*parameterTypes[i]))
-				typeError(
+				m_errorReporter.typeError(
 					arguments[i]->location(),
 					"Invalid type for argument in function call. "
 					"Invalid implicit conversion from " +
@@ -1354,14 +1353,14 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		// call by named arguments
 		auto const& parameterNames = functionType->parameterNames();
 		if (functionType->takesArbitraryParameters())
-			typeError(
+			m_errorReporter.typeError(
 				_functionCall.location(),
 				"Named arguments cannnot be used for functions that take arbitrary parameters."
 			);
 		else if (parameterNames.size() > argumentNames.size())
-			typeError(_functionCall.location(), "Some argument names are missing.");
+			m_errorReporter.typeError(_functionCall.location(), "Some argument names are missing.");
 		else if (parameterNames.size() < argumentNames.size())
-			typeError(_functionCall.location(), "Too many arguments.");
+			m_errorReporter.typeError(_functionCall.location(), "Too many arguments.");
 		else
 		{
 			// check duplicate names
@@ -1371,7 +1370,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 					if (*argumentNames[i] == *argumentNames[j])
 					{
 						duplication = true;
-						typeError(arguments[i]->location(), "Duplicate named argument.");
+						m_errorReporter.typeError(arguments[i]->location(), "Duplicate named argument.");
 					}
 
 			// check actual types
@@ -1385,7 +1384,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 							found = true;
 							// check type convertible
 							if (!type(*arguments[i])->isImplicitlyConvertibleTo(*parameterTypes[j]))
-								typeError(
+								m_errorReporter.typeError(
 									arguments[i]->location(),
 									"Invalid type for argument in function call. "
 									"Invalid implicit conversion from " +
@@ -1398,7 +1397,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 						}
 
 					if (!found)
-						typeError(
+						m_errorReporter.typeError(
 							_functionCall.location(),
 							"Named argument does not match function declaration."
 						);
@@ -1419,11 +1418,11 @@ void TypeChecker::endVisit(NewExpression const& _newExpression)
 		auto contract = dynamic_cast<ContractDefinition const*>(&dereference(*contractName));
 
 		if (!contract)
-			fatalTypeError(_newExpression.location(), "Identifier is not a contract.");
+			m_errorReporter.fatalTypeError(_newExpression.location(), "Identifier is not a contract.");
 		if (!contract->annotation().isFullyImplemented)
-			typeError(_newExpression.location(), "Trying to create an instance of an abstract contract.");
+			m_errorReporter.typeError(_newExpression.location(), "Trying to create an instance of an abstract contract.");
 		if (!contract->constructorIsPublic())
-			typeError(_newExpression.location(), "Contract with internal constructor cannot be created directly.");
+			m_errorReporter.typeError(_newExpression.location(), "Contract with internal constructor cannot be created directly.");
 
 		solAssert(!!m_scope, "");
 		m_scope->annotation().contractDependencies.insert(contract);
@@ -1432,7 +1431,7 @@ void TypeChecker::endVisit(NewExpression const& _newExpression)
 			"Linearized base contracts not yet available."
 		);
 		if (contractDependenciesAreCyclic(*m_scope))
-			typeError(
+			m_errorReporter.typeError(
 				_newExpression.location(),
 				"Circular reference for contract creation (cannot create instance of derived or same contract)."
 			);
@@ -1442,12 +1441,12 @@ void TypeChecker::endVisit(NewExpression const& _newExpression)
 	else if (type->category() == Type::Category::Array)
 	{
 		if (!type->canLiveOutsideStorage())
-			fatalTypeError(
+			m_errorReporter.fatalTypeError(
 				_newExpression.typeName().location(),
 				"Type cannot live outside storage."
 			);
 		if (!type->isDynamicallySized())
-			typeError(
+			m_errorReporter.typeError(
 				_newExpression.typeName().location(),
 				"Length has to be placed in parentheses after the array type for new expression."
 			);
@@ -1462,7 +1461,7 @@ void TypeChecker::endVisit(NewExpression const& _newExpression)
 		_newExpression.annotation().isPure = true;
 	}
 	else
-		fatalTypeError(_newExpression.location(), "Contract or array type expected.");
+		m_errorReporter.fatalTypeError(_newExpression.location(), "Contract or array type expected.");
 }
 
 bool TypeChecker::visit(MemberAccess const& _memberAccess)
@@ -1493,13 +1492,13 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 			exprType
 		);
 		if (!storageType->members(m_scope).membersByName(memberName).empty())
-			fatalTypeError(
+			m_errorReporter.fatalTypeError(
 				_memberAccess.location(),
 				"Member \"" + memberName + "\" is not available in " +
 				exprType->toString() +
 				" outside of storage."
 			);
-		fatalTypeError(
+		m_errorReporter.fatalTypeError(
 			_memberAccess.location(),
 			"Member \"" + memberName + "\" not found or not visible "
 			"after argument-dependent lookup in " + exprType->toString() +
@@ -1507,7 +1506,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 		);
 	}
 	else if (possibleMembers.size() > 1)
-		fatalTypeError(
+		m_errorReporter.fatalTypeError(
 			_memberAccess.location(),
 			"Member \"" + memberName + "\" not unique "
 			"after argument-dependent lookup in " + exprType->toString() +
@@ -1520,7 +1519,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 
 	if (auto funType = dynamic_cast<FunctionType const*>(annotation.type.get()))
 		if (funType->bound() && !exprType->isImplicitlyConvertibleTo(*funType->selfType()))
-			typeError(
+			m_errorReporter.typeError(
 				_memberAccess.location(),
 				"Function \"" + memberName + "\" cannot be called on an object of type " +
 				exprType->toString() + " (expected " + funType->selfType()->toString() + ")"
@@ -1568,10 +1567,10 @@ bool TypeChecker::visit(IndexAccess const& _access)
 	{
 		ArrayType const& actualType = dynamic_cast<ArrayType const&>(*baseType);
 		if (!index)
-			typeError(_access.location(), "Index expression cannot be omitted.");
+			m_errorReporter.typeError(_access.location(), "Index expression cannot be omitted.");
 		else if (actualType.isString())
 		{
-			typeError(_access.location(), "Index access for string is not possible.");
+			m_errorReporter.typeError(_access.location(), "Index access for string is not possible.");
 			index->accept(*this);
 		}
 		else
@@ -1581,7 +1580,7 @@ bool TypeChecker::visit(IndexAccess const& _access)
 			{
 				if (!numberType->isFractional()) // error is reported above
 					if (!actualType.isDynamicallySized() && actualType.length() <= numberType->literalValue(nullptr))
-						typeError(_access.location(), "Out of bounds array access.");
+						m_errorReporter.typeError(_access.location(), "Out of bounds array access.");
 			}
 		}
 		resultType = actualType.baseType();
@@ -1592,7 +1591,7 @@ bool TypeChecker::visit(IndexAccess const& _access)
 	{
 		MappingType const& actualType = dynamic_cast<MappingType const&>(*baseType);
 		if (!index)
-			typeError(_access.location(), "Index expression cannot be omitted.");
+			m_errorReporter.typeError(_access.location(), "Index expression cannot be omitted.");
 		else
 			expectType(*index, *actualType.keyType());
 		resultType = actualType.valueType();
@@ -1614,7 +1613,7 @@ bool TypeChecker::visit(IndexAccess const& _access)
 					length->literalValue(nullptr)
 				));
 			else
-				fatalTypeError(index->location(), "Integer constant expected.");
+				m_errorReporter.fatalTypeError(index->location(), "Integer constant expected.");
 		}
 		break;
 	}
@@ -1622,20 +1621,20 @@ bool TypeChecker::visit(IndexAccess const& _access)
 	{
 		FixedBytesType const& bytesType = dynamic_cast<FixedBytesType const&>(*baseType);
 		if (!index)
-			typeError(_access.location(), "Index expression cannot be omitted.");
+			m_errorReporter.typeError(_access.location(), "Index expression cannot be omitted.");
 		else
 		{
 			expectType(*index, IntegerType(256));
 			if (auto integerType = dynamic_cast<RationalNumberType const*>(type(*index).get()))
 				if (bytesType.numBytes() <= integerType->literalValue(nullptr))
-					typeError(_access.location(), "Out of bounds array access.");
+					m_errorReporter.typeError(_access.location(), "Out of bounds array access.");
 		}
 		resultType = make_shared<FixedBytesType>(1);
 		isLValue = false; // @todo this heavily depends on how it is embedded
 		break;
 	}
 	default:
-		fatalTypeError(
+		m_errorReporter.fatalTypeError(
 			_access.baseExpression().location(),
 			"Indexed expression has to be a type, mapping or array (is " + baseType->toString() + ")"
 		);
@@ -1665,14 +1664,14 @@ bool TypeChecker::visit(Identifier const& _identifier)
 					candidates.push_back(declaration);
 			}
 			if (candidates.empty())
-				fatalTypeError(_identifier.location(), "No matching declaration found after variable lookup.");
+				m_errorReporter.fatalTypeError(_identifier.location(), "No matching declaration found after variable lookup.");
 			else if (candidates.size() == 1)
 				annotation.referencedDeclaration = candidates.front();
 			else
-				fatalTypeError(_identifier.location(), "No unique declaration found after variable lookup.");
+				m_errorReporter.fatalTypeError(_identifier.location(), "No unique declaration found after variable lookup.");
 		}
 		else if (annotation.overloadedDeclarations.empty())
-			fatalTypeError(_identifier.location(), "No candidates for overload resolution found.");
+			m_errorReporter.fatalTypeError(_identifier.location(), "No candidates for overload resolution found.");
 		else if (annotation.overloadedDeclarations.size() == 1)
 			annotation.referencedDeclaration = *annotation.overloadedDeclarations.begin();
 		else
@@ -1688,11 +1687,11 @@ bool TypeChecker::visit(Identifier const& _identifier)
 					candidates.push_back(declaration);
 			}
 			if (candidates.empty())
-				fatalTypeError(_identifier.location(), "No matching declaration found after argument-dependent lookup.");
+				m_errorReporter.fatalTypeError(_identifier.location(), "No matching declaration found after argument-dependent lookup.");
 			else if (candidates.size() == 1)
 				annotation.referencedDeclaration = candidates.front();
 			else
-				fatalTypeError(_identifier.location(), "No unique declaration found after argument-dependent lookup.");
+				m_errorReporter.fatalTypeError(_identifier.location(), "No unique declaration found after argument-dependent lookup.");
 		}
 	}
 	solAssert(
@@ -1702,7 +1701,7 @@ bool TypeChecker::visit(Identifier const& _identifier)
 	annotation.isLValue = annotation.referencedDeclaration->isLValue();
 	annotation.type = annotation.referencedDeclaration->type();
 	if (!annotation.type)
-		fatalTypeError(_identifier.location(), "Declaration referenced before type could be determined.");
+		m_errorReporter.fatalTypeError(_identifier.location(), "Declaration referenced before type could be determined.");
 	if (auto variableDeclaration = dynamic_cast<VariableDeclaration const*>(annotation.referencedDeclaration))
 		annotation.isPure = annotation.isConstant = variableDeclaration->isConstant();
 	else if (dynamic_cast<MagicVariableDeclaration const*>(annotation.referencedDeclaration))
@@ -1727,7 +1726,7 @@ void TypeChecker::endVisit(Literal const& _literal)
 			return;
 		}
 		else
-			warning(
+			m_errorReporter.warning(
 				_literal.location(),
 				"This looks like an address but has an invalid checksum. "
 				"If this is not used as an address, please prepend '00'."
@@ -1736,7 +1735,7 @@ void TypeChecker::endVisit(Literal const& _literal)
 	_literal.annotation().type = Type::forLiteral(_literal);
 	_literal.annotation().isPure = true;
 	if (!_literal.annotation().type)
-		fatalTypeError(_literal.location(), "Invalid literal value.");
+		m_errorReporter.fatalTypeError(_literal.location(), "Invalid literal value.");
 }
 
 bool TypeChecker::contractDependenciesAreCyclic(
@@ -1777,7 +1776,7 @@ void TypeChecker::expectType(Expression const& _expression, Type const& _expecte
 			dynamic_pointer_cast<RationalNumberType const>(type(_expression))->isFractional() &&
 			type(_expression)->mobileType()
 		)
-			typeError(
+			m_errorReporter.typeError(
 				_expression.location(),
 				"Type " +
 				type(_expression)->toString() +
@@ -1788,7 +1787,7 @@ void TypeChecker::expectType(Expression const& _expression, Type const& _expecte
 				" or use an explicit conversion."
 			);
 		else
-			typeError(
+			m_errorReporter.typeError(
 				_expression.location(),
 				"Type " +
 				type(_expression)->toString() +
@@ -1805,33 +1804,8 @@ void TypeChecker::requireLValue(Expression const& _expression)
 	_expression.accept(*this);
 
 	if (_expression.annotation().isConstant)
-		typeError(_expression.location(), "Cannot assign to a constant variable.");
+		m_errorReporter.typeError(_expression.location(), "Cannot assign to a constant variable.");
 	else if (!_expression.annotation().isLValue)
-		typeError(_expression.location(), "Expression has to be an lvalue.");
-}
-
-void TypeChecker::typeError(SourceLocation const& _location, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::TypeError);
-	*err <<
-		errinfo_sourceLocation(_location) <<
-		errinfo_comment(_description);
-
-	m_errors.push_back(err);
+		m_errorReporter.typeError(_expression.location(), "Expression has to be an lvalue.");
 }
 
-void TypeChecker::warning(SourceLocation const& _location, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::Warning);
-	*err <<
-		errinfo_sourceLocation(_location) <<
-		errinfo_comment(_description);
-
-	m_errors.push_back(err);
-}
-
-void TypeChecker::fatalTypeError(SourceLocation const& _location, string const& _description)
-{
-	typeError(_location, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
-}
diff --git a/libsolidity/analysis/TypeChecker.h b/libsolidity/analysis/TypeChecker.h
index 88559f44..2fa66f97 100644
--- a/libsolidity/analysis/TypeChecker.h
+++ b/libsolidity/analysis/TypeChecker.h
@@ -22,7 +22,6 @@
 
 #pragma once
 
-#include <libsolidity/analysis/TypeChecker.h>
 #include <libsolidity/ast/Types.h>
 #include <libsolidity/ast/ASTAnnotations.h>
 #include <libsolidity/ast/ASTForward.h>
@@ -33,6 +32,7 @@ namespace dev
 namespace solidity
 {
 
+class ErrorReporter;
 
 /**
  * The module that performs type analysis on the AST, checks the applicability of operations on
@@ -43,7 +43,7 @@ class TypeChecker: private ASTConstVisitor
 {
 public:
 	/// @param _errors the reference to the list of errors and warnings to add them found during type checking.
-	TypeChecker(ErrorList& _errors): m_errors(_errors) {}
+	TypeChecker(ErrorReporter& _errorReporter): m_errorReporter(_errorReporter) {}
 
 	/// Performs type checking on the given contract and all of its sub-nodes.
 	/// @returns true iff all checks passed. Note even if all checks passed, errors() can still contain warnings
@@ -56,14 +56,6 @@ public:
 	TypePointer const& type(VariableDeclaration const& _variable) const;
 
 private:
-	/// Adds a new error to the list of errors.
-	void typeError(SourceLocation const& _location, std::string const& _description);
-
-	/// Adds a new warning to the list of errors.
-	void warning(SourceLocation const& _location, std::string const& _description);
-
-	/// Adds a new error to the list of errors and throws to abort type checking.
-	void fatalTypeError(SourceLocation const& _location, std::string const& _description);
 
 	virtual bool visit(ContractDefinition const& _contract) override;
 	/// Checks that two functions defined in this contract with the same name have different
@@ -127,7 +119,7 @@ private:
 
 	ContractDefinition const* m_scope = nullptr;
 
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index e79bb6dc..1fc06333 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -520,7 +520,8 @@ bool ContractCompiler::visit(FunctionDefinition const& _function)
 bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 {
 	ErrorList errors;
-	assembly::CodeGenerator codeGen(errors);
+	ErrorReporter errorReporter(errors);
+	assembly::CodeGenerator codeGen(errorReporter);
 	unsigned startStackHeight = m_context.stackHeight();
 	julia::ExternalIdentifierAccess identifierAccess;
 	identifierAccess.resolve = [&](assembly::Identifier const& _identifier, julia::IdentifierContext)
@@ -648,7 +649,7 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 		m_context.nonConstAssembly(),
 		identifierAccess
 	);
-	solAssert(Error::containsOnlyWarnings(errors), "Code generation for inline assembly with errors requested.");
+	solAssert(Error::containsOnlyWarnings(errorReporter.errors()), "Code generation for inline assembly with errors requested.");
 	m_context.setStackOffset(startStackHeight);
 	return false;
 }
diff --git a/libsolidity/formal/Why3Translator.cpp b/libsolidity/formal/Why3Translator.cpp
index 77d3c217..fecab2de 100644
--- a/libsolidity/formal/Why3Translator.cpp
+++ b/libsolidity/formal/Why3Translator.cpp
@@ -32,7 +32,7 @@ bool Why3Translator::process(SourceUnit const& _source)
 	try
 	{
 		if (m_lines.size() != 1 || !m_lines.back().contents.empty())
-			fatalError(_source, "Multiple source units not yet supported");
+			fatalError(_source, string("Multiple source units not yet supported"));
 		appendPreface();
 		_source.accept(*this);
 	}
@@ -55,22 +55,6 @@ string Why3Translator::translation() const
 	return result;
 }
 
-void Why3Translator::error(ASTNode const& _node, string const& _description)
-{
-	auto err = make_shared<Error>(Error::Type::Why3TranslatorError);
-	*err <<
-		errinfo_sourceLocation(_node.location()) <<
-		errinfo_comment(_description);
-	m_errors.push_back(err);
-	m_errorOccured = true;
-}
-
-void Why3Translator::fatalError(ASTNode const& _node, string const& _description)
-{
-	error(_node, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
-}
-
 string Why3Translator::toFormalType(Type const& _type) const
 {
 	if (_type.category() == Type::Category::Bool)
@@ -900,3 +884,15 @@ module Address
 end
    )", 0});
 }
+
+void Why3Translator::error(ASTNode const& _source, std::string const& _description)
+{
+	m_errorOccured = true;
+	m_errorReporter.why3TranslatorError(_source, _description);
+}
+void Why3Translator::fatalError(ASTNode const& _source, std::string const& _description)
+{
+	m_errorOccured = true;
+	m_errorReporter.fatalWhy3TranslatorError(_source, _description);
+}
+
diff --git a/libsolidity/formal/Why3Translator.h b/libsolidity/formal/Why3Translator.h
index 03f3bf9c..b48317be 100644
--- a/libsolidity/formal/Why3Translator.h
+++ b/libsolidity/formal/Why3Translator.h
@@ -23,7 +23,7 @@
 #pragma once
 
 #include <libsolidity/ast/ASTVisitor.h>
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <string>
 
 namespace dev
@@ -43,7 +43,7 @@ class SourceUnit;
 class Why3Translator: private ASTConstVisitor
 {
 public:
-	Why3Translator(ErrorList& _errors): m_lines(std::vector<Line>{{std::string(), 0}}), m_errors(_errors) {}
+	Why3Translator(ErrorReporter& _errorReporter): m_lines(std::vector<Line>{{std::string(), 0}}), m_errorReporter(_errorReporter) {}
 
 	/// Appends formalisation of the given source unit to the output.
 	/// @returns false on error.
@@ -52,11 +52,6 @@ public:
 	std::string translation() const;
 
 private:
-	/// Creates an error and adds it to errors list.
-	void error(ASTNode const& _node, std::string const& _description);
-	/// Reports a fatal error and throws.
-	void fatalError(ASTNode const& _node, std::string const& _description);
-
 	/// Appends imports and constants use throughout the formal code.
 	void appendPreface();
 
@@ -65,6 +60,9 @@ private:
 	using errinfo_noFormalTypeFrom = boost::error_info<struct tag_noFormalTypeFrom, std::string /* name of the type that cannot be translated */ >;
 	struct NoFormalType: virtual Exception {};
 
+	void error(ASTNode const& _source, std::string const& _description);
+	void fatalError(ASTNode const& _source, std::string const& _description);
+
 	void indent() { newLine(); m_lines.back().indentation++; }
 	void unindent();
 	void addLine(std::string const& _line);
@@ -98,7 +96,7 @@ private:
 
 	virtual bool visitNode(ASTNode const& _node) override
 	{
-		error(_node, "Code not supported for formal verification.");
+		m_errorReporter.why3TranslatorError(_node, "Code not supported for formal verification.");
 		return false;
 	}
 
@@ -142,7 +140,7 @@ private:
 		unsigned indentation;
 	};
 	std::vector<Line> m_lines;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 9f512f87..22e43127 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -46,7 +46,7 @@ set<string> const builtinTypes{"bool", "u8", "s8", "u32", "s32", "u64", "s64", "
 
 bool AsmAnalyzer::analyze(Block const& _block)
 {
-	if (!(ScopeFiller(m_info, m_errors))(_block))
+	if (!(ScopeFiller(m_info, m_errorReporter))(_block))
 		return false;
 
 	return (*this)(_block);
@@ -74,11 +74,10 @@ bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 	++m_stackHeight;
 	if (_literal.kind == assembly::LiteralKind::String && _literal.value.size() > 32)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
-			"String literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)",
-			_literal.location
-		));
+		m_errorReporter.typeError(
+			_literal.location,
+			"String literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)"
+		);
 		return false;
 	}
 	m_info.stackHeightInfo[&_literal] = m_stackHeight;
@@ -87,18 +86,17 @@ bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
 
 bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 {
-	size_t numErrorsBefore = m_errors.size();
+	size_t numErrorsBefore = m_errorReporter.errors().size();
 	bool success = true;
 	if (m_currentScope->lookup(_identifier.name, Scope::Visitor(
 		[&](Scope::Variable const& _var)
 		{
 			if (!_var.active)
 			{
-				m_errors.push_back(make_shared<Error>(
-					Error::Type::DeclarationError,
-					"Variable " + _identifier.name + " used before it was declared.",
-					_identifier.location
-				));
+				m_errorReporter.declarationError(
+					_identifier.location,
+					"Variable " + _identifier.name + " used before it was declared."
+				);
 				success = false;
 			}
 			++m_stackHeight;
@@ -109,11 +107,10 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 		},
 		[&](Scope::Function const&)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Function " + _identifier.name + " used without being called.",
-				_identifier.location
-			));
+			m_errorReporter.typeError(
+				_identifier.location,
+				"Function " + _identifier.name + " used without being called."
+			);
 			success = false;
 		}
 	)))
@@ -127,12 +124,8 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 		if (stackSize == size_t(-1))
 		{
 			// Only add an error message if the callback did not do it.
-			if (numErrorsBefore == m_errors.size())
-				m_errors.push_back(make_shared<Error>(
-					Error::Type::DeclarationError,
-					"Identifier not found.",
-					_identifier.location
-				));
+			if (numErrorsBefore == m_errorReporter.errors().size())
+				m_errorReporter.declarationError(_identifier.location, "Identifier not found.");
 			success = false;
 		}
 		m_stackHeight += stackSize == size_t(-1) ? 1 : stackSize;
@@ -187,11 +180,7 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	bool success = boost::apply_visitor(*this, *_varDecl.value);
 	if ((m_stackHeight - stackHeight) != expectedItems)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Variable count mismatch.",
-			_varDecl.location
-		));
+		m_errorReporter.declarationError(_varDecl.location, "Variable count mismatch.");
 		return false;
 	}
 
@@ -233,20 +222,18 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 	if (!m_currentScope->lookup(_funCall.functionName.name, Scope::Visitor(
 		[&](Scope::Variable const&)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Attempt to call variable instead of function.",
-				_funCall.functionName.location
-			));
+			m_errorReporter.typeError(
+				_funCall.functionName.location,
+				"Attempt to call variable instead of function."
+			);
 			success = false;
 		},
 		[&](Scope::Label const&)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Attempt to call label instead of function.",
-				_funCall.functionName.location
-				));
+			m_errorReporter.typeError(
+				_funCall.functionName.location,
+				"Attempt to call label instead of function."
+			);
 			success = false;
 		},
 		[&](Scope::Function const& _fun)
@@ -257,26 +244,18 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 		}
 	)))
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Function not found.",
-			_funCall.functionName.location
-		));
+		m_errorReporter.declarationError(_funCall.functionName.location, "Function not found.");
 		success = false;
 	}
 	if (success)
 	{
 		if (_funCall.arguments.size() != arguments)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Expected " +
-				boost::lexical_cast<string>(arguments) +
-				" arguments but got " +
-				boost::lexical_cast<string>(_funCall.arguments.size()) +
-				".",
-				_funCall.functionName.location
-				));
+			m_errorReporter.typeError(
+				_funCall.functionName.location,
+				"Expected " + boost::lexical_cast<string>(arguments) + " arguments but got " +
+				boost::lexical_cast<string>(_funCall.arguments.size()) + "."
+			);
 			success = false;
 		}
 	}
@@ -317,11 +296,10 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 			auto val = make_tuple(_case.value->kind, _case.value->value);
 			if (!cases.insert(val).second)
 			{
-				m_errors.push_back(make_shared<Error>(
-					Error::Type::DeclarationError,
-					"Duplicate case defined",
-					_case.location
-				));
+				m_errorReporter.declarationError(
+					_case.location,
+					"Duplicate case defined"
+				);
 				success = false;
 			}
 		}
@@ -354,16 +332,15 @@ bool AsmAnalyzer::operator()(Block const& _block)
 	int const stackDiff = m_stackHeight - initialStackHeight;
 	if (stackDiff != 0)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
+		m_errorReporter.declarationError(
+			_block.location,
 			"Unbalanced stack at the end of a block: " +
 			(
 				stackDiff > 0 ?
 				to_string(stackDiff) + string(" surplus item(s).") :
 				to_string(-stackDiff) + string(" missing item(s).")
-			),
-			_block.location
-		));
+			)
+		);
 		success = false;
 	}
 
@@ -375,27 +352,22 @@ bool AsmAnalyzer::operator()(Block const& _block)
 bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t _valueSize)
 {
 	bool success = true;
-	size_t numErrorsBefore = m_errors.size();
+	size_t numErrorsBefore = m_errorReporter.errors().size();
 	size_t variableSize(-1);
 	if (Scope::Identifier const* var = m_currentScope->lookup(_variable.name))
 	{
 		// Check that it is a variable
 		if (var->type() != typeid(Scope::Variable))
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::TypeError,
-				"Assignment requires variable.",
-				_variable.location
-			));
+			m_errorReporter.typeError(_variable.location, "Assignment requires variable.");
 			success = false;
 		}
 		else if (!boost::get<Scope::Variable>(*var).active)
 		{
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Variable " + _variable.name + " used before it was declared.",
-				_variable.location
-			));
+			m_errorReporter.declarationError(
+				_variable.location,
+				"Variable " + _variable.name + " used before it was declared."
+			);
 			success = false;
 		}
 		variableSize = 1;
@@ -405,12 +377,8 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 	if (variableSize == size_t(-1))
 	{
 		// Only add message if the callback did not.
-		if (numErrorsBefore == m_errors.size())
-			m_errors.push_back(make_shared<Error>(
-				Error::Type::DeclarationError,
-				"Variable not found or variable not lvalue.",
-				_variable.location
-			));
+		if (numErrorsBefore == m_errorReporter.errors().size())
+			m_errorReporter.declarationError(_variable.location, "Variable not found or variable not lvalue.");
 		success = false;
 	}
 	if (_valueSize == size_t(-1))
@@ -420,15 +388,14 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 
 	if (_valueSize != variableSize && variableSize != size_t(-1))
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
+		m_errorReporter.typeError(
+			_variable.location,
 			"Variable size (" +
 			to_string(variableSize) +
 			") and value size (" +
 			to_string(_valueSize) +
-			") do not match.",
-			_variable.location
-		));
+			") do not match."
+		);
 		success = false;
 	}
 	return success;
@@ -439,15 +406,14 @@ bool AsmAnalyzer::expectDeposit(int const _deposit, int const _oldHeight, Source
 	int stackDiff = m_stackHeight - _oldHeight;
 	if (stackDiff != _deposit)
 	{
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
+		m_errorReporter.typeError(
+			_location,
 			"Expected instruction(s) to deposit " +
 			boost::lexical_cast<string>(_deposit) +
 			" item(s) to the stack, but did deposit " +
 			boost::lexical_cast<string>(stackDiff) +
-			" item(s).",
-			_location
-		));
+			" item(s)."
+		);
 		return false;
 	}
 	else
@@ -468,9 +434,8 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 		return;
 
 	if (!builtinTypes.count(type))
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::TypeError,
-			"\"" + type + "\" is not a valid type (user defined types are not yet supported).",
-			_location
-		));
+		m_errorReporter.typeError(
+			_location,
+			"\"" + type + "\" is not a valid type (user defined types are not yet supported)."
+		);
 }
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 14b18c4a..7e4d78df 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -22,8 +22,6 @@
 
 #include <libsolidity/inlineasm/AsmStack.h>
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -33,6 +31,7 @@ namespace dev
 {
 namespace solidity
 {
+class ErrorReporter;
 namespace assembly
 {
 
@@ -63,10 +62,10 @@ class AsmAnalyzer: public boost::static_visitor<bool>
 public:
 	explicit AsmAnalyzer(
 		AsmAnalysisInfo& _analysisInfo,
-		ErrorList& _errors,
+		ErrorReporter& _errorReporter,
 		bool _julia = false,
 		julia::ExternalIdentifierAccess::Resolver const& _resolver = julia::ExternalIdentifierAccess::Resolver()
-	): m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors), m_julia(_julia) {}
+	): m_resolver(_resolver), m_info(_analysisInfo), m_errorReporter(_errorReporter), m_julia(_julia) {}
 
 	bool analyze(assembly::Block const& _block);
 
@@ -95,7 +94,7 @@ private:
 	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 	bool m_julia = false;
 };
 
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index af3547fd..11494c2d 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -107,7 +107,7 @@ eth::Assembly assembly::CodeGenerator::assemble(
 {
 	eth::Assembly assembly;
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 	return assembly;
 }
 
@@ -119,5 +119,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(m_errors, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index 1b43d2f6..f075fa93 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -23,7 +23,6 @@
 #pragma once
 
 #include <libsolidity/inlineasm/AsmAnalysis.h>
-#include <libsolidity/interface/Exceptions.h>
 
 #include <functional>
 
@@ -35,6 +34,7 @@ class Assembly;
 }
 namespace solidity
 {
+class ErrorReporter;
 namespace assembly
 {
 struct Block;
@@ -42,8 +42,8 @@ struct Block;
 class CodeGenerator
 {
 public:
-	CodeGenerator(ErrorList& _errors):
-		m_errors(_errors) {}
+	CodeGenerator(ErrorReporter& _errorReporter):
+		m_errorReporter(_errorReporter) {}
 	/// Performs code generation and @returns the result.
 	eth::Assembly assemble(
 		Block const& _parsedData,
@@ -59,7 +59,7 @@ public:
 	);
 
 private:
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 80409c63..0f836406 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -21,10 +21,10 @@
  */
 
 #include <libsolidity/inlineasm/AsmParser.h>
+#include <libsolidity/parsing/Scanner.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <ctype.h>
 #include <algorithm>
-#include <libsolidity/parsing/Scanner.h>
-#include <libsolidity/interface/Exceptions.h>
 
 using namespace std;
 using namespace dev;
@@ -40,7 +40,7 @@ shared_ptr<assembly::Block> Parser::parse(std::shared_ptr<Scanner> const& _scann
 	}
 	catch (FatalError const&)
 	{
-		if (m_errors.empty())
+		if (m_errorReporter.errors().empty())
 			throw; // Something is weird here, rather throw again.
 	}
 	return nullptr;
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index 138af337..e32b1d25 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -37,7 +37,7 @@ namespace assembly
 class Parser: public ParserBase
 {
 public:
-	explicit Parser(ErrorList& _errors, bool _julia = false): ParserBase(_errors), m_julia(_julia) {}
+	explicit Parser(ErrorReporter& _errorReporter, bool _julia = false): ParserBase(_errorReporter), m_julia(_julia) {}
 
 	/// Parses an inline assembly block starting with `{` and ending with `}`.
 	/// @returns an empty shared pointer on error.
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 3fade842..4d26dcf8 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -24,7 +24,7 @@
 #include <libsolidity/inlineasm/AsmScope.h>
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
@@ -37,8 +37,8 @@ using namespace dev;
 using namespace dev::solidity;
 using namespace dev::solidity::assembly;
 
-ScopeFiller::ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors):
-	m_info(_info), m_errors(_errors)
+ScopeFiller::ScopeFiller(AsmAnalysisInfo& _info, ErrorReporter& _errorReporter):
+	m_info(_info), m_errorReporter(_errorReporter)
 {
 	m_currentScope = &scope(nullptr);
 }
@@ -48,11 +48,10 @@ bool ScopeFiller::operator()(Label const& _item)
 	if (!m_currentScope->registerLabel(_item.name))
 	{
 		//@TODO secondary location
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Label name " + _item.name + " already taken in this scope.",
-			_item.location
-		));
+		m_errorReporter.declarationError(
+			_item.location,
+			"Label name " + _item.name + " already taken in this scope."
+		);
 		return false;
 	}
 	return true;
@@ -78,11 +77,10 @@ bool ScopeFiller::operator()(assembly::FunctionDefinition const& _funDef)
 	if (!m_currentScope->registerFunction(_funDef.name, arguments, returns))
 	{
 		//@TODO secondary location
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Function name " + _funDef.name + " already taken in this scope.",
-			_funDef.location
-		));
+		m_errorReporter.declarationError(
+			_funDef.location,
+			"Function name " + _funDef.name + " already taken in this scope."
+		);
 		success = false;
 	}
 
@@ -132,11 +130,10 @@ bool ScopeFiller::registerVariable(TypedName const& _name, SourceLocation const&
 	if (!_scope.registerVariable(_name.name, _name.type))
 	{
 		//@TODO secondary location
-		m_errors.push_back(make_shared<Error>(
-			Error::Type::DeclarationError,
-			"Variable name " + _name.name + " already taken in this scope.",
-			_location
-		));
+		m_errorReporter.declarationError(
+			_location,
+			"Variable name " + _name.name + " already taken in this scope."
+		);
 		return false;
 	}
 	return true;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 42e80141..1166d50f 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -20,8 +20,6 @@
 
 #pragma once
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -29,8 +27,10 @@
 
 namespace dev
 {
+struct SourceLocation;
 namespace solidity
 {
+class ErrorReporter;
 namespace assembly
 {
 
@@ -58,7 +58,7 @@ struct AsmAnalysisInfo;
 class ScopeFiller: public boost::static_visitor<bool>
 {
 public:
-	ScopeFiller(AsmAnalysisInfo& _info, ErrorList& _errors);
+	ScopeFiller(AsmAnalysisInfo& _info, ErrorReporter& _errorReporter);
 
 	bool operator()(assembly::Instruction const&) { return true; }
 	bool operator()(assembly::Literal const&) { return true; }
@@ -84,7 +84,7 @@ private:
 
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index fe443c08..73b1604d 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -46,14 +46,14 @@ bool InlineAssemblyStack::parse(
 )
 {
 	m_parserResult = make_shared<Block>();
-	Parser parser(m_errors);
+	Parser parser(m_errorReporter);
 	auto result = parser.parse(_scanner);
 	if (!result)
 		return false;
 
 	*m_parserResult = std::move(*result);
 	AsmAnalysisInfo analysisInfo;
-	return (AsmAnalyzer(analysisInfo, m_errors, false, _resolver)).analyze(*m_parserResult);
+	return (AsmAnalyzer(analysisInfo, m_errorReporter, false, _resolver)).analyze(*m_parserResult);
 }
 
 string InlineAssemblyStack::toString()
@@ -64,9 +64,9 @@ string InlineAssemblyStack::toString()
 eth::Assembly InlineAssemblyStack::assemble()
 {
 	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, m_errors);
+	AsmAnalyzer analyzer(analysisInfo, m_errorReporter);
 	solAssert(analyzer.analyze(*m_parserResult), "");
-	CodeGenerator codeGen(m_errors);
+	CodeGenerator codeGen(m_errorReporter);
 	return codeGen.assemble(*m_parserResult, analysisInfo);
 }
 
@@ -77,19 +77,20 @@ bool InlineAssemblyStack::parseAndAssemble(
 )
 {
 	ErrorList errors;
+	ErrorReporter errorReporter(errors);
 	auto scanner = make_shared<Scanner>(CharStream(_input), "--CODEGEN--");
-	auto parserResult = Parser(errors).parse(scanner);
-	if (!errors.empty())
+	auto parserResult = Parser(errorReporter).parse(scanner);
+	if (!errorReporter.errors().empty())
 		return false;
 	solAssert(parserResult, "");
 
 	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, errors, false, _identifierAccess.resolve);
+	AsmAnalyzer analyzer(analysisInfo, errorReporter, false, _identifierAccess.resolve);
 	solAssert(analyzer.analyze(*parserResult), "");
-	CodeGenerator(errors).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
+	CodeGenerator(errorReporter).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
 
 	// At this point, the assembly might be messed up, but we should throw an
 	// internal compiler error anyway.
-	return errors.empty();
+	return errorReporter.errors().empty();
 }
 
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
index 23072a88..7452804d 100644
--- a/libsolidity/inlineasm/AsmStack.h
+++ b/libsolidity/inlineasm/AsmStack.h
@@ -22,9 +22,8 @@
 
 #pragma once
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <libjulia/backends/evm/AbstractAssembly.h>
+#include <libsolidity/interface/ErrorReporter.h>
 
 #include <string>
 #include <functional>
@@ -46,6 +45,8 @@ struct Identifier;
 class InlineAssemblyStack
 {
 public:
+	InlineAssemblyStack():
+		m_errorReporter(m_errorList) {}
 	/// Parse the given inline assembly chunk starting with `{` and ending with the corresponding `}`.
 	/// @return false or error.
 	bool parse(
@@ -65,11 +66,12 @@ public:
 		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 
-	ErrorList const& errors() const { return m_errors; }
+	ErrorList const& errors() const { return m_errorReporter.errors(); }
 
 private:
 	std::shared_ptr<Block> m_parserResult;
-	ErrorList m_errors;
+	ErrorList m_errorList;
+	ErrorReporter m_errorReporter;
 };
 
 }
diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index c4bd63c4..b027ac3c 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -45,13 +45,13 @@ bool AssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string
 {
 	m_analysisSuccessful = false;
 	m_scanner = make_shared<Scanner>(CharStream(_source), _sourceName);
-	m_parserResult = assembly::Parser(m_errors, m_language == Language::JULIA).parse(m_scanner);
-	if (!m_errors.empty())
+	m_parserResult = assembly::Parser(m_errorReporter, m_language == Language::JULIA).parse(m_scanner);
+	if (!m_errorReporter.errors().empty())
 		return false;
 	solAssert(m_parserResult, "");
 
 	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
-	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errors);
+	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errorReporter);
 	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
 	return m_analysisSuccessful;
 }
@@ -66,7 +66,7 @@ eth::LinkerObject AssemblyStack::assemble(Machine _machine)
 	{
 	case Machine::EVM:
 	{
-		auto assembly = assembly::CodeGenerator(m_errors).assemble(*m_parserResult, *m_analysisInfo);
+		auto assembly = assembly::CodeGenerator(m_errorReporter).assemble(*m_parserResult, *m_analysisInfo);
 		return assembly.assemble();
 	}
 	case Machine::EVM15:
diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
index 40662ac3..62a5134a 100644
--- a/libsolidity/interface/AssemblyStack.h
+++ b/libsolidity/interface/AssemblyStack.h
@@ -21,8 +21,8 @@
 
 #pragma once
 
-#include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libevmasm/LinkerObject.h>
 
 #include <string>
@@ -50,7 +50,7 @@ public:
 	enum class Machine { EVM, EVM15, eWasm };
 
 	explicit AssemblyStack(Language _language = Language::Assembly):
-		m_language(_language)
+		m_language(_language), m_errorReporter(m_errors)
 	{}
 
 	/// @returns the scanner used during parsing
@@ -79,6 +79,7 @@ private:
 	std::shared_ptr<assembly::Block> m_parserResult;
 	std::shared_ptr<assembly::AsmAnalysisInfo> m_analysisInfo;
 	ErrorList m_errors;
+	ErrorReporter m_errorReporter;
 };
 
 }
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 328df91f..44220402 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -57,9 +57,6 @@ using namespace std;
 using namespace dev;
 using namespace dev::solidity;
 
-CompilerStack::CompilerStack(ReadFile::Callback const& _readFile):
-	m_readFile(_readFile) {}
-
 void CompilerStack::setRemappings(vector<string> const& _remappings)
 {
 	vector<Remapping> remappings;
@@ -96,7 +93,7 @@ void CompilerStack::reset(bool _keepSources)
 	m_scopes.clear();
 	m_sourceOrder.clear();
 	m_contracts.clear();
-	m_errors.clear();
+	m_errorReporter.clear();
 	m_stackState = Empty;
 }
 
@@ -121,15 +118,11 @@ bool CompilerStack::parse()
 	//reset
 	if(m_stackState != SourcesSet)
 		return false;
-	m_errors.clear();
+	m_errorReporter.clear();
 	ASTNode::resetID();
 
 	if (SemVerVersion{string(VersionString)}.isPrerelease())
-	{
-		auto err = make_shared<Error>(Error::Type::Warning);
-		*err << errinfo_comment("This is a pre-release compiler version, please do not use it in production.");
-		m_errors.push_back(err);
-	}
+		m_errorReporter.warning("This is a pre-release compiler version, please do not use it in production.");
 
 	vector<string> sourcesToParse;
 	for (auto const& s: m_sources)
@@ -139,9 +132,9 @@ bool CompilerStack::parse()
 		string const& path = sourcesToParse[i];
 		Source& source = m_sources[path];
 		source.scanner->reset();
-		source.ast = Parser(m_errors).parse(source.scanner);
+		source.ast = Parser(m_errorReporter).parse(source.scanner);
 		if (!source.ast)
-			solAssert(!Error::containsOnlyWarnings(m_errors), "Parser returned null but did not report error.");
+			solAssert(!Error::containsOnlyWarnings(m_errorReporter.errors()), "Parser returned null but did not report error.");
 		else
 		{
 			source.ast->annotation().path = path;
@@ -154,7 +147,7 @@ bool CompilerStack::parse()
 			}
 		}
 	}
-	if (Error::containsOnlyWarnings(m_errors))
+	if (Error::containsOnlyWarnings(m_errorReporter.errors()))
 	{
 		m_stackState = ParsingSuccessful;
 		return true;
@@ -170,18 +163,18 @@ bool CompilerStack::analyze()
 	resolveImports();
 
 	bool noErrors = true;
-	SyntaxChecker syntaxChecker(m_errors);
+	SyntaxChecker syntaxChecker(m_errorReporter);
 	for (Source const* source: m_sourceOrder)
 		if (!syntaxChecker.checkSyntax(*source->ast))
 			noErrors = false;
 
-	DocStringAnalyser docStringAnalyser(m_errors);
+	DocStringAnalyser docStringAnalyser(m_errorReporter);
 	for (Source const* source: m_sourceOrder)
 		if (!docStringAnalyser.analyseDocStrings(*source->ast))
 			noErrors = false;
 
 	m_globalContext = make_shared<GlobalContext>();
-	NameAndTypeResolver resolver(m_globalContext->declarations(), m_scopes, m_errors);
+	NameAndTypeResolver resolver(m_globalContext->declarations(), m_scopes, m_errorReporter);
 	for (Source const* source: m_sourceOrder)
 		if (!resolver.registerDeclarations(*source->ast))
 			return false;
@@ -217,7 +210,7 @@ bool CompilerStack::analyze()
 			{
 				m_globalContext->setCurrentContract(*contract);
 				resolver.updateDeclaration(*m_globalContext->currentThis());
-				TypeChecker typeChecker(m_errors);
+				TypeChecker typeChecker(m_errorReporter);
 				if (typeChecker.checkTypeRequirements(*contract))
 				{
 					contract->setDevDocumentation(Natspec::devDocumentation(*contract));
@@ -237,7 +230,7 @@ bool CompilerStack::analyze()
 
 	if (noErrors)
 	{
-		PostTypeChecker postTypeChecker(m_errors);
+		PostTypeChecker postTypeChecker(m_errorReporter);
 		for (Source const* source: m_sourceOrder)
 			if (!postTypeChecker.check(*source->ast))
 				noErrors = false;
@@ -245,7 +238,7 @@ bool CompilerStack::analyze()
 
 	if (noErrors)
 	{
-		StaticAnalyzer staticAnalyzer(m_errors);
+		StaticAnalyzer staticAnalyzer(m_errorReporter);
 		for (Source const* source: m_sourceOrder)
 			if (!staticAnalyzer.analyze(*source->ast))
 				noErrors = false;
@@ -323,11 +316,11 @@ void CompilerStack::link()
 	}
 }
 
-bool CompilerStack::prepareFormalAnalysis(ErrorList* _errors)
+bool CompilerStack::prepareFormalAnalysis(ErrorReporter* _errorReporter)
 {
-	if (!_errors)
-		_errors = &m_errors;
-	Why3Translator translator(*_errors);
+	if (!_errorReporter)
+		_errorReporter = &m_errorReporter;
+	Why3Translator translator(*_errorReporter);
 	for (Source const* source: m_sourceOrder)
 		if (!translator.process(*source->ast))
 			return false;
@@ -582,11 +575,10 @@ StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast, std::string
 				newSources[importPath] = result.contentsOrErrorMessage;
 			else
 			{
-				auto err = make_shared<Error>(Error::Type::ParserError);
-				*err <<
-					errinfo_sourceLocation(import->location()) <<
-					errinfo_comment("Source \"" + importPath + "\" not found: " + result.contentsOrErrorMessage);
-				m_errors.push_back(std::move(err));
+				m_errorReporter.parserError(
+					import->location(),
+					string("Source \"" + importPath + "\" not found: " + result.contentsOrErrorMessage)
+				);
 				continue;
 			}
 		}
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index 84d15d70..76d36c7b 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -35,7 +35,7 @@
 #include <libdevcore/FixedHash.h>
 #include <libevmasm/SourceLocation.h>
 #include <libevmasm/LinkerObject.h>
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/ReadFile.h>
 
 namespace dev
@@ -80,7 +80,10 @@ public:
 	/// Creates a new compiler stack.
 	/// @param _readFile callback to used to read files for import statements. Must return
 	/// and must not emit exceptions.
-	explicit CompilerStack(ReadFile::Callback const& _readFile = ReadFile::Callback());
+	explicit CompilerStack(ReadFile::Callback const& _readFile = ReadFile::Callback()):
+		m_readFile(_readFile),
+		m_errorList(),
+		m_errorReporter(m_errorList) {}
 
 	/// Sets path remappings in the format "context:prefix=target"
 	void setRemappings(std::vector<std::string> const& _remappings);
@@ -130,7 +133,7 @@ public:
 	/// Tries to translate all source files into a language suitable for formal analysis.
 	/// @param _errors list to store errors - defaults to the internal error list.
 	/// @returns false on error.
-	bool prepareFormalAnalysis(ErrorList* _errors = nullptr);
+	bool prepareFormalAnalysis(ErrorReporter* _errorReporter = nullptr);
 	std::string const& formalTranslation() const { return m_formalTranslation; }
 
 	/// @returns the assembled object for a contract.
@@ -207,7 +210,7 @@ public:
 	std::tuple<int, int, int, int> positionFromSourceLocation(SourceLocation const& _sourceLocation) const;
 
 	/// @returns the list of errors that occured during parsing and type checking.
-	ErrorList const& errors() const { return m_errors; }
+	ErrorList const& errors() { return m_errorReporter.errors(); }
 
 private:
 	/**
@@ -289,7 +292,8 @@ private:
 	std::vector<Source const*> m_sourceOrder;
 	std::map<std::string const, Contract> m_contracts;
 	std::string m_formalTranslation;
-	ErrorList m_errors;
+	ErrorList m_errorList;
+	ErrorReporter m_errorReporter;
 	bool m_metadataLiteralSources = false;
 	State m_stackState = Empty;
 };
diff --git a/libsolidity/interface/ErrorReporter.cpp b/libsolidity/interface/ErrorReporter.cpp
new file mode 100644
index 00000000..2cbb952c
--- /dev/null
+++ b/libsolidity/interface/ErrorReporter.cpp
@@ -0,0 +1,186 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Rhett <roadriverrail@gmail.com>
+ * @date 2017
+ * Error helper class.
+ */
+
+#include <libsolidity/interface/ErrorReporter.h>
+#include <libsolidity/ast/AST.h>
+#include <memory>
+
+using namespace std;
+using namespace dev;
+using namespace dev::solidity;
+
+ErrorReporter& ErrorReporter::operator=(ErrorReporter const& _errorReporter)
+{
+	if (&_errorReporter == this)
+		return *this;
+	m_errorList = _errorReporter.m_errorList;
+	return *this;
+}
+
+
+void ErrorReporter::warning(string const& _description)
+{
+	error(Error::Type::Warning, SourceLocation(), _description);
+}
+
+void ErrorReporter::warning(SourceLocation const& _location, string const& _description)
+{
+	error(Error::Type::Warning, _location, _description);
+}
+
+void ErrorReporter::error(Error::Type _type, SourceLocation const& _location, string const& _description)
+{
+	auto err = make_shared<Error>(_type);
+	*err <<
+		errinfo_sourceLocation(_location) <<
+		errinfo_comment(_description);
+
+	m_errorList.push_back(err);
+}
+
+void ErrorReporter::error(Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, string const& _description)
+{
+	auto err = make_shared<Error>(_type);
+	*err <<
+		errinfo_sourceLocation(_location) <<
+		errinfo_secondarySourceLocation(_secondaryLocation) <<
+		errinfo_comment(_description);
+
+	m_errorList.push_back(err);
+}
+
+
+void ErrorReporter::fatalError(Error::Type _type, SourceLocation const& _location, string const& _description)
+{
+	error(_type, _location, _description);
+	BOOST_THROW_EXCEPTION(FatalError());
+}
+
+ErrorList const& ErrorReporter::errors() const
+{
+	return m_errorList;
+}
+
+void ErrorReporter::clear()
+{
+	m_errorList.clear();
+}
+
+void ErrorReporter::declarationError(SourceLocation const& _location, SecondarySourceLocation const&_secondaryLocation, string const& _description)
+{
+	error(
+		Error::Type::DeclarationError,
+		_location,
+		_secondaryLocation,
+		_description
+	);
+}
+
+void ErrorReporter::declarationError(SourceLocation const& _location, string const& _description)
+{
+	error(
+		Error::Type::DeclarationError,
+		_location,
+		_description
+	);
+}
+
+void ErrorReporter::fatalDeclarationError(SourceLocation const& _location, std::string const& _description)
+{
+	fatalError(
+		Error::Type::DeclarationError,
+		_location,
+		_description);
+}
+
+void ErrorReporter::parserError(SourceLocation const& _location, string const& _description)
+{
+	error(
+		Error::Type::ParserError,
+		_location,
+		_description
+	);
+}
+
+void ErrorReporter::fatalParserError(SourceLocation const& _location, string const& _description)
+{
+	fatalError(
+		Error::Type::ParserError,
+		_location,
+		_description
+	);
+}
+
+void ErrorReporter::syntaxError(SourceLocation const& _location, string const& _description)
+{
+	error(
+		Error::Type::SyntaxError,
+		_location,
+		_description
+	);
+}
+
+void ErrorReporter::typeError(SourceLocation const& _location, string const& _description)
+{
+	error(
+		Error::Type::TypeError,
+		_location,
+		_description
+	);
+}
+
+
+void ErrorReporter::fatalTypeError(SourceLocation const& _location, string const& _description)
+{
+	fatalError(Error::Type::TypeError,
+		_location,
+		_description
+	);
+}
+
+void ErrorReporter::docstringParsingError(string const& _description)
+{
+	error(
+		Error::Type::DocstringParsingError,
+		SourceLocation(),
+		_description
+	);
+}
+
+void ErrorReporter::why3TranslatorError(ASTNode const& _location, std::string const& _description)
+{
+	error(
+		Error::Type::Why3TranslatorError,
+		_location.location(),
+		_description
+	);
+}
+
+void ErrorReporter::fatalWhy3TranslatorError(ASTNode const& _location, std::string const& _description)
+{
+	fatalError(
+		Error::Type::Why3TranslatorError,
+		_location.location(),
+		_description
+	);
+}
+
diff --git a/libsolidity/interface/ErrorReporter.h b/libsolidity/interface/ErrorReporter.h
new file mode 100644
index 00000000..83324446
--- /dev/null
+++ b/libsolidity/interface/ErrorReporter.h
@@ -0,0 +1,106 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Rhett <roadriverrail@gmail.com>
+ * @date 2017
+ * Error reporting helper class.
+ */
+
+#pragma once
+
+#include <libsolidity/interface/Exceptions.h>
+#include <libevmasm/SourceLocation.h>
+
+namespace dev
+{
+namespace solidity
+{
+
+class ASTNode;
+
+class ErrorReporter
+{
+public:
+
+	ErrorReporter(ErrorList& _errors):
+		m_errorList(_errors) { }
+
+	ErrorReporter& operator=(ErrorReporter const& _errorReporter);
+
+	void warning(std::string const& _description = std::string());
+
+	void warning(
+		SourceLocation const& _location = SourceLocation(),
+		std::string const& _description = std::string()
+	);
+
+	void error(
+		Error::Type _type,
+		SourceLocation const& _location = SourceLocation(),
+		std::string const& _description = std::string()
+	);
+
+	void declarationError(
+		SourceLocation const& _location,
+		SecondarySourceLocation const& _secondaryLocation = SecondarySourceLocation(),
+		std::string const& _description = std::string()
+	);
+
+	void declarationError(
+		SourceLocation const& _location,
+		std::string const& _description = std::string()
+	);
+
+	void fatalDeclarationError(SourceLocation const& _location, std::string const& _description);
+
+	void parserError(SourceLocation const& _location, std::string const& _description);
+
+	void fatalParserError(SourceLocation const& _location, std::string const& _description);
+
+	void syntaxError(SourceLocation const& _location, std::string const& _description);
+
+	void typeError(SourceLocation const& _location, std::string const& _description);
+
+	void fatalTypeError(SourceLocation const& _location, std::string const& _description);
+
+	void docstringParsingError(std::string const& _location);
+
+	void why3TranslatorError(ASTNode const& _location, std::string const& _description);
+
+	void fatalWhy3TranslatorError(ASTNode const& _location, std::string const& _description);
+
+	ErrorList const& errors() const;
+
+	void clear();
+
+private:
+	void error(Error::Type _type,
+		SourceLocation const& _location,
+		SecondarySourceLocation const& _secondaryLocation,
+		std::string const& _description = std::string());
+
+	void fatalError(Error::Type _type,
+		SourceLocation const& _location = SourceLocation(),
+		std::string const& _description = std::string());
+
+	ErrorList& m_errorList;
+};
+
+
+}
+}
+
diff --git a/libsolidity/parsing/DocStringParser.cpp b/libsolidity/parsing/DocStringParser.cpp
index 8e912126..cd6c1d8a 100644
--- a/libsolidity/parsing/DocStringParser.cpp
+++ b/libsolidity/parsing/DocStringParser.cpp
@@ -1,5 +1,6 @@
 
 #include <libsolidity/parsing/DocStringParser.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Utils.h>
 
 #include <boost/range/irange.hpp>
@@ -51,9 +52,9 @@ string::const_iterator skipWhitespace(
 
 }
 
-bool DocStringParser::parse(string const& _docString, ErrorList& _errors)
+bool DocStringParser::parse(string const& _docString, ErrorReporter& _errorReporter)
 {
-	m_errors = &_errors;
+	m_errorReporter = &_errorReporter;
 	m_errorsOccurred = false;
 	m_lastTag = nullptr;
 
@@ -172,8 +173,6 @@ void DocStringParser::newTag(string const& _tagName)
 
 void DocStringParser::appendError(string const& _description)
 {
-	auto err = make_shared<Error>(Error::Type::DocstringParsingError);
-	*err << errinfo_comment(_description);
-	m_errors->push_back(err);
 	m_errorsOccurred = true;
+	m_errorReporter->docstringParsingError(_description);
 }
diff --git a/libsolidity/parsing/DocStringParser.h b/libsolidity/parsing/DocStringParser.h
index c7f81c55..5f2819cc 100644
--- a/libsolidity/parsing/DocStringParser.h
+++ b/libsolidity/parsing/DocStringParser.h
@@ -23,7 +23,6 @@
 #pragma once
 
 #include <string>
-#include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/ast/ASTAnnotations.h>
 
 namespace dev
@@ -31,12 +30,14 @@ namespace dev
 namespace solidity
 {
 
+class ErrorReporter;
+
 class DocStringParser
 {
 public:
 	/// Parse the given @a _docString and stores the parsed components internally.
 	/// @returns false on error and appends the error to @a _errors.
-	bool parse(std::string const& _docString, ErrorList& _errors);
+	bool parse(std::string const& _docString, ErrorReporter& _errorReporter);
 
 	std::multimap<std::string, DocTag> const& tags() const { return m_docTags; }
 
@@ -62,7 +63,7 @@ private:
 	/// Mapping tag name -> content.
 	std::multimap<std::string, DocTag> m_docTags;
 	DocTag* m_lastTag = nullptr;
-	ErrorList* m_errors = nullptr;
+	ErrorReporter* m_errorReporter = nullptr;
 	bool m_errorsOccurred = false;
 };
 
diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 5b318b2b..ec27f89b 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -26,7 +26,7 @@
 #include <libsolidity/parsing/Parser.h>
 #include <libsolidity/parsing/Scanner.h>
 #include <libsolidity/inlineasm/AsmParser.h>
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 
 using namespace std;
 
@@ -94,7 +94,7 @@ ASTPointer<SourceUnit> Parser::parse(shared_ptr<Scanner> const& _scanner)
 	}
 	catch (FatalError const&)
 	{
-		if (m_errors.empty())
+		if (m_errorReporter.errors().empty())
 			throw; // Something is weird here, rather throw again.
 		return nullptr;
 	}
@@ -865,7 +865,7 @@ ASTPointer<InlineAssembly> Parser::parseInlineAssembly(ASTPointer<ASTString> con
 		m_scanner->next();
 	}
 
-	assembly::Parser asmParser(m_errors);
+	assembly::Parser asmParser(m_errorReporter);
 	shared_ptr<assembly::Block> block = asmParser.parse(m_scanner);
 	nodeFactory.markEndPosition();
 	return nodeFactory.createNode<InlineAssembly>(_docString, block);
diff --git a/libsolidity/parsing/Parser.h b/libsolidity/parsing/Parser.h
index 5ec3dbed..19631c58 100644
--- a/libsolidity/parsing/Parser.h
+++ b/libsolidity/parsing/Parser.h
@@ -35,7 +35,7 @@ class Scanner;
 class Parser: public ParserBase
 {
 public:
-	Parser(ErrorList& _errors): ParserBase(_errors) {}
+	Parser(ErrorReporter& _errorReporter): ParserBase(_errorReporter) {}
 
 	ASTPointer<SourceUnit> parse(std::shared_ptr<Scanner> const& _scanner);
 
diff --git a/libsolidity/parsing/ParserBase.cpp b/libsolidity/parsing/ParserBase.cpp
index ac103bda..9987b82c 100644
--- a/libsolidity/parsing/ParserBase.cpp
+++ b/libsolidity/parsing/ParserBase.cpp
@@ -22,6 +22,7 @@
 
 #include <libsolidity/parsing/ParserBase.h>
 #include <libsolidity/parsing/Scanner.h>
+#include <libsolidity/interface/ErrorReporter.h>
 
 using namespace std;
 using namespace dev;
@@ -82,16 +83,10 @@ void ParserBase::expectToken(Token::Value _value)
 
 void ParserBase::parserError(string const& _description)
 {
-	auto err = make_shared<Error>(Error::Type::ParserError);
-	*err <<
-		errinfo_sourceLocation(SourceLocation(position(), position(), sourceName())) <<
-		errinfo_comment(_description);
-
-	m_errors.push_back(err);
+	m_errorReporter.parserError(SourceLocation(position(), position(), sourceName()), _description);
 }
 
 void ParserBase::fatalParserError(string const& _description)
 {
-	parserError(_description);
-	BOOST_THROW_EXCEPTION(FatalError());
+	m_errorReporter.fatalParserError(SourceLocation(position(), position(), sourceName()), _description);
 }
diff --git a/libsolidity/parsing/ParserBase.h b/libsolidity/parsing/ParserBase.h
index 18b39a5e..ae56cead 100644
--- a/libsolidity/parsing/ParserBase.h
+++ b/libsolidity/parsing/ParserBase.h
@@ -23,7 +23,6 @@
 #pragma once
 
 #include <memory>
-#include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/parsing/Scanner.h>
 #include <libsolidity/parsing/Token.h>
 
@@ -32,12 +31,13 @@ namespace dev
 namespace solidity
 {
 
+class ErrorReporter;
 class Scanner;
 
 class ParserBase
 {
 public:
-	ParserBase(ErrorList& errors): m_errors(errors) {}
+	ParserBase(ErrorReporter& errorReporter): m_errorReporter(errorReporter) {}
 
 	std::shared_ptr<std::string const> const& sourceName() const;
 
@@ -67,7 +67,7 @@ protected:
 
 	std::shared_ptr<Scanner> m_scanner;
 	/// The reference to the list of errors and warning to add errors/warnings during parsing
-	ErrorList& m_errors;
+	ErrorReporter& m_errorReporter;
 };
 
 }
-- 
cgit v1.2.3


From 2e7190534be9d6994cdd485b1d94400e039693d3 Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Tue, 30 May 2017 18:52:43 +0200
Subject: documentation field added to ContractDefinition-Node

---
 libsolidity/ast/ASTJsonConverter.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index cdf70cf9..d2f27519 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -252,6 +252,7 @@ bool ASTJsonConverter::visit(ContractDefinition const& _node)
 {
 	setJsonNode(_node, "ContractDefinition", {
 		make_pair("name", _node.name()),
+		make_pair("documentation", _node.documentation() ? Json::Value(*_node.documentation()) : Json::nullValue),
 		make_pair("contractKind", contractKind(_node.contractKind())),
 		make_pair("fullyImplemented", _node.annotation().isFullyImplemented),
 		make_pair("linearizedBaseContracts", getContainerIds(_node.annotation().linearizedBaseContracts)),
-- 
cgit v1.2.3


From 597bf8a43d9462eaba8dca63bb8b765bf6b122a7 Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Tue, 30 May 2017 19:07:47 +0200
Subject: fix Literalprint

---
 libsolidity/ast/ASTJsonConverter.cpp | 21 +++++++++++++++++++--
 libsolidity/ast/ASTJsonConverter.h   |  1 +
 2 files changed, 20 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index cdf70cf9..e1bcf6a1 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -704,13 +704,13 @@ bool ASTJsonConverter::visit(ElementaryTypeNameExpression const& _node)
 
 bool ASTJsonConverter::visit(Literal const& _node)
 {
-	char const* tokenString = Token::toString(_node.token());
+	string tokenString = tokenKind(_node.token());
 	Json::Value value{_node.value()};
 	if (!dev::validateUTF8(_node.value()))
 		value = Json::nullValue;
 	Token::Value subdenomination = Token::Value(_node.subDenomination());
 	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair("token", tokenString ? tokenString : Json::Value()),
+		make_pair(m_legacy ? "token" : "kind", tokenString),
 		make_pair("value", value),
 		make_pair(m_legacy ? "hexvalue" : "hexValue", toHex(_node.value())),
 		make_pair(
@@ -793,6 +793,23 @@ string ASTJsonConverter::functionCallKind(FunctionCallKind _kind)
 	}
 }
 
+string ASTJsonConverter::tokenKind(Token::Value _token)
+{
+	switch (_token)
+	{
+	case dev::solidity::Token::Number:
+		return "number";
+	case dev::solidity::Token::StringLiteral:
+		return "string";
+	case dev::solidity::Token::TrueLiteral:
+		return "bool";
+	case dev::solidity::Token::FalseLiteral:
+		return "bool";
+	default:
+		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown kind of literal token."));
+	}
+}
+
 string ASTJsonConverter::type(Expression const& _expression)
 {
 	return _expression.annotation().type ? _expression.annotation().type->toString() : "Unknown";
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index 5ee40536..746b3f78 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -133,6 +133,7 @@ private:
 	std::string location(VariableDeclaration::Location _location);
 	std::string contractKind(ContractDefinition::ContractKind _kind);
 	std::string functionCallKind(FunctionCallKind _kind);
+	std::string tokenKind(Token::Value _token);
 	std::string type(Expression const& _expression);
 	std::string type(VariableDeclaration const& _varDecl);
 	int nodeId(ASTNode const& _node)
-- 
cgit v1.2.3


From c212d7c2e6b16063191d85471871eeddf0e6510d Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 1 Jun 2017 13:28:05 +0100
Subject: Remove unused functions from CompilerStack

---
 libsolidity/interface/CompilerStack.cpp | 35 ---------------------------------
 libsolidity/interface/CompilerStack.h   | 13 ------------
 2 files changed, 48 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 44220402..c3fcc1ef 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -400,15 +400,6 @@ eth::LinkerObject const& CompilerStack::cloneObject(string const& _contractName)
 	return contract(_contractName).cloneObject;
 }
 
-dev::h256 CompilerStack::contractCodeHash(string const& _contractName) const
-{
-	auto const& obj = runtimeObject(_contractName);
-	if (obj.bytecode.empty() || !obj.linkReferences.empty())
-		return dev::h256();
-	else
-		return dev::keccak256(obj.bytecode);
-}
-
 Json::Value CompilerStack::streamAssembly(ostream& _outStream, string const& _contractName, StringMap _sourceCodes, bool _inJsonFormat) const
 {
 	Contract const& currentContract = contract(_contractName);
@@ -522,24 +513,6 @@ ContractDefinition const& CompilerStack::contractDefinition(string const& _contr
 	return *contract(_contractName).contract;
 }
 
-size_t CompilerStack::functionEntryPoint(
-	std::string const& _contractName,
-	FunctionDefinition const& _function
-) const
-{
-	shared_ptr<Compiler> const& compiler = contract(_contractName).compiler;
-	if (!compiler)
-		return 0;
-	eth::AssemblyItem tag = compiler->functionEntryLabel(_function);
-	if (tag.type() == eth::UndefinedItem)
-		return 0;
-	eth::AssemblyItems const& items = compiler->runtimeAssemblyItems();
-	for (size_t i = 0; i < items.size(); ++i)
-		if (items.at(i).type() == eth::Tag && items.at(i).data() == tag.data())
-			return i;
-	return 0;
-}
-
 tuple<int, int, int, int> CompilerStack::positionFromSourceLocation(SourceLocation const& _sourceLocation) const
 {
 	int startLine;
@@ -744,14 +717,6 @@ void CompilerStack::compileContract(
 	}
 }
 
-std::string CompilerStack::defaultContractName() const
-{
-	if (m_stackState != CompilationSuccessful)
-		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Compilation was not successful."));
-
-	return contract("").contract->name();
-}
-
 CompilerStack::Contract const& CompilerStack::contract(string const& _contractName) const
 {
 	if (m_contracts.empty())
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index 76d36c7b..d97b3960 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -117,7 +117,6 @@ public:
 	bool parseAndAnalyze(std::string const& _sourceCode);
 	/// @returns a list of the contract names in the sources.
 	std::vector<std::string> contractNames() const;
-	std::string defaultContractName() const;
 
 	/// Compiles the source units that were previously added and parsed.
 	/// @returns false on error.
@@ -159,11 +158,6 @@ public:
 	/// @returns either the contract's name or a mixture of its name and source file, sanitized for filesystem use
 	std::string const filesystemFriendlyName(std::string const& _contractName) const;
 
-	/// @returns hash of the runtime bytecode for the contract, i.e. the code that is
-	/// returned by the constructor or the zero-h256 if the contract still needs to be linked or
-	/// does not have runtime code.
-	dev::h256 contractCodeHash(std::string const& _contractName = "") const;
-
 	/// Streams a verbose version of the assembly to @a _outStream.
 	/// @arg _sourceCodes is the map of input files to source code strings
 	/// @arg _inJsonFromat shows whether the out should be in Json format
@@ -197,13 +191,6 @@ public:
 	/// does not exist.
 	ContractDefinition const& contractDefinition(std::string const& _contractName) const;
 
-	/// @returns the offset of the entry point of the given function into the list of assembly items
-	/// or zero if it is not found or does not exist.
-	size_t functionEntryPoint(
-		std::string const& _contractName,
-		FunctionDefinition const& _function
-	) const;
-
 	/// Helper function for logs printing. Do only use in error cases, it's quite expensive.
 	/// line and columns are numbered starting from 1 with following order:
 	/// start line, start column, end line, end column
-- 
cgit v1.2.3


From 05004253ba9f7bf5a3d71d8ed590367619ebbe4f Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 14:16:01 +0200
Subject: Refactor to use expectExpression in analyzer.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 60 ++++++++++++++---------------------
 libsolidity/inlineasm/AsmAnalysis.h   |  7 +++-
 2 files changed, 29 insertions(+), 38 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 22e43127..8ed59bc9 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -139,13 +139,8 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	solAssert(!m_julia, "");
 	bool success = true;
 	for (auto const& arg: _instr.arguments | boost::adaptors::reversed)
-	{
-		int const stackHeight = m_stackHeight;
-		if (!boost::apply_visitor(*this, arg))
-			success = false;
-		if (!expectDeposit(1, stackHeight, locationOf(arg)))
+		if (!expectExpression(arg))
 			success = false;
-	}
 	// Parser already checks that the number of arguments is correct.
 	solAssert(instructionInfo(_instr.instruction.instruction).args == int(_instr.arguments.size()), "");
 	if (!(*this)(_instr.instruction))
@@ -260,13 +255,8 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 		}
 	}
 	for (auto const& arg: _funCall.arguments | boost::adaptors::reversed)
-	{
-		int const stackHeight = m_stackHeight;
-		if (!boost::apply_visitor(*this, arg))
+		if (!expectExpression(arg))
 			success = false;
-		if (!expectDeposit(1, stackHeight, locationOf(arg)))
-			success = false;
-	}
 	m_stackHeight += int(returns) - int(arguments);
 	m_info.stackHeightInfo[&_funCall] = m_stackHeight;
 	return success;
@@ -276,20 +266,16 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 {
 	bool success = true;
 
-	int const initialStackHeight = m_stackHeight;
-	if (!boost::apply_visitor(*this, *_switch.expression))
+	if (!expectExpression(*_switch.expression))
 		success = false;
-	expectDeposit(1, initialStackHeight, locationOf(*_switch.expression));
 
 	set<tuple<LiteralKind, string>> cases;
 	for (auto const& _case: _switch.cases)
 	{
 		if (_case.value)
 		{
-			int const initialStackHeight = m_stackHeight;
-			if (!(*this)(*_case.value))
+			if (!expectExpression(*_case.value))
 				success = false;
-			expectDeposit(1, initialStackHeight, _case.value->location);
 			m_stackHeight--;
 
 			/// Note: the parser ensures there is only one default case
@@ -349,6 +335,25 @@ bool AsmAnalyzer::operator()(Block const& _block)
 	return success;
 }
 
+bool AsmAnalyzer::expectExpression(Statement const& _statement)
+{
+	bool success = true;
+	int const initialHeight = m_stackHeight;
+	if (!boost::apply_visitor(*this, _statement))
+		success = false;
+	if (m_stackHeight - initialHeight != 1)
+	{
+		m_errorReporter.typeError(
+			locationOf(_statement),
+			"Expected instruction(s) to deposit one item to the stack but did deposit " +
+			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
+			" items."
+		);
+		success = false;
+	}
+	return success;
+}
+
 bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t _valueSize)
 {
 	bool success = true;
@@ -401,25 +406,6 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 	return success;
 }
 
-bool AsmAnalyzer::expectDeposit(int const _deposit, int const _oldHeight, SourceLocation const& _location)
-{
-	int stackDiff = m_stackHeight - _oldHeight;
-	if (stackDiff != _deposit)
-	{
-		m_errorReporter.typeError(
-			_location,
-			"Expected instruction(s) to deposit " +
-			boost::lexical_cast<string>(_deposit) +
-			" item(s) to the stack, but did deposit " +
-			boost::lexical_cast<string>(stackDiff) +
-			" item(s)."
-		);
-		return false;
-	}
-	else
-		return true;
-}
-
 Scope& AsmAnalyzer::scope(Block const* _block)
 {
 	solAssert(m_info.scopes.count(_block) == 1, "Scope requested but not present.");
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 7e4d78df..e52e6302 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -47,6 +47,8 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+
 
 struct Scope;
 
@@ -83,10 +85,13 @@ public:
 	bool operator()(assembly::Block const& _block);
 
 private:
+	/// Visits the statement and expects it to deposit one item onto the stack.
+	bool expectExpression(Statement const& _statement);
+
 	/// Verifies that a variable to be assigned to exists and has the same size
 	/// as the value, @a _valueSize, unless that is equal to -1.
 	bool checkAssignment(assembly::Identifier const& _assignment, size_t _valueSize = size_t(-1));
-	bool expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location);
+
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
 
-- 
cgit v1.2.3


From 998ca552b8966d67bbbc7482e972563efade9a80 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 1 Jun 2017 13:28:32 +0100
Subject: Fix state after CompilerStack.reset()

---
 libsolidity/interface/CompilerStack.cpp | 20 +++++++++++++++++++-
 libsolidity/interface/CompilerStack.h   |  7 +++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index c3fcc1ef..aca9ce39 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -85,6 +85,7 @@ void CompilerStack::reset(bool _keepSources)
 	}
 	else
 	{
+		m_stackState = Empty;
 		m_sources.clear();
 	}
 	m_optimize = false;
@@ -94,7 +95,6 @@ void CompilerStack::reset(bool _keepSources)
 	m_sourceOrder.clear();
 	m_contracts.clear();
 	m_errorReporter.clear();
-	m_stackState = Empty;
 }
 
 bool CompilerStack::addSource(string const& _name, string const& _content, bool _isLibrary)
@@ -513,6 +513,24 @@ ContractDefinition const& CompilerStack::contractDefinition(string const& _contr
 	return *contract(_contractName).contract;
 }
 
+size_t CompilerStack::functionEntryPoint(
+	std::string const& _contractName,
+	FunctionDefinition const& _function
+) const
+{
+	shared_ptr<Compiler> const& compiler = contract(_contractName).compiler;
+	if (!compiler)
+		return 0;
+	eth::AssemblyItem tag = compiler->functionEntryLabel(_function);
+	if (tag.type() == eth::UndefinedItem)
+		return 0;
+	eth::AssemblyItems const& items = compiler->runtimeAssemblyItems();
+	for (size_t i = 0; i < items.size(); ++i)
+		if (items.at(i).type() == eth::Tag && items.at(i).data() == tag.data())
+			return i;
+	return 0;
+}
+
 tuple<int, int, int, int> CompilerStack::positionFromSourceLocation(SourceLocation const& _sourceLocation) const
 {
 	int startLine;
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index d97b3960..bffdeabd 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -259,6 +259,13 @@ private:
 	Json::Value const& contractABI(Contract const&) const;
 	Json::Value const& natspec(Contract const&, DocumentationType _type) const;
 
+	/// @returns the offset of the entry point of the given function into the list of assembly items
+	/// or zero if it is not found or does not exist.
+	size_t functionEntryPoint(
+		std::string const& _contractName,
+		FunctionDefinition const& _function
+	) const;
+
 	struct Remapping
 	{
 		std::string context;
-- 
cgit v1.2.3


From 40f3e4413b7eb36d32ab314dc1d854d8428116e6 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:31:07 +0200
Subject: Improved error message.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 8ed59bc9..8fa72d7e 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -345,7 +345,7 @@ bool AsmAnalyzer::expectExpression(Statement const& _statement)
 	{
 		m_errorReporter.typeError(
 			locationOf(_statement),
-			"Expected instruction(s) to deposit one item to the stack but did deposit " +
+			"Expected expression to return one item to the stack but did return " +
 			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
 			" items."
 		);
-- 
cgit v1.2.3


From d5408f78ad2089beaabc60e7b876ad1ff0d276a1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:56:49 +0200
Subject: Add comma.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 8fa72d7e..3edc01ad 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -345,7 +345,7 @@ bool AsmAnalyzer::expectExpression(Statement const& _statement)
 	{
 		m_errorReporter.typeError(
 			locationOf(_statement),
-			"Expected expression to return one item to the stack but did return " +
+			"Expected expression to return one item to the stack, but did return " +
 			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
 			" items."
 		);
-- 
cgit v1.2.3


From 62eafdd0103a05d46295fc9b83039adb038683e8 Mon Sep 17 00:00:00 2001
From: djudjuu <julfaber@gmail.com>
Date: Mon, 5 Jun 2017 15:36:06 +0200
Subject: adjusted testcase and renaming

---
 libsolidity/ast/ASTJsonConverter.cpp | 6 ++----
 libsolidity/ast/ASTJsonConverter.h   | 2 +-
 2 files changed, 3 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index e1bcf6a1..1de2e801 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -704,13 +704,12 @@ bool ASTJsonConverter::visit(ElementaryTypeNameExpression const& _node)
 
 bool ASTJsonConverter::visit(Literal const& _node)
 {
-	string tokenString = tokenKind(_node.token());
 	Json::Value value{_node.value()};
 	if (!dev::validateUTF8(_node.value()))
 		value = Json::nullValue;
 	Token::Value subdenomination = Token::Value(_node.subDenomination());
 	std::vector<pair<string, Json::Value>> attributes = {
-		make_pair(m_legacy ? "token" : "kind", tokenString),
+		make_pair(m_legacy ? "token" : "kind", literalTokenKind(_node.token())),
 		make_pair("value", value),
 		make_pair(m_legacy ? "hexvalue" : "hexValue", toHex(_node.value())),
 		make_pair(
@@ -793,7 +792,7 @@ string ASTJsonConverter::functionCallKind(FunctionCallKind _kind)
 	}
 }
 
-string ASTJsonConverter::tokenKind(Token::Value _token)
+string ASTJsonConverter::literalTokenKind(Token::Value _token)
 {
 	switch (_token)
 	{
@@ -802,7 +801,6 @@ string ASTJsonConverter::tokenKind(Token::Value _token)
 	case dev::solidity::Token::StringLiteral:
 		return "string";
 	case dev::solidity::Token::TrueLiteral:
-		return "bool";
 	case dev::solidity::Token::FalseLiteral:
 		return "bool";
 	default:
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index 746b3f78..c2de5c48 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -133,7 +133,7 @@ private:
 	std::string location(VariableDeclaration::Location _location);
 	std::string contractKind(ContractDefinition::ContractKind _kind);
 	std::string functionCallKind(FunctionCallKind _kind);
-	std::string tokenKind(Token::Value _token);
+	std::string literalTokenKind(Token::Value _token);
 	std::string type(Expression const& _expression);
 	std::string type(VariableDeclaration const& _varDecl);
 	int nodeId(ASTNode const& _node)
-- 
cgit v1.2.3


From 937c2083207f28e0b084959492f72ef01119c202 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 7 Jun 2017 14:41:44 +0100
Subject: Reset error list in parseAndAnalyze

---
 libsolidity/interface/AssemblyStack.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index b027ac3c..dc9d7db2 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -43,6 +43,7 @@ Scanner const& AssemblyStack::scanner() const
 
 bool AssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string const& _source)
 {
+	m_errors.clear();
 	m_analysisSuccessful = false;
 	m_scanner = make_shared<Scanner>(CharStream(_source), _sourceName);
 	m_parserResult = assembly::Parser(m_errorReporter, m_language == Language::JULIA).parse(m_scanner);
-- 
cgit v1.2.3


From 502304f30b1dfa45a936d500c173858baf5735df Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Sun, 28 May 2017 14:13:41 +0100
Subject: Add analyze(block) to AssemblyStack

---
 libsolidity/interface/AssemblyStack.cpp | 14 ++++++++++++++
 libsolidity/interface/AssemblyStack.h   |  4 ++++
 2 files changed, 18 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index dc9d7db2..a571a008 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -57,6 +57,20 @@ bool AssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string
 	return m_analysisSuccessful;
 }
 
+bool AssemblyStack::analyze(assembly::Block const& _block, Scanner const* _scanner)
+{
+	m_errors.clear();
+	m_analysisSuccessful = false;
+	if (_scanner)
+		m_scanner = make_shared<Scanner>(*_scanner);
+	m_parserResult = make_shared<assembly::Block>(_block);
+
+	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
+	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errorReporter);
+	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
+	return m_analysisSuccessful;
+}
+
 eth::LinkerObject AssemblyStack::assemble(Machine _machine)
 {
 	solAssert(m_analysisSuccessful, "");
diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
index 62a5134a..f13a25ca 100644
--- a/libsolidity/interface/AssemblyStack.h
+++ b/libsolidity/interface/AssemblyStack.h
@@ -60,6 +60,10 @@ public:
 	/// Multiple calls overwrite the previous state.
 	bool parseAndAnalyze(std::string const& _sourceName, std::string const& _source);
 
+	/// Runs analysis step on the supplied block, returns false if input cannot be assembled.
+	/// Multiple calls overwrite the previous state.
+	bool analyze(assembly::Block const& _block, Scanner const* _scanner = nullptr);
+
 	/// Run the assembly step (should only be called after parseAndAnalyze).
 	eth::LinkerObject assemble(Machine _machine);
 
-- 
cgit v1.2.3


From aa310f9fec9bba90da2f1f57d77270dab673c6f4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 2 Jun 2017 21:52:48 +0100
Subject: Refactor AssemblyStack

---
 libsolidity/interface/AssemblyStack.cpp | 10 ++++++----
 libsolidity/interface/AssemblyStack.h   |  1 +
 2 files changed, 7 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index a571a008..347de350 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -51,10 +51,7 @@ bool AssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string
 		return false;
 	solAssert(m_parserResult, "");
 
-	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
-	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errorReporter);
-	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
-	return m_analysisSuccessful;
+	return analyzeParsed();
 }
 
 bool AssemblyStack::analyze(assembly::Block const& _block, Scanner const* _scanner)
@@ -65,6 +62,11 @@ bool AssemblyStack::analyze(assembly::Block const& _block, Scanner const* _scann
 		m_scanner = make_shared<Scanner>(*_scanner);
 	m_parserResult = make_shared<assembly::Block>(_block);
 
+	return analyzeParsed();
+}
+
+bool AssemblyStack::analyzeParsed()
+{
 	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
 	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errorReporter);
 	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
index f13a25ca..abecaae2 100644
--- a/libsolidity/interface/AssemblyStack.h
+++ b/libsolidity/interface/AssemblyStack.h
@@ -74,6 +74,7 @@ public:
 	std::string print();
 
 private:
+	bool analyzeParsed();
 
 	Language m_language = Language::Assembly;
 
-- 
cgit v1.2.3


From 97cc968a133247e729ed1d189d35ef2b7b53b3d4 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 24 May 2017 18:34:19 +0200
Subject: Initial EVM1.5 assembly implementation.

---
 libsolidity/analysis/ReferencesResolver.cpp |  8 +++++-
 libsolidity/analysis/TypeChecker.cpp        |  3 +-
 libsolidity/codegen/CompilerContext.cpp     |  3 +-
 libsolidity/codegen/ContractCompiler.cpp    | 17 ++++++++----
 libsolidity/inlineasm/AsmAnalysis.cpp       | 19 +++++++++----
 libsolidity/inlineasm/AsmAnalysis.h         |  6 +++-
 libsolidity/inlineasm/AsmCodeGen.cpp        | 43 +++++++++++++++++++++++++----
 libsolidity/inlineasm/AsmScope.cpp          |  8 ++++++
 libsolidity/inlineasm/AsmScope.h            |  4 +++
 libsolidity/interface/AssemblyStack.cpp     |  9 +++++-
 10 files changed, 99 insertions(+), 21 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp
index b70b0f0e..d814f5ec 100644
--- a/libsolidity/analysis/ReferencesResolver.cpp
+++ b/libsolidity/analysis/ReferencesResolver.cpp
@@ -169,7 +169,7 @@ bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 	ErrorList errors;
 	ErrorReporter errorsIgnored(errors);
 	julia::ExternalIdentifierAccess::Resolver resolver =
-	[&](assembly::Identifier const& _identifier, julia::IdentifierContext) {
+	[&](assembly::Identifier const& _identifier, julia::IdentifierContext, bool _crossesFunctionBoundary) {
 		auto declarations = m_resolver.nameFromCurrentScope(_identifier.name);
 		bool isSlot = boost::algorithm::ends_with(_identifier.name, "_slot");
 		bool isOffset = boost::algorithm::ends_with(_identifier.name, "_offset");
@@ -188,6 +188,12 @@ bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 		}
 		if (declarations.size() != 1)
 			return size_t(-1);
+		if (auto var = dynamic_cast<VariableDeclaration const*>(declarations.front()))
+			if (var->isLocalVariable() && _crossesFunctionBoundary)
+			{
+				m_errorReporter.declarationError(_identifier.location, "Cannot access local Solidity variables from inside an inline assembly function.");
+				return size_t(-1);
+			}
 		_inlineAssembly.annotation().externalReferences[&_identifier].isSlot = isSlot;
 		_inlineAssembly.annotation().externalReferences[&_identifier].isOffset = isOffset;
 		_inlineAssembly.annotation().externalReferences[&_identifier].declaration = declarations.front();
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 0fb0d212..b1911ef0 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -632,7 +632,8 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 	// We run the resolve step again regardless.
 	julia::ExternalIdentifierAccess::Resolver identifierAccess = [&](
 		assembly::Identifier const& _identifier,
-		julia::IdentifierContext _context
+		julia::IdentifierContext _context,
+		bool
 	)
 	{
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 404a3af6..9c4fbcbb 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -269,7 +269,8 @@ void CompilerContext::appendInlineAssembly(
 	julia::ExternalIdentifierAccess identifierAccess;
 	identifierAccess.resolve = [&](
 		assembly::Identifier const& _identifier,
-		julia::IdentifierContext
+		julia::IdentifierContext,
+		bool
 	)
 	{
 		auto it = std::find(_localVariables.begin(), _localVariables.end(), _identifier.name);
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index 1fc06333..03926350 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -21,15 +21,20 @@
  */
 
 #include <libsolidity/codegen/ContractCompiler.h>
-#include <algorithm>
-#include <boost/range/adaptor/reversed.hpp>
-#include <libevmasm/Instruction.h>
-#include <libevmasm/Assembly.h>
-#include <libevmasm/GasMeter.h>
 #include <libsolidity/inlineasm/AsmCodeGen.h>
 #include <libsolidity/ast/AST.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/codegen/ExpressionCompiler.h>
 #include <libsolidity/codegen/CompilerUtils.h>
+
+#include <libevmasm/Instruction.h>
+#include <libevmasm/Assembly.h>
+#include <libevmasm/GasMeter.h>
+
+#include <boost/range/adaptor/reversed.hpp>
+
+#include <algorithm>
+
 using namespace std;
 using namespace dev;
 using namespace dev::solidity;
@@ -524,7 +529,7 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 	assembly::CodeGenerator codeGen(errorReporter);
 	unsigned startStackHeight = m_context.stackHeight();
 	julia::ExternalIdentifierAccess identifierAccess;
-	identifierAccess.resolve = [&](assembly::Identifier const& _identifier, julia::IdentifierContext)
+	identifierAccess.resolve = [&](assembly::Identifier const& _identifier, julia::IdentifierContext, bool)
 	{
 		auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
 		if (ref == _inlineAssembly.annotation().externalReferences.end())
diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 3edc01ad..b59a8527 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -25,7 +25,7 @@
 #include <libsolidity/inlineasm/AsmScope.h>
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
-#include <libsolidity/interface/Exceptions.h>
+#include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
@@ -120,7 +120,10 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 	{
 		size_t stackSize(-1);
 		if (m_resolver)
-			stackSize = m_resolver(_identifier, julia::IdentifierContext::RValue);
+		{
+			bool insideFunction = m_currentScope->insideFunction();
+			stackSize = m_resolver(_identifier, julia::IdentifierContext::RValue, insideFunction);
+		}
 		if (stackSize == size_t(-1))
 		{
 			// Only add an error message if the callback did not do it.
@@ -200,7 +203,8 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 	}
 
 	int const stackHeight = m_stackHeight;
-	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
+	// 1 for return label, depends on VM version
+	m_stackHeight = 1 + _funDef.arguments.size() + _funDef.returns.size();
 
 	bool success = (*this)(_funDef.body);
 
@@ -254,10 +258,11 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 			success = false;
 		}
 	}
+	m_stackHeight += 1; // Return label, but depends on backend
 	for (auto const& arg: _funCall.arguments | boost::adaptors::reversed)
 		if (!expectExpression(arg))
 			success = false;
-	m_stackHeight += int(returns) - int(arguments);
+	m_stackHeight += int(returns) - int(arguments) - 1; // Return label, but depends on backend
 	m_info.stackHeightInfo[&_funCall] = m_stackHeight;
 	return success;
 }
@@ -295,6 +300,7 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	}
 
 	m_stackHeight--;
+	m_info.stackHeightInfo[&_switch] = m_stackHeight;
 
 	return success;
 }
@@ -378,7 +384,10 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 		variableSize = 1;
 	}
 	else if (m_resolver)
-		variableSize = m_resolver(_variable, julia::IdentifierContext::LValue);
+	{
+		bool insideFunction = m_currentScope->insideFunction();
+		variableSize = m_resolver(_variable, julia::IdentifierContext::LValue, insideFunction);
+	}
 	if (variableSize == size_t(-1))
 	{
 		// Only add message if the callback did not.
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index e52e6302..d6f9de5b 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -20,7 +20,11 @@
 
 #pragma once
 
-#include <libsolidity/inlineasm/AsmStack.h>
+#include <libsolidity/interface/Exceptions.h>
+
+#include <libsolidity/interface/Exceptions.h>
+
+#include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <boost/variant.hpp>
 
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 11494c2d..875d7ce4 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -87,13 +87,46 @@ public:
 	{
 		m_assembly.appendLibraryAddress(_linkerSymbol);
 	}
+	virtual void appendJump(int _stackDiffAfter) override
+	{
+		appendInstruction(solidity::Instruction::JUMP);
+		m_assembly.adjustDeposit(_stackDiffAfter);
+	}
+	virtual void appendJumpTo(LabelID _label, int _stackDiffAfter) override
+	{
+		appendLabelReference(_label);
+		appendJump(_stackDiffAfter);
+	}
+	virtual void appendJumpToIf(LabelID _label) override
+	{
+		appendLabelReference(_label);
+		appendInstruction(solidity::Instruction::JUMPI);
+	}
+	virtual void appendBeginsub(LabelID, int) override
+	{
+		// TODO we could emulate that, though
+		solAssert(false, "BEGINSUB not implemented for EVM 1.0");
+	}
+	/// Call a subroutine.
+	virtual void appendJumpsub(LabelID, int, int) override
+	{
+		// TODO we could emulate that, though
+		solAssert(false, "JUMPSUB not implemented for EVM 1.0");
+	}
+
+	/// Return from a subroutine.
+	virtual void appendReturnsub(int) override
+	{
+		// TODO we could emulate that, though
+		solAssert(false, "RETURNSUB not implemented for EVM 1.0");
+	}
 
 private:
-	size_t assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
+	LabelID assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
 	{
 		u256 id = _tag.data();
-		solAssert(id <= std::numeric_limits<size_t>::max(), "Tag id too large.");
-		return size_t(id);
+		solAssert(id <= std::numeric_limits<LabelID>::max(), "Tag id too large.");
+		return LabelID(id);
 	}
 
 	eth::Assembly& m_assembly;
@@ -107,7 +140,7 @@ eth::Assembly assembly::CodeGenerator::assemble(
 {
 	eth::Assembly assembly;
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 	return assembly;
 }
 
@@ -119,5 +152,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _parsedData, _analysisInfo, _identifierAccess);
+	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 }
diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index e3f4615a..7a086846 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -79,3 +79,11 @@ bool Scope::exists(string const& _name)
 	else
 		return false;
 }
+
+bool Scope::insideFunction() const
+{
+	for (Scope const* s = this; s; s = s->superScope)
+		if (s->functionScope)
+			return true;
+	return false;
+}
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 498218b4..ad321f77 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -85,6 +85,7 @@ struct Scope
 		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
 		std::vector<JuliaType> arguments;
 		std::vector<JuliaType> returns;
+		boost::optional<LabelID> id;
 	};
 
 	using Identifier = boost::variant<Variable, Label, Function>;
@@ -123,6 +124,9 @@ struct Scope
 	/// across function and assembly boundaries).
 	bool exists(std::string const& _name);
 
+	/// @returns true if this scope is inside a function.
+	bool insideFunction() const;
+
 	Scope* superScope = nullptr;
 	/// If true, variables from the super scope are not visible here (other identifiers are),
 	/// but they are still taken into account to prevent shadowing.
diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index 347de350..c660058e 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -30,6 +30,9 @@
 
 #include <libevmasm/Assembly.h>
 
+#include <libjulia/backends/evm/EVMCodeTransform.h>
+#include <libjulia/backends/evm/EVMAssembly.h>
+
 using namespace std;
 using namespace dev;
 using namespace dev::solidity;
@@ -87,7 +90,11 @@ eth::LinkerObject AssemblyStack::assemble(Machine _machine)
 		return assembly.assemble();
 	}
 	case Machine::EVM15:
-		solUnimplemented("EVM 1.5 backend is not yet implemented.");
+	{
+		julia::EVMAssembly assembly(true);
+		julia::CodeTransform(m_errorReporter, assembly, *m_analysisInfo, true).run(*m_parserResult);
+		return assembly.finalize();
+	}
 	case Machine::eWasm:
 		solUnimplemented("eWasm backend is not yet implemented.");
 	}
-- 
cgit v1.2.3


From fefd3b866d982d95d05e5956d1af48b357162cc8 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 31 May 2017 12:15:43 +0200
Subject: Introduce machine-dependent stack adjustment.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index b59a8527..bfc6b2af 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -203,8 +203,7 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 	}
 
 	int const stackHeight = m_stackHeight;
-	// 1 for return label, depends on VM version
-	m_stackHeight = 1 + _funDef.arguments.size() + _funDef.returns.size();
+	m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
 
 	bool success = (*this)(_funDef.body);
 
@@ -258,11 +257,10 @@ bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
 			success = false;
 		}
 	}
-	m_stackHeight += 1; // Return label, but depends on backend
 	for (auto const& arg: _funCall.arguments | boost::adaptors::reversed)
 		if (!expectExpression(arg))
 			success = false;
-	m_stackHeight += int(returns) - int(arguments) - 1; // Return label, but depends on backend
+	m_stackHeight += int(returns) - int(arguments);
 	m_info.stackHeightInfo[&_funCall] = m_stackHeight;
 	return success;
 }
-- 
cgit v1.2.3


From ba5ee71b7f7b1ac5d6bc4b3a70dde36b34d20d8e Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 31 May 2017 12:54:18 +0200
Subject: Generate only single error in inline assembly.

---
 libsolidity/analysis/ReferencesResolver.cpp | 8 +++++++-
 libsolidity/analysis/ReferencesResolver.h   | 7 +++++--
 2 files changed, 12 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp
index d814f5ec..edf2fc02 100644
--- a/libsolidity/analysis/ReferencesResolver.cpp
+++ b/libsolidity/analysis/ReferencesResolver.cpp
@@ -191,7 +191,7 @@ bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 		if (auto var = dynamic_cast<VariableDeclaration const*>(declarations.front()))
 			if (var->isLocalVariable() && _crossesFunctionBoundary)
 			{
-				m_errorReporter.declarationError(_identifier.location, "Cannot access local Solidity variables from inside an inline assembly function.");
+				declarationError(_identifier.location, "Cannot access local Solidity variables from inside an inline assembly function.");
 				return size_t(-1);
 			}
 		_inlineAssembly.annotation().externalReferences[&_identifier].isSlot = isSlot;
@@ -321,6 +321,12 @@ void ReferencesResolver::fatalTypeError(SourceLocation const& _location, string
 	m_errorReporter.fatalTypeError(_location, _description);
 }
 
+void ReferencesResolver::declarationError(SourceLocation const& _location, string const& _description)
+{
+	m_errorOccurred = true;
+	m_errorReporter.declarationError(_location, _description);
+}
+
 void ReferencesResolver::fatalDeclarationError(SourceLocation const& _location, string const& _description)
 {
 	m_errorOccurred = true;
diff --git a/libsolidity/analysis/ReferencesResolver.h b/libsolidity/analysis/ReferencesResolver.h
index bbde19f9..fef2e73f 100644
--- a/libsolidity/analysis/ReferencesResolver.h
+++ b/libsolidity/analysis/ReferencesResolver.h
@@ -75,10 +75,13 @@ private:
 	/// Adds a new error to the list of errors.
 	void typeError(SourceLocation const& _location, std::string const& _description);
 
-	/// Adds a new error to the list of errors and throws to abort type checking.
+	/// Adds a new error to the list of errors and throws to abort reference resolving.
 	void fatalTypeError(SourceLocation const& _location, std::string const& _description);
 
-	/// Adds a new error to the list of errors and throws to abort type checking.
+	/// Adds a new error to the list of errors.
+	void declarationError(SourceLocation const& _location, std::string const& _description);
+
+	/// Adds a new error to the list of errors and throws to abort reference resolving.
 	void fatalDeclarationError(SourceLocation const& _location, std::string const& _description);
 
 	ErrorReporter& m_errorReporter;
-- 
cgit v1.2.3


From 0185f3cbf6aae954d8c59a556af0e150850022bc Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 31 May 2017 13:06:51 +0200
Subject: Correct stack height adjustment after returnsub.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 875d7ce4..dd91673b 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -115,7 +115,7 @@ public:
 	}
 
 	/// Return from a subroutine.
-	virtual void appendReturnsub(int) override
+	virtual void appendReturnsub(int, int) override
 	{
 		// TODO we could emulate that, though
 		solAssert(false, "RETURNSUB not implemented for EVM 1.0");
-- 
cgit v1.2.3


From 19f707aeaa23b55a4a5940977a9d6351d1f06938 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 18:16:38 +0200
Subject: Some more comments.

---
 libsolidity/inlineasm/AsmAnalysis.h | 2 --
 1 file changed, 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index d6f9de5b..75c0c43b 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -22,8 +22,6 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
-#include <libsolidity/interface/Exceptions.h>
-
 #include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <boost/variant.hpp>
-- 
cgit v1.2.3


From ef3d5874fefa6a86a30d4afdcfd269d599edda5d Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 6 Jun 2017 15:37:43 +0200
Subject: Remove error reporter from code generation phase.

---
 libsolidity/codegen/ContractCompiler.cpp |  6 +-----
 libsolidity/inlineasm/AsmCodeGen.cpp     |  4 ++--
 libsolidity/inlineasm/AsmCodeGen.h       | 10 ++--------
 libsolidity/inlineasm/AsmStack.cpp       |  6 +++---
 libsolidity/interface/AssemblyStack.cpp  |  8 ++++----
 libsolidity/interface/AssemblyStack.h    |  4 ++--
 6 files changed, 14 insertions(+), 24 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index 03926350..dc090634 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -524,9 +524,6 @@ bool ContractCompiler::visit(FunctionDefinition const& _function)
 
 bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 {
-	ErrorList errors;
-	ErrorReporter errorReporter(errors);
-	assembly::CodeGenerator codeGen(errorReporter);
 	unsigned startStackHeight = m_context.stackHeight();
 	julia::ExternalIdentifierAccess identifierAccess;
 	identifierAccess.resolve = [&](assembly::Identifier const& _identifier, julia::IdentifierContext, bool)
@@ -648,13 +645,12 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 		}
 	};
 	solAssert(_inlineAssembly.annotation().analysisInfo, "");
-	codeGen.assemble(
+	assembly::CodeGenerator::assemble(
 		_inlineAssembly.operations(),
 		*_inlineAssembly.annotation().analysisInfo,
 		m_context.nonConstAssembly(),
 		identifierAccess
 	);
-	solAssert(Error::containsOnlyWarnings(errorReporter.errors()), "Code generation for inline assembly with errors requested.");
 	m_context.setStackOffset(startStackHeight);
 	return false;
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index dd91673b..217c6885 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -140,7 +140,7 @@ eth::Assembly assembly::CodeGenerator::assemble(
 {
 	eth::Assembly assembly;
 	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 	return assembly;
 }
 
@@ -152,5 +152,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(m_errorReporter, assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
 }
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index f075fa93..7a149d74 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -34,7 +34,6 @@ class Assembly;
 }
 namespace solidity
 {
-class ErrorReporter;
 namespace assembly
 {
 struct Block;
@@ -42,24 +41,19 @@ struct Block;
 class CodeGenerator
 {
 public:
-	CodeGenerator(ErrorReporter& _errorReporter):
-		m_errorReporter(_errorReporter) {}
 	/// Performs code generation and @returns the result.
-	eth::Assembly assemble(
+	static eth::Assembly assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
 		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
 	/// Performs code generation and appends generated to to _assembly.
-	void assemble(
+	static void assemble(
 		Block const& _parsedData,
 		AsmAnalysisInfo& _analysisInfo,
 		eth::Assembly& _assembly,
 		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
 	);
-
-private:
-	ErrorReporter& m_errorReporter;
 };
 
 }
diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
index 73b1604d..92eb8a7a 100644
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ b/libsolidity/inlineasm/AsmStack.cpp
@@ -66,8 +66,7 @@ eth::Assembly InlineAssemblyStack::assemble()
 	AsmAnalysisInfo analysisInfo;
 	AsmAnalyzer analyzer(analysisInfo, m_errorReporter);
 	solAssert(analyzer.analyze(*m_parserResult), "");
-	CodeGenerator codeGen(m_errorReporter);
-	return codeGen.assemble(*m_parserResult, analysisInfo);
+	return CodeGenerator::assemble(*m_parserResult, analysisInfo);
 }
 
 bool InlineAssemblyStack::parseAndAssemble(
@@ -87,7 +86,8 @@ bool InlineAssemblyStack::parseAndAssemble(
 	AsmAnalysisInfo analysisInfo;
 	AsmAnalyzer analyzer(analysisInfo, errorReporter, false, _identifierAccess.resolve);
 	solAssert(analyzer.analyze(*parserResult), "");
-	CodeGenerator(errorReporter).assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
+	solAssert(errorReporter.errors().empty(), "");
+	CodeGenerator::assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
 
 	// At this point, the assembly might be messed up, but we should throw an
 	// internal compiler error anyway.
diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index c660058e..31d9e494 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -76,7 +76,7 @@ bool AssemblyStack::analyzeParsed()
 	return m_analysisSuccessful;
 }
 
-eth::LinkerObject AssemblyStack::assemble(Machine _machine)
+eth::LinkerObject AssemblyStack::assemble(Machine _machine) const
 {
 	solAssert(m_analysisSuccessful, "");
 	solAssert(m_parserResult, "");
@@ -86,13 +86,13 @@ eth::LinkerObject AssemblyStack::assemble(Machine _machine)
 	{
 	case Machine::EVM:
 	{
-		auto assembly = assembly::CodeGenerator(m_errorReporter).assemble(*m_parserResult, *m_analysisInfo);
+		auto assembly = assembly::CodeGenerator::assemble(*m_parserResult, *m_analysisInfo);
 		return assembly.assemble();
 	}
 	case Machine::EVM15:
 	{
 		julia::EVMAssembly assembly(true);
-		julia::CodeTransform(m_errorReporter, assembly, *m_analysisInfo, true).run(*m_parserResult);
+		julia::CodeTransform(assembly, *m_analysisInfo, true).run(*m_parserResult);
 		return assembly.finalize();
 	}
 	case Machine::eWasm:
@@ -102,7 +102,7 @@ eth::LinkerObject AssemblyStack::assemble(Machine _machine)
 	return eth::LinkerObject();
 }
 
-string AssemblyStack::print()
+string AssemblyStack::print() const
 {
 	solAssert(m_parserResult, "");
 	return assembly::AsmPrinter(m_language == Language::JULIA)(*m_parserResult);
diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
index abecaae2..17d5f055 100644
--- a/libsolidity/interface/AssemblyStack.h
+++ b/libsolidity/interface/AssemblyStack.h
@@ -65,13 +65,13 @@ public:
 	bool analyze(assembly::Block const& _block, Scanner const* _scanner = nullptr);
 
 	/// Run the assembly step (should only be called after parseAndAnalyze).
-	eth::LinkerObject assemble(Machine _machine);
+	eth::LinkerObject assemble(Machine _machine) const;
 
 	/// @returns the errors generated during parsing, analysis (and potentially assembly).
 	ErrorList const& errors() const { return m_errors; }
 
 	/// Pretty-print the input after having parsed it.
-	std::string print();
+	std::string print() const;
 
 private:
 	bool analyzeParsed();
-- 
cgit v1.2.3


From b32d5e4cc011e91efb2e8399c692206bfeaf9ca3 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 7 Jun 2017 11:40:47 +0200
Subject: Visitor bugfix.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 23 +++++++++++++++++------
 libsolidity/inlineasm/AsmAnalysis.h   |  1 +
 2 files changed, 18 insertions(+), 6 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index bfc6b2af..13852880 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -277,8 +277,12 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	{
 		if (_case.value)
 		{
-			if (!expectExpression(*_case.value))
+			int const initialStackHeight = m_stackHeight;
+			// We cannot use "expectExpression" here because *_case.value is not a
+			// Statement and would be converted to a Statement otherwise.
+			if (!(*this)(*_case.value))
 				success = false;
+			expectDeposit(1, initialStackHeight, _case.value->location);
 			m_stackHeight--;
 
 			/// Note: the parser ensures there is only one default case
@@ -345,17 +349,24 @@ bool AsmAnalyzer::expectExpression(Statement const& _statement)
 	int const initialHeight = m_stackHeight;
 	if (!boost::apply_visitor(*this, _statement))
 		success = false;
-	if (m_stackHeight - initialHeight != 1)
+	if (!expectDeposit(1, initialHeight, locationOf(_statement)))
+		success = false;
+	return success;
+}
+
+bool AsmAnalyzer::expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location)
+{
+	if (m_stackHeight - _oldHeight != _deposit)
 	{
 		m_errorReporter.typeError(
-			locationOf(_statement),
+			_location,
 			"Expected expression to return one item to the stack, but did return " +
-			boost::lexical_cast<string>(m_stackHeight - initialHeight) +
+			boost::lexical_cast<string>(m_stackHeight - _oldHeight) +
 			" items."
 		);
-		success = false;
+		return false;
 	}
-	return success;
+	return true;
 }
 
 bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t _valueSize)
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 75c0c43b..dea9a972 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -89,6 +89,7 @@ public:
 private:
 	/// Visits the statement and expects it to deposit one item onto the stack.
 	bool expectExpression(Statement const& _statement);
+	bool expectDeposit(int _deposit, int _oldHeight, SourceLocation const& _location);
 
 	/// Verifies that a variable to be assigned to exists and has the same size
 	/// as the value, @a _valueSize, unless that is equal to -1.
-- 
cgit v1.2.3


From 308a726ad180ae9240bca9fe673429db4a0e60e6 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 7 Jun 2017 14:15:39 +0200
Subject: Fix: Copy resolver.

---
 libsolidity/inlineasm/AsmAnalysis.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index dea9a972..e7748bcf 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -99,7 +99,7 @@ private:
 	void expectValidType(std::string const& type, SourceLocation const& _location);
 
 	int m_stackHeight = 0;
-	julia::ExternalIdentifierAccess::Resolver const& m_resolver;
+	julia::ExternalIdentifierAccess::Resolver m_resolver;
 	Scope* m_currentScope = nullptr;
 	AsmAnalysisInfo& m_info;
 	ErrorReporter& m_errorReporter;
-- 
cgit v1.2.3


From 6b3e7f79cf42edd031a2000978e394d818212b39 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 8 Jun 2017 15:52:15 +0200
Subject: Comments and consistent variable names.

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 217c6885..0e4e744f 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -92,14 +92,14 @@ public:
 		appendInstruction(solidity::Instruction::JUMP);
 		m_assembly.adjustDeposit(_stackDiffAfter);
 	}
-	virtual void appendJumpTo(LabelID _label, int _stackDiffAfter) override
+	virtual void appendJumpTo(LabelID _labelId, int _stackDiffAfter) override
 	{
-		appendLabelReference(_label);
+		appendLabelReference(_labelId);
 		appendJump(_stackDiffAfter);
 	}
-	virtual void appendJumpToIf(LabelID _label) override
+	virtual void appendJumpToIf(LabelID _labelId) override
 	{
-		appendLabelReference(_label);
+		appendLabelReference(_labelId);
 		appendInstruction(solidity::Instruction::JUMPI);
 	}
 	virtual void appendBeginsub(LabelID, int) override
-- 
cgit v1.2.3


From ae6251effd0474cd25379f09148da95b3486e9b4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 11:36:36 +0100
Subject: Use inline assembly directly and not via AsmStack

---
 libsolidity/codegen/CompilerContext.cpp | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 9c4fbcbb..d98efcad 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -25,8 +25,11 @@
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/codegen/Compiler.h>
 #include <libsolidity/interface/Version.h>
-#include <libsolidity/inlineasm/AsmData.h>
-#include <libsolidity/inlineasm/AsmStack.h>
+#include <libsolidity/interface/ErrorReporter.h>
+#include <libsolidity/inlineasm/AsmParser.h>
+#include <libsolidity/inlineasm/AsmCodeGen.h>
+#include <libsolidity/inlineasm/AsmAnalysis.h>
+#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
 #include <boost/algorithm/string/replace.hpp>
 
@@ -302,7 +305,18 @@ void CompilerContext::appendInlineAssembly(
 		}
 	};
 
-	solAssert(assembly::InlineAssemblyStack().parseAndAssemble(*assembly, *m_asm, identifierAccess), "Failed to assemble inline assembly block.");
+	ErrorList errors;
+	ErrorReporter errorReporter(errors);
+	auto scanner = make_shared<Scanner>(CharStream(*assembly), "--CODEGEN--");
+	auto parserResult = assembly::Parser(errorReporter).parse(scanner);
+	solAssert(parserResult, "Failed to parse inline assembly block.");
+	solAssert(errorReporter.errors().empty(), "Failed to parse inline assembly block.");
+
+	assembly::AsmAnalysisInfo analysisInfo;
+	assembly::AsmAnalyzer analyzer(analysisInfo, errorReporter, false, identifierAccess.resolve);
+	solAssert(analyzer.analyze(*parserResult), "Failed to analyze inline assembly block.");
+	solAssert(errorReporter.errors().empty(), "Failed to analyze inline assembly block.");
+	assembly::CodeGenerator::assemble(*parserResult, analysisInfo, *m_asm, identifierAccess);
 }
 
 FunctionDefinition const& CompilerContext::resolveVirtualFunction(
-- 
cgit v1.2.3


From 114c157b04f0ea1429b67d52c35e32f13c5ae9a4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 11:36:56 +0100
Subject: Remove obsolete AsmStack

---
 libsolidity/inlineasm/AsmStack.cpp | 96 --------------------------------------
 libsolidity/inlineasm/AsmStack.h   | 79 -------------------------------
 2 files changed, 175 deletions(-)
 delete mode 100644 libsolidity/inlineasm/AsmStack.cpp
 delete mode 100644 libsolidity/inlineasm/AsmStack.h

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmStack.cpp b/libsolidity/inlineasm/AsmStack.cpp
deleted file mode 100644
index 92eb8a7a..00000000
--- a/libsolidity/inlineasm/AsmStack.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @date 2016
- * Full-stack Solidity inline assember.
- */
-
-#include <libsolidity/inlineasm/AsmStack.h>
-
-#include <libsolidity/inlineasm/AsmParser.h>
-#include <libsolidity/inlineasm/AsmCodeGen.h>
-#include <libsolidity/inlineasm/AsmPrinter.h>
-#include <libsolidity/inlineasm/AsmAnalysis.h>
-#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
-
-#include <libsolidity/parsing/Scanner.h>
-
-#include <libevmasm/Assembly.h>
-#include <libevmasm/SourceLocation.h>
-
-#include <memory>
-
-using namespace std;
-using namespace dev;
-using namespace dev::solidity;
-using namespace dev::solidity::assembly;
-
-bool InlineAssemblyStack::parse(
-	shared_ptr<Scanner> const& _scanner,
-	julia::ExternalIdentifierAccess::Resolver const& _resolver
-)
-{
-	m_parserResult = make_shared<Block>();
-	Parser parser(m_errorReporter);
-	auto result = parser.parse(_scanner);
-	if (!result)
-		return false;
-
-	*m_parserResult = std::move(*result);
-	AsmAnalysisInfo analysisInfo;
-	return (AsmAnalyzer(analysisInfo, m_errorReporter, false, _resolver)).analyze(*m_parserResult);
-}
-
-string InlineAssemblyStack::toString()
-{
-	return AsmPrinter()(*m_parserResult);
-}
-
-eth::Assembly InlineAssemblyStack::assemble()
-{
-	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, m_errorReporter);
-	solAssert(analyzer.analyze(*m_parserResult), "");
-	return CodeGenerator::assemble(*m_parserResult, analysisInfo);
-}
-
-bool InlineAssemblyStack::parseAndAssemble(
-	string const& _input,
-	eth::Assembly& _assembly,
-	julia::ExternalIdentifierAccess const& _identifierAccess
-)
-{
-	ErrorList errors;
-	ErrorReporter errorReporter(errors);
-	auto scanner = make_shared<Scanner>(CharStream(_input), "--CODEGEN--");
-	auto parserResult = Parser(errorReporter).parse(scanner);
-	if (!errorReporter.errors().empty())
-		return false;
-	solAssert(parserResult, "");
-
-	AsmAnalysisInfo analysisInfo;
-	AsmAnalyzer analyzer(analysisInfo, errorReporter, false, _identifierAccess.resolve);
-	solAssert(analyzer.analyze(*parserResult), "");
-	solAssert(errorReporter.errors().empty(), "");
-	CodeGenerator::assemble(*parserResult, analysisInfo, _assembly, _identifierAccess);
-
-	// At this point, the assembly might be messed up, but we should throw an
-	// internal compiler error anyway.
-	return errorReporter.errors().empty();
-}
-
diff --git a/libsolidity/inlineasm/AsmStack.h b/libsolidity/inlineasm/AsmStack.h
deleted file mode 100644
index 7452804d..00000000
--- a/libsolidity/inlineasm/AsmStack.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @date 2016
- * Full-stack Solidity inline assember.
- */
-
-#pragma once
-
-#include <libjulia/backends/evm/AbstractAssembly.h>
-#include <libsolidity/interface/ErrorReporter.h>
-
-#include <string>
-#include <functional>
-
-namespace dev
-{
-namespace eth
-{
-class Assembly;
-}
-namespace solidity
-{
-class Scanner;
-namespace assembly
-{
-struct Block;
-struct Identifier;
-
-class InlineAssemblyStack
-{
-public:
-	InlineAssemblyStack():
-		m_errorReporter(m_errorList) {}
-	/// Parse the given inline assembly chunk starting with `{` and ending with the corresponding `}`.
-	/// @return false or error.
-	bool parse(
-		std::shared_ptr<Scanner> const& _scanner,
-		julia::ExternalIdentifierAccess::Resolver const& _externalIdentifierResolver = julia::ExternalIdentifierAccess::Resolver()
-	);
-	/// Converts the parser result back into a string form (not necessarily the same form
-	/// as the source form, but it should parse into the same parsed form again).
-	std::string toString();
-
-	eth::Assembly assemble();
-
-	/// Parse and assemble a string in one run - for use in Solidity code generation itself.
-	bool parseAndAssemble(
-		std::string const& _input,
-		eth::Assembly& _assembly,
-		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
-	);
-
-	ErrorList const& errors() const { return m_errorReporter.errors(); }
-
-private:
-	std::shared_ptr<Block> m_parserResult;
-	ErrorList m_errorList;
-	ErrorReporter m_errorReporter;
-};
-
-}
-}
-}
-- 
cgit v1.2.3


From 1da3af161f94b28b816fd5522795aaae3af190f3 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 12:45:56 +0100
Subject: Simplify CodeGenerator by remove seldom used case

---
 libsolidity/inlineasm/AsmCodeGen.cpp    | 11 -----------
 libsolidity/inlineasm/AsmCodeGen.h      |  6 ------
 libsolidity/interface/AssemblyStack.cpp |  3 ++-
 3 files changed, 2 insertions(+), 18 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 0e4e744f..27750453 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -132,17 +132,6 @@ private:
 	eth::Assembly& m_assembly;
 };
 
-eth::Assembly assembly::CodeGenerator::assemble(
-	Block const& _parsedData,
-	AsmAnalysisInfo& _analysisInfo,
-	julia::ExternalIdentifierAccess const& _identifierAccess
-)
-{
-	eth::Assembly assembly;
-	EthAssemblyAdapter assemblyAdapter(assembly);
-	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
-	return assembly;
-}
 
 void assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
diff --git a/libsolidity/inlineasm/AsmCodeGen.h b/libsolidity/inlineasm/AsmCodeGen.h
index 7a149d74..2a36a590 100644
--- a/libsolidity/inlineasm/AsmCodeGen.h
+++ b/libsolidity/inlineasm/AsmCodeGen.h
@@ -41,12 +41,6 @@ struct Block;
 class CodeGenerator
 {
 public:
-	/// Performs code generation and @returns the result.
-	static eth::Assembly assemble(
-		Block const& _parsedData,
-		AsmAnalysisInfo& _analysisInfo,
-		julia::ExternalIdentifierAccess const& _identifierAccess = julia::ExternalIdentifierAccess()
-	);
 	/// Performs code generation and appends generated to to _assembly.
 	static void assemble(
 		Block const& _parsedData,
diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index 31d9e494..b6151f56 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -86,7 +86,8 @@ eth::LinkerObject AssemblyStack::assemble(Machine _machine) const
 	{
 	case Machine::EVM:
 	{
-		auto assembly = assembly::CodeGenerator::assemble(*m_parserResult, *m_analysisInfo);
+		eth::Assembly assembly;
+		assembly::CodeGenerator::assemble(*m_parserResult, *m_analysisInfo, assembly);
 		return assembly.assemble();
 	}
 	case Machine::EVM15:
-- 
cgit v1.2.3


From 8768080a02d6862849705ee106c81672368721e6 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 12:47:05 +0100
Subject: Remove excess includes

---
 libsolidity/interface/AssemblyStack.cpp | 1 +
 libsolidity/interface/AssemblyStack.h   | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index b6151f56..75877881 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -26,6 +26,7 @@
 #include <libsolidity/inlineasm/AsmPrinter.h>
 #include <libsolidity/inlineasm/AsmParser.h>
 #include <libsolidity/inlineasm/AsmAnalysis.h>
+#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 #include <libsolidity/inlineasm/AsmCodeGen.h>
 
 #include <libevmasm/Assembly.h>
diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
index 17d5f055..ee2a334c 100644
--- a/libsolidity/interface/AssemblyStack.h
+++ b/libsolidity/interface/AssemblyStack.h
@@ -21,7 +21,6 @@
 
 #pragma once
 
-#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 #include <libsolidity/interface/ErrorReporter.h>
 #include <libevmasm/LinkerObject.h>
 
-- 
cgit v1.2.3


From bf2b5c746ab92d1227c5a4d1f6c7458b2450faa1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 9 Jun 2017 14:44:38 +0200
Subject: Use lowercase when reporting instruction error.

---
 libsolidity/inlineasm/AsmParser.cpp | 38 +++++++++++++++++++++++++++----------
 libsolidity/inlineasm/AsmParser.h   |  3 ++-
 2 files changed, 30 insertions(+), 11 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 3200b360..68a9cb03 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -206,6 +206,20 @@ std::map<string, dev::solidity::Instruction> const& Parser::instructions()
 	return s_instructions;
 }
 
+std::map<dev::solidity::Instruction, string> const& Parser::instructionNames()
+{
+	static map<dev::solidity::Instruction, string> s_instructionNames;
+	if (s_instructionNames.empty())
+	{
+		for (auto const& instr: instructions())
+			s_instructionNames[instr.second] = instr.first;
+		// set the ambiguous instructions to a clear default
+		s_instructionNames[solidity::Instruction::SELFDESTRUCT] = "selfdestruct";
+		s_instructionNames[solidity::Instruction::KECCAK256] = "keccak256";
+	}
+	return s_instructionNames;
+}
+
 assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 {
 	Statement ret;
@@ -233,7 +247,7 @@ assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
 			{
 				InstructionInfo info = dev::solidity::instructionInfo(instr);
 				if (info.ret != 1)
-					fatalParserError("Instruction " + info.name + " not allowed in this context.");
+					fatalParserError("Instruction \"" + literal + "\" not allowed in this context.");
 			}
 			ret = Instruction{location(), instr};
 		}
@@ -363,9 +377,9 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			/// check for premature closing parentheses
 			if (currentToken() == Token::RParen)
 				fatalParserError(string(
-					"Expected expression (" +
-					instrInfo.name +
-					" expects " +
+					"Expected expression (\"" +
+					instructionNames().at(instr) +
+					"\" expects " +
 					boost::lexical_cast<string>(args) +
 					" arguments)"
 				));
@@ -375,9 +389,9 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 			{
 				if (currentToken() != Token::Comma)
 					fatalParserError(string(
-						"Expected comma (" +
-						instrInfo.name +
-						" expects " +
+						"Expected comma (\"" +
+						instructionNames().at(instr) +
+						"\" expects " +
 						boost::lexical_cast<string>(args) +
 						" arguments)"
 					));
@@ -387,9 +401,13 @@ assembly::Statement Parser::parseCall(assembly::Statement&& _instruction)
 		}
 		ret.location.end = endPosition();
 		if (currentToken() == Token::Comma)
-			fatalParserError(
-				string("Expected ')' (" + instrInfo.name + " expects " + boost::lexical_cast<string>(args) + " arguments)")
-			);
+			fatalParserError(string(
+				"Expected ')' (\"" +
+				instructionNames().at(instr) +
+				"\" expects " +
+				boost::lexical_cast<string>(args) +
+				" arguments)"
+			));
 		expectToken(Token::RParen);
 		return ret;
 	}
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index e32b1d25..5fafad23 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -65,7 +65,8 @@ protected:
 	Case parseCase();
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
-	std::map<std::string, dev::solidity::Instruction> const& instructions();
+	static std::map<std::string, dev::solidity::Instruction> const& instructions();
+	static std::map<dev::solidity::Instruction, std::string> const& instructionNames();
 	Statement parseElementaryOperation(bool _onlySinglePusher = false);
 	VariableDeclaration parseVariableDeclaration();
 	FunctionDefinition parseFunctionDefinition();
-- 
cgit v1.2.3


From f0d213e6b56da5be8088008bf2ceadb7fd0030f7 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 29 May 2017 23:50:46 +0100
Subject: Introduce MachineAssemblyObject

---
 libsolidity/interface/AssemblyStack.cpp | 14 ++++++++++----
 libsolidity/interface/AssemblyStack.h   |  8 +++++++-
 2 files changed, 17 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index 75877881..6a5e5494 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -77,7 +77,7 @@ bool AssemblyStack::analyzeParsed()
 	return m_analysisSuccessful;
 }
 
-eth::LinkerObject AssemblyStack::assemble(Machine _machine) const
+MachineAssemblyObject AssemblyStack::assemble(Machine _machine) const
 {
 	solAssert(m_analysisSuccessful, "");
 	solAssert(m_parserResult, "");
@@ -87,21 +87,27 @@ eth::LinkerObject AssemblyStack::assemble(Machine _machine) const
 	{
 	case Machine::EVM:
 	{
+		MachineAssemblyObject object;
 		eth::Assembly assembly;
 		assembly::CodeGenerator::assemble(*m_parserResult, *m_analysisInfo, assembly);
-		return assembly.assemble();
+		object.bytecode = make_shared<eth::LinkerObject>(assembly.assemble());
+		/// TODO: fill out text representation
+		return object;
 	}
 	case Machine::EVM15:
 	{
+		MachineAssemblyObject object;
 		julia::EVMAssembly assembly(true);
 		julia::CodeTransform(assembly, *m_analysisInfo, true).run(*m_parserResult);
-		return assembly.finalize();
+		object.bytecode = make_shared<eth::LinkerObject>(assembly.finalize());
+		/// TOOD: fill out text representation
+		return object;
 	}
 	case Machine::eWasm:
 		solUnimplemented("eWasm backend is not yet implemented.");
 	}
 	// unreachable
-	return eth::LinkerObject();
+	return MachineAssemblyObject();
 }
 
 string AssemblyStack::print() const
diff --git a/libsolidity/interface/AssemblyStack.h b/libsolidity/interface/AssemblyStack.h
index ee2a334c..2ae596ed 100644
--- a/libsolidity/interface/AssemblyStack.h
+++ b/libsolidity/interface/AssemblyStack.h
@@ -38,6 +38,12 @@ struct AsmAnalysisInfo;
 struct Block;
 }
 
+struct MachineAssemblyObject
+{
+	std::shared_ptr<eth::LinkerObject> bytecode;
+	std::string assembly;
+};
+
 /*
  * Full assembly stack that can support EVM-assembly and JULIA as input and EVM, EVM1.5 and
  * eWasm as output.
@@ -64,7 +70,7 @@ public:
 	bool analyze(assembly::Block const& _block, Scanner const* _scanner = nullptr);
 
 	/// Run the assembly step (should only be called after parseAndAnalyze).
-	eth::LinkerObject assemble(Machine _machine) const;
+	MachineAssemblyObject assemble(Machine _machine) const;
 
 	/// @returns the errors generated during parsing, analysis (and potentially assembly).
 	ErrorList const& errors() const { return m_errors; }
-- 
cgit v1.2.3


From ca92bda886740f7c59aaf44aaa8a15e25136c9dc Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 29 May 2017 23:58:03 +0100
Subject: Supply text representation of assembly

---
 libsolidity/interface/AssemblyStack.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index 6a5e5494..7dc1edc7 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -91,7 +91,9 @@ MachineAssemblyObject AssemblyStack::assemble(Machine _machine) const
 		eth::Assembly assembly;
 		assembly::CodeGenerator::assemble(*m_parserResult, *m_analysisInfo, assembly);
 		object.bytecode = make_shared<eth::LinkerObject>(assembly.assemble());
-		/// TODO: fill out text representation
+		ostringstream tmp;
+		assembly.stream(tmp);
+		object.assembly = tmp.str();
 		return object;
 	}
 	case Machine::EVM15:
-- 
cgit v1.2.3


From 05af6c92556acac917983b1a8e0e9e62d28de573 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 24 May 2017 21:51:54 +0100
Subject: Warn if returndatasize/returndatacopy is used

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 20 +++++++++++++++++++-
 libsolidity/inlineasm/AsmAnalysis.h   |  1 +
 2 files changed, 20 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 13852880..36ac0e75 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -65,6 +65,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 	auto const& info = instructionInfo(_instruction.instruction);
 	m_stackHeight += info.ret - info.args;
 	m_info.stackHeightInfo[&_instruction] = m_stackHeight;
+	warnOnFutureInstruction(_instruction.instruction, _instruction.location);
 	return true;
 }
 
@@ -149,6 +150,7 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	if (!(*this)(_instr.instruction))
 		success = false;
 	m_info.stackHeightInfo[&_instr] = m_stackHeight;
+	warnOnFutureInstruction(_instr.instruction.instruction, _instr.location);
 	return success;
 }
 
@@ -431,7 +433,6 @@ Scope& AsmAnalyzer::scope(Block const* _block)
 	solAssert(scopePtr, "Scope requested but not present.");
 	return *scopePtr;
 }
-
 void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _location)
 {
 	if (!m_julia)
@@ -443,3 +444,20 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 			"\"" + type + "\" is not a valid type (user defined types are not yet supported)."
 		);
 }
+
+void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
+{
+	switch (_instr)
+	{
+	case solidity::Instruction::RETURNDATASIZE:
+	case solidity::Instruction::RETURNDATACOPY:
+		m_errorReporter.warning(
+			_location,
+			"The RETURNDATASIZE/RETURNDATACOPY instructions are only available after "
+			"the Metropolis hard fork. Before that they act as an invalid instruction."
+		);
+		break;
+	default:
+		break;
+	}
+}
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index e7748bcf..55b409ba 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -97,6 +97,7 @@ private:
 
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
+	void warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location);
 
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver m_resolver;
-- 
cgit v1.2.3


From 8775e77305f84117827f1e6165c4d3776c51f667 Mon Sep 17 00:00:00 2001
From: Yoichi Hirai <i@yoichihirai.com>
Date: Fri, 9 Jun 2017 15:35:27 +0200
Subject: Add a warning about a varialbe of the name of an instruction

---
 libsolidity/analysis/NameAndTypeResolver.cpp | 22 ++++++++++++++++++++++
 libsolidity/analysis/NameAndTypeResolver.h   |  3 +++
 libsolidity/analysis/ReferencesResolver.cpp  |  2 ++
 3 files changed, 27 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/NameAndTypeResolver.cpp b/libsolidity/analysis/NameAndTypeResolver.cpp
index 2742dcf2..aac90311 100644
--- a/libsolidity/analysis/NameAndTypeResolver.cpp
+++ b/libsolidity/analysis/NameAndTypeResolver.cpp
@@ -26,6 +26,8 @@
 #include <libsolidity/analysis/TypeChecker.h>
 #include <libsolidity/interface/ErrorReporter.h>
 
+#include <boost/algorithm/string.hpp>
+
 using namespace std;
 
 namespace dev
@@ -232,6 +234,26 @@ vector<Declaration const*> NameAndTypeResolver::cleanedDeclarations(
 	return uniqueFunctions;
 }
 
+void NameAndTypeResolver::warnVariablesNamedLikeInstructions()
+{
+	for (auto const& instruction: c_instructions)
+	{
+		string const instructionName{boost::algorithm::to_lower_copy(instruction.first)};
+		auto declarations = nameFromCurrentScope(instructionName);
+		for (Declaration const* const declaration: declarations)
+		{
+			solAssert(!!declaration, "");
+			if (dynamic_cast<MagicVariableDeclaration const* const>(declaration))
+				// Don't warn the user for what the user did not.
+				continue;
+			m_errorReporter.warning(
+				declaration->location(),
+				"Variable is shadowed in inline assembly by an instruction of the same name"
+			);
+		}
+	}
+}
+
 bool NameAndTypeResolver::resolveNamesAndTypesInternal(ASTNode& _node, bool _resolveInsideCode)
 {
 	if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(&_node))
diff --git a/libsolidity/analysis/NameAndTypeResolver.h b/libsolidity/analysis/NameAndTypeResolver.h
index 0441867d..84628778 100644
--- a/libsolidity/analysis/NameAndTypeResolver.h
+++ b/libsolidity/analysis/NameAndTypeResolver.h
@@ -90,6 +90,9 @@ public:
 		std::vector<Declaration const*> const& _declarations
 	);
 
+	/// Generate and store warnings about variables that are named like instructions.
+	void warnVariablesNamedLikeInstructions();
+
 private:
 	/// Internal version of @a resolveNamesAndTypes (called from there) throws exceptions on fatal errors.
 	bool resolveNamesAndTypesInternal(ASTNode& _node, bool _resolveInsideCode = true);
diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp
index edf2fc02..2a5f27df 100644
--- a/libsolidity/analysis/ReferencesResolver.cpp
+++ b/libsolidity/analysis/ReferencesResolver.cpp
@@ -162,6 +162,8 @@ void ReferencesResolver::endVisit(ArrayTypeName const& _typeName)
 
 bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 {
+	m_resolver.warnVariablesNamedLikeInstructions();
+
 	// Errors created in this stage are completely ignored because we do not yet know
 	// the type and size of external identifiers, which would result in false errors.
 	// The only purpose of this step is to fill the inline assembly annotation with
-- 
cgit v1.2.3


From 2e816967d315185b930e3460d822f04bff061492 Mon Sep 17 00:00:00 2001
From: Edward Ruchevits <ruchevits@gmail.com>
Date: Tue, 13 Jun 2017 17:02:57 +0100
Subject: Allow including hashes of method signatures in --combined-json output

---
 libsolidity/interface/CompilerStack.cpp | 8 ++++++++
 libsolidity/interface/CompilerStack.h   | 3 +++
 2 files changed, 11 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index aca9ce39..234539ea 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -481,6 +481,14 @@ Json::Value const& CompilerStack::natspec(Contract const& _contract, Documentati
 	return *(*doc);
 }
 
+Json::Value CompilerStack::functionHashes(ContractDefinition const& _contract)
+{
+	Json::Value functionHashes(Json::objectValue);
+	for (auto const& it: _contract.interfaceFunctions())
+		functionHashes[toHex(it.first.ref())] = it.second->externalSignature();
+	return functionHashes;
+}
+
 string const& CompilerStack::onChainMetadata(string const& _contractName) const
 {
 	if (m_stackState != CompilationSuccessful)
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index bffdeabd..3250429b 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -177,6 +177,9 @@ public:
 	/// @param type The type of the documentation to get.
 	/// Can be one of 4 types defined at @c DocumentationType
 	Json::Value const& natspec(std::string const& _contractName, DocumentationType _type) const;
+
+	Json::Value functionHashes(ContractDefinition const& _contract);
+
 	std::string const& onChainMetadata(std::string const& _contractName) const;
 	void useMetadataLiteralSources(bool _metadataLiteralSources) { m_metadataLiteralSources = _metadataLiteralSources; }
 
-- 
cgit v1.2.3


From 5f7bca94e5174738aea294c51f4bea2f8b450d0d Mon Sep 17 00:00:00 2001
From: Edward Ruchevits <ruchevits@gmail.com>
Date: Tue, 13 Jun 2017 18:04:33 +0100
Subject: Reverted functionHashes output to use method signature as keys

---
 libsolidity/interface/CompilerStack.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 234539ea..b09108b0 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -485,7 +485,7 @@ Json::Value CompilerStack::functionHashes(ContractDefinition const& _contract)
 {
 	Json::Value functionHashes(Json::objectValue);
 	for (auto const& it: _contract.interfaceFunctions())
-		functionHashes[toHex(it.first.ref())] = it.second->externalSignature();
+		functionHashes[it.second->externalSignature()] = toHex(it.first.ref());
 	return functionHashes;
 }
 
-- 
cgit v1.2.3


From 45d96959f88e951af0e2ccf0217f19d75da66ed1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 13 Jun 2017 21:58:25 +0200
Subject: Move LabelIDs to generation phase.

---
 libsolidity/inlineasm/AsmScope.h | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index ad321f77..5e22c6e7 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -75,17 +75,13 @@ struct Scope
 		JuliaType type;
 	};
 
-	struct Label
-	{
-		boost::optional<LabelID> id;
-	};
+	struct Label { };
 
 	struct Function
 	{
 		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
 		std::vector<JuliaType> arguments;
 		std::vector<JuliaType> returns;
-		boost::optional<LabelID> id;
 	};
 
 	using Identifier = boost::variant<Variable, Label, Function>;
-- 
cgit v1.2.3


From c554145f4d7063422a5e105e2b600b640cf3d8d1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 14 Jun 2017 00:01:06 +0200
Subject: Move stack height to generation phase.

---
 libsolidity/inlineasm/AsmScope.h | 2 --
 1 file changed, 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 5e22c6e7..23cf61f2 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -67,8 +67,6 @@ struct Scope
 
 	struct Variable
 	{
-		/// Used during code generation to store the stack height. @todo move there.
-		int stackHeight = 0;
 		/// Used during analysis to check whether we already passed the declaration inside the block.
 		/// @todo move there.
 		bool active = false;
-- 
cgit v1.2.3


From 1bf717fd6513dda5336f95104cebfc0f041f3682 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 14 Jun 2017 00:03:08 +0200
Subject: Remove struct constructor.

---
 libsolidity/inlineasm/AsmScope.cpp | 2 +-
 libsolidity/inlineasm/AsmScope.h   | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index 7a086846..1db5ca41 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -46,7 +46,7 @@ bool Scope::registerFunction(string const& _name, std::vector<JuliaType> const&
 {
 	if (exists(_name))
 		return false;
-	identifiers[_name] = Function(_arguments, _returns);
+	identifiers[_name] = Function{_arguments, _returns};
 	return true;
 }
 
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index 23cf61f2..c8e38c8a 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -77,7 +77,6 @@ struct Scope
 
 	struct Function
 	{
-		Function(std::vector<JuliaType> const& _arguments, std::vector<JuliaType> const& _returns): arguments(_arguments), returns(_returns) {}
 		std::vector<JuliaType> arguments;
 		std::vector<JuliaType> returns;
 	};
-- 
cgit v1.2.3


From 154002cda05a75203b625d23ce507787bd5fa5e4 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 14 Jun 2017 00:07:13 +0200
Subject: Move "active variable" to analysis phase.

---
 libsolidity/inlineasm/AsmAnalysis.cpp |  8 ++++----
 libsolidity/inlineasm/AsmAnalysis.h   |  8 +++++---
 libsolidity/inlineasm/AsmScope.h      | 10 +---------
 3 files changed, 10 insertions(+), 16 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 13852880..bb30fce1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -91,7 +91,7 @@ bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
 	if (m_currentScope->lookup(_identifier.name, Scope::Visitor(
 		[&](Scope::Variable const& _var)
 		{
-			if (!_var.active)
+			if (!m_activeVariables.count(&_var))
 			{
 				m_errorReporter.declarationError(
 					_identifier.location,
@@ -185,7 +185,7 @@ bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
 	for (auto const& variable: _varDecl.variables)
 	{
 		expectValidType(variable.type, variable.location);
-		boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)).active = true;
+		m_activeVariables.insert(&boost::get<Scope::Variable>(m_currentScope->identifiers.at(variable.name)));
 	}
 	m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
 	return success;
@@ -199,7 +199,7 @@ bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
 	for (auto const& var: _funDef.arguments + _funDef.returns)
 	{
 		expectValidType(var.type, var.location);
-		boost::get<Scope::Variable>(varScope.identifiers.at(var.name)).active = true;
+		m_activeVariables.insert(&boost::get<Scope::Variable>(varScope.identifiers.at(var.name)));
 	}
 
 	int const stackHeight = m_stackHeight;
@@ -382,7 +382,7 @@ bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t
 			m_errorReporter.typeError(_variable.location, "Assignment requires variable.");
 			success = false;
 		}
-		else if (!boost::get<Scope::Variable>(*var).active)
+		else if (!m_activeVariables.count(&boost::get<Scope::Variable>(*var)))
 		{
 			m_errorReporter.declarationError(
 				_variable.location,
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index e7748bcf..cd195d97 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -22,6 +22,8 @@
 
 #include <libsolidity/interface/Exceptions.h>
 
+#include <libsolidity/inlineasm/AsmScope.h>
+
 #include <libjulia/backends/evm/AbstractAssembly.h>
 
 #include <boost/variant.hpp>
@@ -51,9 +53,6 @@ struct FunctionCall;
 struct Switch;
 using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
 
-
-struct Scope;
-
 struct AsmAnalysisInfo;
 
 /**
@@ -101,6 +100,9 @@ private:
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver m_resolver;
 	Scope* m_currentScope = nullptr;
+	/// Variables that are active at the current point in assembly (as opposed to
+	/// "part of the scope but not yet declared")
+	std::set<Scope::Variable const*> m_activeVariables;
 	AsmAnalysisInfo& m_info;
 	ErrorReporter& m_errorReporter;
 	bool m_julia = false;
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index c8e38c8a..de9119e0 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -65,16 +65,8 @@ struct Scope
 	using JuliaType = std::string;
 	using LabelID = size_t;
 
-	struct Variable
-	{
-		/// Used during analysis to check whether we already passed the declaration inside the block.
-		/// @todo move there.
-		bool active = false;
-		JuliaType type;
-	};
-
+	struct Variable { JuliaType type; };
 	struct Label { };
-
 	struct Function
 	{
 		std::vector<JuliaType> arguments;
-- 
cgit v1.2.3


From fd8365df08aafc7ab7cfac5fa916d910343d0eb3 Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Wed, 14 Jun 2017 00:09:11 -0300
Subject: Forbid trailing commas in named arguments

---
 libsolidity/parsing/Parser.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index ec27f89b..7c439211 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -1328,16 +1328,21 @@ pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::pars
 	{
 		// call({arg1 : 1, arg2 : 2 })
 		expectToken(Token::LBrace);
+
+		bool first = true;
 		while (m_scanner->currentToken() != Token::RBrace)
 		{
+			if (!first)
+				expectToken(Token::Comma);
+
+			if (m_scanner->currentToken() == Token::RBrace)
+				fatalParserError("Unexpected trailing comma.");
+
 			ret.second.push_back(expectIdentifierToken());
 			expectToken(Token::Colon);
 			ret.first.push_back(parseExpression());
 
-			if (m_scanner->currentToken() == Token::Comma)
-				expectToken(Token::Comma);
-			else
-				break;
+			first = false;
 		}
 		expectToken(Token::RBrace);
 	}
-- 
cgit v1.2.3


From 07cc84fadee7f1f86467a8dba435b2d5b28db268 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 13 Jun 2017 16:42:58 +0200
Subject: Fix a crash about a non-callable expression.

---
 libsolidity/analysis/TypeChecker.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index b1911ef0..50482b8f 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -1287,14 +1287,11 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		membersRemovedForStructConstructor = structType.membersMissingInMemory();
 		_functionCall.annotation().isPure = isPure;
 	}
-	else
-	{
-		functionType = dynamic_pointer_cast<FunctionType const>(expressionType);
+	else if (functionType = dynamic_pointer_cast<FunctionType const>(expressionType))
 		_functionCall.annotation().isPure =
 			isPure &&
 			_functionCall.expression().annotation().isPure &&
 			functionType->isPure();
-	}
 
 	if (!functionType)
 	{
-- 
cgit v1.2.3


From 1b1f35762e7d761a6a97f825699972472ba44888 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 13 Jun 2017 18:38:55 +0200
Subject: Enforce function arguments when parsing functional instructions.

---
 libsolidity/inlineasm/AsmParser.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index 68a9cb03..f9b073ba 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -174,6 +174,19 @@ assembly::Case Parser::parseCase()
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
+	if (operation.type() == typeid(Instruction))
+	{
+		Instruction const& instr = boost::get<Instruction>(operation);
+		int args = instructionInfo(instr.instruction).args;
+		if (args > 0 && currentToken() != Token::LParen)
+			fatalParserError(string(
+				"Expected token \"(\" (\"" +
+				instructionNames().at(instr.instruction) +
+				"\" expects " +
+				boost::lexical_cast<string>(args) +
+				" arguments)"
+			));
+	}
 	if (currentToken() == Token::LParen)
 		return parseCall(std::move(operation));
 	else
-- 
cgit v1.2.3


From 494b9dbfaae2b1cf4c4d76e0be457b1e077af30c Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 20:00:13 +0100
Subject: Issue warning for using CREATE2 in inline assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 7bcbde91..a3d38cc9 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -449,12 +449,13 @@ void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLo
 {
 	switch (_instr)
 	{
+	case solidity::Instruction::CREATE2:
 	case solidity::Instruction::RETURNDATASIZE:
 	case solidity::Instruction::RETURNDATACOPY:
 		m_errorReporter.warning(
 			_location,
-			"The RETURNDATASIZE/RETURNDATACOPY instructions are only available after "
-			"the Metropolis hard fork. Before that they act as an invalid instruction."
+			"The \"" + _instr + "\" instruction is only available after " +
+			"the Metropolis hard fork. Before that it acts as an invalid instruction."
 		);
 		break;
 	default:
-- 
cgit v1.2.3


From a921bd0ae4afbd6eb55d65beb832546971a65dd4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 20:03:32 +0100
Subject: Display user friendly instruction name

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index a3d38cc9..630e0abf 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -447,18 +447,25 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 
 void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
 {
+	string instr;
 	switch (_instr)
 	{
 	case solidity::Instruction::CREATE2:
+		instr = "create2";
+		break;
 	case solidity::Instruction::RETURNDATASIZE:
+		instr = "returndatasize";
+		break;
 	case solidity::Instruction::RETURNDATACOPY:
-		m_errorReporter.warning(
-			_location,
-			"The \"" + _instr + "\" instruction is only available after " +
-			"the Metropolis hard fork. Before that it acts as an invalid instruction."
-		);
+		instr = "returndatacopy";
 		break;
 	default:
 		break;
 	}
+	if (!instr.empty())
+		m_errorReporter.warning(
+			_location,
+			"The \"" + instr + "\" instruction is only available after " +
+			"the Metropolis hard fork. Before that it acts as an invalid instruction."
+		);
 }
-- 
cgit v1.2.3


From 29e7ad3d7b2b1700c085348911b0d6f129d2a5a5 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 14 Jun 2017 16:33:44 +0200
Subject: Silence compiler warning.

---
 libsolidity/analysis/TypeChecker.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 50482b8f..2a8d1ff6 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -1287,7 +1287,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		membersRemovedForStructConstructor = structType.membersMissingInMemory();
 		_functionCall.annotation().isPure = isPure;
 	}
-	else if (functionType = dynamic_pointer_cast<FunctionType const>(expressionType))
+	else if ((functionType = dynamic_pointer_cast<FunctionType const>(expressionType)))
 		_functionCall.annotation().isPure =
 			isPure &&
 			_functionCall.expression().annotation().isPure &&
-- 
cgit v1.2.3


From c20cdd0a0574c350b5cde7b38e87321479cecab3 Mon Sep 17 00:00:00 2001
From: Dimitry <winsvega@mail.ru>
Date: Thu, 8 Jun 2017 17:44:03 +0300
Subject: add new opcode instructions to the parser

STATICCALL        0xfa  6 inputs  (gas address mem1 mem2 mem3 mem4)
---
 libsolidity/inlineasm/AsmAnalysis.cpp | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 630e0abf..1a529118 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -29,6 +29,7 @@
 #include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
+#include <boost/algorithm/string.hpp>
 
 #include <memory>
 #include <functional>
@@ -447,25 +448,18 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 
 void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
 {
-	string instr;
-	switch (_instr)
-	{
-	case solidity::Instruction::CREATE2:
-		instr = "create2";
-		break;
-	case solidity::Instruction::RETURNDATASIZE:
-		instr = "returndatasize";
-		break;
-	case solidity::Instruction::RETURNDATACOPY:
-		instr = "returndatacopy";
-		break;
-	default:
-		break;
-	}
-	if (!instr.empty())
+	static set<solidity::Instruction> futureInstructions{
+		solidity::Instruction::CREATE2,
+		solidity::Instruction::RETURNDATACOPY,
+		solidity::Instruction::RETURNDATASIZE,
+		solidity::Instruction::STATICCALL
+	};
+	if (futureInstructions.count(_instr))
 		m_errorReporter.warning(
 			_location,
-			"The \"" + instr + "\" instruction is only available after " +
+			"The \"" +
+			boost::to_lower_copy(instructionInfo(_instr).name)
+			+ "\" instruction is only available after " +
 			"the Metropolis hard fork. Before that it acts as an invalid instruction."
 		);
 }
-- 
cgit v1.2.3


From 398099f50eaa7a4862950914054dbe68d0eee67b Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 1 Jun 2017 14:31:35 +0100
Subject: Remove obsolete errorTag()

---
 libsolidity/codegen/CompilerContext.h | 2 --
 1 file changed, 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerContext.h b/libsolidity/codegen/CompilerContext.h
index c37142c9..d1e8dabe 100644
--- a/libsolidity/codegen/CompilerContext.h
+++ b/libsolidity/codegen/CompilerContext.h
@@ -141,8 +141,6 @@ public:
 	CompilerContext&  appendInvalid();
 	/// Appends a conditional INVALID instruction
 	CompilerContext&  appendConditionalInvalid();
-	/// Returns an "ErrorTag"
-	eth::AssemblyItem errorTag() { return m_asm->errorTag(); }
 	/// Appends a JUMP to a specific tag
 	CompilerContext& appendJumpTo(eth::AssemblyItem const& _tag) { m_asm->appendJump(_tag); return *this; }
 	/// Appends pushing of a new tag and @returns the new tag.
-- 
cgit v1.2.3


From c08c4b8b6f0e8c4ccc139e525218cb0cb1ac4ad4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 14 Jun 2017 20:38:59 +0100
Subject: Move subroutine helpers from CompilerContext to Assembly

---
 libsolidity/codegen/CompilerContext.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerContext.h b/libsolidity/codegen/CompilerContext.h
index d1e8dabe..030b35a6 100644
--- a/libsolidity/codegen/CompilerContext.h
+++ b/libsolidity/codegen/CompilerContext.h
@@ -149,10 +149,10 @@ public:
 	eth::AssemblyItem newTag() { return m_asm->newTag(); }
 	/// Adds a subroutine to the code (in the data section) and pushes its size (via a tag)
 	/// on the stack. @returns the pushsub assembly item.
-	eth::AssemblyItem addSubroutine(eth::AssemblyPointer const& _assembly) { auto sub = m_asm->newSub(_assembly); m_asm->append(m_asm->newPushSubSize(size_t(sub.data()))); return sub; }
-	void pushSubroutineSize(size_t _subRoutine) { m_asm->append(m_asm->newPushSubSize(_subRoutine)); }
+	eth::AssemblyItem addSubroutine(eth::AssemblyPointer const& _assembly) { return m_asm->appendSubroutine(_assembly); }
+	void pushSubroutineSize(size_t _subRoutine) { m_asm->pushSubroutineSize(_subRoutine); }
 	/// Pushes the offset of the subroutine.
-	void pushSubroutineOffset(size_t _subRoutine) { m_asm->append(eth::AssemblyItem(eth::PushSub, _subRoutine)); }
+	void pushSubroutineOffset(size_t _subRoutine) { m_asm->pushSubroutineOffset(_subRoutine); }
 	/// Pushes the size of the final program
 	void appendProgramSize() { m_asm->appendProgramSize(); }
 	/// Adds data to the data section, pushes a reference to the stack
-- 
cgit v1.2.3


From 60bfae75e51c4f5213c82d17d32e10d939ebf0bf Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Thu, 15 Jun 2017 13:10:08 -0300
Subject: Improve error reporting of trailing commas

---
 libsolidity/parsing/Parser.cpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 7c439211..a49f60e2 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -1335,13 +1335,19 @@ pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::pars
 			if (!first)
 				expectToken(Token::Comma);
 
-			if (m_scanner->currentToken() == Token::RBrace)
-				fatalParserError("Unexpected trailing comma.");
-
 			ret.second.push_back(expectIdentifierToken());
 			expectToken(Token::Colon);
 			ret.first.push_back(parseExpression());
 
+			if (
+				m_scanner->currentToken() == Token::Comma &&
+				m_scanner->peekNextToken() == Token::RBrace
+			)
+			{
+				parserError("Unexpected trailing comma.");
+				m_scanner->next();
+			}
+
 			first = false;
 		}
 		expectToken(Token::RBrace);
-- 
cgit v1.2.3


From 0eaae03bbfaf02327c8b8d3f7b38cc3825ea1062 Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Thu, 15 Jun 2017 21:12:04 -0300
Subject: Try to recover from parser errors where possible

---
 libsolidity/parsing/Parser.cpp | 35 ++++++++++++++++++++++-------------
 1 file changed, 22 insertions(+), 13 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 7c439211..88b41f20 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -347,8 +347,12 @@ Parser::FunctionHeaderParserResult Parser::parseFunctionHeader(bool _forceEmptyN
 		else if (Token::isVisibilitySpecifier(token))
 		{
 			if (result.visibility != Declaration::Visibility::Default)
-				fatalParserError(string("Multiple visibility specifiers."));
-			result.visibility = parseVisibilitySpecifier(token);
+			{
+				parserError(string("Multiple visibility specifiers."));
+				m_scanner->next();
+			}
+			else
+				result.visibility = parseVisibilitySpecifier(token);
 		}
 		else
 			break;
@@ -501,8 +505,12 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
 		if (_options.isStateVariable && Token::isVariableVisibilitySpecifier(token))
 		{
 			if (visibility != Declaration::Visibility::Default)
-				fatalParserError(string("Visibility already specified."));
-			visibility = parseVisibilitySpecifier(token);
+			{
+				parserError(string("Visibility already specified."));
+				m_scanner->next();
+			}
+			else
+				visibility = parseVisibilitySpecifier(token);
 		}
 		else
 		{
@@ -513,14 +521,15 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
 			else if (_options.allowLocationSpecifier && Token::isLocationSpecifier(token))
 			{
 				if (location != VariableDeclaration::Location::Default)
-					fatalParserError(string("Location already specified."));
-				if (!type)
-					fatalParserError(string("Location specifier needs explicit type name."));
-				location = (
-					token == Token::Memory ?
-					VariableDeclaration::Location::Memory :
-					VariableDeclaration::Location::Storage
-				);
+					parserError(string("Location already specified."));
+				else if (!type)
+					parserError(string("Location specifier needs explicit type name."));
+				else
+					location = (
+						token == Token::Memory ?
+						VariableDeclaration::Location::Memory :
+						VariableDeclaration::Location::Storage
+					);
 			}
 			else
 				break;
@@ -702,7 +711,7 @@ ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
 	else if (token == Token::Var)
 	{
 		if (!_allowVar)
-			fatalParserError(string("Expected explicit type name."));
+			parserError(string("Expected explicit type name."));
 		m_scanner->next();
 	}
 	else if (token == Token::Function)
-- 
cgit v1.2.3


From 47925bc14e80d0c33c491dabc3c3dd3ea787b63c Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 28 Apr 2017 14:33:52 +0100
Subject: Parse for statement in assembly parser / printer

---
 libsolidity/inlineasm/AsmAnalysis.cpp    |  5 +++++
 libsolidity/inlineasm/AsmAnalysis.h      |  4 +++-
 libsolidity/inlineasm/AsmAnalysisInfo.h  |  3 ++-
 libsolidity/inlineasm/AsmData.h          |  4 +++-
 libsolidity/inlineasm/AsmParser.cpp      | 16 ++++++++++++++++
 libsolidity/inlineasm/AsmParser.h        |  1 +
 libsolidity/inlineasm/AsmPrinter.cpp     | 13 +++++++++++++
 libsolidity/inlineasm/AsmPrinter.h       |  2 ++
 libsolidity/inlineasm/AsmScopeFiller.cpp |  5 +++++
 libsolidity/inlineasm/AsmScopeFiller.h   |  2 ++
 10 files changed, 52 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 1a529118..68c940e7 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -310,6 +310,11 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	return success;
 }
 
+bool AsmAnalyzer::operator()(assembly::ForLoop const&)
+{
+	solAssert(false, "For loop not supported.");
+}
+
 bool AsmAnalyzer::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 2516722a..5cdf72b1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -51,7 +51,8 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+struct ForLoop;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block, ForLoop>;
 
 struct AsmAnalysisInfo;
 
@@ -83,6 +84,7 @@ public:
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const& _functionCall);
 	bool operator()(assembly::Switch const& _switch);
+	bool operator()(assembly::ForLoop const& _forLoop);
 	bool operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index 78c1fbe0..a75413a2 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -45,10 +45,11 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
 
 struct AsmAnalysisInfo
 {
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index 72afeef1..c2458bd7 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -51,9 +51,10 @@ struct FunctionalInstruction;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 struct Block;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block>;
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
 
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
@@ -82,6 +83,7 @@ struct FunctionDefinition { SourceLocation location; std::string name; TypedName
 struct Case { SourceLocation location; std::shared_ptr<Literal> value; Block body; };
 /// Switch statement
 struct Switch { SourceLocation location; std::shared_ptr<Statement> expression; std::vector<Case> cases; };
+struct ForLoop { SourceLocation location; Block pre; std::shared_ptr<Statement> condition; Block post; Block body; };
 
 struct LocationExtractor: boost::static_visitor<SourceLocation>
 {
diff --git a/libsolidity/inlineasm/AsmParser.cpp b/libsolidity/inlineasm/AsmParser.cpp
index f9b073ba..d282a30d 100644
--- a/libsolidity/inlineasm/AsmParser.cpp
+++ b/libsolidity/inlineasm/AsmParser.cpp
@@ -87,6 +87,8 @@ assembly::Statement Parser::parseStatement()
 		_switch.location.end = _switch.cases.back().body.location.end;
 		return _switch;
 	}
+	case Token::For:
+		return parseForLoop();
 	case Token::Assign:
 	{
 		if (m_julia)
@@ -171,6 +173,20 @@ assembly::Case Parser::parseCase()
 	return _case;
 }
 
+assembly::ForLoop Parser::parseForLoop()
+{
+	ForLoop forLoop = createWithLocation<ForLoop>();
+	expectToken(Token::For);
+	forLoop.pre = parseBlock();
+	forLoop.condition = make_shared<Statement>(parseExpression());
+	if (forLoop.condition->type() == typeid(assembly::Instruction))
+		fatalParserError("Instructions are not supported as conditions for the for statement.");
+	forLoop.post = parseBlock();
+	forLoop.body = parseBlock();
+	forLoop.location.end = forLoop.body.location.end;
+	return forLoop;
+}
+
 assembly::Statement Parser::parseExpression()
 {
 	Statement operation = parseElementaryOperation(true);
diff --git a/libsolidity/inlineasm/AsmParser.h b/libsolidity/inlineasm/AsmParser.h
index 5fafad23..45708afd 100644
--- a/libsolidity/inlineasm/AsmParser.h
+++ b/libsolidity/inlineasm/AsmParser.h
@@ -63,6 +63,7 @@ protected:
 	Block parseBlock();
 	Statement parseStatement();
 	Case parseCase();
+	ForLoop parseForLoop();
 	/// Parses a functional expression that has to push exactly one stack element
 	Statement parseExpression();
 	static std::map<std::string, dev::solidity::Instruction> const& instructions();
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index e282e5e8..0d06fedd 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -181,6 +181,19 @@ string AsmPrinter::operator()(Switch const& _switch)
 	return out;
 }
 
+string AsmPrinter::operator()(assembly::ForLoop const& _forLoop)
+{
+	string out = "for ";
+	out += (*this)(_forLoop.pre);
+	out += "\n";
+	out += boost::apply_visitor(*this, *_forLoop.condition);
+	out += "\n";
+	out += (*this)(_forLoop.post);
+	out += "\n";
+	out += (*this)(_forLoop.body);
+	return out;
+}
+
 string AsmPrinter::operator()(Block const& _block)
 {
 	if (_block.statements.empty())
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index b0d7fc09..8808b058 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -41,6 +41,7 @@ struct VariableDeclaration;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 struct Block;
 
 class AsmPrinter: public boost::static_visitor<std::string>
@@ -59,6 +60,7 @@ public:
 	std::string operator()(assembly::FunctionDefinition const& _functionDefinition);
 	std::string operator()(assembly::FunctionCall const& _functionCall);
 	std::string operator()(assembly::Switch const& _switch);
+	std::string operator()(assembly::ForLoop const& _forLoop);
 	std::string operator()(assembly::Block const& _block);
 
 private:
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 4d26dcf8..1aac902a 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -111,6 +111,11 @@ bool ScopeFiller::operator()(Switch const& _switch)
 	return success;
 }
 
+bool ScopeFiller::operator()(ForLoop const&)
+{
+	solAssert(false, "For loop not supported.");
+}
+
 bool ScopeFiller::operator()(Block const& _block)
 {
 	bool success = true;
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index 1166d50f..f04352c9 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -47,6 +47,7 @@ struct StackAssignment;
 struct FunctionDefinition;
 struct FunctionCall;
 struct Switch;
+struct ForLoop;
 
 struct Scope;
 struct AsmAnalysisInfo;
@@ -71,6 +72,7 @@ public:
 	bool operator()(assembly::FunctionDefinition const& _functionDefinition);
 	bool operator()(assembly::FunctionCall const&) { return true; }
 	bool operator()(assembly::Switch const& _switch);
+	bool operator()(assembly::ForLoop const& _forLoop);
 	bool operator()(assembly::Block const& _block);
 
 private:
-- 
cgit v1.2.3


From 49b11121179040d438dd8795a710f3d9de3de789 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 14:16:12 +0200
Subject: For loops analysis.

---
 libsolidity/inlineasm/AsmAnalysis.cpp    | 26 ++++++++++++++++++++++++--
 libsolidity/inlineasm/AsmScopeFiller.cpp | 19 +++++++++++++++++--
 2 files changed, 41 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 68c940e7..548f1a74 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -310,9 +310,31 @@ bool AsmAnalyzer::operator()(Switch const& _switch)
 	return success;
 }
 
-bool AsmAnalyzer::operator()(assembly::ForLoop const&)
+bool AsmAnalyzer::operator()(assembly::ForLoop const& _for)
 {
-	solAssert(false, "For loop not supported.");
+	Scope* originalScope = m_currentScope;
+
+	bool success = true;
+	if (!(*this)(_for.pre))
+		success = false;
+	// The block was closed already, but we re-open it again and stuff the
+	// condition, the body and the post part inside.
+	m_stackHeight += scope(&_for.pre).numberOfVariables();
+	m_currentScope = &scope(&_for.pre);
+
+	if (!expectExpression(*_for.condition))
+		success = false;
+	m_stackHeight--;
+	if (!(*this)(_for.body))
+		success = false;
+	if (!(*this)(_for.post))
+		success = false;
+
+	m_stackHeight -= scope(&_for.pre).numberOfVariables();
+	m_info.stackHeightInfo[&_for] = m_stackHeight;
+	m_currentScope = originalScope;
+
+	return success;
 }
 
 bool AsmAnalyzer::operator()(Block const& _block)
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 1aac902a..3bef9cec 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -111,9 +111,24 @@ bool ScopeFiller::operator()(Switch const& _switch)
 	return success;
 }
 
-bool ScopeFiller::operator()(ForLoop const&)
+bool ScopeFiller::operator()(ForLoop const& _forLoop)
 {
-	solAssert(false, "For loop not supported.");
+	Scope* originalScope = m_currentScope;
+
+	bool success = true;
+	if (!(*this)(_forLoop.pre))
+		success = false;
+	m_currentScope = &scope(&_forLoop.pre);
+	if (!boost::apply_visitor(*this, *_forLoop.condition))
+		success = false;
+	if (!(*this)(_forLoop.body))
+		success = false;
+	if (!(*this)(_forLoop.post))
+		success = false;
+
+	m_currentScope = originalScope;
+
+	return success;
 }
 
 bool ScopeFiller::operator()(Block const& _block)
-- 
cgit v1.2.3


From 8e5c4bf21dfd9cfaa8de35aef034bb32be290a48 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:41:51 +0200
Subject: Add include file to forward-declare inline assembly structs.

---
 libsolidity/inlineasm/AsmAnalysis.h     | 17 ++---------
 libsolidity/inlineasm/AsmAnalysisInfo.h | 18 ++----------
 libsolidity/inlineasm/AsmData.h         | 23 +++------------
 libsolidity/inlineasm/AsmDataForward.h  | 52 +++++++++++++++++++++++++++++++++
 libsolidity/inlineasm/AsmPrinter.h      | 15 ++--------
 libsolidity/inlineasm/AsmScopeFiller.h  | 16 ++--------
 6 files changed, 64 insertions(+), 77 deletions(-)
 create mode 100644 libsolidity/inlineasm/AsmDataForward.h

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 5cdf72b1..76d2eba1 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -26,6 +26,8 @@
 
 #include <libjulia/backends/evm/AbstractAssembly.h>
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -39,21 +41,6 @@ class ErrorReporter;
 namespace assembly
 {
 
-struct Literal;
-struct Block;
-struct Label;
-struct FunctionalInstruction;
-struct Assignment;
-struct VariableDeclaration;
-struct Instruction;
-struct Identifier;
-struct StackAssignment;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, Block, ForLoop>;
-
 struct AsmAnalysisInfo;
 
 /**
diff --git a/libsolidity/inlineasm/AsmAnalysisInfo.h b/libsolidity/inlineasm/AsmAnalysisInfo.h
index a75413a2..bd3b28c4 100644
--- a/libsolidity/inlineasm/AsmAnalysisInfo.h
+++ b/libsolidity/inlineasm/AsmAnalysisInfo.h
@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 #include <map>
@@ -33,24 +35,8 @@ namespace solidity
 namespace assembly
 {
 
-struct Literal;
-struct Block;
-struct Label;
-struct FunctionalInstruction;
-struct Assignment;
-struct VariableDeclaration;
-struct Instruction;
-struct Identifier;
-struct StackAssignment;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-
 struct Scope;
 
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
-
 struct AsmAnalysisInfo
 {
 	using StackHeightInfo = std::map<void const*, int>;
diff --git a/libsolidity/inlineasm/AsmData.h b/libsolidity/inlineasm/AsmData.h
index c2458bd7..db5840bc 100644
--- a/libsolidity/inlineasm/AsmData.h
+++ b/libsolidity/inlineasm/AsmData.h
@@ -22,10 +22,13 @@
 
 #pragma once
 
-#include <boost/variant.hpp>
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <libevmasm/Instruction.h>
 #include <libevmasm/SourceLocation.h>
 
+#include <boost/variant.hpp>
+
 namespace dev
 {
 namespace solidity
@@ -38,24 +41,6 @@ using Type = std::string;
 struct TypedName { SourceLocation location; std::string name; Type type; };
 using TypedNameList = std::vector<TypedName>;
 
-/// What follows are the AST nodes for assembly.
-
-struct Instruction;
-struct Literal;
-struct Label;
-struct StackAssignment;
-struct Identifier;
-struct Assignment;
-struct VariableDeclaration;
-struct FunctionalInstruction;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-struct Block;
-
-using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
-
 /// Direct EVM instruction (except PUSHi and JUMPDEST)
 struct Instruction { SourceLocation location; solidity::Instruction instruction; };
 /// Literal number or string (up to 32 bytes)
diff --git a/libsolidity/inlineasm/AsmDataForward.h b/libsolidity/inlineasm/AsmDataForward.h
new file mode 100644
index 00000000..4ead7ff5
--- /dev/null
+++ b/libsolidity/inlineasm/AsmDataForward.h
@@ -0,0 +1,52 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @author Christian <c@ethdev.com>
+ * @date 2016
+ * Forward declaration of classes for inline assembly / JULIA AST
+ */
+
+#pragma once
+
+#include <boost/variant.hpp>
+
+namespace dev
+{
+namespace solidity
+{
+namespace assembly
+{
+
+struct Instruction;
+struct Literal;
+struct Label;
+struct StackAssignment;
+struct Identifier;
+struct Assignment;
+struct VariableDeclaration;
+struct FunctionalInstruction;
+struct FunctionDefinition;
+struct FunctionCall;
+struct Switch;
+struct ForLoop;
+struct Block;
+
+using Statement = boost::variant<Instruction, Literal, Label, StackAssignment, Identifier, Assignment, FunctionCall, FunctionalInstruction, VariableDeclaration, FunctionDefinition, Switch, ForLoop, Block>;
+
+}
+}
+}
diff --git a/libsolidity/inlineasm/AsmPrinter.h b/libsolidity/inlineasm/AsmPrinter.h
index 8808b058..f57dddc8 100644
--- a/libsolidity/inlineasm/AsmPrinter.h
+++ b/libsolidity/inlineasm/AsmPrinter.h
@@ -22,6 +22,8 @@
 
 #pragma once
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 namespace dev
@@ -30,19 +32,6 @@ namespace solidity
 {
 namespace assembly
 {
-struct Instruction;
-struct Literal;
-struct Identifier;
-struct FunctionalInstruction;
-struct Label;
-struct StackAssignment;
-struct Assignment;
-struct VariableDeclaration;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-struct Block;
 
 class AsmPrinter: public boost::static_visitor<std::string>
 {
diff --git a/libsolidity/inlineasm/AsmScopeFiller.h b/libsolidity/inlineasm/AsmScopeFiller.h
index f04352c9..80c03d2c 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.h
+++ b/libsolidity/inlineasm/AsmScopeFiller.h
@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include <libsolidity/inlineasm/AsmDataForward.h>
+
 #include <boost/variant.hpp>
 
 #include <functional>
@@ -35,20 +37,6 @@ namespace assembly
 {
 
 struct TypedName;
-struct Literal;
-struct Block;
-struct Label;
-struct FunctionalInstruction;
-struct Assignment;
-struct VariableDeclaration;
-struct Instruction;
-struct Identifier;
-struct StackAssignment;
-struct FunctionDefinition;
-struct FunctionCall;
-struct Switch;
-struct ForLoop;
-
 struct Scope;
 struct AsmAnalysisInfo;
 
-- 
cgit v1.2.3


From 78b49db779376b8ddedc0abb91a82a3384def4f1 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 1 Jun 2017 15:47:11 +0200
Subject: Helper to count the number of variables in a scope.

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 4 +---
 libsolidity/inlineasm/AsmScope.cpp    | 9 +++++++++
 libsolidity/inlineasm/AsmScope.h      | 2 ++
 3 files changed, 12 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 548f1a74..2891ec95 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -349,9 +349,7 @@ bool AsmAnalyzer::operator()(Block const& _block)
 		if (!boost::apply_visitor(*this, s))
 			success = false;
 
-	for (auto const& identifier: scope(&_block).identifiers)
-		if (identifier.second.type() == typeid(Scope::Variable))
-			--m_stackHeight;
+	m_stackHeight -= scope(&_block).numberOfVariables();
 
 	int const stackDiff = m_stackHeight - initialStackHeight;
 	if (stackDiff != 0)
diff --git a/libsolidity/inlineasm/AsmScope.cpp b/libsolidity/inlineasm/AsmScope.cpp
index 1db5ca41..315d5953 100644
--- a/libsolidity/inlineasm/AsmScope.cpp
+++ b/libsolidity/inlineasm/AsmScope.cpp
@@ -80,6 +80,15 @@ bool Scope::exists(string const& _name)
 		return false;
 }
 
+size_t Scope::numberOfVariables() const
+{
+	size_t count = 0;
+	for (auto const& identifier: identifiers)
+		if (identifier.second.type() == typeid(Scope::Variable))
+			count++;
+	return count;
+}
+
 bool Scope::insideFunction() const
 {
 	for (Scope const* s = this; s; s = s->superScope)
diff --git a/libsolidity/inlineasm/AsmScope.h b/libsolidity/inlineasm/AsmScope.h
index de9119e0..cc240565 100644
--- a/libsolidity/inlineasm/AsmScope.h
+++ b/libsolidity/inlineasm/AsmScope.h
@@ -109,6 +109,8 @@ struct Scope
 	/// across function and assembly boundaries).
 	bool exists(std::string const& _name);
 
+	/// @returns the number of variables directly registered inside the scope.
+	size_t numberOfVariables() const;
 	/// @returns true if this scope is inside a function.
 	bool insideFunction() const;
 
-- 
cgit v1.2.3


From 868b5ad3aa9741609e9cd79d6033ee4b172dbe2f Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 9 Jun 2017 13:59:16 +0200
Subject: Split block code generation into main and finalize.

---
 libsolidity/inlineasm/AsmCodeGen.cpp    | 2 +-
 libsolidity/interface/AssemblyStack.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 27750453..3c7c62c6 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -141,5 +141,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess).run(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess)(_parsedData);
 }
diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index 7dc1edc7..2d85895e 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -100,7 +100,7 @@ MachineAssemblyObject AssemblyStack::assemble(Machine _machine) const
 	{
 		MachineAssemblyObject object;
 		julia::EVMAssembly assembly(true);
-		julia::CodeTransform(assembly, *m_analysisInfo, true).run(*m_parserResult);
+		julia::CodeTransform(assembly, *m_analysisInfo, true)(*m_parserResult);
 		object.bytecode = make_shared<eth::LinkerObject>(assembly.finalize());
 		/// TOOD: fill out text representation
 		return object;
-- 
cgit v1.2.3


From d170ceaf3d8f63536a730ccc6388183a7a483514 Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Sat, 17 Jun 2017 12:21:46 -0300
Subject: Display error if payable or constant is specified multiple times

---
 libsolidity/parsing/Parser.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 88b41f20..ec6d11f4 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -323,11 +323,17 @@ Parser::FunctionHeaderParserResult Parser::parseFunctionHeader(bool _forceEmptyN
 		Token::Value token = m_scanner->currentToken();
 		if (token == Token::Const)
 		{
+			if (result.isDeclaredConst)
+				parserError(string("Multiple \"constant\" specifiers."));
+
 			result.isDeclaredConst = true;
 			m_scanner->next();
 		}
 		else if (m_scanner->currentToken() == Token::Payable)
 		{
+			if (result.isPayable)
+				parserError(string("Multiple \"payable\" specifiers."));
+
 			result.isPayable = true;
 			m_scanner->next();
 		}
-- 
cgit v1.2.3


From 0f8ad1d68f60270fb22057e787ff689318c31fa9 Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Thu, 15 Jun 2017 12:36:14 -0300
Subject: Fix segmentation fault with constant function parameters

---
 libsolidity/analysis/TypeChecker.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 2a8d1ff6..4194e1c2 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -463,6 +463,8 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 			m_errorReporter.typeError(var->location(), "Type is required to live outside storage.");
 		if (_function.visibility() >= FunctionDefinition::Visibility::Public && !(type(*var)->interfaceType(isLibraryFunction)))
 			m_errorReporter.fatalTypeError(var->location(), "Internal type is not allowed for public or external functions.");
+
+		var->accept(*this);
 	}
 	for (ASTPointer<ModifierInvocation> const& modifier: _function.modifiers())
 		visitManually(
@@ -487,7 +489,12 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 
 bool TypeChecker::visit(VariableDeclaration const& _variable)
 {
-	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
+	// Forbid any variable declarations inside interfaces unless they are part of
+	// a function's input/output parameters.
+	if (
+		m_scope->contractKind() == ContractDefinition::ContractKind::Interface
+		&& !_variable.isCallableParameter()
+	)
 		m_errorReporter.typeError(_variable.location(), "Variables cannot be declared in interfaces.");
 
 	// Variables can be declared without type (with "var"), in which case the first assignment
-- 
cgit v1.2.3


From 63395b31af701dee20abcf730b0bd3c660cc48e8 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 15 Jun 2017 11:23:22 +0100
Subject: Use compilerStack.functionHashes in StandardCompiler

---
 libsolidity/interface/StandardCompiler.cpp | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index d5dbaa46..b870e0ea 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -115,14 +115,6 @@ StringMap createSourceList(Json::Value const& _input)
 	return sources;
 }
 
-Json::Value methodIdentifiers(ContractDefinition const& _contract)
-{
-	Json::Value methodIdentifiers(Json::objectValue);
-	for (auto const& it: _contract.interfaceFunctions())
-		methodIdentifiers[it.second->externalSignature()] = toHex(it.first.ref());
-	return methodIdentifiers;
-}
-
 Json::Value formatLinkReferences(std::map<size_t, std::string> const& linkReferences)
 {
 	Json::Value ret(Json::objectValue);
@@ -404,7 +396,7 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 		m_compilerStack.streamAssembly(tmp, contractName, createSourceList(_input), false);
 		evmData["assembly"] = tmp.str();
 		evmData["legacyAssembly"] = m_compilerStack.streamAssembly(tmp, contractName, createSourceList(_input), true);
-		evmData["methodIdentifiers"] = methodIdentifiers(m_compilerStack.contractDefinition(contractName));
+		evmData["methodIdentifiers"] = m_compilerStack.functionHashes(m_compilerStack.contractDefinition(contractName));
 		evmData["gasEstimates"] = m_compilerStack.gasEstimates(contractName);
 
 		evmData["bytecode"] = collectEVMObject(
-- 
cgit v1.2.3


From b99e4bc68b8bc0d15809e17a6f9489841062fe52 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 15 Jun 2017 11:33:01 +0100
Subject: Rework functionHashes into methodIdentifiers

---
 libsolidity/interface/CompilerStack.cpp    | 10 +++++-----
 libsolidity/interface/CompilerStack.h      |  3 ++-
 libsolidity/interface/StandardCompiler.cpp |  2 +-
 3 files changed, 8 insertions(+), 7 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index b09108b0..8be2c8dd 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -481,12 +481,12 @@ Json::Value const& CompilerStack::natspec(Contract const& _contract, Documentati
 	return *(*doc);
 }
 
-Json::Value CompilerStack::functionHashes(ContractDefinition const& _contract)
+Json::Value CompilerStack::methodIdentifiers(string const& _contractName) const
 {
-	Json::Value functionHashes(Json::objectValue);
-	for (auto const& it: _contract.interfaceFunctions())
-		functionHashes[it.second->externalSignature()] = toHex(it.first.ref());
-	return functionHashes;
+	Json::Value methodIdentifiers(Json::objectValue);
+	for (auto const& it: contractDefinition(_contractName).interfaceFunctions())
+		methodIdentifiers[it.second->externalSignature()] = toHex(it.first.ref());
+	return methodIdentifiers;
 }
 
 string const& CompilerStack::onChainMetadata(string const& _contractName) const
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index 3250429b..71dbce7e 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -178,7 +178,8 @@ public:
 	/// Can be one of 4 types defined at @c DocumentationType
 	Json::Value const& natspec(std::string const& _contractName, DocumentationType _type) const;
 
-	Json::Value functionHashes(ContractDefinition const& _contract);
+	/// @returns a JSON representing a map of method identifiers (hashes) to function names.
+	Json::Value methodIdentifiers(std::string const& _contractName) const;
 
 	std::string const& onChainMetadata(std::string const& _contractName) const;
 	void useMetadataLiteralSources(bool _metadataLiteralSources) { m_metadataLiteralSources = _metadataLiteralSources; }
diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index b870e0ea..2e5005b8 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -396,7 +396,7 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 		m_compilerStack.streamAssembly(tmp, contractName, createSourceList(_input), false);
 		evmData["assembly"] = tmp.str();
 		evmData["legacyAssembly"] = m_compilerStack.streamAssembly(tmp, contractName, createSourceList(_input), true);
-		evmData["methodIdentifiers"] = m_compilerStack.functionHashes(m_compilerStack.contractDefinition(contractName));
+		evmData["methodIdentifiers"] = m_compilerStack.methodIdentifiers(contractName);
 		evmData["gasEstimates"] = m_compilerStack.gasEstimates(contractName);
 
 		evmData["bytecode"] = collectEVMObject(
-- 
cgit v1.2.3


From ba7d698ee67181afc92fd90d18487245cb303389 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 15 Jun 2017 11:35:30 +0100
Subject: Make compiler.contractDefinition private

---
 libsolidity/interface/CompilerStack.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index 71dbce7e..f7435f0e 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -191,9 +191,6 @@ public:
 	Scanner const& scanner(std::string const& _sourceName = "") const;
 	/// @returns the parsed source unit with the supplied name.
 	SourceUnit const& ast(std::string const& _sourceName = "") const;
-	/// @returns the parsed contract with the supplied name. Throws an exception if the contract
-	/// does not exist.
-	ContractDefinition const& contractDefinition(std::string const& _contractName) const;
 
 	/// Helper function for logs printing. Do only use in error cases, it's quite expensive.
 	/// line and columns are numbered starting from 1 with following order:
@@ -258,6 +255,10 @@ private:
 	Contract const& contract(std::string const& _contractName = "") const;
 	Source const& source(std::string const& _sourceName = "") const;
 
+	/// @returns the parsed contract with the supplied name. Throws an exception if the contract
+	/// does not exist.
+	ContractDefinition const& contractDefinition(std::string const& _contractName) const;
+
 	std::string createOnChainMetadata(Contract const& _contract) const;
 	std::string computeSourceMapping(eth::AssemblyItems const& _items) const;
 	Json::Value const& contractABI(Contract const&) const;
-- 
cgit v1.2.3


From d5f8ce90c7a76870e5a9d0fe6f9fd709a7383572 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 21 Jun 2017 21:50:57 +0100
Subject: Merge interface/Exceptions and interface/Utils

---
 libsolidity/ast/AST.cpp                    |  2 --
 libsolidity/ast/AST.h                      |  1 -
 libsolidity/ast/ASTJsonConverter.cpp       |  1 -
 libsolidity/ast/ASTJsonConverter.h         |  1 -
 libsolidity/ast/Types.cpp                  |  1 -
 libsolidity/codegen/ArrayUtils.cpp         |  2 +-
 libsolidity/codegen/ExpressionCompiler.cpp |  1 +
 libsolidity/codegen/ExpressionCompiler.h   |  2 +-
 libsolidity/inlineasm/AsmAnalysis.cpp      |  1 -
 libsolidity/inlineasm/AsmPrinter.cpp       |  2 +-
 libsolidity/inlineasm/AsmScopeFiller.cpp   |  2 +-
 libsolidity/interface/Exceptions.cpp       |  1 -
 libsolidity/interface/Exceptions.h         | 11 ++++++++
 libsolidity/interface/Utils.h              | 45 ------------------------------
 libsolidity/interface/Version.cpp          |  2 +-
 libsolidity/parsing/DocStringParser.cpp    |  2 +-
 libsolidity/parsing/Scanner.cpp            |  2 +-
 libsolidity/parsing/Token.h                |  1 -
 18 files changed, 19 insertions(+), 61 deletions(-)
 delete mode 100644 libsolidity/interface/Utils.h

(limited to 'libsolidity')

diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index 03112d2d..40dfa348 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -20,10 +20,8 @@
  * Solidity abstract syntax tree.
  */
 
-#include <libsolidity/interface/Utils.h>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/ast/ASTVisitor.h>
-#include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/ast/AST_accept.h>
 
 #include <libdevcore/SHA3.h>
diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index ba1d0589..83572692 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -29,7 +29,6 @@
 #include <boost/noncopyable.hpp>
 #include <libevmasm/SourceLocation.h>
 #include <libevmasm/Instruction.h>
-#include <libsolidity/interface/Utils.h>
 #include <libsolidity/ast/ASTForward.h>
 #include <libsolidity/parsing/Token.h>
 #include <libsolidity/ast/Types.h>
diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 4ad1f962..a90debb2 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -24,7 +24,6 @@
 #include <boost/algorithm/string/join.hpp>
 #include <libdevcore/UTF8.h>
 #include <libsolidity/ast/AST.h>
-#include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/inlineasm/AsmData.h>
 #include <libsolidity/inlineasm/AsmPrinter.h>
 
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index c2de5c48..27114c2a 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -26,7 +26,6 @@
 #include <stack>
 #include <libsolidity/ast/ASTVisitor.h>
 #include <libsolidity/interface/Exceptions.h>
-#include <libsolidity/interface/Utils.h>
 #include <libsolidity/ast/ASTAnnotations.h>
 #include <json/json.h>
 
diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
index cfee041e..bd3346f9 100644
--- a/libsolidity/ast/Types.cpp
+++ b/libsolidity/ast/Types.cpp
@@ -22,7 +22,6 @@
 
 #include <libsolidity/ast/Types.h>
 
-#include <libsolidity/interface/Utils.h>
 #include <libsolidity/ast/AST.h>
 
 #include <libdevcore/CommonIO.h>
diff --git a/libsolidity/codegen/ArrayUtils.cpp b/libsolidity/codegen/ArrayUtils.cpp
index 6a641b02..67ca22f1 100644
--- a/libsolidity/codegen/ArrayUtils.cpp
+++ b/libsolidity/codegen/ArrayUtils.cpp
@@ -25,7 +25,7 @@
 #include <libsolidity/codegen/CompilerContext.h>
 #include <libsolidity/codegen/CompilerUtils.h>
 #include <libsolidity/ast/Types.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/codegen/LValue.h>
 
 using namespace std;
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index 25154bc0..03bba80c 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -32,6 +32,7 @@
 #include <libsolidity/codegen/CompilerUtils.h>
 #include <libsolidity/codegen/LValue.h>
 #include <libevmasm/GasMeter.h>
+
 using namespace std;
 
 namespace dev
diff --git a/libsolidity/codegen/ExpressionCompiler.h b/libsolidity/codegen/ExpressionCompiler.h
index d0a8ac15..3b8cf1c6 100644
--- a/libsolidity/codegen/ExpressionCompiler.h
+++ b/libsolidity/codegen/ExpressionCompiler.h
@@ -28,7 +28,7 @@
 #include <libevmasm/SourceLocation.h>
 #include <libsolidity/ast/ASTVisitor.h>
 #include <libsolidity/codegen/LValue.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 
 namespace dev {
 namespace eth
diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index 2891ec95..b0d044ae 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -26,7 +26,6 @@
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
 #include <libsolidity/interface/ErrorReporter.h>
-#include <libsolidity/interface/Utils.h>
 
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/algorithm/string.hpp>
diff --git a/libsolidity/inlineasm/AsmPrinter.cpp b/libsolidity/inlineasm/AsmPrinter.cpp
index 0d06fedd..062ff453 100644
--- a/libsolidity/inlineasm/AsmPrinter.cpp
+++ b/libsolidity/inlineasm/AsmPrinter.cpp
@@ -22,7 +22,7 @@
 
 #include <libsolidity/inlineasm/AsmPrinter.h>
 #include <libsolidity/inlineasm/AsmData.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/replace.hpp>
diff --git a/libsolidity/inlineasm/AsmScopeFiller.cpp b/libsolidity/inlineasm/AsmScopeFiller.cpp
index 3bef9cec..5b3174b8 100644
--- a/libsolidity/inlineasm/AsmScopeFiller.cpp
+++ b/libsolidity/inlineasm/AsmScopeFiller.cpp
@@ -25,7 +25,7 @@
 #include <libsolidity/inlineasm/AsmAnalysisInfo.h>
 
 #include <libsolidity/interface/ErrorReporter.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 
 #include <boost/range/adaptor/reversed.hpp>
 
diff --git a/libsolidity/interface/Exceptions.cpp b/libsolidity/interface/Exceptions.cpp
index c09180de..deee92aa 100644
--- a/libsolidity/interface/Exceptions.cpp
+++ b/libsolidity/interface/Exceptions.cpp
@@ -21,7 +21,6 @@
  */
 
 #include <libsolidity/interface/Exceptions.h>
-#include <libsolidity/interface/Utils.h>
 
 using namespace std;
 using namespace dev;
diff --git a/libsolidity/interface/Exceptions.h b/libsolidity/interface/Exceptions.h
index 0803d8cc..5fdb8f11 100644
--- a/libsolidity/interface/Exceptions.h
+++ b/libsolidity/interface/Exceptions.h
@@ -25,6 +25,7 @@
 #include <string>
 #include <utility>
 #include <libdevcore/Exceptions.h>
+#include <libdevcore/Assertions.h>
 #include <libevmasm/SourceLocation.h>
 
 namespace dev
@@ -39,6 +40,16 @@ struct InternalCompilerError: virtual Exception {};
 struct FatalError: virtual Exception {};
 struct UnimplementedFeatureError: virtual Exception{};
 
+/// Assertion that throws an InternalCompilerError containing the given description if it is not met.
+#define solAssert(CONDITION, DESCRIPTION) \
+        assertThrow(CONDITION, ::dev::solidity::InternalCompilerError, DESCRIPTION)
+
+#define solUnimplementedAssert(CONDITION, DESCRIPTION) \
+        assertThrow(CONDITION, ::dev::solidity::UnimplementedFeatureError, DESCRIPTION)
+
+#define solUnimplemented(DESCRIPTION) \
+        solUnimplementedAssert(false, DESCRIPTION)
+
 class Error: virtual public Exception
 {
 public:
diff --git a/libsolidity/interface/Utils.h b/libsolidity/interface/Utils.h
deleted file mode 100644
index 0027759c..00000000
--- a/libsolidity/interface/Utils.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @date 2014
- * Solidity Utilities.
- */
-
-#pragma once
-
-#include <libdevcore/Assertions.h>
-#include <libsolidity/interface/Exceptions.h>
-
-namespace dev
-{
-namespace solidity
-{
-struct InternalCompilerError;
-struct UnimplementedFeatureError;
-}
-}
-
-/// Assertion that throws an InternalCompilerError containing the given description if it is not met.
-#define solAssert(CONDITION, DESCRIPTION) \
-	assertThrow(CONDITION, ::dev::solidity::InternalCompilerError, DESCRIPTION)
-
-#define solUnimplementedAssert(CONDITION, DESCRIPTION) \
-	assertThrow(CONDITION, ::dev::solidity::UnimplementedFeatureError, DESCRIPTION)
-
-#define solUnimplemented(DESCRIPTION) \
-	solUnimplementedAssert(false, DESCRIPTION)
diff --git a/libsolidity/interface/Version.cpp b/libsolidity/interface/Version.cpp
index 0d23f9c3..a35bfd29 100644
--- a/libsolidity/interface/Version.cpp
+++ b/libsolidity/interface/Version.cpp
@@ -24,7 +24,7 @@
 #include <string>
 #include <libdevcore/CommonData.h>
 #include <libdevcore/Common.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 #include <solidity/BuildInfo.h>
 
 using namespace dev;
diff --git a/libsolidity/parsing/DocStringParser.cpp b/libsolidity/parsing/DocStringParser.cpp
index cd6c1d8a..0409de72 100644
--- a/libsolidity/parsing/DocStringParser.cpp
+++ b/libsolidity/parsing/DocStringParser.cpp
@@ -1,7 +1,7 @@
 
 #include <libsolidity/parsing/DocStringParser.h>
 #include <libsolidity/interface/ErrorReporter.h>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 
 #include <boost/range/irange.hpp>
 #include <boost/range/algorithm.hpp>
diff --git a/libsolidity/parsing/Scanner.cpp b/libsolidity/parsing/Scanner.cpp
index 0e60fd0b..fdca23ea 100644
--- a/libsolidity/parsing/Scanner.cpp
+++ b/libsolidity/parsing/Scanner.cpp
@@ -52,7 +52,7 @@
 
 #include <algorithm>
 #include <tuple>
-#include <libsolidity/interface/Utils.h>
+#include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/parsing/Scanner.h>
 
 using namespace std;
diff --git a/libsolidity/parsing/Token.h b/libsolidity/parsing/Token.h
index 9a557ebd..39c0eff9 100644
--- a/libsolidity/parsing/Token.h
+++ b/libsolidity/parsing/Token.h
@@ -43,7 +43,6 @@
 #pragma once
 
 #include <libdevcore/Common.h>
-#include <libsolidity/interface/Utils.h>
 #include <libsolidity/interface/Exceptions.h>
 #include <libdevcore/UndefMacros.h>
 
-- 
cgit v1.2.3


From f340ff87645a4b1026bbe7f95ad4f63a955a87a2 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 22 Jun 2017 16:39:42 +0200
Subject: Fix strings interpreted as addresses.

---
 libsolidity/ast/AST.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index 40dfa348..b929b6fe 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -534,6 +534,8 @@ bool Literal::looksLikeAddress() const
 {
 	if (subDenomination() != SubDenomination::None)
 		return false;
+	if (token() != Token::Number)
+		return false;
 
 	string lit = value();
 	return lit.substr(0, 2) == "0x" && abs(int(lit.length()) - 42) <= 1;
-- 
cgit v1.2.3


From 83ea7793d99ddc1f1c5bd897c3a2b5e457d2ce29 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 22 Jun 2017 17:55:06 +0200
Subject: Fix ABI encoding of empty string literal.

---
 libsolidity/codegen/CompilerUtils.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 3baaaddf..bfe72961 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -128,7 +128,7 @@ void CompilerUtils::storeInMemoryDynamic(Type const& _type, bool _padToWordBound
 		m_context << Instruction::DUP1;
 		storeStringData(bytesConstRef(str->value()));
 		if (_padToWordBoundaries)
-			m_context << u256(((str->value().size() + 31) / 32) * 32);
+			m_context << u256(max<size_t>(32, ((str->value().size() + 31) / 32) * 32));
 		else
 			m_context << u256(str->value().size());
 		m_context << Instruction::ADD;
-- 
cgit v1.2.3


From 007ffe94309f1a8b39da78bbbfe922de41be1f55 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 29 May 2017 15:05:12 +0100
Subject: Avoid including Scanner.h in ParserBase.h

---
 libsolidity/codegen/CompilerContext.cpp |  1 +
 libsolidity/parsing/ParserBase.cpp      | 20 ++++++++++++++++++++
 libsolidity/parsing/ParserBase.h        |  9 ++++-----
 3 files changed, 25 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index d98efcad..9d0d6d37 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -26,6 +26,7 @@
 #include <libsolidity/codegen/Compiler.h>
 #include <libsolidity/interface/Version.h>
 #include <libsolidity/interface/ErrorReporter.h>
+#include <libsolidity/parsing/Scanner.h>
 #include <libsolidity/inlineasm/AsmParser.h>
 #include <libsolidity/inlineasm/AsmCodeGen.h>
 #include <libsolidity/inlineasm/AsmAnalysis.h>
diff --git a/libsolidity/parsing/ParserBase.cpp b/libsolidity/parsing/ParserBase.cpp
index 9987b82c..5657c2c0 100644
--- a/libsolidity/parsing/ParserBase.cpp
+++ b/libsolidity/parsing/ParserBase.cpp
@@ -43,6 +43,26 @@ int ParserBase::endPosition() const
 	return m_scanner->currentLocation().end;
 }
 
+Token::Value ParserBase::currentToken() const
+{
+	return m_scanner->currentToken();
+}
+
+Token::Value ParserBase::peekNextToken() const
+{
+	return m_scanner->peekNextToken();
+}
+
+std::string ParserBase::currentLiteral() const
+{
+	return m_scanner->currentLiteral();
+}
+
+Token::Value ParserBase::advance()
+{
+	return m_scanner->next();
+}
+
 void ParserBase::expectToken(Token::Value _value)
 {
 	Token::Value tok = m_scanner->currentToken();
diff --git a/libsolidity/parsing/ParserBase.h b/libsolidity/parsing/ParserBase.h
index ae56cead..5b03ab5e 100644
--- a/libsolidity/parsing/ParserBase.h
+++ b/libsolidity/parsing/ParserBase.h
@@ -23,7 +23,6 @@
 #pragma once
 
 #include <memory>
-#include <libsolidity/parsing/Scanner.h>
 #include <libsolidity/parsing/Token.h>
 
 namespace dev
@@ -51,10 +50,10 @@ protected:
 	///@name Helper functions
 	/// If current token value is not _value, throw exception otherwise advance token.
 	void expectToken(Token::Value _value);
-	Token::Value currentToken() const { return m_scanner->currentToken(); }
-	Token::Value peekNextToken() const { return m_scanner->peekNextToken(); }
-	std::string currentLiteral() const { return m_scanner->currentLiteral(); }
-	Token::Value advance() { return m_scanner->next(); }
+	Token::Value currentToken() const;
+	Token::Value peekNextToken() const;
+	std::string currentLiteral() const;
+	Token::Value advance();
 	///@}
 
 	/// Creates a @ref ParserError and annotates it with the current position and the
-- 
cgit v1.2.3


From 5cf2332d6d273e6c9ac4c2b2bdb41c18b9cbf535 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 23:55:34 +0100
Subject: Support appendAssemblySize() in AbstractAssembly

---
 libsolidity/inlineasm/AsmCodeGen.cpp | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 3c7c62c6..2bbd1b70 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -121,6 +121,11 @@ public:
 		solAssert(false, "RETURNSUB not implemented for EVM 1.0");
 	}
 
+	virtual void appendAssemblySize() override
+	{
+		m_assembly.appendProgramSize();
+	}
+
 private:
 	LabelID assemblyTagToIdentifier(eth::AssemblyItem const& _tag) const
 	{
-- 
cgit v1.2.3


From 0fb1621a983025d41ef05d1156bc167ce4490259 Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Thu, 22 Jun 2017 10:59:00 -0300
Subject: Fix address literals not being treated as compile-time constants

The early return implemented for address literals in TypeChecker was
preventing the isPure annotation from getting applied. Closes #2441
---
 libsolidity/analysis/TypeChecker.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 4194e1c2..40853608 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -1726,10 +1726,7 @@ void TypeChecker::endVisit(Literal const& _literal)
 	if (_literal.looksLikeAddress())
 	{
 		if (_literal.passesAddressChecksum())
-		{
 			_literal.annotation().type = make_shared<IntegerType>(0, IntegerType::Modifier::Address);
-			return;
-		}
 		else
 			m_errorReporter.warning(
 				_literal.location(),
@@ -1737,10 +1734,13 @@ void TypeChecker::endVisit(Literal const& _literal)
 				"If this is not used as an address, please prepend '00'."
 			);
 	}
-	_literal.annotation().type = Type::forLiteral(_literal);
-	_literal.annotation().isPure = true;
+	if (!_literal.annotation().type)
+		_literal.annotation().type = Type::forLiteral(_literal);
+
 	if (!_literal.annotation().type)
 		m_errorReporter.fatalTypeError(_literal.location(), "Invalid literal value.");
+
+	_literal.annotation().isPure = true;
 }
 
 bool TypeChecker::contractDependenciesAreCyclic(
-- 
cgit v1.2.3


From 831ed083875b73faf91f9d3335e2599540366712 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 24 May 2017 11:47:43 +0200
Subject: Change invalid opcode to revert for input validation.

---
 libsolidity/codegen/CompilerContext.cpp    | 14 ++++++++++++++
 libsolidity/codegen/CompilerContext.h      | 10 +++++++---
 libsolidity/codegen/CompilerUtils.cpp      | 15 ++++++++++++---
 libsolidity/codegen/CompilerUtils.h        | 10 +++++++++-
 libsolidity/codegen/ContractCompiler.cpp   |  9 ++++-----
 libsolidity/codegen/ExpressionCompiler.cpp | 14 ++++++--------
 6 files changed, 52 insertions(+), 20 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 9d0d6d37..1937b529 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -244,6 +244,20 @@ CompilerContext& CompilerContext::appendConditionalInvalid()
 	return *this;
 }
 
+CompilerContext& CompilerContext::appendRevert()
+{
+	return *this << u256(0) << u256(0) << Instruction::REVERT;
+}
+
+CompilerContext& CompilerContext::appendConditionalRevert()
+{
+	*this << Instruction::ISZERO;
+	eth::AssemblyItem afterTag = appendConditionalJump();
+	appendRevert();
+	*this << afterTag;
+	return *this;
+}
+
 void CompilerContext::resetVisitedNodes(ASTNode const* _node)
 {
 	stack<ASTNode const*> newStack;
diff --git a/libsolidity/codegen/CompilerContext.h b/libsolidity/codegen/CompilerContext.h
index 030b35a6..1968c1e1 100644
--- a/libsolidity/codegen/CompilerContext.h
+++ b/libsolidity/codegen/CompilerContext.h
@@ -136,11 +136,15 @@ public:
 	/// Appends a JUMP to a new tag and @returns the tag
 	eth::AssemblyItem appendJumpToNew() { return m_asm->appendJump().tag(); }
 	/// Appends a JUMP to a tag already on the stack
-	CompilerContext&  appendJump(eth::AssemblyItem::JumpType _jumpType = eth::AssemblyItem::JumpType::Ordinary);
+	CompilerContext& appendJump(eth::AssemblyItem::JumpType _jumpType = eth::AssemblyItem::JumpType::Ordinary);
 	/// Appends an INVALID instruction
-	CompilerContext&  appendInvalid();
+	CompilerContext& appendInvalid();
 	/// Appends a conditional INVALID instruction
-	CompilerContext&  appendConditionalInvalid();
+	CompilerContext& appendConditionalInvalid();
+	/// Appends a REVERT(0, 0) call
+	CompilerContext& appendRevert();
+	/// Appends a conditional REVERT(0, 0) call
+	CompilerContext& appendConditionalRevert();
 	/// Appends a JUMP to a specific tag
 	CompilerContext& appendJumpTo(eth::AssemblyItem const& _tag) { m_asm->appendJump(_tag); return *this; }
 	/// Appends pushing of a new tag and @returns the new tag.
diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index bfe72961..7fed1975 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -392,7 +392,13 @@ void CompilerUtils::pushCombinedFunctionEntryLabel(Declaration const& _function)
 			Instruction::OR;
 }
 
-void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetType, bool _cleanupNeeded, bool _chopSignBits)
+void CompilerUtils::convertType(
+	Type const& _typeOnStack,
+	Type const& _targetType,
+	bool _cleanupNeeded,
+	bool _chopSignBits,
+	bool _asPartOfArgumentDecoding
+)
 {
 	// For a type extension, we need to remove all higher-order bits that we might have ignored in
 	// previous operations.
@@ -450,7 +456,10 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 			EnumType const& enumType = dynamic_cast<decltype(enumType)>(_typeOnStack);
 			solAssert(enumType.numberOfMembers() > 0, "empty enum should have caused a parser error.");
 			m_context << u256(enumType.numberOfMembers() - 1) << Instruction::DUP2 << Instruction::GT;
-			m_context.appendConditionalInvalid();
+			if (_asPartOfArgumentDecoding)
+				m_context.appendConditionalRevert();
+			else
+				m_context.appendConditionalInvalid();
 			enumOverflowCheckPending = false;
 		}
 		break;
@@ -985,7 +994,7 @@ unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCallda
 			m_context << shiftFactor << Instruction::MUL;
 	}
 	if (_fromCalldata)
-		convertType(_type, _type, true);
+		convertType(_type, _type, true, false, true);
 
 	return numBytes;
 }
diff --git a/libsolidity/codegen/CompilerUtils.h b/libsolidity/codegen/CompilerUtils.h
index a88951bc..caf2cdc2 100644
--- a/libsolidity/codegen/CompilerUtils.h
+++ b/libsolidity/codegen/CompilerUtils.h
@@ -135,7 +135,15 @@ public:
 	/// If @a _cleanupNeeded, high order bits cleanup is also done if no type conversion would be
 	/// necessary.
 	/// If @a _chopSignBits, the function resets the signed bits out of the width of the signed integer.
-	void convertType(Type const& _typeOnStack, Type const& _targetType, bool _cleanupNeeded = false, bool _chopSignBits = false);
+	/// If @a _asPartOfArgumentDecoding is true, failed conversions are flagged via REVERT,
+	/// otherwise they are flagged with INVALID.
+	void convertType(
+		Type const& _typeOnStack,
+		Type const& _targetType,
+		bool _cleanupNeeded = false,
+		bool _chopSignBits = false,
+		bool _asPartOfArgumentDecoding = false
+	);
 
 	/// Creates a zero-value for the given type and puts it onto the stack. This might allocate
 	/// memory for memory references.
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index dc090634..ace82ad4 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -111,7 +111,7 @@ void ContractCompiler::appendCallValueCheck()
 {
 	// Throw if function is not payable but call contained ether.
 	m_context << Instruction::CALLVALUE;
-	m_context.appendConditionalInvalid();
+	m_context.appendConditionalRevert();
 }
 
 void ContractCompiler::appendInitAndConstructorCode(ContractDefinition const& _contract)
@@ -276,7 +276,7 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 		appendReturnValuePacker(FunctionType(*fallback).returnParameterTypes(), _contract.isLibrary());
 	}
 	else
-		m_context.appendInvalid();
+		m_context.appendRevert();
 
 	for (auto const& it: interfaceFunctions)
 	{
@@ -368,7 +368,7 @@ void ContractCompiler::appendCalldataUnpacker(TypePointers const& _typeParameter
 					// copy to memory
 					// move calldata type up again
 					CompilerUtils(m_context).moveIntoStack(calldataType->sizeOnStack());
-					CompilerUtils(m_context).convertType(*calldataType, arrayType);
+					CompilerUtils(m_context).convertType(*calldataType, arrayType, false, false, true);
 					// fetch next pointer again
 					CompilerUtils(m_context).moveToStackTop(arrayType.sizeOnStack());
 				}
@@ -805,8 +805,7 @@ bool ContractCompiler::visit(Throw const& _throw)
 {
 	CompilerContext::LocationSetter locationSetter(m_context, _throw);
 	// Do not send back an error detail.
-	m_context << u256(0) << u256(0);
-	m_context << Instruction::REVERT;
+	m_context.appendRevert();
 	return false;
 }
 
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index 03bba80c..2fc3bf6b 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -587,7 +587,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			m_context << Instruction::CREATE;
 			// Check if zero (out of stack or not enough balance).
 			m_context << Instruction::DUP1 << Instruction::ISZERO;
-			m_context.appendConditionalInvalid();
+			m_context.appendConditionalRevert();
 			if (function.valueSet())
 				m_context << swapInstruction(1) << Instruction::POP;
 			break;
@@ -651,7 +651,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			{
 				// Check if zero (out of stack or not enough balance).
 				m_context << Instruction::ISZERO;
-				m_context.appendConditionalInvalid();
+				m_context.appendConditionalRevert();
 			}
 			break;
 		case FunctionType::Kind::Selfdestruct:
@@ -660,9 +660,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			m_context << Instruction::SELFDESTRUCT;
 			break;
 		case FunctionType::Kind::Revert:
-			// memory offset returned - zero length
-			m_context << u256(0) << u256(0);
-			m_context << Instruction::REVERT;
+			m_context.appendRevert();
 			break;
 		case FunctionType::Kind::SHA3:
 		{
@@ -890,7 +888,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 				// condition was not met, flag an error
 				m_context << Instruction::INVALID;
 			else
-				m_context << u256(0) << u256(0) << Instruction::REVERT;
+				m_context.appendRevert();
 			// the success branch
 			m_context << success;
 			break;
@@ -1695,7 +1693,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
 	if (funKind == FunctionType::Kind::External || funKind == FunctionType::Kind::CallCode || funKind == FunctionType::Kind::DelegateCall)
 	{
 		m_context << Instruction::DUP1 << Instruction::EXTCODESIZE << Instruction::ISZERO;
-		m_context.appendConditionalInvalid();
+		m_context.appendConditionalRevert();
 		existenceChecked = true;
 	}
 
@@ -1731,7 +1729,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
 	{
 		//Propagate error condition (if CALL pushes 0 on stack).
 		m_context << Instruction::ISZERO;
-		m_context.appendConditionalInvalid();
+		m_context.appendConditionalRevert();
 	}
 
 	utils().popStackSlots(remainsSize);
-- 
cgit v1.2.3


From 64067975e4d06a984fb7b92dcfb7484561c01de3 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 16 Jun 2017 15:52:56 +0200
Subject: Review suggestions.

---
 libsolidity/codegen/ExpressionCompiler.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index 2fc3bf6b..a7cfe4dc 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -886,7 +886,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			auto success = m_context.appendConditionalJump();
 			if (function.kind() == FunctionType::Kind::Assert)
 				// condition was not met, flag an error
-				m_context << Instruction::INVALID;
+				m_context.appendInvalid();
 			else
 				m_context.appendRevert();
 			// the success branch
-- 
cgit v1.2.3


From 5a75581f6643a229ab12a861d0b0663ea3e5158e Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 23 Jun 2017 18:55:47 +0200
Subject: Disallow invoking the same modifier multiple times.

---
 libsolidity/analysis/TypeChecker.cpp     | 13 +++++++++++++
 libsolidity/codegen/CompilerContext.cpp  |  1 +
 libsolidity/codegen/ContractCompiler.cpp |  4 ++++
 3 files changed, 18 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 40853608..e1d90e68 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -466,13 +466,26 @@ bool TypeChecker::visit(FunctionDefinition const& _function)
 
 		var->accept(*this);
 	}
+	set<Declaration const*> modifiers;
 	for (ASTPointer<ModifierInvocation> const& modifier: _function.modifiers())
+	{
 		visitManually(
 			*modifier,
 			_function.isConstructor() ?
 			dynamic_cast<ContractDefinition const&>(*_function.scope()).annotation().linearizedBaseContracts :
 			vector<ContractDefinition const*>()
 		);
+		Declaration const* decl = &dereference(*modifier->name());
+		if (modifiers.count(decl))
+		{
+			if (dynamic_cast<ContractDefinition const*>(decl))
+				m_errorReporter.declarationError(modifier->location(), "Base constructor already provided.");
+			else
+				m_errorReporter.declarationError(modifier->location(), "Modifier already used for this function.");
+		}
+		else
+			modifiers.insert(decl);
+	}
 	if (m_scope->contractKind() == ContractDefinition::ContractKind::Interface)
 	{
 		if (_function.isImplemented())
diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 9d0d6d37..729fb9cc 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -124,6 +124,7 @@ void CompilerContext::addVariable(VariableDeclaration const& _declaration,
 								  unsigned _offsetToCurrent)
 {
 	solAssert(m_asm->deposit() >= 0 && unsigned(m_asm->deposit()) >= _offsetToCurrent, "");
+	solAssert(m_localVariables.count(&_declaration) == 0, "Variable already present");
 	m_localVariables[&_declaration] = unsigned(m_asm->deposit()) - _offsetToCurrent;
 }
 
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index dc090634..8724521b 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -879,6 +879,7 @@ void ContractCompiler::appendModifierOrFunctionCode()
 	solAssert(m_currentFunction, "");
 	unsigned stackSurplus = 0;
 	Block const* codeBlock = nullptr;
+	vector<VariableDeclaration const*> addedVariables;
 
 	m_modifierDepth++;
 
@@ -902,6 +903,7 @@ void ContractCompiler::appendModifierOrFunctionCode()
 			for (unsigned i = 0; i < modifier.parameters().size(); ++i)
 			{
 				m_context.addVariable(*modifier.parameters()[i]);
+				addedVariables.push_back(modifier.parameters()[i].get());
 				compileExpression(
 					*modifierInvocation->arguments()[i],
 					modifier.parameters()[i]->annotation().type
@@ -928,6 +930,8 @@ void ContractCompiler::appendModifierOrFunctionCode()
 		m_returnTags.pop_back();
 
 		CompilerUtils(m_context).popStackSlots(stackSurplus);
+		for (auto var: addedVariables)
+			m_context.removeVariable(*var);
 	}
 	m_modifierDepth--;
 }
-- 
cgit v1.2.3


From 7a3ea61ffd226cc09ef419c47c0506699aa69b50 Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Thu, 22 Jun 2017 11:14:14 -0300
Subject: Warn if decimal literals are used in a bytesXX context

Fixes #2349
---
 libsolidity/analysis/TypeChecker.cpp | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 2a8d1ff6..cb9435e8 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -22,6 +22,7 @@
 
 #include <libsolidity/analysis/TypeChecker.h>
 #include <memory>
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/inlineasm/AsmAnalysis.h>
@@ -1793,7 +1794,23 @@ void TypeChecker::expectType(Expression const& _expression, Type const& _expecte
 				_expectedType.toString() +
 				"."
 			);
-	}		
+	}
+
+	if (
+		type(_expression)->category() == Type::Category::RationalNumber &&
+		_expectedType.category() == Type::Category::FixedBytes
+	)
+	{
+		auto literal = dynamic_cast<Literal const*>(&_expression);
+
+		if (literal && !boost::starts_with(literal->value(), "0x"))
+			m_errorReporter.warning(
+				_expression.location(),
+				"Decimal literal assigned to bytesXX variable will be left-aligned. "
+				"Use an explicit conversion to silence this warning."
+			);
+	}
+
 }
 
 void TypeChecker::requireLValue(Expression const& _expression)
-- 
cgit v1.2.3


From 555dc4f46fae9da72aaff70059686aa34172910b Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 30 May 2017 09:17:02 +0100
Subject: Remove Why3 generator

---
 libsolidity/formal/Why3Translator.cpp   | 898 --------------------------------
 libsolidity/formal/Why3Translator.h     | 147 ------
 libsolidity/interface/CompilerStack.cpp |  15 -
 libsolidity/interface/CompilerStack.h   |   7 -
 4 files changed, 1067 deletions(-)
 delete mode 100644 libsolidity/formal/Why3Translator.cpp
 delete mode 100644 libsolidity/formal/Why3Translator.h

(limited to 'libsolidity')

diff --git a/libsolidity/formal/Why3Translator.cpp b/libsolidity/formal/Why3Translator.cpp
deleted file mode 100644
index fecab2de..00000000
--- a/libsolidity/formal/Why3Translator.cpp
+++ /dev/null
@@ -1,898 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @date 2015
- * Component that translates Solidity code into the why3 programming language.
- */
-
-#include <libsolidity/formal/Why3Translator.h>
-#include <boost/algorithm/string/predicate.hpp>
-
-using namespace std;
-using namespace dev;
-using namespace dev::solidity;
-
-bool Why3Translator::process(SourceUnit const& _source)
-{
-	try
-	{
-		if (m_lines.size() != 1 || !m_lines.back().contents.empty())
-			fatalError(_source, string("Multiple source units not yet supported"));
-		appendPreface();
-		_source.accept(*this);
-	}
-	catch (NoFormalType&)
-	{
-		solAssert(false, "There is a call to toFormalType() that does not catch NoFormalType exceptions.");
-	}
-	catch (FatalError& /*_e*/)
-	{
-		solAssert(m_errorOccured, "");
-	}
-	return !m_errorOccured;
-}
-
-string Why3Translator::translation() const
-{
-	string result;
-	for (auto const& line: m_lines)
-		result += string(line.indentation, '\t') + line.contents + "\n";
-	return result;
-}
-
-string Why3Translator::toFormalType(Type const& _type) const
-{
-	if (_type.category() == Type::Category::Bool)
-		return "bool";
-	else if (auto type = dynamic_cast<IntegerType const*>(&_type))
-	{
-		if (!type->isAddress() && !type->isSigned() && type->numBits() == 256)
-			return "uint256";
-	}
-	else if (auto type = dynamic_cast<ArrayType const*>(&_type))
-	{
-		if (!type->isByteArray() && type->isDynamicallySized() && type->dataStoredIn(DataLocation::Memory))
-		{
-			// Not catching NoFormalType exception.  Let the caller deal with it.
-			string base = toFormalType(*type->baseType());
-			return "array " + base;
-		}
-	}
-	else if (auto mappingType = dynamic_cast<MappingType const*>(&_type))
-	{
-		solAssert(mappingType->keyType(), "A mappingType misses a keyType.");
-		if (dynamic_cast<IntegerType const*>(&*mappingType->keyType()))
-		{
-			//@TODO Use the information from the key type and specify the length of the array as an invariant.
-			// Also the constructor need to specify the length of the array.
-			solAssert(mappingType->valueType(), "A mappingType misses a valueType.");
-			// Not catching NoFormalType exception.  Let the caller deal with it.
-			string valueTypeFormal = toFormalType(*mappingType->valueType());
-			return "array " + valueTypeFormal;
-		}
-	}
-
-	BOOST_THROW_EXCEPTION(NoFormalType()
-		<< errinfo_noFormalTypeFrom(_type.toString(true)));
-}
-
-void Why3Translator::addLine(string const& _line)
-{
-	newLine();
-	add(_line);
-	newLine();
-}
-
-void Why3Translator::add(string const& _str)
-{
-	m_lines.back().contents += _str;
-}
-
-void Why3Translator::newLine()
-{
-	if (!m_lines.back().contents.empty())
-		m_lines.push_back({"", m_lines.back().indentation});
-}
-
-void Why3Translator::unindent()
-{
-	newLine();
-	solAssert(m_lines.back().indentation > 0, "");
-	m_lines.back().indentation--;
-}
-
-bool Why3Translator::visit(ContractDefinition const& _contract)
-{
-	if (m_seenContract)
-		error(_contract, "More than one contract not supported.");
-	m_seenContract = true;
-	m_currentContract.contract = &_contract;
-	if (_contract.isLibrary())
-		error(_contract, "Libraries not supported.");
-
-	addLine("module Contract_" + _contract.name());
-	indent();
-	addLine("use import int.Int");
-	addLine("use import ref.Ref");
-	addLine("use import map.Map");
-	addLine("use import array.Array");
-	addLine("use import int.ComputerDivision");
-	addLine("use import mach.int.Unsigned");
-	addLine("use import UInt256");
-	addLine("exception Revert");
-	addLine("exception Return");
-
-	if (_contract.stateVariables().empty())
-		addLine("type state = ()");
-	else
-	{
-		addLine("type state = {");
-		indent();
-		m_currentContract.stateVariables = _contract.stateVariables();
-		for (VariableDeclaration const* variable: m_currentContract.stateVariables)
-		{
-			string varType;
-			try
-			{
-				varType = toFormalType(*variable->annotation().type);
-			}
-			catch (NoFormalType &err)
-			{
-				string const* typeNamePtr = boost::get_error_info<errinfo_noFormalTypeFrom>(err);
-				string typeName = typeNamePtr ? " \"" + *typeNamePtr + "\"" : "";
-				fatalError(*variable, "Type" + typeName + " not supported for state variable.");
-			}
-			addLine("mutable _" + variable->name() + ": " + varType);
-		}
-		unindent();
-		addLine("}");
-	}
-
-	addLine("type account = {");
-	indent();
-	addLine("mutable balance: uint256;");
-	addLine("storage: state");
-	unindent();
-	addLine("}");
-
-	addLine("val external_call (this: account): bool");
-	indent();
-	addLine("ensures { result = false -> this = (old this) }");
-	addLine("writes { this }");
-	addSourceFromDocStrings(m_currentContract.contract->annotation());
-	unindent();
-
-	if (!_contract.baseContracts().empty())
-		error(*_contract.baseContracts().front(), "Inheritance not supported.");
-	if (!_contract.definedStructs().empty())
-		error(*_contract.definedStructs().front(), "User-defined types not supported.");
-	if (!_contract.definedEnums().empty())
-		error(*_contract.definedEnums().front(), "User-defined types not supported.");
-	if (!_contract.events().empty())
-		error(*_contract.events().front(), "Events not supported.");
-	if (!_contract.functionModifiers().empty())
-		error(*_contract.functionModifiers().front(), "Modifiers not supported.");
-
-	ASTNode::listAccept(_contract.definedFunctions(), *this);
-
-	return false;
-}
-
-void Why3Translator::endVisit(ContractDefinition const&)
-{
-	m_currentContract.reset();
-	unindent();
-	addLine("end");
-}
-
-bool Why3Translator::visit(FunctionDefinition const& _function)
-{
-	if (!_function.isImplemented())
-	{
-		error(_function, "Unimplemented functions not supported.");
-		return false;
-	}
-	if (_function.name().empty())
-	{
-		error(_function, "Fallback functions not supported.");
-		return false;
-	}
-	if (!_function.modifiers().empty())
-	{
-		error(_function, "Modifiers not supported.");
-		return false;
-	}
-
-	m_localVariables.clear();
-	for (auto const& var: _function.parameters())
-		m_localVariables[var->name()] = var.get();
-	for (auto const& var: _function.returnParameters())
-		m_localVariables[var->name()] = var.get();
-	for (auto const& var: _function.localVariables())
-		m_localVariables[var->name()] = var;
-
-	add("let rec _" + _function.name());
-	add(" (this: account)");
-	for (auto const& param: _function.parameters())
-	{
-		string paramType;
-		try
-		{
-			paramType = toFormalType(*param->annotation().type);
-		}
-		catch (NoFormalType &err)
-		{
-			string const* typeName = boost::get_error_info<errinfo_noFormalTypeFrom>(err);
-			error(*param, "Parameter type \"" + (typeName ? *typeName : "") + "\" not supported.");
-		}
-		if (param->name().empty())
-			error(*param, "Anonymous function parameters not supported.");
-		add(" (arg_" + param->name() + ": " + paramType + ")");
-	}
-	add(":");
-
-	indent();
-	indent();
-	string retString = "(";
-	for (auto const& retParam: _function.returnParameters())
-	{
-		string paramType;
-		try
-		{
-			paramType = toFormalType(*retParam->annotation().type);
-		}
-		catch (NoFormalType &err)
-		{
-			string const* typeName = boost::get_error_info<errinfo_noFormalTypeFrom>(err);
-			error(*retParam, "Parameter type " + (typeName ? *typeName : "") + " not supported.");
-		}
-		if (retString.size() != 1)
-			retString += ", ";
-		retString += paramType;
-	}
-	add(retString + ")");
-	unindent();
-
-	addSourceFromDocStrings(_function.annotation());
-	if (!m_currentContract.contract)
-		error(_function, "Only functions inside contracts allowed.");
-	addSourceFromDocStrings(m_currentContract.contract->annotation());
-
-	if (_function.isDeclaredConst())
-		addLine("ensures { (old this) = this }");
-	else
-		addLine("writes { this }");
-
-	addLine("=");
-
-	// store the prestate in the case we need to revert
-	addLine("let prestate = {balance = this.balance; storage = " + copyOfStorage() + "} in ");
-
-	// initialise local variables
-	for (auto const& variable: _function.parameters())
-		addLine("let _" + variable->name() + " = ref arg_" + variable->name() + " in");
-	for (auto const& variable: _function.returnParameters())
-	{
-		if (variable->name().empty())
-			error(*variable, "Unnamed return variables not yet supported.");
-		string varType;
-		try
-		{
-			varType = toFormalType(*variable->annotation().type);
-		}
-		catch (NoFormalType &err)
-		{
-			string const* typeNamePtr = boost::get_error_info<errinfo_noFormalTypeFrom>(err);
-			error(*variable, "Type " + (typeNamePtr ? *typeNamePtr : "") + "in return parameter not yet supported.");
-		}
-		addLine("let _" + variable->name() + ": ref " + varType + " = ref (of_int 0) in");
-	}
-	for (VariableDeclaration const* variable: _function.localVariables())
-	{
-		if (variable->name().empty())
-			error(*variable, "Unnamed variables not yet supported.");
-		string varType;
-		try
-		{
-			varType = toFormalType(*variable->annotation().type);
-		}
-		catch (NoFormalType &err)
-		{
-			string const* typeNamePtr = boost::get_error_info<errinfo_noFormalTypeFrom>(err);
-			error(*variable, "Type " + (typeNamePtr ? *typeNamePtr : "") + "in variable declaration not yet supported.");
-		}
-		addLine("let _" + variable->name() + ": ref " + varType + " = ref (of_int 0) in");
-	}
-	addLine("try");
-
-	_function.body().accept(*this);
-	add(";");
-	addLine("raise Return");
-
-	string retVals;
-	for (auto const& variable: _function.returnParameters())
-	{
-		if (!retVals.empty())
-			retVals += ", ";
-		retVals += "!_" + variable->name();
-	}
-	addLine("with Return -> (" + retVals + ") |");
-	string reversion = "     Revert -> this.balance <- prestate.balance; ";
-	for (auto const* variable: m_currentContract.stateVariables)
-		reversion += "this.storage._" + variable->name() + " <- prestate.storage._" + variable->name() + "; ";
-	//@TODO in case of reversion the return values are wrong - we need to change the
-	// return type to include a bool to signify if an exception was thrown.
-	reversion += "(" + retVals + ")";
-	addLine(reversion);
-	unindent();
-	addLine("end");
-	addLine("");
-	return false;
-}
-
-void Why3Translator::endVisit(FunctionDefinition const&)
-{
-	m_localVariables.clear();
-}
-
-bool Why3Translator::visit(Block const& _node)
-{
-	addSourceFromDocStrings(_node.annotation());
-	add("begin");
-	indent();
-	for (size_t i = 0; i < _node.statements().size(); ++i)
-	{
-		_node.statements()[i]->accept(*this);
-		if (i != _node.statements().size() - 1)
-		{
-			auto it = m_lines.end() - 1;
-			while (it != m_lines.begin() && it->contents.empty())
-				--it;
-			if (!boost::algorithm::ends_with(it->contents, "begin"))
-				it->contents += ";";
-		}
-		newLine();
-	}
-	unindent();
-	add("end");
-	return false;
-}
-
-bool Why3Translator::visit(IfStatement const& _node)
-{
-	addSourceFromDocStrings(_node.annotation());
-
-	add("if ");
-	_node.condition().accept(*this);
-	add(" then");
-	visitIndentedUnlessBlock(_node.trueStatement());
-	if (_node.falseStatement())
-	{
-		newLine();
-		add("else");
-		visitIndentedUnlessBlock(*_node.falseStatement());
-	}
-	return false;
-}
-
-bool Why3Translator::visit(WhileStatement const& _node)
-{
-	addSourceFromDocStrings(_node.annotation());
-
-	// Why3 does not appear to support do-while loops,
-	// so we will simulate them by performing a while
-	// loop with the body prepended once.
-
-	if (_node.isDoWhile())
-	{
-		visitIndentedUnlessBlock(_node.body());
-		newLine();
-	}
-
-	add("while ");
-	_node.condition().accept(*this);
-	newLine();
-	add("do");
-	visitIndentedUnlessBlock(_node.body());
-	add("done");
-	return false;
-}
-
-bool Why3Translator::visit(Return const& _node)
-{
-	addSourceFromDocStrings(_node.annotation());
-
-	if (_node.expression())
-	{
-		solAssert(!!_node.annotation().functionReturnParameters, "");
-		auto const& params = _node.annotation().functionReturnParameters->parameters();
-		if (params.size() != 1)
-		{
-			error(_node, "Directly returning tuples not supported. Rather assign to return variable.");
-			return false;
-		}
-		add("begin _" + params.front()->name() + " := ");
-		_node.expression()->accept(*this);
-		add("; raise Return end");
-	}
-	else
-		add("raise Return");
-	return false;
-}
-
-bool Why3Translator::visit(Throw const& _node)
-{
-	addSourceFromDocStrings(_node.annotation());
-	add("raise Revert");
-	return false;
-}
-
-bool Why3Translator::visit(VariableDeclarationStatement const& _node)
-{
-	addSourceFromDocStrings(_node.annotation());
-
-	if (_node.declarations().size() != 1)
-	{
-		error(_node, "Multiple variables not supported.");
-		return false;
-	}
-	if (_node.initialValue())
-	{
-		add("_" + _node.declarations().front()->name() + " := ");
-		_node.initialValue()->accept(*this);
-	}
-	return false;
-}
-
-bool Why3Translator::visit(ExpressionStatement const& _node)
-{
-	addSourceFromDocStrings(_node.annotation());
-	return true;
-}
-
-bool Why3Translator::visit(Assignment const& _node)
-{
-	if (_node.assignmentOperator() != Token::Assign)
-		error(_node, "Compound assignment not supported.");
-
-	_node.leftHandSide().accept(*this);
-
-	add(m_currentLValueIsRef ? " := " : " <- ");
-	_node.rightHandSide().accept(*this);
-
-	return false;
-}
-
-bool Why3Translator::visit(TupleExpression const& _node)
-{
-	if (_node.components().size() != 1)
-		error(_node, "Only tuples with exactly one component supported.");
-	add("(");
-	return true;
-}
-
-bool Why3Translator::visit(UnaryOperation const& _unaryOperation)
-{
-	try
-	{
-		toFormalType(*_unaryOperation.annotation().type);
-	}
-	catch (NoFormalType &err)
-	{
-		string const* typeNamePtr = boost::get_error_info<errinfo_noFormalTypeFrom>(err);
-		error(_unaryOperation, "Type \"" + (typeNamePtr ? *typeNamePtr : "") + "\" supported in unary operation.");
-	}
-
-	switch (_unaryOperation.getOperator())
-	{
-	case Token::Not: // !
-		add("(not ");
-		break;
-	default:
-		error(_unaryOperation, "Operator not supported.");
-		break;
-	}
-
-	_unaryOperation.subExpression().accept(*this);
-	add(")");
-
-	return false;
-}
-
-bool Why3Translator::visit(BinaryOperation const& _binaryOperation)
-{
-	Expression const& leftExpression = _binaryOperation.leftExpression();
-	Expression const& rightExpression = _binaryOperation.rightExpression();
-	solAssert(!!_binaryOperation.annotation().commonType, "");
-	Type const& commonType = *_binaryOperation.annotation().commonType;
-	Token::Value const c_op = _binaryOperation.getOperator();
-
-	if (commonType.category() == Type::Category::RationalNumber)
-	{
-		auto const& constantNumber = dynamic_cast<RationalNumberType const&>(commonType);
-		if (constantNumber.isFractional())
-			error(_binaryOperation, "Fractional numbers not supported.");
-		else
-			add("(of_int " + toString(commonType.literalValue(nullptr)) + ")");
-		return false;
-	}
-	static const map<Token::Value, char const*> optrans({
-		{Token::And, " && "},
-		{Token::Or, " || "},
-		{Token::BitOr, " lor "},
-		{Token::BitXor, " lxor "},
-		{Token::BitAnd, " land "},
-		{Token::Add, " + "},
-		{Token::Sub, " - "},
-		{Token::Mul, " * "},
-		{Token::Div, " / "},
-		{Token::Mod, " mod "},
-		{Token::Equal, " = "},
-		{Token::NotEqual, " <> "},
-		{Token::LessThan, " < "},
-		{Token::GreaterThan, " > "},
-		{Token::LessThanOrEqual, " <= "},
-		{Token::GreaterThanOrEqual, " >= "}
-	});
-	if (!optrans.count(c_op))
-	{
-		error(_binaryOperation, "Operator not supported.");
-		return true;
-	}
-
-	add("(");
-	leftExpression.accept(*this);
-	add(optrans.at(c_op));
-	rightExpression.accept(*this);
-	add(")");
-
-	return false;
-}
-
-bool Why3Translator::visit(FunctionCall const& _node)
-{
-	if (_node.annotation().kind == FunctionCallKind::TypeConversion || _node.annotation().kind == FunctionCallKind::StructConstructorCall)
-	{
-		error(_node, "Only ordinary function calls supported.");
-		return true;
-	}
-	FunctionType const& function = dynamic_cast<FunctionType const&>(*_node.expression().annotation().type);
-	switch (function.kind())
-	{
-	case FunctionType::Kind::AddMod:
-	case FunctionType::Kind::MulMod:
-	{
-		//@todo require that third parameter is not zero
-		add("(of_int (mod (Int.(");
-		add(function.kind() == FunctionType::Kind::AddMod ? "+" : "*");
-		add(") (to_int ");
-		_node.arguments().at(0)->accept(*this);
-		add(") (to_int ");
-		_node.arguments().at(1)->accept(*this);
-		add(")) (to_int ");
-		_node.arguments().at(2)->accept(*this);
-		add(")))");
-		return false;
-	}
-	case FunctionType::Kind::Internal:
-	{
-		if (!_node.names().empty())
-		{
-			error(_node, "Function calls with named arguments not supported.");
-			return true;
-		}
-
-		//@TODO check type conversions
-
-		add("(");
-		_node.expression().accept(*this);
-		add(" state");
-		for (auto const& arg: _node.arguments())
-		{
-			add(" ");
-			arg->accept(*this);
-		}
-		add(")");
-		return false;
-	}
-	case FunctionType::Kind::Bare:
-	{
-		if (!_node.arguments().empty())
-		{
-			error(_node, "Function calls with named arguments not supported.");
-			return true;
-		}
-
-		add("(");
-		indent();
-		add("let amount = 0 in ");
-		_node.expression().accept(*this);
-		addLine("if amount <= this.balance then");
-		indent();
-		addLine("let balance_precall = this.balance in");
-		addLine("begin");
-		indent();
-		addLine("this.balance <- this.balance - amount;");
-		addLine("if not (external_call this) then begin this.balance = balance_precall; false end else true");
-		unindent();
-		addLine("end");
-		unindent();
-		addLine("else false");
-
-		unindent();
-		add(")");
-		return false;
-	}
-	case FunctionType::Kind::SetValue:
-	{
-		add("let amount = ");
-		solAssert(_node.arguments().size() == 1, "");
-		_node.arguments()[0]->accept(*this);
-		add(" in ");
-		return false;
-	}
-	default:
-		error(_node, "Only internal function calls supported.");
-		return true;
-	}
-}
-
-bool Why3Translator::visit(MemberAccess const& _node)
-{
-	if (
-		_node.expression().annotation().type->category() == Type::Category::Array &&
-		_node.memberName() == "length" &&
-		!_node.annotation().lValueRequested
-	)
-	{
-		add("(of_int ");
-		_node.expression().accept(*this);
-		add(".length");
-		add(")");
-	}
-	else if (
-		_node.memberName() == "call" &&
-		*_node.expression().annotation().type == IntegerType(160, IntegerType::Modifier::Address)
-	)
-	{
-		// Do nothing, do not even visit the address because this will be an external call
-		//@TODO ensure that the expression itself does not have side-effects
-		return false;
-	}
-	else
-		error(_node, "Member access: Only call and array length supported.");
-	return false;
-}
-
-bool Why3Translator::visit(IndexAccess const& _node)
-{
-	auto baseType = dynamic_cast<ArrayType const*>(_node.baseExpression().annotation().type.get());
-	if (!baseType)
-	{
-		error(_node, "Index access only supported for arrays.");
-		return true;
-	}
-	if (_node.annotation().lValueRequested)
-	{
-		error(_node, "Assignment to array elements not supported.");
-		return true;
-	}
-	add("(");
-	_node.baseExpression().accept(*this);
-	add("[to_int ");
-	_node.indexExpression()->accept(*this);
-	add("]");
-	add(")");
-
-	return false;
-}
-
-bool Why3Translator::visit(Identifier const& _identifier)
-{
-	Declaration const* declaration = _identifier.annotation().referencedDeclaration;
-	if (FunctionDefinition const* functionDef = dynamic_cast<FunctionDefinition const*>(declaration))
-		add("_" + functionDef->name());
-	else if (auto variable = dynamic_cast<VariableDeclaration const*>(declaration))
-	{
-		bool isStateVar = isStateVariable(variable);
-		bool lvalue = _identifier.annotation().lValueRequested;
-		if (isStateVar)
-			add("this.storage.");
-		else if (!lvalue)
-			add("!(");
-		add("_" + variable->name());
-		if (!isStateVar && !lvalue)
-			add(")");
-		m_currentLValueIsRef = !isStateVar;
-	}
-	else
-		error(_identifier, "Not supported.");
-	return false;
-}
-
-bool Why3Translator::visit(Literal const& _literal)
-{
-	TypePointer type = _literal.annotation().type;
-	switch (type->category())
-	{
-	case Type::Category::Bool:
-		if (type->literalValue(&_literal) == 0)
-			add("false");
-		else
-			add("true");
-		break;
-	case Type::Category::RationalNumber:
-	{
-		auto const& constantNumber = dynamic_cast<RationalNumberType const&>(*type);
-		if (constantNumber.isFractional())
-			error(_literal, "Fractional numbers not supported.");
-		else
-			add("(of_int " + toString(type->literalValue(&_literal)) + ")");
-		break;
-	}
-	default:
-		error(_literal, "Not supported.");
-	}
-	return false;
-}
-
-bool Why3Translator::visit(PragmaDirective const& _pragma)
-{
-	if (_pragma.tokens().empty())
-		error(_pragma, "Not supported");
-	else if (_pragma.literals().empty())
-		error(_pragma, "Not supported");
-	else if (_pragma.literals()[0] != "solidity")
-		error(_pragma, "Not supported");
-	else if (_pragma.tokens()[0] != Token::Identifier)
-		error(_pragma, "A literal 'solidity' is not an identifier.  Strange");
-
-	return false;
-}
-
-bool Why3Translator::isStateVariable(VariableDeclaration const* _var) const
-{
-	return contains(m_currentContract.stateVariables, _var);
-}
-
-bool Why3Translator::isStateVariable(string const& _name) const
-{
-	for (auto const& var: m_currentContract.stateVariables)
-		if (var->name() == _name)
-			return true;
-	return false;
-}
-
-bool Why3Translator::isLocalVariable(VariableDeclaration const* _var) const
-{
-	for (auto const& var: m_localVariables)
-		if (var.second == _var)
-			return true;
-	return false;
-}
-
-bool Why3Translator::isLocalVariable(string const& _name) const
-{
-	return m_localVariables.count(_name);
-}
-
-string Why3Translator::copyOfStorage() const
-{
-	if (m_currentContract.stateVariables.empty())
-		return "()";
-	string ret = "{";
-	bool first = true;
-	for (auto const* variable: m_currentContract.stateVariables)
-	{
-		if (first)
-			first = false;
-		else
-			ret += "; ";
-		ret += "_" + variable->name() + " = this.storage._" + variable->name();
-	}
-	return ret + "}";
-}
-
-void Why3Translator::visitIndentedUnlessBlock(Statement const& _statement)
-{
-	bool isBlock = !!dynamic_cast<Block const*>(&_statement);
-	if (isBlock)
-		newLine();
-	else
-		indent();
-	_statement.accept(*this);
-	if (isBlock)
-		newLine();
-	else
-		unindent();
-}
-
-void Why3Translator::addSourceFromDocStrings(DocumentedAnnotation const& _annotation)
-{
-	auto why3Range = _annotation.docTags.equal_range("why3");
-	for (auto i = why3Range.first; i != why3Range.second; ++i)
-		addLine(transformVariableReferences(i->second.content));
-}
-
-string Why3Translator::transformVariableReferences(string const& _annotation)
-{
-	string ret;
-	auto pos = _annotation.begin();
-	while (true)
-	{
-		auto hash = find(pos, _annotation.end(), '#');
-		ret.append(pos, hash);
-		if (hash == _annotation.end())
-			break;
-
-		auto hashEnd = find_if(hash + 1, _annotation.end(), [](char _c)
-		{
-			return
-				(_c != '_' && _c != '$') &&
-				!('a' <= _c && _c <= 'z') &&
-				!('A' <= _c && _c <= 'Z') &&
-				!('0' <= _c && _c <= '9');
-		});
-		string varName(hash + 1, hashEnd);
-		if (isLocalVariable(varName))
-			ret += "(!_" + varName + ")";
-		else if (isStateVariable(varName))
-			ret += "(this.storage._" + varName + ")";
-		//@todo return variables
-		else
-			ret.append(hash, hashEnd);
-
-		pos = hashEnd;
-	}
-	return ret;
-}
-
-void Why3Translator::appendPreface()
-{
-	m_lines.push_back(Line{R"(
-module UInt256
-	use import mach.int.Unsigned
-	type uint256
-	constant max_uint256: int = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-	clone export mach.int.Unsigned with
-		type t = uint256,
-		constant max = max_uint256
-end
-
-module Address
-	use import mach.int.Unsigned
-	type address
-	constant max_address: int = 0xffffffffffffffffffffffffffffffffffffffff (* 160 bit = 40 f's *)
-	clone export mach.int.Unsigned with
-		type t = address,
-		constant max = max_address
-end
-   )", 0});
-}
-
-void Why3Translator::error(ASTNode const& _source, std::string const& _description)
-{
-	m_errorOccured = true;
-	m_errorReporter.why3TranslatorError(_source, _description);
-}
-void Why3Translator::fatalError(ASTNode const& _source, std::string const& _description)
-{
-	m_errorOccured = true;
-	m_errorReporter.fatalWhy3TranslatorError(_source, _description);
-}
-
diff --git a/libsolidity/formal/Why3Translator.h b/libsolidity/formal/Why3Translator.h
deleted file mode 100644
index b48317be..00000000
--- a/libsolidity/formal/Why3Translator.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-	This file is part of solidity.
-
-	solidity is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	solidity is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/**
- * @author Christian <c@ethdev.com>
- * @date 2015
- * Component that translates Solidity code into the why3 programming language.
- */
-
-#pragma once
-
-#include <libsolidity/ast/ASTVisitor.h>
-#include <libsolidity/interface/ErrorReporter.h>
-#include <string>
-
-namespace dev
-{
-namespace solidity
-{
-
-class SourceUnit;
-
-/**
- * Simple translator from Solidity to Why3.
- *
- * @todo detect side effects in sub-expressions and limit them to one per statement. #1043
- * @todo `x = y = z`
- * @todo implicit and explicit type conversion
- */
-class Why3Translator: private ASTConstVisitor
-{
-public:
-	Why3Translator(ErrorReporter& _errorReporter): m_lines(std::vector<Line>{{std::string(), 0}}), m_errorReporter(_errorReporter) {}
-
-	/// Appends formalisation of the given source unit to the output.
-	/// @returns false on error.
-	bool process(SourceUnit const& _source);
-
-	std::string translation() const;
-
-private:
-	/// Appends imports and constants use throughout the formal code.
-	void appendPreface();
-
-	/// @returns a string representation of the corresponding formal type or throws NoFormalType exception.
-	std::string toFormalType(Type const& _type) const;
-	using errinfo_noFormalTypeFrom = boost::error_info<struct tag_noFormalTypeFrom, std::string /* name of the type that cannot be translated */ >;
-	struct NoFormalType: virtual Exception {};
-
-	void error(ASTNode const& _source, std::string const& _description);
-	void fatalError(ASTNode const& _source, std::string const& _description);
-
-	void indent() { newLine(); m_lines.back().indentation++; }
-	void unindent();
-	void addLine(std::string const& _line);
-	void add(std::string const& _str);
-	void newLine();
-	void appendSemicolon();
-
-	virtual bool visit(SourceUnit const&) override { return true; }
-	virtual bool visit(ContractDefinition const& _contract) override;
-	virtual void endVisit(ContractDefinition const& _contract) override;
-	virtual bool visit(FunctionDefinition const& _function) override;
-	virtual void endVisit(FunctionDefinition const& _function) override;
-	virtual bool visit(Block const&) override;
-	virtual bool visit(IfStatement const& _node) override;
-	virtual bool visit(WhileStatement const& _node) override;
-	virtual bool visit(Return const& _node) override;
-	virtual bool visit(Throw const& _node) override;
-	virtual bool visit(VariableDeclarationStatement const& _node) override;
-	virtual bool visit(ExpressionStatement const&) override;
-	virtual bool visit(Assignment const& _node) override;
-	virtual bool visit(TupleExpression const& _node) override;
-	virtual void endVisit(TupleExpression const&) override { add(")"); }
-	virtual bool visit(UnaryOperation const& _node) override;
-	virtual bool visit(BinaryOperation const& _node) override;
-	virtual bool visit(FunctionCall const& _node) override;
-	virtual bool visit(MemberAccess const& _node) override;
-	virtual bool visit(IndexAccess const& _node) override;
-	virtual bool visit(Identifier const& _node) override;
-	virtual bool visit(Literal const& _node) override;
-	virtual bool visit(PragmaDirective const& _node) override;
-
-	virtual bool visitNode(ASTNode const& _node) override
-	{
-		m_errorReporter.why3TranslatorError(_node, "Code not supported for formal verification.");
-		return false;
-	}
-
-	bool isStateVariable(VariableDeclaration const* _var) const;
-	bool isStateVariable(std::string const& _name) const;
-	bool isLocalVariable(VariableDeclaration const* _var) const;
-	bool isLocalVariable(std::string const& _name) const;
-
-	/// @returns a string representing an expression that is a copy of this.storage
-	std::string copyOfStorage() const;
-
-	/// Visits the given statement and indents it unless it is a block
-	/// (which does its own indentation).
-	void visitIndentedUnlessBlock(Statement const& _statement);
-
-	void addSourceFromDocStrings(DocumentedAnnotation const& _annotation);
-	/// Transforms substring like `#varName` and `#stateVarName` to code that evaluates to their value.
-	std::string transformVariableReferences(std::string const& _annotation);
-
-	/// True if we have already seen a contract. For now, only a single contract
-	/// is supported.
-	bool m_seenContract = false;
-	bool m_errorOccured = false;
-
-	/// Metadata relating to the current contract
-	struct ContractMetadata
-	{
-		ContractDefinition const* contract = nullptr;
-		std::vector<VariableDeclaration const*> stateVariables;
-
-		void reset() { contract = nullptr; stateVariables.clear(); }
-	};
-
-	ContractMetadata m_currentContract;
-	bool m_currentLValueIsRef = false;
-	std::map<std::string, VariableDeclaration const*> m_localVariables;
-
-	struct Line
-	{
-		std::string contents;
-		unsigned indentation;
-	};
-	std::vector<Line> m_lines;
-	ErrorReporter& m_errorReporter;
-};
-
-}
-}
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 8be2c8dd..e2507821 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -40,7 +40,6 @@
 #include <libsolidity/interface/ABI.h>
 #include <libsolidity/interface/Natspec.h>
 #include <libsolidity/interface/GasEstimator.h>
-#include <libsolidity/formal/Why3Translator.h>
 
 #include <libevmasm/Exceptions.h>
 
@@ -316,20 +315,6 @@ void CompilerStack::link()
 	}
 }
 
-bool CompilerStack::prepareFormalAnalysis(ErrorReporter* _errorReporter)
-{
-	if (!_errorReporter)
-		_errorReporter = &m_errorReporter;
-	Why3Translator translator(*_errorReporter);
-	for (Source const* source: m_sourceOrder)
-		if (!translator.process(*source->ast))
-			return false;
-
-	m_formalTranslation = translator.translation();
-
-	return true;
-}
-
 eth::AssemblyItems const* CompilerStack::assemblyItems(string const& _contractName) const
 {
 	Contract const& currentContract = contract(_contractName);
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index f7435f0e..c51ae9c9 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -129,12 +129,6 @@ public:
 	/// @returns false on error.
 	bool compile(std::string const& _sourceCode, bool _optimize = false, unsigned _runs = 200);
 
-	/// Tries to translate all source files into a language suitable for formal analysis.
-	/// @param _errors list to store errors - defaults to the internal error list.
-	/// @returns false on error.
-	bool prepareFormalAnalysis(ErrorReporter* _errorReporter = nullptr);
-	std::string const& formalTranslation() const { return m_formalTranslation; }
-
 	/// @returns the assembled object for a contract.
 	eth::LinkerObject const& object(std::string const& _contractName = "") const;
 	/// @returns the runtime object for the contract.
@@ -290,7 +284,6 @@ private:
 	std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>> m_scopes;
 	std::vector<Source const*> m_sourceOrder;
 	std::map<std::string const, Contract> m_contracts;
-	std::string m_formalTranslation;
 	ErrorList m_errorList;
 	ErrorReporter m_errorReporter;
 	bool m_metadataLiteralSources = false;
-- 
cgit v1.2.3


From 0aaa6d876d56e450ce907e5a8b1db6cfd220312f Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 22 Jun 2017 18:25:22 +0200
Subject: Use for loop for assembly memcopy.

---
 libsolidity/codegen/CompilerUtils.cpp | 38 ++++++++++++++---------------------
 1 file changed, 15 insertions(+), 23 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 7fed1975..26eadf9d 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -305,15 +305,9 @@ void CompilerUtils::memoryCopy32()
 
 	m_context.appendInlineAssembly(R"(
 		{
-		jumpi(end, eq(len, 0))
-		start:
-		mstore(dst, mload(src))
-		jumpi(end, iszero(gt(len, 32)))
-		dst := add(dst, 32)
-		src := add(src, 32)
-		len := sub(len, 32)
-		jump(start)
-		end:
+			for { let i := 0 } lt(i, len) { i := add(i, 32) } {
+				mstore(add(dst, i), mload(add(src, i)))
+			}
 		}
 	)",
 		{ "len", "dst", "src" }
@@ -327,21 +321,19 @@ void CompilerUtils::memoryCopy()
 
 	m_context.appendInlineAssembly(R"(
 		{
-		// copy 32 bytes at once
-		start32:
-		jumpi(end32, lt(len, 32))
-		mstore(dst, mload(src))
-		dst := add(dst, 32)
-		src := add(src, 32)
-		len := sub(len, 32)
-		jump(start32)
-		end32:
+			// copy 32 bytes at once
+			for {} iszero(lt(len, 32)) {
+						dst := add(dst, 32)
+						src := add(src, 32)
+						len := sub(len, 32)
+					}
+			{ mstore(dst, mload(src)) }
 
-		// copy the remainder (0 < len < 32)
-		let mask := sub(exp(256, sub(32, len)), 1)
-		let srcpart := and(mload(src), not(mask))
-		let dstpart := and(mload(dst), mask)
-		mstore(dst, or(srcpart, dstpart))
+			// copy the remainder (0 < len < 32)
+			let mask := sub(exp(256, sub(32, len)), 1)
+			let srcpart := and(mload(src), not(mask))
+			let dstpart := and(mload(dst), mask)
+			mstore(dst, or(srcpart, dstpart))
 		}
 	)",
 		{ "len", "dst", "src" }
-- 
cgit v1.2.3


From d94a12a34c4c3846a40002a4e3a79c2b1f0b6972 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Mon, 26 Jun 2017 09:19:11 +0200
Subject: Reformat.

---
 libsolidity/codegen/CompilerUtils.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 26eadf9d..4edec155 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -322,12 +322,15 @@ void CompilerUtils::memoryCopy()
 	m_context.appendInlineAssembly(R"(
 		{
 			// copy 32 bytes at once
-			for {} iszero(lt(len, 32)) {
-						dst := add(dst, 32)
-						src := add(src, 32)
-						len := sub(len, 32)
-					}
-			{ mstore(dst, mload(src)) }
+			for
+				{}
+				iszero(lt(len, 32))
+				{
+					dst := add(dst, 32)
+					src := add(src, 32)
+					len := sub(len, 32)
+				}
+				{ mstore(dst, mload(src)) }
 
 			// copy the remainder (0 < len < 32)
 			let mask := sub(exp(256, sub(32, len)), 1)
-- 
cgit v1.2.3


From f47e6e90fb55066ff602a1448fc2d3f650449559 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 23 Jun 2017 18:37:15 +0200
Subject: Disallow comparisons between some types.

---
 libsolidity/ast/Types.cpp                  | 10 ++++++++++
 libsolidity/ast/Types.h                    |  9 ++++-----
 libsolidity/codegen/ExpressionCompiler.cpp |  1 +
 3 files changed, 15 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
index bd3346f9..0234f842 100644
--- a/libsolidity/ast/Types.cpp
+++ b/libsolidity/ast/Types.cpp
@@ -2248,6 +2248,16 @@ TypePointer FunctionType::unaryOperatorResult(Token::Value _operator) const
 	return TypePointer();
 }
 
+TypePointer FunctionType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
+{
+	if (_other->category() != category() || !Token::isCompareOp(_operator))
+		return TypePointer();
+	FunctionType const& other = dynamic_cast<FunctionType const&>(*_other);
+	if (kind() == Kind::Internal && other.kind() == Kind::Internal && sizeOnStack() == 1 && other.sizeOnStack() == 1)
+		return commonType(shared_from_this(), _other);
+	return TypePointer();
+}
+
 string FunctionType::canonicalName(bool) const
 {
 	solAssert(m_kind == Kind::External, "");
diff --git a/libsolidity/ast/Types.h b/libsolidity/ast/Types.h
index c4ffc44c..f7a73ab5 100644
--- a/libsolidity/ast/Types.h
+++ b/libsolidity/ast/Types.h
@@ -933,6 +933,7 @@ public:
 	virtual bool operator==(Type const& _other) const override;
 	virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override;
 	virtual TypePointer unaryOperatorResult(Token::Value _operator) const override;
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override;
 	virtual std::string canonicalName(bool /*_addDataLocation*/) const override;
 	virtual std::string toString(bool _short) const override;
 	virtual unsigned calldataEncodedSize(bool _padded) const override;
@@ -1038,6 +1039,7 @@ public:
 	virtual std::string toString(bool _short) const override;
 	virtual std::string canonicalName(bool _addDataLocation) const override;
 	virtual bool canLiveOutsideStorage() const override { return false; }
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
 	virtual TypePointer encodingType() const override
 	{
 		return std::make_shared<IntegerType>(256);
@@ -1116,11 +1118,7 @@ public:
 
 	explicit ModuleType(SourceUnit const& _source): m_sourceUnit(_source) {}
 
-	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override
-	{
-		return TypePointer();
-	}
-
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
 	virtual std::string identifier() const override;
 	virtual bool operator==(Type const& _other) const override;
 	virtual bool canBeStored() const override { return false; }
@@ -1178,6 +1176,7 @@ public:
 	virtual std::string identifier() const override { return "t_inaccessible"; }
 	virtual bool isImplicitlyConvertibleTo(Type const&) const override { return false; }
 	virtual bool isExplicitlyConvertibleTo(Type const&) const override { return false; }
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
 	virtual unsigned calldataEncodedSize(bool _padded) const override { (void)_padded; return 32; }
 	virtual bool canBeStored() const override { return false; }
 	virtual bool canLiveOutsideStorage() const override { return false; }
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index a7cfe4dc..a65549fd 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -1366,6 +1366,7 @@ void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryO
 
 void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type const& _type)
 {
+	solAssert(_type.sizeOnStack() == 1, "Comparison of multi-slot types.");
 	if (_operator == Token::Equal || _operator == Token::NotEqual)
 	{
 		if (FunctionType const* funType = dynamic_cast<decltype(funType)>(&_type))
-- 
cgit v1.2.3


From 4407a13c1730bf9ed4bcaf00c3f72640f6ddb2a7 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Mon, 26 Jun 2017 16:30:13 +0200
Subject: Only allow equality checks for internal function types.

---
 libsolidity/ast/Types.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
index 0234f842..7dc6c4a6 100644
--- a/libsolidity/ast/Types.cpp
+++ b/libsolidity/ast/Types.cpp
@@ -2250,7 +2250,7 @@ TypePointer FunctionType::unaryOperatorResult(Token::Value _operator) const
 
 TypePointer FunctionType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
 {
-	if (_other->category() != category() || !Token::isCompareOp(_operator))
+	if (_other->category() != category() || !(_operator == Token::Equal || _operator == Token::NotEqual))
 		return TypePointer();
 	FunctionType const& other = dynamic_cast<FunctionType const&>(*_other);
 	if (kind() == Kind::Internal && other.kind() == Kind::Internal && sizeOnStack() == 1 && other.sizeOnStack() == 1)
-- 
cgit v1.2.3


From d0b6de0b346b319c85747fdbee76c1d204d6ced6 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Wed, 21 Jun 2017 19:32:56 +0200
Subject: Warn about copies in storage that might overwrite unexpectedly.

---
 libsolidity/analysis/TypeChecker.cpp | 31 +++++++++++++++++++++++++++++++
 libsolidity/analysis/TypeChecker.h   |  3 +++
 2 files changed, 34 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 40ff59f6..ef8a9345 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -364,6 +364,35 @@ void TypeChecker::checkLibraryRequirements(ContractDefinition const& _contract)
 			m_errorReporter.typeError(var->location(), "Library cannot have non-constant state variables");
 }
 
+void TypeChecker::checkDoubleStorageAssignment(Assignment const& _assignment)
+{
+	TupleType const& lhs = dynamic_cast<TupleType const&>(*type(_assignment.leftHandSide()));
+	TupleType const& rhs = dynamic_cast<TupleType const&>(*type(_assignment.rightHandSide()));
+
+	bool fillRight = !lhs.components().empty() && (!lhs.components().back() || lhs.components().front());
+	size_t storageToStorageCopies = 0;
+	size_t toStorageCopies = 0;
+	for (size_t i = 0; i < lhs.components().size(); ++i)
+	{
+		ReferenceType const* ref = dynamic_cast<ReferenceType const*>(lhs.components()[i].get());
+		if (!ref || !ref->dataStoredIn(DataLocation::Storage) || ref->isPointer())
+			continue;
+		size_t rhsPos = fillRight ? i : rhs.components().size() - (lhs.components().size() - i);
+		solAssert(rhsPos < rhs.components().size(), "");
+		toStorageCopies++;
+		if (rhs.components()[rhsPos]->dataStoredIn(DataLocation::Storage))
+			storageToStorageCopies++;
+	}
+	if (storageToStorageCopies >= 1 && toStorageCopies >= 2)
+		m_errorReporter.warning(
+			_assignment.location(),
+			"This assignment performs two copies to storage. Since storage copies do not first "
+			"copy to a temporary location, one of them might be overwritten before the second "
+			"is executed and thus may have unexpected effects. It is safer to perform the copies "
+			"separately or assign to storage pointers first."
+		);
+}
+
 void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
 {
 	auto base = dynamic_cast<ContractDefinition const*>(&dereference(_inheritance.name()));
@@ -1047,6 +1076,8 @@ bool TypeChecker::visit(Assignment const& _assignment)
 		// Sequenced assignments of tuples is not valid, make the result a "void" type.
 		_assignment.annotation().type = make_shared<TupleType>();
 		expectType(_assignment.rightHandSide(), *tupleType);
+
+		checkDoubleStorageAssignment(_assignment);
 	}
 	else if (t->category() == Type::Category::Mapping)
 	{
diff --git a/libsolidity/analysis/TypeChecker.h b/libsolidity/analysis/TypeChecker.h
index 2fa66f97..ee43d13a 100644
--- a/libsolidity/analysis/TypeChecker.h
+++ b/libsolidity/analysis/TypeChecker.h
@@ -69,6 +69,9 @@ private:
 	void checkContractExternalTypeClashes(ContractDefinition const& _contract);
 	/// Checks that all requirements for a library are fulfilled if this is a library.
 	void checkLibraryRequirements(ContractDefinition const& _contract);
+	/// Checks (and warns) if a tuple assignment might cause unexpected overwrites in storage.
+	/// Should only be called if the left hand side is tuple-typed.
+	void checkDoubleStorageAssignment(Assignment const& _assignment);
 
 	virtual void endVisit(InheritanceSpecifier const& _inheritance) override;
 	virtual void endVisit(UsingForDirective const& _usingFor) override;
-- 
cgit v1.2.3


From 70fd5c17704119a3f52aba5c67eda96c2a222d2d Mon Sep 17 00:00:00 2001
From: Federico Bond <federicobond@gmail.com>
Date: Sat, 24 Jun 2017 14:09:19 -0300
Subject: Warn deprecated usage of parameter names in function types

---
 libsolidity/analysis/SyntaxChecker.cpp | 12 ++++++++++++
 libsolidity/analysis/SyntaxChecker.h   |  2 ++
 2 files changed, 14 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp
index 35d71d85..02e2fdcf 100644
--- a/libsolidity/analysis/SyntaxChecker.cpp
+++ b/libsolidity/analysis/SyntaxChecker.cpp
@@ -148,3 +148,15 @@ bool SyntaxChecker::visit(PlaceholderStatement const&)
 	return true;
 }
 
+bool SyntaxChecker::visit(FunctionTypeName const& _node)
+{
+	for (auto const& decl: _node.parameterTypeList()->parameters())
+		if (!decl->name().empty())
+			m_errorReporter.warning(decl->location(), "Naming function type parameters is deprecated.");
+
+	for (auto const& decl: _node.returnParameterTypeList()->parameters())
+		if (!decl->name().empty())
+			m_errorReporter.warning(decl->location(), "Naming function type return parameters is deprecated.");
+
+	return true;
+}
diff --git a/libsolidity/analysis/SyntaxChecker.h b/libsolidity/analysis/SyntaxChecker.h
index b1857aa5..ec6ac434 100644
--- a/libsolidity/analysis/SyntaxChecker.h
+++ b/libsolidity/analysis/SyntaxChecker.h
@@ -63,6 +63,8 @@ private:
 
 	virtual bool visit(PlaceholderStatement const& _placeholderStatement) override;
 
+	virtual bool visit(FunctionTypeName const& _node) override;
+
 	ErrorReporter& m_errorReporter;
 
 	/// Flag that indicates whether a function modifier actually contains '_'.
-- 
cgit v1.2.3


From ab15040caa0b2b401f9bebc8d8247e8e6b6d1540 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Mon, 26 Jun 2017 16:27:12 +0200
Subject: Comment about zero length.

---
 libsolidity/codegen/CompilerUtils.h | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.h b/libsolidity/codegen/CompilerUtils.h
index caf2cdc2..0ee053a9 100644
--- a/libsolidity/codegen/CompilerUtils.h
+++ b/libsolidity/codegen/CompilerUtils.h
@@ -110,10 +110,12 @@ public:
 	void zeroInitialiseMemoryArray(ArrayType const& _type);
 
 	/// Copies full 32 byte words in memory (regions cannot overlap), i.e. may copy more than length.
+	/// Length can be zero, in this case, it copies nothing.
 	/// Stack pre: <size> <target> <source>
 	/// Stack post:
 	void memoryCopy32();
 	/// Copies data in memory (regions cannot overlap).
+	/// Length can be zero, in this case, it copies nothing.
 	/// Stack pre: <size> <target> <source>
 	/// Stack post:
 	void memoryCopy();
-- 
cgit v1.2.3


From 9f19bc8cbca127309fd8057e20d2facc22529fc0 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Thu, 22 Jun 2017 16:08:59 +0200
Subject: Warn if using var x = 0

---
 libsolidity/analysis/TypeChecker.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index ef8a9345..1c91a2b0 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -956,6 +956,30 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 					var.location(),
 					"Cannot declare variable with void (empty tuple) type."
 				);
+			else if (valueComponentType->category() == Type::Category::RationalNumber)
+			{
+				string typeName = var.annotation().type->toString(true);
+				string extension;
+				if (auto type = dynamic_cast<IntegerType const*>(var.annotation().type.get()))
+				{
+					int numBits = type->numBits();
+					bool isSigned = type->isSigned();
+					if (isSigned)
+						numBits--;
+					extension = ", which can hold values up to " + string((u256(1) << numBits) - 1);
+				}
+				else
+					solAssert(dynamic_cast<FixedPointType const*>(var.annotation().type.get()), "Unknown type.");
+
+				m_errorReporter.warning(
+					_statement.location(),
+					"The type of this variable was inferred as " +
+					typeName +
+					extension +
+					". This is probably not desired. Use an explicit type to silence this warning."
+				);
+			}
+
 			var.accept(*this);
 		}
 		else
-- 
cgit v1.2.3


From c3e5d6b7ef64f7924754d1b0a1c5577e038e7bf4 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Mon, 26 Jun 2017 09:49:45 +0200
Subject: Give min and max values in warning message.

---
 libsolidity/analysis/TypeChecker.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 1c91a2b0..b276a2d4 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -964,9 +964,17 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 				{
 					int numBits = type->numBits();
 					bool isSigned = type->isSigned();
+					string minValue;
+					string maxValue;
 					if (isSigned)
+					{
 						numBits--;
-					extension = ", which can hold values up to " + string((u256(1) << numBits) - 1);
+						minValue = "-" + bigint(bigint(1) << numBits).str();
+					}
+					else
+						minValue = "0";
+					maxValue = bigint((bigint(1) << numBits) - 1).str();
+					extension = ", which can hold values between " + minValue + " and " + maxValue;
 				}
 				else
 					solAssert(dynamic_cast<FixedPointType const*>(var.annotation().type.get()), "Unknown type.");
-- 
cgit v1.2.3


From 168f64f4cb55a7055261a4c66ca54f496e96b503 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 23 Jun 2017 17:20:07 +0200
Subject: Fix negative stack size checks.

---
 libsolidity/codegen/ContractCompiler.cpp   | 10 ++++++++++
 libsolidity/codegen/ExpressionCompiler.cpp |  1 +
 2 files changed, 11 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index 977a2c7c..61a90050 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -267,12 +267,16 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 	m_context << notFound;
 	if (fallback)
 	{
+		m_context.setStackOffset(0);
 		if (!fallback->isPayable())
 			appendCallValueCheck();
 
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
 		fallback->accept(*this);
 		m_context << returnTag;
+		m_context.adjustStackOffset(
+			CompilerUtils(m_context).sizeOnStack(FunctionType(*fallback).returnParameterTypes()) - 1
+		);
 		appendReturnValuePacker(FunctionType(*fallback).returnParameterTypes(), _contract.isLibrary());
 	}
 	else
@@ -285,6 +289,7 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 		CompilerContext::LocationSetter locationSetter(m_context, functionType->declaration());
 
 		m_context << callDataUnpackerEntryPoints.at(it.first);
+		m_context.setStackOffset(0);
 		// We have to allow this for libraries, because value of the previous
 		// call is still visible in the delegatecall.
 		if (!functionType->isPayable() && !_contract.isLibrary())
@@ -295,6 +300,11 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 		appendCalldataUnpacker(functionType->parameterTypes());
 		m_context.appendJumpTo(m_context.functionEntryLabel(functionType->declaration()));
 		m_context << returnTag;
+		m_context.adjustStackOffset(
+			CompilerUtils(m_context).sizeOnStack(functionType->returnParameterTypes()) -
+			CompilerUtils(m_context).sizeOnStack(functionType->parameterTypes()) -
+			1
+		);
 		appendReturnValuePacker(functionType->returnParameterTypes(), _contract.isLibrary());
 	}
 }
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index a65549fd..9d4024c9 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -88,6 +88,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
 	FunctionType accessorType(_varDecl);
 
 	TypePointers paramTypes = accessorType.parameterTypes();
+	m_context.adjustStackOffset(1 + CompilerUtils::sizeOnStack(paramTypes));
 
 	// retrieve the position of the variable
 	auto const& location = m_context.storageLocationOfVariable(_varDecl);
-- 
cgit v1.2.3


From 8b0c866f025f3b48db36b0e48451062806a1ab06 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 26 Jun 2017 12:49:05 +0100
Subject: Add hasHexPrefix() to AST::Literal

---
 libsolidity/analysis/TypeChecker.cpp |  2 +-
 libsolidity/ast/AST.cpp              | 18 ++++++++++++------
 libsolidity/ast/AST.h                |  3 +++
 3 files changed, 16 insertions(+), 7 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index b276a2d4..436d960b 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -1886,7 +1886,7 @@ void TypeChecker::expectType(Expression const& _expression, Type const& _expecte
 	{
 		auto literal = dynamic_cast<Literal const*>(&_expression);
 
-		if (literal && !boost::starts_with(literal->value(), "0x"))
+		if (literal && !literal->hasHexPrefix())
 			m_errorReporter.warning(
 				_expression.location(),
 				"Decimal literal assigned to bytesXX variable will be left-aligned. "
diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index b929b6fe..54ded609 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -530,20 +530,26 @@ IdentifierAnnotation& Identifier::annotation() const
 	return dynamic_cast<IdentifierAnnotation&>(*m_annotation);
 }
 
+bool Literal::hasHexPrefix() const
+{
+	if (token() != Token::Number)
+		return false;
+	return value().substr(0, 2) == "0x";
+}
+
 bool Literal::looksLikeAddress() const
 {
 	if (subDenomination() != SubDenomination::None)
 		return false;
-	if (token() != Token::Number)
+
+	if (!hasHexPrefix())
 		return false;
 
-	string lit = value();
-	return lit.substr(0, 2) == "0x" && abs(int(lit.length()) - 42) <= 1;
+	return abs(int(value().length()) - 42) <= 1;
 }
 
 bool Literal::passesAddressChecksum() const
 {
-	string lit = value();
-	solAssert(lit.substr(0, 2) == "0x", "Expected hex prefix");
-	return dev::passesAddressChecksum(lit, true);
+	solAssert(hasHexPrefix(), "Expected hex prefix");
+	return dev::passesAddressChecksum(value(), true);
 }
diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index 83572692..24b16176 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -1590,6 +1590,9 @@ public:
 
 	SubDenomination subDenomination() const { return m_subDenomination; }
 
+	/// @returns true if this is a number with a hex prefix.
+	bool hasHexPrefix() const;
+
 	/// @returns true if this looks like a checksummed address.
 	bool looksLikeAddress() const;
 	/// @returns true if it passes the address checksum test.
-- 
cgit v1.2.3


From ef9a7b2144993e097da6bde7675abd5651bf64cc Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Tue, 27 Jun 2017 14:29:04 +0200
Subject: Stack adjustment and code generation for fallback function.

This assumes that the fallback function does not have return parameters.
---
 libsolidity/codegen/ContractCompiler.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index 61a90050..b6352b39 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -271,13 +271,15 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 		if (!fallback->isPayable())
 			appendCallValueCheck();
 
+		// Return tag is used to jump out of the function.
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
 		fallback->accept(*this);
 		m_context << returnTag;
-		m_context.adjustStackOffset(
-			CompilerUtils(m_context).sizeOnStack(FunctionType(*fallback).returnParameterTypes()) - 1
-		);
-		appendReturnValuePacker(FunctionType(*fallback).returnParameterTypes(), _contract.isLibrary());
+		solAssert(FunctionType(*fallback).parameterTypes().empty(), "");
+		solAssert(FunctionType(*fallback).returnParameterTypes().empty(), "");
+		// Return tag gets consumed.
+		m_context.adjustStackOffset(-1);
+		m_context << Instruction::STOP;
 	}
 	else
 		m_context.appendRevert();
-- 
cgit v1.2.3


From 6a708b0cfe245499f85f7260f7267b399c9a7fcb Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 28 Jun 2017 16:55:20 +0100
Subject: Document appendFunctionSelector

---
 libsolidity/codegen/ContractCompiler.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index b6352b39..74b07d4d 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -297,16 +297,20 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 		if (!functionType->isPayable() && !_contract.isLibrary())
 			appendCallValueCheck();
 
+		// Return tag is used to jump out of the function.
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
+		// Parameter for calldataUnpacker
 		m_context << CompilerUtils::dataStartOffset;
 		appendCalldataUnpacker(functionType->parameterTypes());
 		m_context.appendJumpTo(m_context.functionEntryLabel(functionType->declaration()));
 		m_context << returnTag;
+		// Return tag and input parameters get consumed.
 		m_context.adjustStackOffset(
 			CompilerUtils(m_context).sizeOnStack(functionType->returnParameterTypes()) -
 			CompilerUtils(m_context).sizeOnStack(functionType->parameterTypes()) -
 			1
 		);
+		// Consumes the return parameters.
 		appendReturnValuePacker(functionType->returnParameterTypes(), _contract.isLibrary());
 	}
 }
-- 
cgit v1.2.3


From 06fe61f89bc3f576176a665b851d9b95f9175618 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 28 Jun 2017 16:59:34 +0100
Subject: Rename to isHexNumber()

---
 libsolidity/analysis/TypeChecker.cpp | 2 +-
 libsolidity/ast/AST.cpp              | 6 +++---
 libsolidity/ast/AST.h                | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 436d960b..1563467c 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -1886,7 +1886,7 @@ void TypeChecker::expectType(Expression const& _expression, Type const& _expecte
 	{
 		auto literal = dynamic_cast<Literal const*>(&_expression);
 
-		if (literal && !literal->hasHexPrefix())
+		if (literal && !literal->isHexNumber())
 			m_errorReporter.warning(
 				_expression.location(),
 				"Decimal literal assigned to bytesXX variable will be left-aligned. "
diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index 54ded609..2df31eed 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -530,7 +530,7 @@ IdentifierAnnotation& Identifier::annotation() const
 	return dynamic_cast<IdentifierAnnotation&>(*m_annotation);
 }
 
-bool Literal::hasHexPrefix() const
+bool Literal::isHexNumber() const
 {
 	if (token() != Token::Number)
 		return false;
@@ -542,7 +542,7 @@ bool Literal::looksLikeAddress() const
 	if (subDenomination() != SubDenomination::None)
 		return false;
 
-	if (!hasHexPrefix())
+	if (!isHexNumber())
 		return false;
 
 	return abs(int(value().length()) - 42) <= 1;
@@ -550,6 +550,6 @@ bool Literal::looksLikeAddress() const
 
 bool Literal::passesAddressChecksum() const
 {
-	solAssert(hasHexPrefix(), "Expected hex prefix");
+	solAssert(isHexNumber(), "Expected hex number");
 	return dev::passesAddressChecksum(value(), true);
 }
diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index 24b16176..e8831dc0 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -1591,7 +1591,7 @@ public:
 	SubDenomination subDenomination() const { return m_subDenomination; }
 
 	/// @returns true if this is a number with a hex prefix.
-	bool hasHexPrefix() const;
+	bool isHexNumber() const;
 
 	/// @returns true if this looks like a checksummed address.
 	bool looksLikeAddress() const;
-- 
cgit v1.2.3


From c70d73809a6b36305f65e4ecb68acc3f63c7b304 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 28 Jun 2017 17:00:14 +0100
Subject: Use boost::starts_with

---
 libsolidity/ast/AST.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index 2df31eed..403f4b79 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -534,7 +534,7 @@ bool Literal::isHexNumber() const
 {
 	if (token() != Token::Number)
 		return false;
-	return value().substr(0, 2) == "0x";
+	return boost::starts_with(value(), "0x");
 }
 
 bool Literal::looksLikeAddress() const
-- 
cgit v1.2.3


From 71d866cd7ab8013f36ab5b01d849a74b9908aae0 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 30 Jun 2017 14:09:35 +0200
Subject: Abort early if there is nothing to encode or decode.

---
 libsolidity/codegen/CompilerUtils.cpp    | 3 +++
 libsolidity/codegen/ContractCompiler.cpp | 9 ++++++---
 2 files changed, 9 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 4edec155..a105036f 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -180,6 +180,9 @@ void CompilerUtils::encodeToMemory(
 		t = t->mobileType()->interfaceType(_encodeAsLibraryTypes)->encodingType();
 	}
 
+	if (_givenTypes.empty())
+		return;
+
 	// Stack during operation:
 	// <v1> <v2> ... <vn> <mem_start> <dyn_head_1> ... <dyn_head_r> <end_of_mem>
 	// The values dyn_head_i are added during the first loop and they point to the head part
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index 74b07d4d..c358a519 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -299,9 +299,12 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 
 		// Return tag is used to jump out of the function.
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
-		// Parameter for calldataUnpacker
-		m_context << CompilerUtils::dataStartOffset;
-		appendCalldataUnpacker(functionType->parameterTypes());
+		if (!functionType->parameterTypes().empty())
+		{
+			// Parameter for calldataUnpacker
+			m_context << CompilerUtils::dataStartOffset;
+			appendCalldataUnpacker(functionType->parameterTypes());
+		}
 		m_context.appendJumpTo(m_context.functionEntryLabel(functionType->declaration()));
 		m_context << returnTag;
 		// Return tag and input parameters get consumed.
-- 
cgit v1.2.3


From 044058276ea27b3d43622b28416ad4dc41091a31 Mon Sep 17 00:00:00 2001
From: chriseth <chris@ethereum.org>
Date: Fri, 30 Jun 2017 16:37:08 +0200
Subject: Warn about callcode.

---
 libsolidity/analysis/StaticAnalyzer.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/StaticAnalyzer.cpp b/libsolidity/analysis/StaticAnalyzer.cpp
index 375e9bde..b1b31163 100644
--- a/libsolidity/analysis/StaticAnalyzer.cpp
+++ b/libsolidity/analysis/StaticAnalyzer.cpp
@@ -123,6 +123,14 @@ bool StaticAnalyzer::visit(MemberAccess const& _memberAccess)
 					"\"msg.value\" used in non-payable function. Do you want to add the \"payable\" modifier to this function?"
 				);
 
+	if (_memberAccess.memberName() == "callcode")
+		if (auto const* type = dynamic_cast<FunctionType const*>(_memberAccess.annotation().type.get()))
+			if (type->kind() == FunctionType::Kind::BareCallCode)
+				m_errorReporter.warning(
+					_memberAccess.location(),
+					"\"callcode\" has been deprecated in favour of \"delegatecall\"."
+				);
+
 	return true;
 }
 
-- 
cgit v1.2.3


From d4fecc7b11586a108578a1834b634981bc854f91 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Tue, 13 Jun 2017 19:10:26 +0100
Subject: Warn on JUMP/JUMPI in inline assembly

---
 libsolidity/inlineasm/AsmAnalysis.cpp | 13 ++++++++++---
 libsolidity/inlineasm/AsmAnalysis.h   |  2 +-
 2 files changed, 11 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmAnalysis.cpp b/libsolidity/inlineasm/AsmAnalysis.cpp
index b0d044ae..7e00ffae 100644
--- a/libsolidity/inlineasm/AsmAnalysis.cpp
+++ b/libsolidity/inlineasm/AsmAnalysis.cpp
@@ -65,7 +65,7 @@ bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
 	auto const& info = instructionInfo(_instruction.instruction);
 	m_stackHeight += info.ret - info.args;
 	m_info.stackHeightInfo[&_instruction] = m_stackHeight;
-	warnOnFutureInstruction(_instruction.instruction, _instruction.location);
+	warnOnInstructions(_instruction.instruction, _instruction.location);
 	return true;
 }
 
@@ -150,7 +150,6 @@ bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
 	if (!(*this)(_instr.instruction))
 		success = false;
 	m_info.stackHeightInfo[&_instr] = m_stackHeight;
-	warnOnFutureInstruction(_instr.instruction.instruction, _instr.location);
 	return success;
 }
 
@@ -470,7 +469,7 @@ void AsmAnalyzer::expectValidType(string const& type, SourceLocation const& _loc
 		);
 }
 
-void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location)
+void AsmAnalyzer::warnOnInstructions(solidity::Instruction _instr, SourceLocation const& _location)
 {
 	static set<solidity::Instruction> futureInstructions{
 		solidity::Instruction::CREATE2,
@@ -486,4 +485,12 @@ void AsmAnalyzer::warnOnFutureInstruction(solidity::Instruction _instr, SourceLo
 			+ "\" instruction is only available after " +
 			"the Metropolis hard fork. Before that it acts as an invalid instruction."
 		);
+
+	if (_instr == solidity::Instruction::JUMP || _instr == solidity::Instruction::JUMPI)
+		m_errorReporter.warning(
+			_location,
+			"Jump instructions are low-level EVM features that can lead to "
+			"incorrect stack access. Because of that they are discouraged. "
+			"Please consider using \"switch\" or \"for\" statements instead."
+		);
 }
diff --git a/libsolidity/inlineasm/AsmAnalysis.h b/libsolidity/inlineasm/AsmAnalysis.h
index 76d2eba1..9b2a8f9c 100644
--- a/libsolidity/inlineasm/AsmAnalysis.h
+++ b/libsolidity/inlineasm/AsmAnalysis.h
@@ -85,7 +85,7 @@ private:
 
 	Scope& scope(assembly::Block const* _block);
 	void expectValidType(std::string const& type, SourceLocation const& _location);
-	void warnOnFutureInstruction(solidity::Instruction _instr, SourceLocation const& _location);
+	void warnOnInstructions(solidity::Instruction _instr, SourceLocation const& _location);
 
 	int m_stackHeight = 0;
 	julia::ExternalIdentifierAccess::Resolver m_resolver;
-- 
cgit v1.2.3


From c5947ae6e314fc66612846a760bafe4467414c6b Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 30 Jun 2017 22:30:43 +0100
Subject: Remove Why3 error class

---
 libsolidity/interface/ErrorReporter.cpp | 19 -------------------
 libsolidity/interface/ErrorReporter.h   |  4 ----
 libsolidity/interface/Exceptions.cpp    |  3 ---
 libsolidity/interface/Exceptions.h      |  1 -
 4 files changed, 27 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/ErrorReporter.cpp b/libsolidity/interface/ErrorReporter.cpp
index 2cbb952c..6e2667a5 100644
--- a/libsolidity/interface/ErrorReporter.cpp
+++ b/libsolidity/interface/ErrorReporter.cpp
@@ -165,22 +165,3 @@ void ErrorReporter::docstringParsingError(string const& _description)
 		_description
 	);
 }
-
-void ErrorReporter::why3TranslatorError(ASTNode const& _location, std::string const& _description)
-{
-	error(
-		Error::Type::Why3TranslatorError,
-		_location.location(),
-		_description
-	);
-}
-
-void ErrorReporter::fatalWhy3TranslatorError(ASTNode const& _location, std::string const& _description)
-{
-	fatalError(
-		Error::Type::Why3TranslatorError,
-		_location.location(),
-		_description
-	);
-}
-
diff --git a/libsolidity/interface/ErrorReporter.h b/libsolidity/interface/ErrorReporter.h
index 83324446..e5605d24 100644
--- a/libsolidity/interface/ErrorReporter.h
+++ b/libsolidity/interface/ErrorReporter.h
@@ -79,10 +79,6 @@ public:
 
 	void docstringParsingError(std::string const& _location);
 
-	void why3TranslatorError(ASTNode const& _location, std::string const& _description);
-
-	void fatalWhy3TranslatorError(ASTNode const& _location, std::string const& _description);
-
 	ErrorList const& errors() const;
 
 	void clear();
diff --git a/libsolidity/interface/Exceptions.cpp b/libsolidity/interface/Exceptions.cpp
index deee92aa..9f2a2d06 100644
--- a/libsolidity/interface/Exceptions.cpp
+++ b/libsolidity/interface/Exceptions.cpp
@@ -46,9 +46,6 @@ Error::Error(Type _type, SourceLocation const& _location, string const& _descrip
 	case Type::TypeError:
 		m_typeName = "TypeError";
 		break;
-	case Type::Why3TranslatorError:
-		m_typeName = "Why3TranslatorError";
-		break;
 	case Type::Warning:
 		m_typeName = "Warning";
 		break;
diff --git a/libsolidity/interface/Exceptions.h b/libsolidity/interface/Exceptions.h
index 5fdb8f11..09301b10 100644
--- a/libsolidity/interface/Exceptions.h
+++ b/libsolidity/interface/Exceptions.h
@@ -60,7 +60,6 @@ public:
 		ParserError,
 		TypeError,
 		SyntaxError,
-		Why3TranslatorError,
 		Warning
 	};
 
-- 
cgit v1.2.3


From a46b3479bb0ccba26566eecd1824450ab4cadf1d Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 30 Jun 2017 22:34:03 +0100
Subject: Remove parsing of why3 doc strings

---
 libsolidity/analysis/DocStringAnalyser.cpp | 12 +-----------
 libsolidity/analysis/DocStringAnalyser.h   |  2 --
 2 files changed, 1 insertion(+), 13 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/analysis/DocStringAnalyser.cpp b/libsolidity/analysis/DocStringAnalyser.cpp
index 6a8fa08e..9a846b31 100644
--- a/libsolidity/analysis/DocStringAnalyser.cpp
+++ b/libsolidity/analysis/DocStringAnalyser.cpp
@@ -40,7 +40,7 @@ bool DocStringAnalyser::analyseDocStrings(SourceUnit const& _sourceUnit)
 
 bool DocStringAnalyser::visit(ContractDefinition const& _node)
 {
-	static const set<string> validTags = set<string>{"author", "title", "dev", "notice", "why3"};
+	static const set<string> validTags = set<string>{"author", "title", "dev", "notice"};
 	parseDocStrings(_node, _node.annotation(), validTags, "contracts");
 
 	return true;
@@ -66,16 +66,6 @@ bool DocStringAnalyser::visit(EventDefinition const& _node)
 	return true;
 }
 
-bool DocStringAnalyser::visitNode(ASTNode const& _node)
-{
-	if (auto node = dynamic_cast<Statement const*>(&_node))
-	{
-		static const set<string> validTags = {"why3"};
-		parseDocStrings(*node, node->annotation(), validTags, "statements");
-	}
-	return true;
-}
-
 void DocStringAnalyser::handleCallable(
 	CallableDeclaration const& _callable,
 	Documented const& _node,
diff --git a/libsolidity/analysis/DocStringAnalyser.h b/libsolidity/analysis/DocStringAnalyser.h
index e871cb60..158b4060 100644
--- a/libsolidity/analysis/DocStringAnalyser.h
+++ b/libsolidity/analysis/DocStringAnalyser.h
@@ -48,8 +48,6 @@ private:
 	virtual bool visit(ModifierDefinition const& _modifier) override;
 	virtual bool visit(EventDefinition const& _event) override;
 
-	virtual bool visitNode(ASTNode const&) override;
-
 	void handleCallable(
 		CallableDeclaration const& _callable,
 		Documented const& _node,
-- 
cgit v1.2.3


From a33a5e3c0846e7db8d87fdd5de890a63d359581d Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 13:55:17 +0100
Subject: Run analyzer in Julia mode if requested in AssemblyStack

---
 libsolidity/interface/AssemblyStack.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index 2d85895e..7cda096e 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -72,7 +72,7 @@ bool AssemblyStack::analyze(assembly::Block const& _block, Scanner const* _scann
 bool AssemblyStack::analyzeParsed()
 {
 	m_analysisInfo = make_shared<assembly::AsmAnalysisInfo>();
-	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errorReporter);
+	assembly::AsmAnalyzer analyzer(*m_analysisInfo, m_errorReporter, m_language == Language::JULIA);
 	m_analysisSuccessful = analyzer.analyze(*m_parserResult);
 	return m_analysisSuccessful;
 }
-- 
cgit v1.2.3


From 0494fa98c0c973bf9e8b3dfa4873e1b5744e7715 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 21 Nov 2016 12:23:43 +0000
Subject: Add shift helper to CompilerUtils

---
 libsolidity/codegen/CompilerUtils.cpp | 10 ++++++++++
 libsolidity/codegen/CompilerUtils.h   |  6 ++++++
 2 files changed, 16 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index a105036f..1da21607 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -1007,6 +1007,16 @@ void CompilerUtils::cleanHigherOrderBits(IntegerType const& _typeOnStack)
 		m_context << ((u256(1) << _typeOnStack.numBits()) - 1) << Instruction::AND;
 }
 
+void CompilerUtils::leftShiftNumberOnStack(u256 _shiftFactor)
+{
+	m_context << _shiftFactor << Instruction::MUL;
+}
+
+void CompilerUtils::rightShiftNumberOnStack(u256 _shiftFactor, bool _isSigned)
+{
+	m_context << _shiftFactor << Instruction::SWAP1 << (_isSigned ? Instruction::SDIV : Instruction::DIV);
+}
+
 unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWords)
 {
 	unsigned numBytes = _type.calldataEncodedSize(_padToWords);
diff --git a/libsolidity/codegen/CompilerUtils.h b/libsolidity/codegen/CompilerUtils.h
index 0ee053a9..278f9302 100644
--- a/libsolidity/codegen/CompilerUtils.h
+++ b/libsolidity/codegen/CompilerUtils.h
@@ -176,6 +176,12 @@ public:
 	static unsigned sizeOnStack(std::vector<T> const& _variables);
 	static unsigned sizeOnStack(std::vector<std::shared_ptr<Type const>> const& _variableTypes);
 
+	/// Helper function to shift top value on the stack to the left.
+	void leftShiftNumberOnStack(u256 _shiftFactor);
+
+	/// Helper function to shift top value on the stack to the right.
+	void rightShiftNumberOnStack(u256 _shiftFactor, bool _isSigned = false);
+
 	/// Appends code that computes tha Keccak-256 hash of the topmost stack element of 32 byte type.
 	void computeHashStatic();
 
-- 
cgit v1.2.3


From c7ae042114e50ceccd2c230abf80ac7b246d0a44 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 21 Nov 2016 12:23:51 +0000
Subject: Use shift helper

---
 libsolidity/codegen/CompilerUtils.cpp      | 12 ++++++------
 libsolidity/codegen/ExpressionCompiler.cpp |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 1da21607..4d8f32ca 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -371,10 +371,10 @@ void CompilerUtils::combineExternalFunctionType(bool _leftAligned)
 	m_context << u256(0xffffffffUL) << Instruction::AND << Instruction::SWAP1;
 	if (!_leftAligned)
 		m_context << ((u256(1) << 160) - 1) << Instruction::AND;
-	m_context << (u256(1) << 32) << Instruction::MUL;
+	leftShiftNumberOnStack(u256(1) << 32);
 	m_context << Instruction::OR;
 	if (_leftAligned)
-		m_context << (u256(1) << 64) << Instruction::MUL;
+		leftShiftNumberOnStack(u256(1) << 64);
 }
 
 void CompilerUtils::pushCombinedFunctionEntryLabel(Declaration const& _function)
@@ -425,7 +425,7 @@ void CompilerUtils::convertType(
 			// conversion from bytes to integer. no need to clean the high bit
 			// only to shift right because of opposite alignment
 			IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType);
-			m_context << (u256(1) << (256 - typeOnStack.numBytes() * 8)) << Instruction::SWAP1 << Instruction::DIV;
+			rightShiftNumberOnStack(u256(1) << (256 - typeOnStack.numBytes() * 8), false);
 			if (targetIntegerType.numBits() < typeOnStack.numBytes() * 8)
 				convertType(IntegerType(typeOnStack.numBytes() * 8), _targetType, _cleanupNeeded);
 		}
@@ -476,7 +476,7 @@ void CompilerUtils::convertType(
 			if (auto typeOnStack = dynamic_cast<IntegerType const*>(&_typeOnStack))
 				if (targetBytesType.numBytes() * 8 > typeOnStack->numBits())
 					cleanHigherOrderBits(*typeOnStack);
-			m_context << (u256(1) << (256 - targetBytesType.numBytes() * 8)) << Instruction::MUL;
+			leftShiftNumberOnStack(u256(1) << (256 - targetBytesType.numBytes() * 8));
 		}
 		else if (targetTypeCategory == Type::Category::Enum)
 		{
@@ -987,9 +987,9 @@ unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCallda
 		bool leftAligned = _type.category() == Type::Category::FixedBytes;
 		// add leading or trailing zeros by dividing/multiplying depending on alignment
 		u256 shiftFactor = u256(1) << ((32 - numBytes) * 8);
-		m_context << shiftFactor << Instruction::SWAP1 << Instruction::DIV;
+		rightShiftNumberOnStack(shiftFactor, false);
 		if (leftAligned)
-			m_context << shiftFactor << Instruction::MUL;
+			leftShiftNumberOnStack(shiftFactor);
 	}
 	if (_fromCalldata)
 		convertType(_type, _type, true, false, true);
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index 9d4024c9..d3586443 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -526,7 +526,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 
 			if (m_context.runtimeContext())
 				// We have a runtime context, so we need the creation part.
-				m_context << (u256(1) << 32) << Instruction::SWAP1 << Instruction::DIV;
+				utils().rightShiftNumberOnStack(u256(1) << 32, false);
 			else
 				// Extract the runtime part.
 				m_context << ((u256(1) << 32) - 1) << Instruction::AND;
@@ -1269,7 +1269,7 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 		m_context.appendConditionalInvalid();
 
 		m_context << Instruction::BYTE;
-		m_context << (u256(1) << (256 - 8)) << Instruction::MUL;
+		utils().leftShiftNumberOnStack(u256(1) << (256 - 8));
 	}
 	else if (baseType.category() == Type::Category::TypeType)
 	{
-- 
cgit v1.2.3


From 8fd1d4167d2d05363ecf6af7ada42da940199900 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Wed, 30 Nov 2016 10:03:26 +0000
Subject: Change shiftNumberOnStack to bits

---
 libsolidity/codegen/CompilerUtils.cpp      | 18 +++++++++---------
 libsolidity/codegen/CompilerUtils.h        |  4 ++--
 libsolidity/codegen/ExpressionCompiler.cpp |  4 ++--
 3 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 4d8f32ca..8ea86684 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -371,10 +371,10 @@ void CompilerUtils::combineExternalFunctionType(bool _leftAligned)
 	m_context << u256(0xffffffffUL) << Instruction::AND << Instruction::SWAP1;
 	if (!_leftAligned)
 		m_context << ((u256(1) << 160) - 1) << Instruction::AND;
-	leftShiftNumberOnStack(u256(1) << 32);
+	leftShiftNumberOnStack(32);
 	m_context << Instruction::OR;
 	if (_leftAligned)
-		leftShiftNumberOnStack(u256(1) << 64);
+		leftShiftNumberOnStack(64);
 }
 
 void CompilerUtils::pushCombinedFunctionEntryLabel(Declaration const& _function)
@@ -425,7 +425,7 @@ void CompilerUtils::convertType(
 			// conversion from bytes to integer. no need to clean the high bit
 			// only to shift right because of opposite alignment
 			IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType);
-			rightShiftNumberOnStack(u256(1) << (256 - typeOnStack.numBytes() * 8), false);
+			rightShiftNumberOnStack(256 - typeOnStack.numBytes() * 8, false);
 			if (targetIntegerType.numBits() < typeOnStack.numBytes() * 8)
 				convertType(IntegerType(typeOnStack.numBytes() * 8), _targetType, _cleanupNeeded);
 		}
@@ -476,7 +476,7 @@ void CompilerUtils::convertType(
 			if (auto typeOnStack = dynamic_cast<IntegerType const*>(&_typeOnStack))
 				if (targetBytesType.numBytes() * 8 > typeOnStack->numBits())
 					cleanHigherOrderBits(*typeOnStack);
-			leftShiftNumberOnStack(u256(1) << (256 - targetBytesType.numBytes() * 8));
+			leftShiftNumberOnStack(256 - targetBytesType.numBytes() * 8);
 		}
 		else if (targetTypeCategory == Type::Category::Enum)
 		{
@@ -986,7 +986,7 @@ unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCallda
 	{
 		bool leftAligned = _type.category() == Type::Category::FixedBytes;
 		// add leading or trailing zeros by dividing/multiplying depending on alignment
-		u256 shiftFactor = u256(1) << ((32 - numBytes) * 8);
+		int shiftFactor = (32 - numBytes) * 8;
 		rightShiftNumberOnStack(shiftFactor, false);
 		if (leftAligned)
 			leftShiftNumberOnStack(shiftFactor);
@@ -1007,14 +1007,14 @@ void CompilerUtils::cleanHigherOrderBits(IntegerType const& _typeOnStack)
 		m_context << ((u256(1) << _typeOnStack.numBits()) - 1) << Instruction::AND;
 }
 
-void CompilerUtils::leftShiftNumberOnStack(u256 _shiftFactor)
+void CompilerUtils::leftShiftNumberOnStack(unsigned _bits)
 {
-	m_context << _shiftFactor << Instruction::MUL;
+	m_context << (u256(1) << _bits) << Instruction::MUL;
 }
 
-void CompilerUtils::rightShiftNumberOnStack(u256 _shiftFactor, bool _isSigned)
+void CompilerUtils::rightShiftNumberOnStack(unsigned _bits, bool _isSigned)
 {
-	m_context << _shiftFactor << Instruction::SWAP1 << (_isSigned ? Instruction::SDIV : Instruction::DIV);
+	m_context << (u256(1) << _bits) << Instruction::SWAP1 << (_isSigned ? Instruction::SDIV : Instruction::DIV);
 }
 
 unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWords)
diff --git a/libsolidity/codegen/CompilerUtils.h b/libsolidity/codegen/CompilerUtils.h
index 278f9302..fb169463 100644
--- a/libsolidity/codegen/CompilerUtils.h
+++ b/libsolidity/codegen/CompilerUtils.h
@@ -177,10 +177,10 @@ public:
 	static unsigned sizeOnStack(std::vector<std::shared_ptr<Type const>> const& _variableTypes);
 
 	/// Helper function to shift top value on the stack to the left.
-	void leftShiftNumberOnStack(u256 _shiftFactor);
+	void leftShiftNumberOnStack(unsigned _bits);
 
 	/// Helper function to shift top value on the stack to the right.
-	void rightShiftNumberOnStack(u256 _shiftFactor, bool _isSigned = false);
+	void rightShiftNumberOnStack(unsigned _bits, bool _isSigned = false);
 
 	/// Appends code that computes tha Keccak-256 hash of the topmost stack element of 32 byte type.
 	void computeHashStatic();
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index d3586443..82518e8c 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -526,7 +526,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 
 			if (m_context.runtimeContext())
 				// We have a runtime context, so we need the creation part.
-				utils().rightShiftNumberOnStack(u256(1) << 32, false);
+				utils().rightShiftNumberOnStack(32, false);
 			else
 				// Extract the runtime part.
 				m_context << ((u256(1) << 32) - 1) << Instruction::AND;
@@ -1269,7 +1269,7 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 		m_context.appendConditionalInvalid();
 
 		m_context << Instruction::BYTE;
-		utils().leftShiftNumberOnStack(u256(1) << (256 - 8));
+		utils().leftShiftNumberOnStack(256 - 8);
 	}
 	else if (baseType.category() == Type::Category::TypeType)
 	{
-- 
cgit v1.2.3


From 68b0ac4fdd86b02d9a12c762b5cf57d5873da82a Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Sun, 12 Feb 2017 14:48:46 +0000
Subject: More uses of shift helper

---
 libsolidity/codegen/CompilerUtils.cpp | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 8ea86684..94be90ab 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -353,13 +353,16 @@ void CompilerUtils::splitExternalFunctionType(bool _leftAligned)
 	// address (right aligned), function identifier (right aligned)
 	if (_leftAligned)
 	{
-		m_context << Instruction::DUP1 << (u256(1) << (64 + 32)) << Instruction::SWAP1 << Instruction::DIV;
+		m_context << Instruction::DUP1;
+		rightShiftNumberOnStack(64 + 32, false);
 		// <input> <address>
-		m_context << Instruction::SWAP1 << (u256(1) << 64) << Instruction::SWAP1 << Instruction::DIV;
+		m_context << Instruction::SWAP1;
+		rightShiftNumberOnStack(64, false);
 	}
 	else
 	{
-		m_context << Instruction::DUP1 << (u256(1) << 32) << Instruction::SWAP1 << Instruction::DIV;
+		m_context << Instruction::DUP1;
+		rightShiftNumberOnStack(32, false);
 		m_context << ((u256(1) << 160) - 1) << Instruction::AND << Instruction::SWAP1;
 	}
 	m_context << u256(0xffffffffUL) << Instruction::AND;
@@ -383,11 +386,12 @@ void CompilerUtils::pushCombinedFunctionEntryLabel(Declaration const& _function)
 	// If there is a runtime context, we have to merge both labels into the same
 	// stack slot in case we store it in storage.
 	if (CompilerContext* rtc = m_context.runtimeContext())
+	{
+		leftShiftNumberOnStack(32);
 		m_context <<
-			(u256(1) << 32) <<
-			Instruction::MUL <<
 			rtc->functionEntryLabel(_function).toSubAssemblyTag(m_context.runtimeSub()) <<
 			Instruction::OR;
+	}
 }
 
 void CompilerUtils::convertType(
@@ -1029,7 +1033,7 @@ unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWords)
 		convertType(_type, _type, true);
 		if (numBytes != 32 && !leftAligned && !_padToWords)
 			// shift the value accordingly before storing
-			m_context << (u256(1) << ((32 - numBytes) * 8)) << Instruction::MUL;
+			leftShiftNumberOnStack((32 - numBytes) * 8);
 	}
 	return numBytes;
 }
-- 
cgit v1.2.3


From d2612655956f88938faba30bd00c9531a69142b4 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Thu, 15 Jun 2017 13:02:05 +0100
Subject: Use shift helper in LValue

---
 libsolidity/codegen/LValue.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/LValue.cpp b/libsolidity/codegen/LValue.cpp
index a74a3d74..e19cf41e 100644
--- a/libsolidity/codegen/LValue.cpp
+++ b/libsolidity/codegen/LValue.cpp
@@ -186,7 +186,7 @@ void StorageItem::retrieveValue(SourceLocation const&, bool _remove) const
 			solUnimplemented("Not yet implemented - FixedPointType.");
 		if (m_dataType->category() == Type::Category::FixedBytes)
 		{
-			m_context << (u256(0x1) << (256 - 8 * m_dataType->storageBytes())) << Instruction::MUL;
+			CompilerUtils(m_context).leftShiftNumberOnStack(256 - 8 * m_dataType->storageBytes());
 			cleaned = true;
 		}
 		else if (
@@ -267,9 +267,7 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc
 			else if (m_dataType->category() == Type::Category::FixedBytes)
 			{
 				solAssert(_sourceType.category() == Type::Category::FixedBytes, "source not fixed bytes");
-				m_context
-					<< (u256(0x1) << (256 - 8 * dynamic_cast<FixedBytesType const&>(*m_dataType).numBytes()))
-					<< Instruction::SWAP1 << Instruction::DIV;
+				CompilerUtils(m_context).rightShiftNumberOnStack(256 - 8 * dynamic_cast<FixedBytesType const&>(*m_dataType).numBytes(), false);
 			}
 			else
 			{
-- 
cgit v1.2.3


From 677700d5ac1c5079aa20a6a9e5667c7e8596da27 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Sat, 1 Jul 2017 11:48:12 +0100
Subject: Add assert to shift helper

---
 libsolidity/codegen/CompilerUtils.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'libsolidity')

diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index 94be90ab..7067ddd5 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -1013,11 +1013,13 @@ void CompilerUtils::cleanHigherOrderBits(IntegerType const& _typeOnStack)
 
 void CompilerUtils::leftShiftNumberOnStack(unsigned _bits)
 {
+	solAssert(_bits < 256, "");
 	m_context << (u256(1) << _bits) << Instruction::MUL;
 }
 
 void CompilerUtils::rightShiftNumberOnStack(unsigned _bits, bool _isSigned)
 {
+	solAssert(_bits < 256, "");
 	m_context << (u256(1) << _bits) << Instruction::SWAP1 << (_isSigned ? Instruction::SDIV : Instruction::DIV);
 }
 
-- 
cgit v1.2.3


From 7798a2711213823de409577226f2f1c7f7f2e861 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Fri, 9 Jun 2017 14:38:23 +0100
Subject: Add Julia mode as an option to EVMCodeTransform

---
 libsolidity/inlineasm/AsmCodeGen.cpp    | 3 +--
 libsolidity/interface/AssemblyStack.cpp | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 2bbd1b70..74743737 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -137,7 +137,6 @@ private:
 	eth::Assembly& m_assembly;
 };
 
-
 void assembly::CodeGenerator::assemble(
 	Block const& _parsedData,
 	AsmAnalysisInfo& _analysisInfo,
@@ -146,5 +145,5 @@ void assembly::CodeGenerator::assemble(
 )
 {
 	EthAssemblyAdapter assemblyAdapter(_assembly);
-	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, _identifierAccess)(_parsedData);
+	julia::CodeTransform(assemblyAdapter, _analysisInfo, false, false, _identifierAccess)(_parsedData);
 }
diff --git a/libsolidity/interface/AssemblyStack.cpp b/libsolidity/interface/AssemblyStack.cpp
index 7cda096e..23524bb3 100644
--- a/libsolidity/interface/AssemblyStack.cpp
+++ b/libsolidity/interface/AssemblyStack.cpp
@@ -100,7 +100,7 @@ MachineAssemblyObject AssemblyStack::assemble(Machine _machine) const
 	{
 		MachineAssemblyObject object;
 		julia::EVMAssembly assembly(true);
-		julia::CodeTransform(assembly, *m_analysisInfo, true)(*m_parserResult);
+		julia::CodeTransform(assembly, *m_analysisInfo, m_language == Language::JULIA, true)(*m_parserResult);
 		object.bytecode = make_shared<eth::LinkerObject>(assembly.finalize());
 		/// TOOD: fill out text representation
 		return object;
-- 
cgit v1.2.3


From 08069bf4a426247d8fa6fb0e1a2002a9ea2f9ded Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 3 Jul 2017 11:58:24 +0100
Subject: Export CompilerStack state

---
 libsolidity/interface/CompilerStack.h | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index c51ae9c9..03a1b806 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -77,6 +77,14 @@ enum class DocumentationType: uint8_t
 class CompilerStack: boost::noncopyable
 {
 public:
+	enum State {
+		Empty,
+		SourcesSet,
+		ParsingSuccessful,
+		AnalysisSuccessful,
+		CompilationSuccessful
+	};
+
 	/// Creates a new compiler stack.
 	/// @param _readFile callback to used to read files for import statements. Must return
 	/// and must not emit exceptions.
@@ -194,6 +202,8 @@ public:
 	/// @returns the list of errors that occured during parsing and type checking.
 	ErrorList const& errors() { return m_errorReporter.errors(); }
 
+	State state() const { return m_stackState; }
+
 private:
 	/**
 	 * Information pertaining to one source unit, filled gradually during parsing and compilation.
@@ -220,14 +230,6 @@ private:
 		mutable std::unique_ptr<std::string const> sourceMapping;
 		mutable std::unique_ptr<std::string const> runtimeSourceMapping;
 	};
-	enum State {
-		Empty,
-		SourcesSet,
-		ParsingSuccessful,
-		AnalysisSuccessful,
-		CompilationSuccessful
-	};
-
 	/// Loads the missing sources from @a _ast (named @a _path) using the callback
 	/// @a m_readFile and stores the absolute paths of all imports in the AST annotations.
 	/// @returns the newly loaded sources.
-- 
cgit v1.2.3


From 75c193e9595c290967d14a5e203f0a6192c10aa2 Mon Sep 17 00:00:00 2001
From: Alex Beregszaszi <alex@rtfs.hu>
Date: Mon, 3 Jul 2017 12:02:06 +0100
Subject: Use more refined states in StandardCompiler

---
 libsolidity/interface/StandardCompiler.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'libsolidity')

diff --git a/libsolidity/interface/StandardCompiler.cpp b/libsolidity/interface/StandardCompiler.cpp
index 2e5005b8..e677afc8 100644
--- a/libsolidity/interface/StandardCompiler.cpp
+++ b/libsolidity/interface/StandardCompiler.cpp
@@ -265,11 +265,9 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 
 	auto scannerFromSourceName = [&](string const& _sourceName) -> solidity::Scanner const& { return m_compilerStack.scanner(_sourceName); };
 
-	bool success = false;
-
 	try
 	{
-		success = m_compilerStack.compile(optimize, optimizeRuns, libraries);
+		m_compilerStack.compile(optimize, optimizeRuns, libraries);
 
 		for (auto const& error: m_compilerStack.errors())
 		{
@@ -359,13 +357,16 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 	if (errors.size() > 0)
 		output["errors"] = errors;
 
+	bool parsingSuccess = m_compilerStack.state() >= CompilerStack::State::ParsingSuccessful;
+	bool compilationSuccess = m_compilerStack.state() == CompilerStack::State::CompilationSuccessful;
+
 	/// Inconsistent state - stop here to receive error reports from users
-	if (!success && (errors.size() == 0))
+	if (!compilationSuccess && (errors.size() == 0))
 		return formatFatalError("InternalCompilerError", "No error reported, but compilation failed.");
 
 	output["sources"] = Json::objectValue;
 	unsigned sourceIndex = 0;
-	for (auto const& source: m_compilerStack.sourceNames())
+	for (auto const& source: parsingSuccess ? m_compilerStack.sourceNames() : vector<string>())
 	{
 		Json::Value sourceResult = Json::objectValue;
 		sourceResult["id"] = sourceIndex++;
@@ -375,7 +376,7 @@ Json::Value StandardCompiler::compileInternal(Json::Value const& _input)
 	}
 
 	Json::Value contractsOutput = Json::objectValue;
-	for (string const& contractName: success ? m_compilerStack.contractNames() : vector<string>())
+	for (string const& contractName: compilationSuccess ? m_compilerStack.contractNames() : vector<string>())
 	{
 		size_t colon = contractName.find(':');
 		solAssert(colon != string::npos, "");
-- 
cgit v1.2.3