Merge remote-tracking branch 'origin/develop' into release

37 files changed, 897 insertions, 274 deletions

diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp
index a7b9e8b8..a0768a34 100644
--- a/libsolidity/analysis/ReferencesResolver.cpp
+++ b/libsolidity/analysis/ReferencesResolver.cpp
@@ -83,6 +83,31 @@ void ReferencesResolver::endVisit(UserDefinedTypeName const& _typeName)
 		fatalTypeError(_typeName.location(), "Name has to refer to a struct, enum or contract.");
 }
 
+void ReferencesResolver::endVisit(FunctionTypeName const& _typeName)
+{
+	switch (_typeName.visibility())
+	{
+	case VariableDeclaration::Visibility::Default:
+	case VariableDeclaration::Visibility::Internal:
+	case VariableDeclaration::Visibility::External:
+		break;
+	default:
+		typeError(_typeName.location(), "Invalid visibility, can only be \"external\" or \"internal\".");
+	}
+
+	if (_typeName.isPayable() && _typeName.visibility() != VariableDeclaration::Visibility::External)
+		fatalTypeError(_typeName.location(), "Only external function types can be payable.");
+	if (_typeName.visibility() == VariableDeclaration::Visibility::External)
+		for (auto const& t: _typeName.parameterTypes() + _typeName.returnParameterTypes())
+		{
+			solAssert(t->annotation().type, "Type not set for parameter.");
+			if (!t->annotation().type->canBeUsedExternally(false))
+				fatalTypeError(t->location(), "Internal type cannot be used for external function type.");
+		}
+
+	_typeName.annotation().type = make_shared<FunctionType>(_typeName);
+}
+
 void ReferencesResolver::endVisit(Mapping const& _typeName)
 {
 	TypePointer keyType = _typeName.keyType().annotation().type;
diff --git a/libsolidity/analysis/ReferencesResolver.h b/libsolidity/analysis/ReferencesResolver.h
index 1986b2bb..bfaef2e1 100644
--- a/libsolidity/analysis/ReferencesResolver.h
+++ b/libsolidity/analysis/ReferencesResolver.h
@@ -62,6 +62,7 @@ private:
 	virtual bool visit(Identifier const& _identifier) override;
 	virtual bool visit(ElementaryTypeName const& _typeName) override;
 	virtual void endVisit(UserDefinedTypeName const& _typeName) override;
+	virtual void endVisit(FunctionTypeName const& _typeName) override;
 	virtual void endVisit(Mapping const& _typeName) override;
 	virtual void endVisit(ArrayTypeName const& _typeName) override;
 	virtual bool visit(InlineAssembly const& _inlineAssembly) override;
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index 46f4f7f6..8b6d45e2 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -574,6 +574,14 @@ bool TypeChecker::visit(EventDefinition const& _eventDef)
 	return false;
 }
 
+void TypeChecker::endVisit(FunctionTypeName const& _funType)
+{
+	FunctionType const& fun = dynamic_cast<FunctionType const&>(*_funType.annotation().type);
+	if (fun.location() == FunctionType::Location::External)
+		if (!fun.canBeUsedExternally(false))
+			typeError(_funType.location(), "External function type uses internal types.");
+}
+
 bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 {
 	// Inline assembly does not have its own type-checking phase, so we just run the
@@ -996,9 +1004,9 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 						fatalTypeError(components[i]->location(), "Invalid mobile type.");
 
 					if (i == 0)
-						inlineArrayType = types[i]->mobileType();
+						inlineArrayType = types[i];
 					else if (inlineArrayType)
-						inlineArrayType = Type::commonType(inlineArrayType, types[i]->mobileType());
+						inlineArrayType = Type::commonType(inlineArrayType, types[i]);
 				}
 			}
 			else
diff --git a/libsolidity/analysis/TypeChecker.h b/libsolidity/analysis/TypeChecker.h
index be1e02be..5874bb50 100644
--- a/libsolidity/analysis/TypeChecker.h
+++ b/libsolidity/analysis/TypeChecker.h
@@ -87,6 +87,7 @@ private:
 	/// case this is a base constructor call.
 	void visitManually(ModifierInvocation const& _modifier, std::vector<ContractDefinition const*> const& _bases);
 	virtual bool visit(EventDefinition const& _eventDef) override;
+	virtual void endVisit(FunctionTypeName const& _funType) override;
 	virtual bool visit(InlineAssembly const& _inlineAssembly) override;
 	virtual bool visit(IfStatement const& _ifStatement) override;
 	virtual bool visit(WhileStatement const& _whileStatement) override;
diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index 695d9881..305668e7 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -160,22 +160,22 @@ vector<pair<FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::inter
 	return *m_interfaceFunctionList;
 }
 
-string const& ContractDefinition::devDocumentation() const
+Json::Value const& ContractDefinition::devDocumentation() const
 {
 	return m_devDocumentation;
 }
 
-string const& ContractDefinition::userDocumentation() const
+Json::Value const& ContractDefinition::userDocumentation() const
 {
 	return m_userDocumentation;
 }
 
-void ContractDefinition::setDevDocumentation(string const& _devDocumentation)
+void ContractDefinition::setDevDocumentation(Json::Value const& _devDocumentation)
 {
 	m_devDocumentation = _devDocumentation;
 }
 
-void ContractDefinition::setUserDocumentation(string const& _userDocumentation)
+void ContractDefinition::setUserDocumentation(Json::Value const& _userDocumentation)
 {
 	m_userDocumentation = _userDocumentation;
 }
diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index 7ed4ddce..a2b70fe9 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -35,6 +35,7 @@
 #include <libsolidity/ast/Types.h>
 #include <libsolidity/interface/Exceptions.h>
 #include <libsolidity/ast/ASTAnnotations.h>
+#include <json/json.h>
 
 namespace dev
 {
@@ -343,11 +344,11 @@ public:
 	/// Returns the fallback function or nullptr if no fallback function was specified.
 	FunctionDefinition const* fallbackFunction() const;
 
-	std::string const& userDocumentation() const;
-	void setUserDocumentation(std::string const& _userDocumentation);
+	Json::Value const& userDocumentation() const;
+	void setUserDocumentation(Json::Value const& _userDocumentation);
 
-	std::string const& devDocumentation() const;
-	void setDevDocumentation(std::string const& _devDocumentation);
+	Json::Value const& devDocumentation() const;
+	void setDevDocumentation(Json::Value const& _devDocumentation);
 
 	virtual TypePointer type() const override;
 
@@ -359,8 +360,8 @@ private:
 	bool m_isLibrary;
 
 	// parsed Natspec documentation of the contract.
-	std::string m_userDocumentation;
-	std::string m_devDocumentation;
+	Json::Value m_userDocumentation;
+	Json::Value m_devDocumentation;
 
 	std::vector<ContractDefinition const*> m_linearizedBaseContracts;
 	mutable std::unique_ptr<std::vector<std::pair<FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList;
@@ -822,6 +823,41 @@ private:
 };
 
 /**
+ * A literal function type. Its source form is "function (paramType1, paramType2) internal / external returns (retType1, retType2)"
+ */
+class FunctionTypeName: public TypeName
+{
+public:
+	FunctionTypeName(
+		SourceLocation const& _location,
+		ASTPointer<ParameterList> const& _parameterTypes,
+		ASTPointer<ParameterList> const& _returnTypes,
+		Declaration::Visibility _visibility,
+		bool _isDeclaredConst,
+		bool _isPayable
+	):
+		TypeName(_location), m_parameterTypes(_parameterTypes), m_returnTypes(_returnTypes),
+		m_visibility(_visibility), m_isDeclaredConst(_isDeclaredConst), m_isPayable(_isPayable)
+	{}
+	virtual void accept(ASTVisitor& _visitor) override;
+	virtual void accept(ASTConstVisitor& _visitor) const override;
+
+	std::vector<ASTPointer<VariableDeclaration>> const& parameterTypes() const { return m_parameterTypes->parameters(); }
+	std::vector<ASTPointer<VariableDeclaration>> const& returnParameterTypes() const { return m_returnTypes->parameters(); }
+
+	Declaration::Visibility visibility() const { return m_visibility; }
+	bool isDeclaredConst() const { return m_isDeclaredConst; }
+	bool isPayable() const { return m_isPayable; }
+
+private:
+	ASTPointer<ParameterList> m_parameterTypes;
+	ASTPointer<ParameterList> m_returnTypes;
+	Declaration::Visibility m_visibility;
+	bool m_isDeclaredConst;
+	bool m_isPayable;
+};
+
+/**
  * A mapping type. Its source form is "mapping('keyType' => 'valueType')"
  */
 class Mapping: public TypeName
@@ -1005,18 +1041,22 @@ public:
 		SourceLocation const& _location,
 		ASTPointer<ASTString> const& _docString,
 		ASTPointer<Expression> const& _condition,
-		ASTPointer<Statement> const& _body
+		ASTPointer<Statement> const& _body,
+		bool _isDoWhile
 	):
-		BreakableStatement(_location, _docString), m_condition(_condition), m_body(_body) {}
+		BreakableStatement(_location, _docString), m_condition(_condition), m_body(_body),
+		m_isDoWhile(_isDoWhile) {}
 	virtual void accept(ASTVisitor& _visitor) override;
 	virtual void accept(ASTConstVisitor& _visitor) const override;
 
 	Expression const& condition() const { return *m_condition; }
 	Statement const& body() const { return *m_body; }
+	bool isDoWhile() const { return m_isDoWhile; }
 
 private:
 	ASTPointer<Expression> m_condition;
 	ASTPointer<Statement> m_body;
+	bool m_isDoWhile;
 };
 
 /**
diff --git a/libsolidity/ast/ASTForward.h b/libsolidity/ast/ASTForward.h
index 59fc1b57..52bbf396 100644
--- a/libsolidity/ast/ASTForward.h
+++ b/libsolidity/ast/ASTForward.h
@@ -54,6 +54,7 @@ class MagicVariableDeclaration;
 class TypeName;
 class ElementaryTypeName;
 class UserDefinedTypeName;
+class FunctionTypeName;
 class Mapping;
 class ArrayTypeName;
 class Statement;
diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp
index 0ea5e093..37dfd3c6 100644
--- a/libsolidity/ast/ASTJsonConverter.cpp
+++ b/libsolidity/ast/ASTJsonConverter.cpp
@@ -174,7 +174,8 @@ bool ASTJsonConverter::visit(FunctionDefinition const& _node)
 	addJsonNode(_node, "FunctionDefinition", {
 		make_pair("name", _node.name()),
 		make_pair("public", _node.isPublic()),
-		make_pair("constant", _node.isDeclaredConst())
+		make_pair("constant", _node.isDeclaredConst()),
+		make_pair("payable", _node.isPayable())
 	}, true);
 	return true;
 }
@@ -225,6 +226,20 @@ bool ASTJsonConverter::visit(UserDefinedTypeName const& _node)
 	return true;
 }
 
+bool ASTJsonConverter::visit(FunctionTypeName const& _node)
+{
+	string visibility = "internal";
+	if (_node.visibility() == Declaration::Visibility::External)
+		visibility = "external";
+
+	addJsonNode(_node, "FunctionTypeName", {
+		make_pair("payable", _node.isPayable()),
+		make_pair("visibility", visibility),
+		make_pair("constant", _node.isDeclaredConst())
+	}, true);
+	return true;
+}
+
 bool ASTJsonConverter::visit(Mapping const& _node)
 {
 	addJsonNode(_node, "Mapping", {}, true);
@@ -263,7 +278,11 @@ bool ASTJsonConverter::visit(IfStatement const& _node)
 
 bool ASTJsonConverter::visit(WhileStatement const& _node)
 {
-	addJsonNode(_node, "WhileStatement", {}, true);
+	addJsonNode(
+		_node,
+		_node.isDoWhile() ? "DoWhileStatement" : "WhileStatement",
+		{},
+		true);
 	return true;
 }
 
@@ -502,6 +521,11 @@ void ASTJsonConverter::endVisit(UserDefinedTypeName const&)
 {
 }
 
+void ASTJsonConverter::endVisit(FunctionTypeName const&)
+{
+	goUp();
+}
+
 void ASTJsonConverter::endVisit(Mapping const&)
 {
 	goUp();
diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h
index 7c7b37f8..0a71779c 100644
--- a/libsolidity/ast/ASTJsonConverter.h
+++ b/libsolidity/ast/ASTJsonConverter.h
@@ -69,6 +69,7 @@ public:
 	bool visit(TypeName const& _node) override;
 	bool visit(ElementaryTypeName const& _node) override;
 	bool visit(UserDefinedTypeName const& _node) override;
+	bool visit(FunctionTypeName const& _node) override;
 	bool visit(Mapping const& _node) override;
 	bool visit(ArrayTypeName const& _node) override;
 	bool visit(InlineAssembly const& _node) override;
@@ -114,6 +115,7 @@ public:
 	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;
diff --git a/libsolidity/ast/ASTPrinter.cpp b/libsolidity/ast/ASTPrinter.cpp
index a9de457a..053b9b82 100644
--- a/libsolidity/ast/ASTPrinter.cpp
+++ b/libsolidity/ast/ASTPrinter.cpp
@@ -164,6 +164,13 @@ bool ASTPrinter::visit(UserDefinedTypeName const& _node)
 	return goDeeper();
 }
 
+bool ASTPrinter::visit(FunctionTypeName const& _node)
+{
+	writeLine("FunctionTypeName");
+	printSourcePart(_node);
+	return goDeeper();
+}
+
 bool ASTPrinter::visit(Mapping const& _node)
 {
 	writeLine("Mapping");
@@ -208,7 +215,7 @@ bool ASTPrinter::visit(IfStatement const& _node)
 
 bool ASTPrinter::visit(WhileStatement const& _node)
 {
-	writeLine("WhileStatement");
+	writeLine(_node.isDoWhile() ? "DoWhileStatement" : "WhileStatement");
 	printSourcePart(_node);
 	return goDeeper();
 }
@@ -442,6 +449,11 @@ void ASTPrinter::endVisit(UserDefinedTypeName const&)
 	m_indentation--;
 }
 
+void ASTPrinter::endVisit(FunctionTypeName const&)
+{
+	m_indentation--;
+}
+
 void ASTPrinter::endVisit(Mapping const&)
 {
 	m_indentation--;
diff --git a/libsolidity/ast/ASTPrinter.h b/libsolidity/ast/ASTPrinter.h
index f0ab1098..9f88a1fd 100644
--- a/libsolidity/ast/ASTPrinter.h
+++ b/libsolidity/ast/ASTPrinter.h
@@ -63,6 +63,7 @@ public:
 	bool visit(TypeName const& _node) override;
 	bool visit(ElementaryTypeName const& _node) override;
 	bool visit(UserDefinedTypeName const& _node) override;
+	bool visit(FunctionTypeName const& _node) override;
 	bool visit(Mapping const& _node) override;
 	bool visit(ArrayTypeName const& _node) override;
 	bool visit(InlineAssembly const& _node) override;
@@ -106,6 +107,7 @@ public:
 	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;
diff --git a/libsolidity/ast/ASTVisitor.h b/libsolidity/ast/ASTVisitor.h
index 3a1b55d3..e72afe69 100644
--- a/libsolidity/ast/ASTVisitor.h
+++ b/libsolidity/ast/ASTVisitor.h
@@ -61,6 +61,7 @@ public:
 	virtual bool visit(TypeName& _node) { return visitNode(_node); }
 	virtual bool visit(ElementaryTypeName& _node) { return visitNode(_node); }
 	virtual bool visit(UserDefinedTypeName& _node) { return visitNode(_node); }
+	virtual bool visit(FunctionTypeName& _node) { return visitNode(_node); }
 	virtual bool visit(Mapping& _node) { return visitNode(_node); }
 	virtual bool visit(ArrayTypeName& _node) { return visitNode(_node); }
 	virtual bool visit(InlineAssembly& _node) { return visitNode(_node); }
@@ -106,6 +107,7 @@ public:
 	virtual void endVisit(TypeName& _node) { endVisitNode(_node); }
 	virtual void endVisit(ElementaryTypeName& _node) { endVisitNode(_node); }
 	virtual void endVisit(UserDefinedTypeName& _node) { endVisitNode(_node); }
+	virtual void endVisit(FunctionTypeName& _node) { endVisitNode(_node); }
 	virtual void endVisit(Mapping& _node) { endVisitNode(_node); }
 	virtual void endVisit(ArrayTypeName& _node) { endVisitNode(_node); }
 	virtual void endVisit(InlineAssembly& _node) { endVisitNode(_node); }
@@ -163,6 +165,7 @@ public:
 	virtual bool visit(TypeName const& _node) { return visitNode(_node); }
 	virtual bool visit(ElementaryTypeName const& _node) { return visitNode(_node); }
 	virtual bool visit(UserDefinedTypeName const& _node) { return visitNode(_node); }
+	virtual bool visit(FunctionTypeName const& _node) { return visitNode(_node); }
 	virtual bool visit(Mapping const& _node) { return visitNode(_node); }
 	virtual bool visit(ArrayTypeName const& _node) { return visitNode(_node); }
 	virtual bool visit(Block const& _node) { return visitNode(_node); }
@@ -208,6 +211,7 @@ public:
 	virtual void endVisit(TypeName const& _node) { endVisitNode(_node); }
 	virtual void endVisit(ElementaryTypeName const& _node) { endVisitNode(_node); }
 	virtual void endVisit(UserDefinedTypeName const& _node) { endVisitNode(_node); }
+	virtual void endVisit(FunctionTypeName const& _node) { endVisitNode(_node); }
 	virtual void endVisit(Mapping const& _node) { endVisitNode(_node); }
 	virtual void endVisit(ArrayTypeName const& _node) { endVisitNode(_node); }
 	virtual void endVisit(Block const& _node) { endVisitNode(_node); }
diff --git a/libsolidity/ast/AST_accept.h b/libsolidity/ast/AST_accept.h
index b5a3806b..f521e092 100644
--- a/libsolidity/ast/AST_accept.h
+++ b/libsolidity/ast/AST_accept.h
@@ -327,6 +327,26 @@ void UserDefinedTypeName::accept(ASTConstVisitor& _visitor) const
 	_visitor.endVisit(*this);
 }
 
+void FunctionTypeName::accept(ASTVisitor& _visitor)
+{
+	if (_visitor.visit(*this))
+	{
+		m_parameterTypes->accept(_visitor);
+		m_returnTypes->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
+void FunctionTypeName::accept(ASTConstVisitor& _visitor) const
+{
+	if (_visitor.visit(*this))
+	{
+		m_parameterTypes->accept(_visitor);
+		m_returnTypes->accept(_visitor);
+	}
+	_visitor.endVisit(*this);
+}
+
 void Mapping::accept(ASTVisitor& _visitor)
 {
 	if (_visitor.visit(*this))
diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
index 7fe97fa7..4488398f 100644
--- a/libsolidity/ast/Types.cpp
+++ b/libsolidity/ast/Types.cpp
@@ -200,10 +200,10 @@ TypePointer Type::commonType(TypePointer const& _a, TypePointer const& _b)
 {
 	if (!_a || !_b)
 		return TypePointer();
-	else if (_b->isImplicitlyConvertibleTo(*_a))
-		return _a;
-	else if (_a->isImplicitlyConvertibleTo(*_b))
-		return _b;
+	else if (_b->isImplicitlyConvertibleTo(*_a->mobileType()))
+		return _a->mobileType();
+	else if (_a->isImplicitlyConvertibleTo(*_b->mobileType()))
+		return _b->mobileType();
 	else
 		return TypePointer();
 }
@@ -1265,6 +1265,7 @@ TypePointer ArrayType::decodingType() const
 
 TypePointer ArrayType::interfaceType(bool _inLibrary) const
 {
+	// Note: This has to fulfill canBeUsedExternally(_inLibrary) ==  !!interfaceType(_inLibrary)
 	if (_inLibrary && location() == DataLocation::Storage)
 		return shared_from_this();
 
@@ -1282,6 +1283,21 @@ TypePointer ArrayType::interfaceType(bool _inLibrary) const
 		return make_shared<ArrayType>(DataLocation::Memory, baseExt, m_length);
 }
 
+bool ArrayType::canBeUsedExternally(bool _inLibrary) const
+{
+	// Note: This has to fulfill canBeUsedExternally(_inLibrary) ==  !!interfaceType(_inLibrary)
+	if (_inLibrary && location() == DataLocation::Storage)
+		return true;
+	else if (m_arrayKind != ArrayKind::Ordinary)
+		return true;
+	else if (!m_baseType->canBeUsedExternally(_inLibrary))
+		return false;
+	else if (m_baseType->category() == Category::Array && m_baseType->isDynamicallySized())
+		return false;
+	else
+		return true;
+}
+
 u256 ArrayType::memorySize() const
 {
 	solAssert(!isDynamicallySized(), "");
@@ -1451,7 +1467,7 @@ u256 StructType::storageSize() const
 
 string StructType::toString(bool _short) const
 {
-	string ret = "struct " + m_struct.name();
+	string ret = "struct " + m_struct.annotation().canonicalName;
 	if (!_short)
 		ret += " " + stringForReferencePart();
 	return ret;
@@ -1561,7 +1577,7 @@ bool EnumType::operator==(Type const& _other) const
 
 unsigned EnumType::storageBytes() const
 {
-	size_t elements = m_enum.members().size();
+	size_t elements = numberOfMembers();
 	if (elements <= 1)
 		return 1;
 	else
@@ -1570,7 +1586,7 @@ unsigned EnumType::storageBytes() const
 
 string EnumType::toString(bool) const
 {
-	return string("enum ") + m_enum.name();
+	return string("enum ") + m_enum.annotation().canonicalName;
 }
 
 string EnumType::canonicalName(bool) const
@@ -1578,9 +1594,14 @@ string EnumType::canonicalName(bool) const
 	return m_enum.annotation().canonicalName;
 }
 
+size_t EnumType::numberOfMembers() const
+{
+	return m_enum.members().size();
+};
+
 bool EnumType::isExplicitlyConvertibleTo(Type const& _convertTo) const
 {
-	return _convertTo.category() == category() || _convertTo.category() == Category::Integer;
+	return _convertTo == *this || _convertTo.category() == Category::Integer;
 }
 
 unsigned EnumType::memberValue(ASTString const& _member) const
@@ -1699,7 +1720,7 @@ TypePointer TupleType::closestTemporaryType(TypePointer const& _targetType) cons
 FunctionType::FunctionType(FunctionDefinition const& _function, bool _isInternal):
 	m_location(_isInternal ? Location::Internal : Location::External),
 	m_isConstant(_function.isDeclaredConst()),
-	m_isPayable(_function.isPayable()),
+	m_isPayable(_isInternal ? false : _function.isPayable()),
 	m_declaration(&_function)
 {
 	TypePointers params;
@@ -1800,6 +1821,38 @@ FunctionType::FunctionType(EventDefinition const& _event):
 	swap(paramNames, m_parameterNames);
 }
 
+FunctionType::FunctionType(FunctionTypeName const& _typeName):
+	m_location(_typeName.visibility() == VariableDeclaration::Visibility::External ? Location::External : Location::Internal),
+	m_isConstant(_typeName.isDeclaredConst()),
+	m_isPayable(_typeName.isPayable())
+{
+	if (_typeName.isPayable())
+	{
+		solAssert(m_location == Location::External, "Internal payable function type used.");
+		solAssert(!m_isConstant, "Payable constant function");
+	}
+	for (auto const& t: _typeName.parameterTypes())
+	{
+		solAssert(t->annotation().type, "Type not set for parameter.");
+		if (m_location == Location::External)
+			solAssert(
+				t->annotation().type->canBeUsedExternally(false),
+				"Internal type used as parameter for external function."
+			);
+		m_parameterTypes.push_back(t->annotation().type);
+	}
+	for (auto const& t: _typeName.returnParameterTypes())
+	{
+		solAssert(t->annotation().type, "Type not set for return parameter.");
+		if (m_location == Location::External)
+			solAssert(
+				t->annotation().type->canBeUsedExternally(false),
+				"Internal type used as return parameter for external function."
+			);
+		m_returnParameterTypes.push_back(t->annotation().type);
+	}
+}
+
 FunctionTypePointer FunctionType::newExpressionType(ContractDefinition const& _contract)
 {
 	FunctionDefinition const* constructor = _contract.constructor();
@@ -1875,22 +1928,69 @@ bool FunctionType::operator==(Type const& _other) const
 	return true;
 }
 
+TypePointer FunctionType::unaryOperatorResult(Token::Value _operator) const
+{
+	if (_operator == Token::Value::Delete)
+		return make_shared<TupleType>();
+	return TypePointer();
+}
+
+string FunctionType::canonicalName(bool) const
+{
+	solAssert(m_location == Location::External, "");
+	return "function";
+}
+
 string FunctionType::toString(bool _short) const
 {
 	string name = "function (";
 	for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
 		name += (*it)->toString(_short) + (it + 1 == m_parameterTypes.end() ? "" : ",");
-	name += ") returns (";
-	for (auto it = m_returnParameterTypes.begin(); it != m_returnParameterTypes.end(); ++it)
-		name += (*it)->toString(_short) + (it + 1 == m_returnParameterTypes.end() ? "" : ",");
-	return name + ")";
+	name += ")";
+	if (m_isConstant)
+		name += " constant";
+	if (m_isPayable)
+		name += " payable";
+	if (m_location == Location::External)
+		name += " external";
+	if (!m_returnParameterTypes.empty())
+	{
+		name += " returns (";
+		for (auto it = m_returnParameterTypes.begin(); it != m_returnParameterTypes.end(); ++it)
+			name += (*it)->toString(_short) + (it + 1 == m_returnParameterTypes.end() ? "" : ",");
+		name += ")";
+	}
+	return name;
+}
+
+unsigned FunctionType::calldataEncodedSize(bool _padded) const
+{
+	unsigned size = storageBytes();
+	if (_padded)
+		size = ((size + 31) / 32) * 32;
+	return size;
 }
 
 u256 FunctionType::storageSize() const
 {
-	BOOST_THROW_EXCEPTION(
-		InternalCompilerError()
-			<< errinfo_comment("Storage size of non-storable function type requested."));
+	if (m_location == Location::External || m_location == Location::Internal)
+		return 1;
+	else
+		BOOST_THROW_EXCEPTION(
+			InternalCompilerError()
+				<< errinfo_comment("Storage size of non-storable function type requested."));
+}
+
+unsigned FunctionType::storageBytes() const
+{
+	if (m_location == Location::External)
+		return 20 + 4;
+	else if (m_location == Location::Internal)
+		return 8; // it should really not be possible to create larger programs
+	else
+		BOOST_THROW_EXCEPTION(
+			InternalCompilerError()
+				<< errinfo_comment("Storage size of non-storable function type requested."));
 }
 
 unsigned FunctionType::sizeOnStack() const
@@ -2013,6 +2113,23 @@ MemberList::MemberMap FunctionType::nativeMembers(ContractDefinition const*) con
 	}
 }
 
+TypePointer FunctionType::encodingType() const
+{
+	// Only external functions can be encoded, internal functions cannot leave code boundaries.
+	if (m_location == Location::External)
+		return shared_from_this();
+	else
+		return TypePointer();
+}
+
+TypePointer FunctionType::interfaceType(bool /*_inLibrary*/) const
+{
+	if (m_location == Location::External)
+		return shared_from_this();
+	else
+		return TypePointer();
+}
+
 bool FunctionType::canTakeArguments(TypePointers const& _argumentTypes, TypePointer const& _selfType) const
 {
 	solAssert(!bound() || _selfType, "");
diff --git a/libsolidity/ast/Types.h b/libsolidity/ast/Types.h
index 3f94d11a..34fcfc82 100644
--- a/libsolidity/ast/Types.h
+++ b/libsolidity/ast/Types.h
@@ -254,6 +254,9 @@ public:
 	/// @param _inLibrary if set, returns types as used in a library, e.g. struct and contract types
 	/// are returned without modification.
 	virtual TypePointer interfaceType(bool /*_inLibrary*/) const { return TypePointer(); }
+	/// @returns true iff this type can be passed on via calls (to libraries if _inLibrary is true),
+	/// should be have identical to !!interfaceType(_inLibrary) but might do optimizations.
+	virtual bool canBeUsedExternally(bool _inLibrary) const { return !!interfaceType(_inLibrary); }
 
 private:
 	/// @returns a member list containing all members added to this type by `using for` directives.
@@ -580,6 +583,7 @@ public:
 	virtual TypePointer encodingType() const override;
 	virtual TypePointer decodingType() const override;
 	virtual TypePointer interfaceType(bool _inLibrary) const override;
+	virtual bool canBeUsedExternally(bool _inLibrary) const override;
 
 	/// @returns true if this is a byte array or a string
 	bool isByteArray() const { return m_arrayKind != ArrayKind::Ordinary; }
@@ -738,6 +742,7 @@ public:
 	EnumDefinition const& enumDefinition() const { return m_enum; }
 	/// @returns the value that the string has in the Enum
 	unsigned int memberValue(ASTString const& _member) const;
+	size_t numberOfMembers() const;
 
 private:
 	EnumDefinition const& m_enum;
@@ -820,6 +825,8 @@ public:
 	explicit FunctionType(VariableDeclaration const& _varDecl);
 	/// Creates the function type of an event.
 	explicit FunctionType(EventDefinition const& _event);
+	/// Creates the type of a function type name.
+	explicit FunctionType(FunctionTypeName const& _typeName);
 	/// Function type constructor to be used for a plain type (not derived from a declaration).
 	FunctionType(
 		strings const& _parameterTypes,
@@ -889,12 +896,19 @@ public:
 	TypePointer selfType() const;
 
 	virtual bool operator==(Type const& _other) const override;
+	virtual TypePointer unaryOperatorResult(Token::Value _operator) const override;
+	virtual std::string canonicalName(bool /*_addDataLocation*/) const override;
 	virtual std::string toString(bool _short) const override;
-	virtual bool canBeStored() const override { return false; }
+	virtual unsigned calldataEncodedSize(bool _padded) const override;
+	virtual bool canBeStored() const override { return m_location == Location::Internal || m_location == Location::External; }
 	virtual u256 storageSize() const override;
-	virtual bool canLiveOutsideStorage() const override { return false; }
+	virtual unsigned storageBytes() const override;
+	virtual bool isValueType() const override { return true; }
+	virtual bool canLiveOutsideStorage() const override { return m_location == Location::Internal || m_location == Location::External; }
 	virtual unsigned sizeOnStack() const override;
 	virtual MemberList::MemberMap nativeMembers(ContractDefinition const* _currentScope) const override;
+	virtual TypePointer encodingType() const override;
+	virtual TypePointer interfaceType(bool _inLibrary) const override;
 
 	/// @returns TypePointer of a new FunctionType object. All input/return parameters are an
 	/// appropriate external types (i.e. the interfaceType()s) of input/return parameters of
diff --git a/libsolidity/codegen/ArrayUtils.cpp b/libsolidity/codegen/ArrayUtils.cpp
index e7e8a98e..b5f5cd8e 100644
--- a/libsolidity/codegen/ArrayUtils.cpp
+++ b/libsolidity/codegen/ArrayUtils.cpp
@@ -270,7 +270,7 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
 
 void ArrayUtils::copyArrayToMemory(ArrayType const& _sourceType, bool _padToWordBoundaries) const
 {
-	solAssert(
+	solUnimplementedAssert(
 		!_sourceType.baseType()->isDynamicallySized(),
 		"Nested dynamic arrays not implemented here."
 	);
diff --git a/libsolidity/codegen/Compiler.cpp b/libsolidity/codegen/Compiler.cpp
index 1ae5dda9..54639515 100644
--- a/libsolidity/codegen/Compiler.cpp
+++ b/libsolidity/codegen/Compiler.cpp
@@ -33,14 +33,15 @@ void Compiler::compileContract(
 	std::map<const ContractDefinition*, eth::Assembly const*> const& _contracts
 )
 {
-	ContractCompiler runtimeCompiler(m_runtimeContext, m_optimize);
+	ContractCompiler runtimeCompiler(nullptr, m_runtimeContext, m_optimize);
 	runtimeCompiler.compileContract(_contract, _contracts);
 
-	ContractCompiler creationCompiler(m_context, m_optimize);
-	m_runtimeSub = creationCompiler.compileConstructor(m_runtimeContext, _contract, _contracts);
+	// This might modify m_runtimeContext because it can access runtime functions at
+	// creation time.
+	ContractCompiler creationCompiler(&runtimeCompiler, m_context, m_optimize);
+	m_runtimeSub = creationCompiler.compileConstructor(_contract, _contracts);
 
-	if (m_optimize)
-		m_context.optimise(m_optimizeRuns);
+	m_context.optimise(m_optimize, m_optimizeRuns);
 
 	if (_contract.isLibrary())
 	{
@@ -54,11 +55,11 @@ void Compiler::compileClone(
 	map<ContractDefinition const*, eth::Assembly const*> const& _contracts
 )
 {
-	ContractCompiler cloneCompiler(m_context, m_optimize);
+	ContractCompiler runtimeCompiler(nullptr, m_runtimeContext, m_optimize);
+	ContractCompiler cloneCompiler(&runtimeCompiler, m_context, m_optimize);
 	m_runtimeSub = cloneCompiler.compileClone(_contract, _contracts);
 
-	if (m_optimize)
-		m_context.optimise(m_optimizeRuns);
+	m_context.optimise(m_optimize, m_optimizeRuns);
 }
 
 eth::AssemblyItem Compiler::functionEntryLabel(FunctionDefinition const& _function) const
diff --git a/libsolidity/codegen/Compiler.h b/libsolidity/codegen/Compiler.h
index fccb68a9..4a87de0e 100644
--- a/libsolidity/codegen/Compiler.h
+++ b/libsolidity/codegen/Compiler.h
@@ -35,7 +35,9 @@ class Compiler
 public:
 	explicit Compiler(bool _optimize = false, unsigned _runs = 200):
 		m_optimize(_optimize),
-		m_optimizeRuns(_runs)
+		m_optimizeRuns(_runs),
+		m_runtimeContext(),
+		m_context(&m_runtimeContext)
 	{ }
 
 	void compileContract(
@@ -69,9 +71,9 @@ public:
 private:
 	bool const m_optimize;
 	unsigned const m_optimizeRuns;
-	CompilerContext m_context;
-	size_t m_runtimeSub = size_t(-1); ///< Identifier of the runtime sub-assembly, if present.
 	CompilerContext m_runtimeContext;
+	size_t m_runtimeSub = size_t(-1); ///< Identifier of the runtime sub-assembly, if present.
+	CompilerContext m_context;
 };
 
 }
diff --git a/libsolidity/codegen/CompilerContext.cpp b/libsolidity/codegen/CompilerContext.cpp
index 3ac5bd3c..c76db2a6 100644
--- a/libsolidity/codegen/CompilerContext.cpp
+++ b/libsolidity/codegen/CompilerContext.cpp
@@ -60,8 +60,8 @@ void CompilerContext::startFunction(Declaration const& _function)
 void CompilerContext::addVariable(VariableDeclaration const& _declaration,
 								  unsigned _offsetToCurrent)
 {
-	solAssert(m_asm.deposit() >= 0 && unsigned(m_asm.deposit()) >= _offsetToCurrent, "");
-	m_localVariables[&_declaration] = unsigned(m_asm.deposit()) - _offsetToCurrent;
+	solAssert(m_asm->deposit() >= 0 && unsigned(m_asm->deposit()) >= _offsetToCurrent, "");
+	m_localVariables[&_declaration] = unsigned(m_asm->deposit()) - _offsetToCurrent;
 }
 
 void CompilerContext::removeVariable(VariableDeclaration const& _declaration)
@@ -92,22 +92,22 @@ eth::AssemblyItem CompilerContext::functionEntryLabelIfExists(Declaration const&
 	return m_functionCompilationQueue.entryLabelIfExists(_declaration);
 }
 
-eth::AssemblyItem CompilerContext::virtualFunctionEntryLabel(FunctionDefinition const& _function)
+FunctionDefinition const& CompilerContext::resolveVirtualFunction(FunctionDefinition const& _function)
 {
 	// Libraries do not allow inheritance and their functions can be inlined, so we should not
 	// search the inheritance hierarchy (which will be the wrong one in case the function
 	// is inlined).
 	if (auto scope = dynamic_cast<ContractDefinition const*>(_function.scope()))
 		if (scope->isLibrary())
-			return functionEntryLabel(_function);
+			return _function;
 	solAssert(!m_inheritanceHierarchy.empty(), "No inheritance hierarchy set.");
-	return virtualFunctionEntryLabel(_function, m_inheritanceHierarchy.begin());
+	return resolveVirtualFunction(_function, m_inheritanceHierarchy.begin());
 }
 
-eth::AssemblyItem CompilerContext::superFunctionEntryLabel(FunctionDefinition const& _function, ContractDefinition const& _base)
+FunctionDefinition const& CompilerContext::superFunction(FunctionDefinition const& _function, ContractDefinition const& _base)
 {
 	solAssert(!m_inheritanceHierarchy.empty(), "No inheritance hierarchy set.");
-	return virtualFunctionEntryLabel(_function, superContract(_base));
+	return resolveVirtualFunction(_function, superContract(_base));
 }
 
 FunctionDefinition const* CompilerContext::nextConstructor(ContractDefinition const& _contract) const
@@ -145,12 +145,12 @@ unsigned CompilerContext::baseStackOffsetOfVariable(Declaration const& _declarat
 
 unsigned CompilerContext::baseToCurrentStackOffset(unsigned _baseOffset) const
 {
-	return m_asm.deposit() - _baseOffset - 1;
+	return m_asm->deposit() - _baseOffset - 1;
 }
 
 unsigned CompilerContext::currentToBaseStackOffset(unsigned _offset) const
 {
-	return m_asm.deposit() - _offset - 1;
+	return m_asm->deposit() - _offset - 1;
 }
 
 pair<u256, unsigned> CompilerContext::storageLocationOfVariable(const Declaration& _declaration) const
@@ -217,17 +217,17 @@ void CompilerContext::appendInlineAssembly(
 		return true;
 	};
 
-	solAssert(assembly::InlineAssemblyStack().parseAndAssemble(*assembly, m_asm, identifierAccess), "");
+	solAssert(assembly::InlineAssemblyStack().parseAndAssemble(*assembly, *m_asm, identifierAccess), "");
 }
 
 void CompilerContext::injectVersionStampIntoSub(size_t _subIndex)
 {
-	eth::Assembly& sub = m_asm.sub(_subIndex);
+	eth::Assembly& sub = m_asm->sub(_subIndex);
 	sub.injectStart(Instruction::POP);
 	sub.injectStart(fromBigEndian<u256>(binaryVersion()));
 }
 
-eth::AssemblyItem CompilerContext::virtualFunctionEntryLabel(
+FunctionDefinition const& CompilerContext::resolveVirtualFunction(
 	FunctionDefinition const& _function,
 	vector<ContractDefinition const*>::const_iterator _searchStart
 )
@@ -242,9 +242,9 @@ eth::AssemblyItem CompilerContext::virtualFunctionEntryLabel(
 				!function->isConstructor() &&
 				FunctionType(*function).hasEqualArgumentTypes(functionType)
 			)
-				return functionEntryLabel(*function);
+				return *function;
 	solAssert(false, "Super function " + name + " not found.");
-	return m_asm.newTag(); // not reached
+	return _function; // not reached
 }
 
 vector<ContractDefinition const*>::const_iterator CompilerContext::superContract(ContractDefinition const& _contract) const
@@ -257,7 +257,7 @@ vector<ContractDefinition const*>::const_iterator CompilerContext::superContract
 
 void CompilerContext::updateSourceLocation()
 {
-	m_asm.setSourceLocation(m_visitedNodes.empty() ? SourceLocation() : m_visitedNodes.top()->location());
+	m_asm->setSourceLocation(m_visitedNodes.empty() ? SourceLocation() : m_visitedNodes.top()->location());
 }
 
 eth::AssemblyItem CompilerContext::FunctionCompilationQueue::entryLabel(
diff --git a/libsolidity/codegen/CompilerContext.h b/libsolidity/codegen/CompilerContext.h
index 0c1500b0..8ccbddfd 100644
--- a/libsolidity/codegen/CompilerContext.h
+++ b/libsolidity/codegen/CompilerContext.h
@@ -44,6 +44,14 @@ namespace solidity {
 class CompilerContext
 {
 public:
+	CompilerContext(CompilerContext* _runtimeContext = nullptr):
+		m_asm(std::make_shared<eth::Assembly>()),
+		m_runtimeContext(_runtimeContext)
+	{
+		if (m_runtimeContext)
+			m_runtimeSub = size_t(m_asm->newSub(m_runtimeContext->m_asm).data());
+	}
+
 	void addMagicGlobal(MagicVariableDeclaration const& _declaration);
 	void addStateVariable(VariableDeclaration const& _declaration, u256 const& _storageOffset, unsigned _byteOffset);
 	void addVariable(VariableDeclaration const& _declaration, unsigned _offsetToCurrent = 0);
@@ -52,9 +60,9 @@ public:
 	void setCompiledContracts(std::map<ContractDefinition const*, eth::Assembly const*> const& _contracts) { m_compiledContracts = _contracts; }
 	eth::Assembly const& compiledContract(ContractDefinition const& _contract) const;
 
-	void setStackOffset(int _offset) { m_asm.setDeposit(_offset); }
-	void adjustStackOffset(int _adjustment) { m_asm.adjustDeposit(_adjustment); }
-	unsigned stackHeight() const { solAssert(m_asm.deposit() >= 0, ""); return unsigned(m_asm.deposit()); }
+	void setStackOffset(int _offset) { m_asm->setDeposit(_offset); }
+	void adjustStackOffset(int _adjustment) { m_asm->adjustDeposit(_adjustment); }
+	unsigned stackHeight() const { solAssert(m_asm->deposit() >= 0, ""); return unsigned(m_asm->deposit()); }
 
 	bool isMagicGlobal(Declaration const* _declaration) const { return m_magicGlobals.count(_declaration) != 0; }
 	bool isLocalVariable(Declaration const* _declaration) const;
@@ -67,10 +75,10 @@ public:
 	eth::AssemblyItem functionEntryLabelIfExists(Declaration const& _declaration) const;
 	void setInheritanceHierarchy(std::vector<ContractDefinition const*> const& _hierarchy) { m_inheritanceHierarchy = _hierarchy; }
 	/// @returns the entry label of the given function and takes overrides into account.
-	eth::AssemblyItem virtualFunctionEntryLabel(FunctionDefinition const& _function);
-	/// @returns the entry label of a function that overrides the given declaration from the most derived class just
+	FunctionDefinition const& resolveVirtualFunction(FunctionDefinition const& _function);
+	/// @returns the function that overrides the given declaration from the most derived class just
 	/// above _base in the current inheritance hierarchy.
-	eth::AssemblyItem superFunctionEntryLabel(FunctionDefinition const& _function, ContractDefinition const& _base);
+	FunctionDefinition const& superFunction(FunctionDefinition const& _function, ContractDefinition const& _base);
 	FunctionDefinition const* nextConstructor(ContractDefinition const& _contract) const;
 
 	/// @returns the next function in the queue of functions that are still to be compiled
@@ -95,30 +103,33 @@ public:
 	std::pair<u256, unsigned> storageLocationOfVariable(Declaration const& _declaration) const;
 
 	/// Appends a JUMPI instruction to a new tag and @returns the tag
-	eth::AssemblyItem appendConditionalJump() { return m_asm.appendJumpI().tag(); }
+	eth::AssemblyItem appendConditionalJump() { return m_asm->appendJumpI().tag(); }
 	/// Appends a JUMPI instruction to @a _tag
-	CompilerContext& appendConditionalJumpTo(eth::AssemblyItem const& _tag) { m_asm.appendJumpI(_tag); return *this; }
+	CompilerContext& appendConditionalJumpTo(eth::AssemblyItem const& _tag) { m_asm->appendJumpI(_tag); return *this; }
 	/// Appends a JUMP to a new tag and @returns the tag
-	eth::AssemblyItem appendJumpToNew() { return m_asm.appendJump().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);
 	/// Returns an "ErrorTag"
-	eth::AssemblyItem errorTag() { return m_asm.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; }
+	CompilerContext& appendJumpTo(eth::AssemblyItem const& _tag) { m_asm->appendJump(_tag); return *this; }
 	/// Appends pushing of a new tag and @returns the new tag.
-	eth::AssemblyItem pushNewTag() { return m_asm.append(m_asm.newPushTag()).tag(); }
+	eth::AssemblyItem pushNewTag() { return m_asm->append(m_asm->newPushTag()).tag(); }
 	/// @returns a new tag without pushing any opcodes or data
-	eth::AssemblyItem newTag() { return m_asm.newTag(); }
+	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 assembly item corresponding to the pushed subroutine, i.e. its offset.
-	eth::AssemblyItem addSubroutine(eth::Assembly const& _assembly) { return m_asm.appendSubSize(_assembly); }
+	/// 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)); }
+	/// Pushes the offset of the subroutine.
+	void pushSubroutineOffset(size_t _subRoutine) { m_asm->append(eth::AssemblyItem(eth::PushSub, _subRoutine)); }
 	/// Pushes the size of the final program
-	void appendProgramSize() { return m_asm.appendProgramSize(); }
+	void appendProgramSize() { m_asm->appendProgramSize(); }
 	/// Adds data to the data section, pushes a reference to the stack
-	eth::AssemblyItem appendData(bytes const& _data) { return m_asm.append(_data); }
+	eth::AssemblyItem appendData(bytes const& _data) { return m_asm->append(_data); }
 	/// Appends the address (virtual, will be filled in by linker) of a library.
-	void appendLibraryAddress(std::string const& _identifier) { m_asm.appendLibraryAddress(_identifier); }
+	void appendLibraryAddress(std::string const& _identifier) { m_asm->appendLibraryAddress(_identifier); }
 	/// Resets the stack of visited nodes with a new stack having only @c _node
 	void resetVisitedNodes(ASTNode const* _node);
 	/// Pops the stack of visited nodes
@@ -127,10 +138,10 @@ public:
 	void pushVisitedNodes(ASTNode const* _node) { m_visitedNodes.push(_node); updateSourceLocation(); }
 
 	/// Append elements to the current instruction list and adjust @a m_stackOffset.
-	CompilerContext& operator<<(eth::AssemblyItem const& _item) { m_asm.append(_item); return *this; }
-	CompilerContext& operator<<(Instruction _instruction) { m_asm.append(_instruction); return *this; }
-	CompilerContext& operator<<(u256 const& _value) { m_asm.append(_value); return *this; }
-	CompilerContext& operator<<(bytes const& _data) { m_asm.append(_data); return *this; }
+	CompilerContext& operator<<(eth::AssemblyItem const& _item) { m_asm->append(_item); return *this; }
+	CompilerContext& operator<<(Instruction _instruction) { m_asm->append(_instruction); return *this; }
+	CompilerContext& operator<<(u256 const& _value) { m_asm->append(_value); return *this; }
+	CompilerContext& operator<<(bytes const& _data) { m_asm->append(_data); return *this; }
 
 	/// Appends inline assembly. @a _replacements are string-matching replacements that are performed
 	/// prior to parsing the inline assembly.
@@ -144,22 +155,27 @@ public:
 	/// Prepends "PUSH <compiler version number> POP"
 	void injectVersionStampIntoSub(size_t _subIndex);
 
-	void optimise(unsigned _runs = 200) { m_asm.optimise(true, true, _runs); }
+	void optimise(bool _fullOptimsation, unsigned _runs = 200) { m_asm->optimise(_fullOptimsation, true, _runs); }
+
+	/// @returns the runtime context if in creation mode and runtime context is set, nullptr otherwise.
+	CompilerContext* runtimeContext() { return m_runtimeContext; }
+	/// @returns the identifier of the runtime subroutine.
+	size_t runtimeSub() const { return m_runtimeSub; }
 
-	eth::Assembly const& assembly() const { return m_asm; }
+	eth::Assembly const& assembly() const { return *m_asm; }
 	/// @returns non-const reference to the underlying assembly. Should be avoided in favour of
 	/// wrappers in this class.
-	eth::Assembly& nonConstAssembly() { return m_asm; }
+	eth::Assembly& nonConstAssembly() { return *m_asm; }
 
 	/// @arg _sourceCodes is the map of input files to source code strings
 	/// @arg _inJsonFormat shows whether the out should be in Json format
 	Json::Value streamAssembly(std::ostream& _stream, StringMap const& _sourceCodes = StringMap(), bool _inJsonFormat = false) const
 	{
-		return m_asm.stream(_stream, "", _sourceCodes, _inJsonFormat);
+		return m_asm->stream(_stream, "", _sourceCodes, _inJsonFormat);
 	}
 
-	eth::LinkerObject const& assembledObject() { return m_asm.assemble(); }
-	eth::LinkerObject const& assembledRuntimeObject(size_t _subIndex) { return m_asm.sub(_subIndex).assemble(); }
+	eth::LinkerObject const& assembledObject() { return m_asm->assemble(); }
+	eth::LinkerObject const& assembledRuntimeObject(size_t _subIndex) { return m_asm->sub(_subIndex).assemble(); }
 
 	/**
 	 * Helper class to pop the visited nodes stack when a scope closes
@@ -172,9 +188,9 @@ public:
 	};
 
 private:
-	/// @returns the entry label of the given function - searches the inheritance hierarchy
-	/// startig from the given point towards the base.
-	eth::AssemblyItem virtualFunctionEntryLabel(
+	/// Searches the inheritance hierarchy towards the base starting from @a _searchStart and returns
+	/// the first function definition that is overwritten by _function.
+	FunctionDefinition const& resolveVirtualFunction(
 		FunctionDefinition const& _function,
 		std::vector<ContractDefinition const*>::const_iterator _searchStart
 	);
@@ -215,7 +231,7 @@ private:
 		mutable std::queue<Declaration const*> m_functionsToCompile;
 	} m_functionCompilationQueue;
 
-	eth::Assembly m_asm;
+	eth::AssemblyPointer m_asm;
 	/// Magic global variables like msg, tx or this, distinguished by type.
 	std::set<Declaration const*> m_magicGlobals;
 	/// Other already compiled contracts to be used in contract creation calls.
@@ -228,6 +244,10 @@ private:
 	std::vector<ContractDefinition const*> m_inheritanceHierarchy;
 	/// Stack of current visited AST nodes, used for location attachment
 	std::stack<ASTNode const*> m_visitedNodes;
+	/// The runtime context if in Creation mode, this is used for generating tags that would be stored into the storage and then used at runtime.
+	CompilerContext *m_runtimeContext;
+	/// The index of the runtime subroutine.
+	size_t m_runtimeSub = -1;
 };
 
 }
diff --git a/libsolidity/codegen/CompilerUtils.cpp b/libsolidity/codegen/CompilerUtils.cpp
index e064c1a6..bfe5386b 100644
--- a/libsolidity/codegen/CompilerUtils.cpp
+++ b/libsolidity/codegen/CompilerUtils.cpp
@@ -133,12 +133,22 @@ void CompilerUtils::storeInMemoryDynamic(Type const& _type, bool _padToWordBound
 			m_context << u256(str->value().size());
 		m_context << Instruction::ADD;
 	}
+	else if (
+		_type.category() == Type::Category::Function &&
+		dynamic_cast<FunctionType const&>(_type).location() == FunctionType::Location::External
+	)
+	{
+		solUnimplementedAssert(_padToWordBoundaries, "Non-padded store for function not implemented.");
+		combineExternalFunctionType(true);
+		m_context << Instruction::DUP2 << Instruction::MSTORE;
+		m_context << u256(_padToWordBoundaries ? 32 : 24) << Instruction::ADD;
+	}
 	else
 	{
 		unsigned numBytes = prepareMemoryStore(_type, _padToWordBoundaries);
 		if (numBytes > 0)
 		{
-			solAssert(
+			solUnimplementedAssert(
 				_type.sizeOnStack() == 1,
 				"Memory store of types with stack size != 1 not implemented."
 			);
@@ -161,7 +171,7 @@ void CompilerUtils::encodeToMemory(
 	solAssert(targetTypes.size() == _givenTypes.size(), "");
 	for (TypePointer& t: targetTypes)
 	{
-		solAssert(
+		solUnimplementedAssert(
 			t->mobileType() &&
 			t->mobileType()->interfaceType(_encodeAsLibraryTypes) &&
 			t->mobileType()->interfaceType(_encodeAsLibraryTypes)->encodingType(),
@@ -206,7 +216,8 @@ void CompilerUtils::encodeToMemory(
 			else if (
 				_givenTypes[i]->dataStoredIn(DataLocation::Storage) ||
 				_givenTypes[i]->dataStoredIn(DataLocation::CallData) ||
-				_givenTypes[i]->category() == Type::Category::StringLiteral
+				_givenTypes[i]->category() == Type::Category::StringLiteral ||
+				_givenTypes[i]->category() == Type::Category::Function
 			)
 				type = _givenTypes[i]; // delay conversion
 			else
@@ -304,6 +315,49 @@ void CompilerUtils::memoryCopy()
 	m_context << Instruction::POP; // ignore return value
 }
 
+void CompilerUtils::splitExternalFunctionType(bool _leftAligned)
+{
+	// We have to split the left-aligned <address><function identifier> into two stack slots:
+	// address (right aligned), function identifier (right aligned)
+	if (_leftAligned)
+	{
+		m_context << Instruction::DUP1 << (u256(1) << (64 + 32)) << Instruction::SWAP1 << Instruction::DIV;
+		// <input> <address>
+		m_context << Instruction::SWAP1 << (u256(1) << 64) << Instruction::SWAP1 << Instruction::DIV;
+	}
+	else
+	{
+		m_context << Instruction::DUP1 << (u256(1) << 32) << Instruction::SWAP1 << Instruction::DIV;
+		m_context << ((u256(1) << 160) - 1) << Instruction::AND << Instruction::SWAP1;
+	}
+	m_context << u256(0xffffffffUL) << Instruction::AND;
+}
+
+void CompilerUtils::combineExternalFunctionType(bool _leftAligned)
+{
+	// <address> <function_id>
+	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;
+	m_context << Instruction::OR;
+	if (_leftAligned)
+		m_context << (u256(1) << 64) << Instruction::MUL;
+}
+
+void CompilerUtils::pushCombinedFunctionEntryLabel(Declaration const& _function)
+{
+	m_context << m_context.functionEntryLabel(_function).pushTag();
+	// 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())
+		m_context <<
+			(u256(1) << 32) <<
+			Instruction::MUL <<
+			rtc->functionEntryLabel(_function).toSubAssemblyTag(m_context.runtimeSub()) <<
+			Instruction::OR;
+}
+
 void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetType, bool _cleanupNeeded)
 {
 	// For a type extension, we need to remove all higher-order bits that we might have ignored in
@@ -315,6 +369,8 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 	Type::Category stackTypeCategory = _typeOnStack.category();
 	Type::Category targetTypeCategory = _targetType.category();
 
+	bool enumOverflowCheckPending = (targetTypeCategory == Type::Category::Enum || stackTypeCategory == Type::Category::Enum);
+
 	switch (stackTypeCategory)
 	{
 	case Type::Category::FixedBytes:
@@ -348,10 +404,18 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 	}
 		break;
 	case Type::Category::Enum:
-		solAssert(targetTypeCategory == Type::Category::Integer || targetTypeCategory == Type::Category::Enum, "");
+		solAssert(_targetType == _typeOnStack || targetTypeCategory == Type::Category::Integer, "");
+		if (enumOverflowCheckPending)
+		{
+			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.appendConditionalJumpTo(m_context.errorTag());
+			enumOverflowCheckPending = false;
+		}
 		break;
 	case Type::Category::FixedPoint:
-		solAssert(false, "Not yet implemented - FixedPointType.");
+		solUnimplemented("Not yet implemented - FixedPointType.");
 	case Type::Category::Integer:
 	case Type::Category::Contract:
 	case Type::Category::RationalNumber:
@@ -372,6 +436,11 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 			solAssert(_typeOnStack.mobileType(), "");
 			// just clean
 			convertType(_typeOnStack, *_typeOnStack.mobileType(), true);
+			EnumType const& enumType = dynamic_cast<decltype(enumType)>(_targetType);
+			solAssert(enumType.numberOfMembers() > 0, "empty enum should have caused a parser error.");
+			m_context << u256(enumType.numberOfMembers() - 1) << Instruction::DUP2 << Instruction::GT;
+			m_context.appendConditionalJumpTo(m_context.errorTag());
+			enumOverflowCheckPending = false;
 		}
 		else if (targetTypeCategory == Type::Category::FixedPoint)
 		{
@@ -386,7 +455,7 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 			if (auto typeOnStack = dynamic_cast<IntegerType const*>(&_typeOnStack))
 				if (targetFixedPointType.integerBits() > typeOnStack->numBits())
 					cleanHigherOrderBits(*typeOnStack);
-			solAssert(false, "Not yet implemented - FixedPointType.");
+			solUnimplemented("Not yet implemented - FixedPointType.");
 		}
 		else
 		{
@@ -399,7 +468,7 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 				RationalNumberType const& constType = dynamic_cast<RationalNumberType const&>(_typeOnStack);
 				// We know that the stack is clean, we only have to clean for a narrowing conversion
 				// where cleanup is forced.
-				solAssert(!constType.isFractional(), "Not yet implemented - FixedPointType.");
+				solUnimplementedAssert(!constType.isFractional(), "Not yet implemented - FixedPointType.");
 				if (targetType.numBits() < constType.integerType()->numBits() && _cleanupNeeded)
 					cleanHigherOrderBits(targetType);
 			}
@@ -651,15 +720,26 @@ void CompilerUtils::convertType(Type const& _typeOnStack, Type const& _targetTyp
 		solAssert(_targetType == _typeOnStack, "Invalid conversion for bool.");
 		if (_cleanupNeeded)
 			m_context << Instruction::ISZERO << Instruction::ISZERO;
+		break;
 	default:
 		// All other types should not be convertible to non-equal types.
 		solAssert(_typeOnStack == _targetType, "Invalid type conversion requested.");
 		break;
 	}
+
+	solAssert(!enumOverflowCheckPending, "enum overflow checking missing.");
 }
 
 void CompilerUtils::pushZeroValue(Type const& _type)
 {
+	if (auto const* funType = dynamic_cast<FunctionType const*>(&_type))
+	{
+		if (funType->location() == FunctionType::Location::Internal)
+		{
+			m_context << m_context.errorTag();
+			return;
+		}
+	}
 	auto const* referenceType = dynamic_cast<ReferenceType const*>(&_type);
 	if (!referenceType || referenceType->location() == DataLocation::Storage)
 	{
@@ -804,21 +884,27 @@ void CompilerUtils::storeStringData(bytesConstRef _data)
 unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCalldata, bool _padToWordBoundaries)
 {
 	unsigned numBytes = _type.calldataEncodedSize(_padToWordBoundaries);
-	bool leftAligned = _type.category() == Type::Category::FixedBytes;
+	bool isExternalFunctionType = false;
+	if (auto const* funType = dynamic_cast<FunctionType const*>(&_type))
+		if (funType->location() == FunctionType::Location::External)
+			isExternalFunctionType = true;
 	if (numBytes == 0)
+	{
 		m_context << Instruction::POP << u256(0);
-	else
+		return numBytes;
+	}
+	solAssert(numBytes <= 32, "Static memory load of more than 32 bytes requested.");
+	m_context << (_fromCalldata ? Instruction::CALLDATALOAD : Instruction::MLOAD);
+	if (isExternalFunctionType)
+		splitExternalFunctionType(true);
+	else if (numBytes != 32)
 	{
-		solAssert(numBytes <= 32, "Static memory load of more than 32 bytes requested.");
-		m_context << (_fromCalldata ? Instruction::CALLDATALOAD : Instruction::MLOAD);
-		if (numBytes != 32)
-		{
-			// 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;
-			if (leftAligned)
-				m_context << shiftFactor << Instruction::MUL;
-		}
+		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;
+		if (leftAligned)
+			m_context << shiftFactor << Instruction::MUL;
 	}
 
 	return numBytes;
diff --git a/libsolidity/codegen/CompilerUtils.h b/libsolidity/codegen/CompilerUtils.h
index da74dc90..8e4033d6 100644
--- a/libsolidity/codegen/CompilerUtils.h
+++ b/libsolidity/codegen/CompilerUtils.h
@@ -114,6 +114,17 @@ public:
 	/// Stack post:
 	void memoryCopy();
 
+	/// Converts the combined and left-aligned (right-aligned if @a _rightAligned is true)
+	/// external function type <address><function identifier> into two stack slots:
+	/// address (right aligned), function identifier (right aligned)
+	void splitExternalFunctionType(bool _rightAligned);
+	/// Performs the opposite operation of splitExternalFunctionType(_rightAligned)
+	void combineExternalFunctionType(bool _rightAligned);
+	/// Appends code that combines the construction-time (if available) and runtime function
+	/// entry label of the given function into a single stack slot.
+	/// Note: This might cause the compilation queue of the runtime context to be extended.
+	void pushCombinedFunctionEntryLabel(Declaration const& _function);
+
 	/// Appends code for an implicit or explicit type conversion. This includes erasing higher
 	/// order bits (@see appendHighBitCleanup) when widening integer but also copy to memory
 	/// if a reference type is converted from calldata or storage to memory.
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
index ebb84784..8d60d6b3 100644
--- a/libsolidity/codegen/ContractCompiler.cpp
+++ b/libsolidity/codegen/ContractCompiler.cpp
@@ -60,14 +60,13 @@ void ContractCompiler::compileContract(
 }
 
 size_t ContractCompiler::compileConstructor(
-	CompilerContext const& _runtimeContext,
 	ContractDefinition const& _contract,
 	std::map<const ContractDefinition*, eth::Assembly const*> const& _contracts
 )
 {
 	CompilerContext::LocationSetter locationSetter(m_context, _contract);
 	initializeContext(_contract, _contracts);
-	return packIntoContractCreator(_contract, _runtimeContext);
+	return packIntoContractCreator(_contract);
 }
 
 size_t ContractCompiler::compileClone(
@@ -80,7 +79,7 @@ size_t ContractCompiler::compileClone(
 	appendInitAndConstructorCode(_contract);
 
 	//@todo determine largest return size of all runtime functions
-	eth::AssemblyItem runtimeSub = m_context.addSubroutine(cloneRuntime());
+	auto runtimeSub = m_context.addSubroutine(cloneRuntime());
 
 	// stack contains sub size
 	m_context << Instruction::DUP1 << runtimeSub << u256(0) << Instruction::CODECOPY;
@@ -88,7 +87,6 @@ size_t ContractCompiler::compileClone(
 
 	appendMissingFunctions();
 
-	solAssert(runtimeSub.data() < numeric_limits<size_t>::max(), "");
 	return size_t(runtimeSub.data());
 }
 
@@ -104,6 +102,13 @@ void ContractCompiler::initializeContext(
 	m_context.resetVisitedNodes(&_contract);
 }
 
+void ContractCompiler::appendCallValueCheck()
+{
+	// Throw if function is not payable but call contained ether.
+	m_context << Instruction::CALLVALUE;
+	m_context.appendConditionalJumpTo(m_context.errorTag());
+}
+
 void ContractCompiler::appendInitAndConstructorCode(ContractDefinition const& _contract)
 {
 	// Determine the arguments that are used for the base constructors.
@@ -139,23 +144,35 @@ void ContractCompiler::appendInitAndConstructorCode(ContractDefinition const& _c
 		appendConstructor(*constructor);
 	else if (auto c = m_context.nextConstructor(_contract))
 		appendBaseConstructor(*c);
+	else
+		appendCallValueCheck();
 }
 
-size_t ContractCompiler::packIntoContractCreator(ContractDefinition const& _contract, CompilerContext const& _runtimeContext)
+size_t ContractCompiler::packIntoContractCreator(ContractDefinition const& _contract)
 {
-	appendInitAndConstructorCode(_contract);
+	solAssert(!!m_runtimeCompiler, "");
 
-	eth::AssemblyItem runtimeSub = m_context.addSubroutine(_runtimeContext.assembly());
+	appendInitAndConstructorCode(_contract);
 
-	// stack contains sub size
-	m_context << Instruction::DUP1 << runtimeSub << u256(0) << Instruction::CODECOPY;
-	m_context << u256(0) << Instruction::RETURN;
+	// We jump to the deploy routine because we first have to append all missing functions,
+	// which can cause further functions to be added to the runtime context.
+	eth::AssemblyItem deployRoutine = m_context.appendJumpToNew();
 
-	// note that we have to include the functions again because of absolute jump labels
+	// We have to include copies of functions in the construction time and runtime context
+	// because of absolute jumps.
 	appendMissingFunctions();
+	m_runtimeCompiler->appendMissingFunctions();
 
-	solAssert(runtimeSub.data() < numeric_limits<size_t>::max(), "");
-	return size_t(runtimeSub.data());
+	m_context << deployRoutine;
+
+	solAssert(m_context.runtimeSub() != size_t(-1), "Runtime sub not registered");
+	m_context.pushSubroutineSize(m_context.runtimeSub());
+	m_context << Instruction::DUP1;
+	m_context.pushSubroutineOffset(m_context.runtimeSub());
+	m_context << u256(0) << Instruction::CODECOPY;
+	m_context << u256(0) << Instruction::RETURN;
+
+	return m_context.runtimeSub();
 }
 
 void ContractCompiler::appendBaseConstructor(FunctionDefinition const& _constructor)
@@ -176,6 +193,9 @@ void ContractCompiler::appendBaseConstructor(FunctionDefinition const& _construc
 void ContractCompiler::appendConstructor(FunctionDefinition const& _constructor)
 {
 	CompilerContext::LocationSetter locationSetter(m_context, _constructor);
+	if (!_constructor.isPayable())
+		appendCallValueCheck();
+
 	// copy constructor arguments from code to memory and then to stack, they are supplied after the actual program
 	if (!_constructor.parameters().empty())
 	{
@@ -243,11 +263,8 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 	if (fallback)
 	{
 		if (!fallback->isPayable())
-		{
-			// Throw if function is not payable but call contained ether.
-			m_context << Instruction::CALLVALUE;
-			m_context.appendConditionalJumpTo(m_context.errorTag());
-		}
+			appendCallValueCheck();
+
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
 		fallback->accept(*this);
 		m_context << returnTag;
@@ -266,11 +283,7 @@ void ContractCompiler::appendFunctionSelector(ContractDefinition const& _contrac
 		// We have to allow this for libraries, because value of the previous
 		// call is still visible in the delegatecall.
 		if (!functionType->isPayable() && !_contract.isLibrary())
-		{
-			// Throw if function is not payable but call contained ether.
-			m_context << Instruction::CALLVALUE;
-			m_context.appendConditionalJumpTo(m_context.errorTag());
-		}
+			appendCallValueCheck();
 
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
 		m_context << CompilerUtils::dataStartOffset;
@@ -293,13 +306,14 @@ void ContractCompiler::appendCalldataUnpacker(TypePointers const& _typeParameter
 	{
 		// stack: v1 v2 ... v(k-1) base_offset current_offset
 		TypePointer type = parameterType->decodingType();
+		solAssert(type, "No decoding type found.");
 		if (type->category() == Type::Category::Array)
 		{
 			auto const& arrayType = dynamic_cast<ArrayType const&>(*type);
-			solAssert(!arrayType.baseType()->isDynamicallySized(), "Nested arrays not yet implemented.");
+			solUnimplementedAssert(!arrayType.baseType()->isDynamicallySized(), "Nested arrays not yet implemented.");
 			if (_fromMemory)
 			{
-				solAssert(
+				solUnimplementedAssert(
 					arrayType.baseType()->isValueType(),
 					"Nested memory arrays not yet implemented here."
 				);
@@ -515,7 +529,19 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 			{
 				solAssert(!!decl->type(), "Type of declaration required but not yet determined.");
 				if (FunctionDefinition const* functionDef = dynamic_cast<FunctionDefinition const*>(decl))
-					_assembly.append(m_context.virtualFunctionEntryLabel(*functionDef).pushTag());
+				{
+					functionDef = &m_context.resolveVirtualFunction(*functionDef);
+					_assembly.append(m_context.functionEntryLabel(*functionDef).pushTag());
+					// 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);
+					}
+				}
 				else if (auto variable = dynamic_cast<VariableDeclaration const*>(decl))
 				{
 					solAssert(!variable->isConstant(), "");
@@ -611,12 +637,25 @@ bool ContractCompiler::visit(WhileStatement const& _whileStatement)
 	m_breakTags.push_back(loopEnd);
 
 	m_context << loopStart;
-	compileExpression(_whileStatement.condition());
-	m_context << Instruction::ISZERO;
-	m_context.appendConditionalJumpTo(loopEnd);
+
+	// While loops have the condition prepended
+	if (!_whileStatement.isDoWhile())
+	{
+		compileExpression(_whileStatement.condition());
+		m_context << Instruction::ISZERO;
+		m_context.appendConditionalJumpTo(loopEnd);
+	}
 
 	_whileStatement.body().accept(*this);
 
+	// Do-while loops have the condition appended
+	if (_whileStatement.isDoWhile())
+	{
+		compileExpression(_whileStatement.condition());
+		m_context << Instruction::ISZERO;
+		m_context.appendConditionalJumpTo(loopEnd);
+	}
+
 	m_context.appendJumpTo(loopStart);
 	m_context << loopEnd;
 
@@ -858,7 +897,7 @@ void ContractCompiler::compileExpression(Expression const& _expression, TypePoin
 		CompilerUtils(m_context).convertType(*_expression.annotation().type, *_targetType);
 }
 
-eth::Assembly ContractCompiler::cloneRuntime()
+eth::AssemblyPointer ContractCompiler::cloneRuntime()
 {
 	eth::Assembly a;
 	a << Instruction::CALLDATASIZE;
@@ -876,5 +915,5 @@ eth::Assembly ContractCompiler::cloneRuntime()
 	a.appendJumpI(a.errorTag());
 	//@todo adjust for larger return values, make this dynamic.
 	a << u256(0x20) << u256(0) << Instruction::RETURN;
-	return a;
+	return make_shared<eth::Assembly>(a);
 }
diff --git a/libsolidity/codegen/ContractCompiler.h b/libsolidity/codegen/ContractCompiler.h
index 0799a543..10febcf7 100644
--- a/libsolidity/codegen/ContractCompiler.h
+++ b/libsolidity/codegen/ContractCompiler.h
@@ -38,11 +38,12 @@ namespace solidity {
 class ContractCompiler: private ASTConstVisitor
 {
 public:
-	explicit ContractCompiler(CompilerContext& _context, bool _optimise):
+	explicit ContractCompiler(ContractCompiler* _runtimeCompiler, CompilerContext& _context, bool _optimise):
 		m_optimise(_optimise),
+		m_runtimeCompiler(_runtimeCompiler),
 		m_context(_context)
 	{
-		m_context = CompilerContext();
+		m_context = CompilerContext(_runtimeCompiler ? &_runtimeCompiler->m_context : nullptr);
 	}
 
 	void compileContract(
@@ -52,7 +53,6 @@ public:
 	/// Compiles the constructor part of the contract.
 	/// @returns the identifier of the runtime sub-assembly.
 	size_t compileConstructor(
-		CompilerContext const& _runtimeContext,
 		ContractDefinition const& _contract,
 		std::map<ContractDefinition const*, eth::Assembly const*> const& _contracts
 	);
@@ -74,12 +74,13 @@ private:
 	/// Adds the code that is run at creation time. Should be run after exchanging the run-time context
 	/// with a new and initialized context. Adds the constructor code.
 	/// @returns the identifier of the runtime sub assembly
-	size_t packIntoContractCreator(ContractDefinition const& _contract, CompilerContext const& _runtimeContext);
+	size_t packIntoContractCreator(ContractDefinition const& _contract);
 	/// Appends state variable initialisation and constructor code.
 	void appendInitAndConstructorCode(ContractDefinition const& _contract);
 	void appendBaseConstructor(FunctionDefinition const& _constructor);
 	void appendConstructor(FunctionDefinition const& _constructor);
 	void appendFunctionSelector(ContractDefinition const& _contract);
+	void appendCallValueCheck();
 	/// Creates code that unpacks the arguments for the given function represented by a vector of TypePointers.
 	/// From memory if @a _fromMemory is true, otherwise from call data.
 	/// Expects source offset on the stack, which is removed.
@@ -114,9 +115,11 @@ private:
 	void compileExpression(Expression const& _expression, TypePointer const& _targetType = TypePointer());
 
 	/// @returns the runtime assembly for clone contracts.
-	static eth::Assembly cloneRuntime();
+	static eth::AssemblyPointer cloneRuntime();
 
 	bool const m_optimise;
+	/// Pointer to the runtime compiler in case this is a creation compiler.
+	ContractCompiler* m_runtimeCompiler = nullptr;
 	CompilerContext& m_context;
 	std::vector<eth::AssemblyItem> m_breakTags; ///< tag to jump to for a "break" statement
 	std::vector<eth::AssemblyItem> m_continueTags; ///< tag to jump to for a "continue" statement
diff --git a/libsolidity/codegen/ExpressionCompiler.cpp b/libsolidity/codegen/ExpressionCompiler.cpp
index 9a096e2d..7a328528 100644
--- a/libsolidity/codegen/ExpressionCompiler.cpp
+++ b/libsolidity/codegen/ExpressionCompiler.cpp
@@ -99,7 +99,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
 		if (auto mappingType = dynamic_cast<MappingType const*>(returnType.get()))
 		{
 			solAssert(CompilerUtils::freeMemoryPointer >= 0x40, "");
-			solAssert(
+			solUnimplementedAssert(
 				!paramTypes[i]->isDynamicallySized(),
 				"Accessors for mapping with dynamically-sized keys not yet implemented."
 			);
@@ -211,7 +211,7 @@ bool ExpressionCompiler::visit(Assignment const& _assignment)
 	Token::Value op = _assignment.assignmentOperator();
 	if (op != Token::Assign) // compound assignment
 	{
-		solAssert(_assignment.annotation().type->isValueType(), "Compound operators not implemented for non-value types.");
+		solUnimplementedAssert(_assignment.annotation().type->isValueType(), "Compound operators not implemented for non-value types.");
 		unsigned lvalueSize = m_currentLValue->sizeOnStack();
 		unsigned itemSize = _assignment.annotation().type->sizeOnStack();
 		if (lvalueSize > 0)
@@ -312,7 +312,7 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
 		if (!_unaryOperation.isPrefixOperation())
 		{
 			// store value for later
-			solAssert(_unaryOperation.annotation().type->sizeOnStack() == 1, "Stack size != 1 not implemented.");
+			solUnimplementedAssert(_unaryOperation.annotation().type->sizeOnStack() == 1, "Stack size != 1 not implemented.");
 			m_context << Instruction::DUP1;
 			if (m_currentLValue->sizeOnStack() > 0)
 				for (unsigned i = 1 + m_currentLValue->sizeOnStack(); i > 0; --i)
@@ -488,6 +488,13 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 				parameterSize += function.selfType()->sizeOnStack();
 			}
 
+			if (m_context.runtimeContext())
+				// We have a runtime context, so we need the creation part.
+				m_context << (u256(1) << 32) << Instruction::SWAP1 << Instruction::DIV;
+			else
+				// Extract the runtime part.
+				m_context << ((u256(1) << 32) - 1) << Instruction::AND;
+
 			m_context.appendJump(eth::AssemblyItem::JumpType::IntoFunction);
 			m_context << returnLabel;
 
@@ -521,8 +528,11 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 			// copy the contract's code into memory
 			eth::Assembly const& assembly = m_context.compiledContract(contract);
 			utils().fetchFreeMemoryPointer();
+			// TODO we create a copy here, which is actually what we want.
+			// This should be revisited at the point where we fix
+			// https://github.com/ethereum/solidity/issues/1092
 			// pushes size
-			eth::AssemblyItem subroutine = m_context.addSubroutine(assembly);
+			auto subroutine = m_context.addSubroutine(make_shared<eth::Assembly>(assembly));
 			m_context << Instruction::DUP1 << subroutine;
 			m_context << Instruction::DUP4 << Instruction::CODECOPY;
 
@@ -845,9 +855,8 @@ bool ExpressionCompiler::visit(MemberAccess const& _memberAccess)
 			);
 			if (funType->location() == FunctionType::Location::Internal)
 			{
-				m_context << m_context.functionEntryLabel(
-					dynamic_cast<FunctionDefinition const&>(funType->declaration())
-				).pushTag();
+				FunctionDefinition const& funDef = dynamic_cast<decltype(funDef)>(funType->declaration());
+				utils().pushCombinedFunctionEntryLabel(funDef);
 				utils().moveIntoStack(funType->selfType()->sizeOnStack(), 1);
 			}
 			else
@@ -883,7 +892,7 @@ bool ExpressionCompiler::visit(MemberAccess const& _memberAccess)
 					// us to link against it although we actually do not need it.
 					auto const* function = dynamic_cast<FunctionDefinition const*>(_memberAccess.annotation().referencedDeclaration);
 					solAssert(!!function, "Function not found in member access");
-					m_context << m_context.functionEntryLabel(*function).pushTag();
+					utils().pushCombinedFunctionEntryLabel(*function);
 				}
 			}
 			else if (dynamic_cast<TypeType const*>(_memberAccess.annotation().type.get()))
@@ -915,10 +924,10 @@ bool ExpressionCompiler::visit(MemberAccess const& _memberAccess)
 		if (type.isSuper())
 		{
 			solAssert(!!_memberAccess.annotation().referencedDeclaration, "Referenced declaration not resolved.");
-			m_context << m_context.superFunctionEntryLabel(
+			utils().pushCombinedFunctionEntryLabel(m_context.superFunction(
 				dynamic_cast<FunctionDefinition const&>(*_memberAccess.annotation().referencedDeclaration),
 				type.contractDefinition()
-			).pushTag();
+			));
 		}
 		else
 		{
@@ -1141,7 +1150,7 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 			break;
 		case DataLocation::CallData:
 			//@todo if we implement this, the value in calldata has to be added to the base offset
-			solAssert(!arrayType.baseType()->isDynamicallySized(), "Nested arrays not yet implemented.");
+			solUnimplementedAssert(!arrayType.baseType()->isDynamicallySized(), "Nested arrays not yet implemented.");
 			if (arrayType.baseType()->isValueType())
 				CompilerUtils(m_context).loadFromMemoryDynamic(
 					*arrayType.baseType(),
@@ -1203,7 +1212,7 @@ void ExpressionCompiler::endVisit(Identifier const& _identifier)
 		}
 	}
 	else if (FunctionDefinition const* functionDef = dynamic_cast<FunctionDefinition const*>(declaration))
-		m_context << m_context.virtualFunctionEntryLabel(*functionDef).pushTag();
+		utils().pushCombinedFunctionEntryLabel(m_context.resolveVirtualFunction(*functionDef));
 	else if (auto variable = dynamic_cast<VariableDeclaration const*>(declaration))
 		appendVariable(*variable, static_cast<Expression const&>(_identifier));
 	else if (auto contract = dynamic_cast<ContractDefinition const*>(declaration))
@@ -1266,6 +1275,17 @@ void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type
 {
 	if (_operator == Token::Equal || _operator == Token::NotEqual)
 	{
+		if (FunctionType const* funType = dynamic_cast<decltype(funType)>(&_type))
+		{
+			if (funType->location() == FunctionType::Location::Internal)
+			{
+				// We have to remove the upper bits (construction time value) because they might
+				// be "unknown" in one of the operands and not in the other.
+				m_context << ((u256(1) << 32) - 1) << Instruction::AND;
+				m_context << Instruction::SWAP1;
+				m_context << ((u256(1) << 32) - 1) << Instruction::AND;
+			}
+		}
 		m_context << Instruction::EQ;
 		if (_operator == Token::NotEqual)
 			m_context << Instruction::ISZERO;
@@ -1318,7 +1338,7 @@ void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Ty
 	bool const c_isSigned = type.isSigned();
 
 	if (_type.category() == Type::Category::FixedPoint)
-		solAssert(false, "Not yet implemented - FixedPointType.");
+		solUnimplemented("Not yet implemented - FixedPointType.");
 
 	switch (_operator)
 	{
@@ -1372,7 +1392,7 @@ void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator)
 
 void ExpressionCompiler::appendShiftOperatorCode(Token::Value _operator)
 {
-	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Shift operators not yet implemented."));
+	BOOST_THROW_EXCEPTION(UnimplementedFeatureError() << errinfo_comment("Shift operators not yet implemented."));
 	switch (_operator)
 	{
 	case Token::SHL:
@@ -1634,7 +1654,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
 
 void ExpressionCompiler::appendExpressionCopyToMemory(Type const& _expectedType, Expression const& _expression)
 {
-	solAssert(_expectedType.isValueType(), "Not implemented for non-value types.");
+	solUnimplementedAssert(_expectedType.isValueType(), "Not implemented for non-value types.");
 	_expression.accept(*this);
 	utils().convertType(*_expression.annotation().type, _expectedType, true);
 	utils().storeInMemoryDynamic(_expectedType);
diff --git a/libsolidity/codegen/LValue.cpp b/libsolidity/codegen/LValue.cpp
index c1e05792..2ec7f800 100644
--- a/libsolidity/codegen/LValue.cpp
+++ b/libsolidity/codegen/LValue.cpp
@@ -120,7 +120,7 @@ void MemoryItem::storeValue(Type const& _sourceType, SourceLocation const&, bool
 	}
 	else
 	{
-		solAssert(_sourceType == *m_dataType, "Conversion not implemented for assignment to memory.");
+		solUnimplementedAssert(_sourceType == *m_dataType, "Conversion not implemented for assignment to memory.");
 
 		solAssert(m_dataType->sizeOnStack() == 1, "");
 		if (!_move)
@@ -153,7 +153,8 @@ StorageItem::StorageItem(CompilerContext& _compilerContext, Type const& _type):
 {
 	if (m_dataType->isValueType())
 	{
-		solAssert(m_dataType->storageSize() == m_dataType->sizeOnStack(), "");
+		if (m_dataType->category() != Type::Category::Function)
+			solAssert(m_dataType->storageSize() == m_dataType->sizeOnStack(), "");
 		solAssert(m_dataType->storageSize() == 1, "Invalid storage size.");
 	}
 }
@@ -176,21 +177,39 @@ void StorageItem::retrieveValue(SourceLocation const&, bool _remove) const
 		m_context << Instruction::POP << Instruction::SLOAD;
 	else
 	{
+		bool cleaned = false;
 		m_context
 			<< Instruction::SWAP1 << Instruction::SLOAD << Instruction::SWAP1
 			<< u256(0x100) << Instruction::EXP << Instruction::SWAP1 << Instruction::DIV;
 		if (m_dataType->category() == Type::Category::FixedPoint)
 			// implementation should be very similar to the integer case.
-			solAssert(false, "Not yet implemented - FixedPointType.");
+			solUnimplemented("Not yet implemented - FixedPointType.");
 		if (m_dataType->category() == Type::Category::FixedBytes)
+		{
 			m_context << (u256(0x1) << (256 - 8 * m_dataType->storageBytes())) << Instruction::MUL;
+			cleaned = true;
+		}
 		else if (
 			m_dataType->category() == Type::Category::Integer &&
 			dynamic_cast<IntegerType const&>(*m_dataType).isSigned()
 		)
+		{
 			m_context << u256(m_dataType->storageBytes() - 1) << Instruction::SIGNEXTEND;
-		else
+			cleaned = true;
+		}
+		else if (FunctionType const* fun = dynamic_cast<decltype(fun)>(m_dataType))
+		{
+			if (fun->location() == FunctionType::Location::External)
+			{
+				CompilerUtils(m_context).splitExternalFunctionType(false);
+				cleaned = true;
+			}
+		}
+		if (!cleaned)
+		{
+			solAssert(m_dataType->sizeOnStack() == 1, "");
 			m_context << ((u256(0x1) << (8 * m_dataType->storageBytes())) - 1) << Instruction::AND;
+		}
 	}
 }
 
@@ -204,6 +223,7 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc
 		solAssert(m_dataType->storageBytes() > 0, "Invalid storage bytes size.");
 		if (m_dataType->storageBytes() == 32)
 		{
+			solAssert(m_dataType->sizeOnStack() == 1, "Invalid stack size.");
 			// offset should be zero
 			m_context << Instruction::POP;
 			if (!_move)
@@ -222,16 +242,27 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc
 			m_context
 				<< Instruction::DUP2 << ((u256(1) << (8 * m_dataType->storageBytes())) - 1)
 				<< Instruction::MUL;
-			m_context << Instruction::NOT << Instruction::AND;
-			// stack: value storage_ref multiplier cleared_value
-			m_context
-				<< Instruction::SWAP1 << Instruction::DUP4;
+			m_context << Instruction::NOT << Instruction::AND << Instruction::SWAP1;
+			// stack: value storage_ref cleared_value multiplier
+			utils.copyToStackTop(3 + m_dataType->sizeOnStack(), m_dataType->sizeOnStack());
 			// stack: value storage_ref cleared_value multiplier value
-			if (m_dataType->category() == Type::Category::FixedBytes)
+			if (FunctionType const* fun = dynamic_cast<decltype(fun)>(m_dataType))
+			{
+				if (fun->location() == FunctionType::Location::External)
+					// Combine the two-item function type into a single stack slot.
+					utils.combineExternalFunctionType(false);
+				else
+					m_context <<
+						((u256(1) << (8 * m_dataType->storageBytes())) - 1) <<
+						Instruction::AND;
+			}
+			else if (m_dataType->category() == Type::Category::FixedBytes)
 				m_context
 					<< (u256(0x1) << (256 - 8 * dynamic_cast<FixedBytesType const&>(*m_dataType).numBytes()))
 					<< Instruction::SWAP1 << Instruction::DIV;
 			else
+			{
+				solAssert(m_dataType->sizeOnStack() == 1, "Invalid stack size for opaque type.");
 				// remove the higher order bits
 				m_context
 					<< (u256(1) << (8 * (32 - m_dataType->storageBytes())))
@@ -239,11 +270,12 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc
 					<< Instruction::DUP2
 					<< Instruction::MUL
 					<< Instruction::DIV;
+			}
 			m_context  << Instruction::MUL << Instruction::OR;
 			// stack: value storage_ref updated_value
 			m_context << Instruction::SWAP1 << Instruction::SSTORE;
 			if (_move)
-				m_context << Instruction::POP;
+				utils.popStackElement(*m_dataType);
 		}
 	}
 	else
diff --git a/libsolidity/formal/Why3Translator.cpp b/libsolidity/formal/Why3Translator.cpp
index 813fa3ab..5934d593 100644
--- a/libsolidity/formal/Why3Translator.cpp
+++ b/libsolidity/formal/Why3Translator.cpp
@@ -410,6 +410,16 @@ 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();
diff --git a/libsolidity/grammar.txt b/libsolidity/grammar.txt
index d84ee10c..c8bc3aed 100644
--- a/libsolidity/grammar.txt
+++ b/libsolidity/grammar.txt
@@ -22,7 +22,7 @@ StructDefinition = 'struct' Identifier '{'
                      ( VariableDeclaration ';' (VariableDeclaration ';')* )? '}'
 ModifierDefinition = 'modifier' Identifier ParameterList? Block
 FunctionDefinition = 'function' Identifier? ParameterList
-                     ( FunctionCall | Identifier | 'constant' | 'external' | 'public' | 'internal' | 'private' )*
+                     ( FunctionCall | Identifier | 'constant' |' payable' | 'external' | 'public' | 'internal' | 'private' )*
                      ( 'returns' ParameterList )? Block
 EventDefinition = 'event' Identifier IndexedParameterList 'anonymous'? ';'
 
@@ -31,18 +31,21 @@ EnumDefinition = 'enum' Identifier '{' EnumValue? (',' EnumValue)* '}'
 
 IndexedParameterList = '(' ( TypeName 'indexed'? Identifier? (',' TypeName 'indexed'? Identifier?)* )? ')'
 ParameterList =        '(' ( TypeName            Identifier? (',' TypeName            Identifier?)* )? ')'
+TypeNameList =         '(' ( TypeName (',' TypeName )* )? ')'
 
 // semantic restriction: mappings and structs (recursively) containing mappings
 // are not allowed in argument lists
 VariableDeclaration = TypeName Identifier
-TypeName = ElementaryTypeName | Identifier StorageLocation? | Mapping | ArrayTypeName
+TypeName = ElementaryTypeName | Identifier StorageLocation? | Mapping | ArrayTypeName | FunctionTypeName
 Mapping = 'mapping' '(' ElementaryTypeName '=>' TypeName ')'
 ArrayTypeName = TypeName StorageLocation? '[' Expression? ']'
+FunctionTypeName = 'function' TypeNameList ( 'internal' | 'external' | 'constant' | 'payable' )*
+                   ( 'returns' TypeNameList )?
 StorageLocation = 'memory' | 'storage'
 
 Block = '{' Statement* '}'
 Statement = IfStatement | WhileStatement | ForStatement | Block |
-            ( PlaceholderStatement | Continue | Break | Return |
+            ( DoWhileStatement | PlaceholderStatement | Continue | Break | Return |
               Throw | SimpleStatement ) ';'
 
 ExpressionStatement = Expression
@@ -51,6 +54,7 @@ WhileStatement = 'while' '(' Expression ')' Statement
 PlaceholderStatement = '_'
 SimpleStatement = VariableDefinition | ExpressionStatement
 ForStatement = 'for' '(' (SimpleStatement)? ';' (Expression)? ';' (ExpressionStatement)? ')' Statement
+DoWhileStatement = 'do' Statement 'while' '(' Expression ')'
 Continue = 'continue'
 Break = 'break'
 Return = 'return' Expression?
@@ -64,7 +68,7 @@ Expression =
   | Expression '**' Expression
   | Expression ('*' | '/' | '%') Expression
   | Expression ('+' | '-') Expression
-  | Expression ('<<' | '>>' | '>>>')
+  | Expression ('<<' | '>>')
   | Expression '&' Expression
   | Expression '^' Expression
   | Expression '|' Expression
diff --git a/libsolidity/inlineasm/AsmCodeGen.cpp b/libsolidity/inlineasm/AsmCodeGen.cpp
index 5d920cb7..771f1042 100644
--- a/libsolidity/inlineasm/AsmCodeGen.cpp
+++ b/libsolidity/inlineasm/AsmCodeGen.cpp
@@ -81,7 +81,11 @@ struct GeneratorState
 class LabelOrganizer: public boost::static_visitor<>
 {
 public:
-	LabelOrganizer(GeneratorState& _state): m_state(_state) {}
+	LabelOrganizer(GeneratorState& _state): m_state(_state)
+	{
+		// Make the Solidity ErrorTag available to inline assembly
+		m_state.labels.insert(make_pair("invalidJumpLabel", m_state.assembly.errorTag()));
+	}
 
 	template <class T>
 	void operator()(T const& /*_item*/) { }
@@ -216,10 +220,18 @@ public:
 		size_t numVariables = m_state.variables.size();
 		int deposit = m_state.assembly.deposit();
 		std::for_each(_block.statements.begin(), _block.statements.end(), boost::apply_visitor(*this));
-		deposit = m_state.assembly.deposit() - deposit;
+
+		// pop variables
+		while (m_state.variables.size() > numVariables)
+		{
+			m_state.assembly.append(solidity::Instruction::POP);
+			m_state.variables.pop_back();
+		}
 
 		m_state.assembly.setSourceLocation(_block.location);
 
+		deposit = m_state.assembly.deposit() - deposit;
+
 		// issue warnings for stack height discrepancies
 		if (deposit < 0)
 		{
@@ -238,12 +250,6 @@ public:
 			);
 		}
 
-		// pop variables
-		while (m_state.variables.size() > numVariables)
-		{
-			m_state.assembly.append(solidity::Instruction::POP);
-			m_state.variables.pop_back();
-		}
 	}
 
 private:
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index efbbd237..f1eb2614 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -37,6 +37,7 @@
 #include <libsolidity/interface/InterfaceHandler.h>
 #include <libsolidity/formal/Why3Translator.h>
 
+#include <libevmasm/Exceptions.h>
 #include <libdevcore/SHA3.h>
 
 #include <boost/algorithm/string.hpp>
@@ -345,17 +346,17 @@ map<string, unsigned> CompilerStack::sourceIndices() const
 	return indices;
 }
 
-string const& CompilerStack::interface(string const& _contractName) const
+Json::Value const& CompilerStack::interface(string const& _contractName) const
 {
 	return metadata(_contractName, DocumentationType::ABIInterface);
 }
 
-string const& CompilerStack::metadata(string const& _contractName, DocumentationType _type) const
+Json::Value const& CompilerStack::metadata(string const& _contractName, DocumentationType _type) const
 {
 	if (!m_parseSuccessful)
 		BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
 
-	std::unique_ptr<string const>* doc;
+	std::unique_ptr<Json::Value const>* doc;
 	Contract const& currentContract = contract(_contractName);
 
 	// checks wheather we already have the documentation
@@ -376,7 +377,7 @@ string const& CompilerStack::metadata(string const& _contractName, Documentation
 
 	// caches the result
 	if (!*doc)
-		doc->reset(new string(InterfaceHandler::documentation(*currentContract.contract, _type)));
+		doc->reset(new Json::Value(InterfaceHandler::documentation(*currentContract.contract, _type)));
 
 	return *(*doc);
 }
@@ -590,9 +591,19 @@ void CompilerStack::compileContract(
 	compiledContract.runtimeObject = compiler->runtimeObject();
 	_compiledContracts[compiledContract.contract] = &compiler->assembly();
 
-	Compiler cloneCompiler(_optimize, _runs);
-	cloneCompiler.compileClone(_contract, _compiledContracts);
-	compiledContract.cloneObject = cloneCompiler.assembledObject();
+	try
+	{
+		Compiler cloneCompiler(_optimize, _runs);
+		cloneCompiler.compileClone(_contract, _compiledContracts);
+		compiledContract.cloneObject = cloneCompiler.assembledObject();
+	}
+	catch (eth::AssemblyException const&)
+	{
+		// In some cases (if the constructor requests a runtime function), it is not
+		// possible to compile the clone.
+
+		// TODO: Report error / warning
+	}
 }
 
 std::string CompilerStack::defaultContractName() const
diff --git a/libsolidity/interface/CompilerStack.h b/libsolidity/interface/CompilerStack.h
index da479638..1fd30c4d 100644
--- a/libsolidity/interface/CompilerStack.h
+++ b/libsolidity/interface/CompilerStack.h
@@ -162,14 +162,14 @@ 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 string representing the contract interface in JSON.
+	/// @returns a JSON representing the contract interface.
 	/// Prerequisite: Successful call to parse or compile.
-	std::string const& interface(std::string const& _contractName = "") const;
-	/// @returns a string representing the contract's documentation in JSON.
+	Json::Value const& interface(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.
 	/// Can be one of 4 types defined at @c DocumentationType
-	std::string const& metadata(std::string const& _contractName, DocumentationType _type) const;
+	Json::Value const& metadata(std::string const& _contractName, DocumentationType _type) const;
 
 	/// @returns the previously used scanner, useful for counting lines during error reporting.
 	Scanner const& scanner(std::string const& _sourceName = "") const;
@@ -213,9 +213,9 @@ private:
 		eth::LinkerObject object;
 		eth::LinkerObject runtimeObject;
 		eth::LinkerObject cloneObject;
-		mutable std::unique_ptr<std::string const> interface;
-		mutable std::unique_ptr<std::string const> userDocumentation;
-		mutable std::unique_ptr<std::string const> devDocumentation;
+		mutable std::unique_ptr<Json::Value const> interface;
+		mutable std::unique_ptr<Json::Value const> userDocumentation;
+		mutable std::unique_ptr<Json::Value const> devDocumentation;
 		mutable std::unique_ptr<std::string const> sourceMapping;
 		mutable std::unique_ptr<std::string const> runtimeSourceMapping;
 	};
diff --git a/libsolidity/interface/Exceptions.h b/libsolidity/interface/Exceptions.h
index 07835320..c651548a 100644
--- a/libsolidity/interface/Exceptions.h
+++ b/libsolidity/interface/Exceptions.h
@@ -37,6 +37,7 @@ using ErrorList = std::vector<std::shared_ptr<Error const>>;
 struct CompilerError: virtual Exception {};
 struct InternalCompilerError: virtual Exception {};
 struct FatalError: virtual Exception {};
+struct UnimplementedFeatureError: virtual Exception{};
 
 class Error: virtual public Exception
 {
diff --git a/libsolidity/interface/InterfaceHandler.cpp b/libsolidity/interface/InterfaceHandler.cpp
index de16a372..9944bb22 100644
--- a/libsolidity/interface/InterfaceHandler.cpp
+++ b/libsolidity/interface/InterfaceHandler.cpp
@@ -8,7 +8,7 @@ using namespace std;
 using namespace dev;
 using namespace dev::solidity;
 
-string InterfaceHandler::documentation(
+Json::Value InterfaceHandler::documentation(
 	ContractDefinition const& _contractDef,
 	DocumentationType _type
 )
@@ -24,10 +24,9 @@ string InterfaceHandler::documentation(
 	}
 
 	BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation type"));
-	return "";
 }
 
-string InterfaceHandler::abiInterface(ContractDefinition const& _contractDef)
+Json::Value InterfaceHandler::abiInterface(ContractDefinition const& _contractDef)
 {
 	Json::Value abi(Json::arrayValue);
 
@@ -67,8 +66,9 @@ string InterfaceHandler::abiInterface(ContractDefinition const& _contractDef)
 	{
 		Json::Value method;
 		method["type"] = "constructor";
-		auto externalFunction = FunctionType(*_contractDef.constructor()).interfaceFunctionType();
+		auto externalFunction = FunctionType(*_contractDef.constructor(), false).interfaceFunctionType();
 		solAssert(!!externalFunction, "");
+		method["payable"] = externalFunction->isPayable();
 		method["inputs"] = populateParameters(
 			externalFunction->parameterNames(),
 			externalFunction->parameterTypeNames(_contractDef.isLibrary())
@@ -77,7 +77,7 @@ string InterfaceHandler::abiInterface(ContractDefinition const& _contractDef)
 	}
 	if (_contractDef.fallbackFunction())
 	{
-		auto externalFunctionType = FunctionType(*_contractDef.fallbackFunction()).interfaceFunctionType();
+		auto externalFunctionType = FunctionType(*_contractDef.fallbackFunction(), false).interfaceFunctionType();
 		solAssert(!!externalFunctionType, "");
 		Json::Value method;
 		method["type"] = "fallback";
@@ -103,10 +103,11 @@ string InterfaceHandler::abiInterface(ContractDefinition const& _contractDef)
 		event["inputs"] = params;
 		abi.append(event);
 	}
-	return Json::FastWriter().write(abi);
+
+	return abi;
 }
 
-string InterfaceHandler::userDocumentation(ContractDefinition const& _contractDef)
+Json::Value InterfaceHandler::userDocumentation(ContractDefinition const& _contractDef)
 {
 	Json::Value doc;
 	Json::Value methods(Json::objectValue);
@@ -126,10 +127,10 @@ string InterfaceHandler::userDocumentation(ContractDefinition const& _contractDe
 			}
 	doc["methods"] = methods;
 
-	return Json::StyledWriter().write(doc);
+	return doc;
 }
 
-string InterfaceHandler::devDocumentation(ContractDefinition const& _contractDef)
+Json::Value InterfaceHandler::devDocumentation(ContractDefinition const& _contractDef)
 {
 	Json::Value doc;
 	Json::Value methods(Json::objectValue);
@@ -175,7 +176,7 @@ string InterfaceHandler::devDocumentation(ContractDefinition const& _contractDef
 	}
 	doc["methods"] = methods;
 
-	return Json::StyledWriter().write(doc);
+	return doc;
 }
 
 string InterfaceHandler::extractDoc(multimap<string, DocTag> const& _tags, string const& _name)
diff --git a/libsolidity/interface/InterfaceHandler.h b/libsolidity/interface/InterfaceHandler.h
index 54199e4e..d4f2eaf4 100644
--- a/libsolidity/interface/InterfaceHandler.h
+++ b/libsolidity/interface/InterfaceHandler.h
@@ -64,24 +64,24 @@ public:
 	/// @param _contractDef The contract definition
 	/// @param _type        The type of the documentation. Can be one of the
 	///                     types provided by @c DocumentationType
-	/// @return             A string with the json representation of provided type
-	static std::string documentation(
+	/// @return             A JSON representation of provided type
+	static Json::Value documentation(
 		ContractDefinition const& _contractDef,
 		DocumentationType _type
 	);
 	/// Get the ABI Interface of the contract
 	/// @param _contractDef The contract definition
-	/// @return             A string with the json representation of the contract's ABI Interface
-	static std::string abiInterface(ContractDefinition const& _contractDef);
+	/// @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 string with the json representation of the contract's user documentation
-	static std::string userDocumentation(ContractDefinition const& _contractDef);
+	/// @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 string with the json representation
+	/// @return             A JSON representation
 	///                     of the contract's developer documentation
-	static std::string devDocumentation(ContractDefinition const& _contractDef);
+	static Json::Value devDocumentation(ContractDefinition const& _contractDef);
 
 private:
 	/// @returns concatenation of all content under the given tag name.
diff --git a/libsolidity/interface/Utils.h b/libsolidity/interface/Utils.h
index 738669ac..eef8c917 100644
--- a/libsolidity/interface/Utils.h
+++ b/libsolidity/interface/Utils.h
@@ -30,6 +30,7 @@ namespace dev
 namespace solidity
 {
 struct InternalCompilerError;
+struct UnimplementedFeatureError;
 }
 }
 
@@ -37,3 +38,8 @@ struct InternalCompilerError;
 #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/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 0e99d1e7..02b7d5e0 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -217,7 +217,9 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition(bool _isLibrary)
 		if (currentTokenValue == Token::RBrace)
 			break;
 		else if (currentTokenValue == Token::Function)
-			subNodes.push_back(parseFunctionDefinition(name.get()));
+			// This can be a function or a state variable of function type (especially
+			// complicated to distinguish fallback function from function type state variable)
+			subNodes.push_back(parseFunctionDefinitionOrFunctionTypeStateVariable(name.get()));
 		else if (currentTokenValue == Token::Struct)
 			subNodes.push_back(parseStructDefinition());
 		else if (currentTokenValue == Token::Enum)
@@ -288,81 +290,121 @@ Declaration::Visibility Parser::parseVisibilitySpecifier(Token::Value _token)
 	return visibility;
 }
 
-ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const* _contractName)
+Parser::FunctionHeaderParserResult Parser::parseFunctionHeader(bool _forceEmptyName, bool _allowModifiers)
 {
-	ASTNodeFactory nodeFactory(*this);
-	ASTPointer<ASTString> docstring;
-	if (m_scanner->currentCommentLiteral() != "")
-		docstring = make_shared<ASTString>(m_scanner->currentCommentLiteral());
-
+	FunctionHeaderParserResult result;
 	expectToken(Token::Function);
-	ASTPointer<ASTString> name;
-	if (m_scanner->currentToken() == Token::LParen)
-		name = make_shared<ASTString>(); // anonymous function
+	if (_forceEmptyName || m_scanner->currentToken() == Token::LParen)
+		result.name = make_shared<ASTString>(); // anonymous function
 	else
-		name = expectIdentifierToken();
+		result.name = expectIdentifierToken();
 	VarDeclParserOptions options;
 	options.allowLocationSpecifier = true;
-	ASTPointer<ParameterList> parameters(parseParameterList(options));
-	bool isDeclaredConst = false;
-	bool isPayable = false;
-	Declaration::Visibility visibility(Declaration::Visibility::Default);
-	vector<ASTPointer<ModifierInvocation>> modifiers;
+	result.parameters = parseParameterList(options);
 	while (true)
 	{
 		Token::Value token = m_scanner->currentToken();
 		if (token == Token::Const)
 		{
-			isDeclaredConst = true;
+			result.isDeclaredConst = true;
 			m_scanner->next();
 		}
 		else if (m_scanner->currentToken() == Token::Payable)
 		{
-			isPayable = true;
+			result.isPayable = true;
 			m_scanner->next();
 		}
-		else if (token == Token::Identifier)
-			modifiers.push_back(parseModifierInvocation());
+		else if (_allowModifiers && token == Token::Identifier)
+		{
+			// This can either be a modifier (function declaration) or the name of the
+			// variable (function type name plus variable).
+			if (
+				m_scanner->peekNextToken() == Token::Semicolon ||
+				m_scanner->peekNextToken() == Token::Assign
+			)
+				// Variable declaration, break here.
+				break;
+			else
+				result.modifiers.push_back(parseModifierInvocation());
+		}
 		else if (Token::isVisibilitySpecifier(token))
 		{
-			if (visibility != Declaration::Visibility::Default)
+			if (result.visibility != Declaration::Visibility::Default)
 				fatalParserError(string("Multiple visibility specifiers."));
-			visibility = parseVisibilitySpecifier(token);
+			result.visibility = parseVisibilitySpecifier(token);
 		}
 		else
 			break;
 	}
-	ASTPointer<ParameterList> returnParameters;
 	if (m_scanner->currentToken() == Token::Returns)
 	{
 		bool const permitEmptyParameterList = false;
 		m_scanner->next();
-		returnParameters = parseParameterList(options, permitEmptyParameterList);
+		result.returnParameters = parseParameterList(options, permitEmptyParameterList);
 	}
 	else
-		returnParameters = createEmptyParameterList();
-	ASTPointer<Block> block = ASTPointer<Block>();
-	nodeFactory.markEndPosition();
-	if (m_scanner->currentToken() != Token::Semicolon)
+		result.returnParameters = createEmptyParameterList();
+	return result;
+}
+
+ASTPointer<ASTNode> Parser::parseFunctionDefinitionOrFunctionTypeStateVariable(ASTString const* _contractName)
+{
+	ASTNodeFactory nodeFactory(*this);
+	ASTPointer<ASTString> docstring;
+	if (m_scanner->currentCommentLiteral() != "")
+		docstring = make_shared<ASTString>(m_scanner->currentCommentLiteral());
+
+	FunctionHeaderParserResult header = parseFunctionHeader(false, true);
+
+	if (
+		!header.modifiers.empty() ||
+		!header.name->empty() ||
+		m_scanner->currentToken() == Token::Semicolon ||
+		m_scanner->currentToken() == Token::LBrace
+	)
 	{
-		block = parseBlock();
-		nodeFactory.setEndPositionFromNode(block);
+		// this has to be a function
+		ASTPointer<Block> block = ASTPointer<Block>();
+		nodeFactory.markEndPosition();
+		if (m_scanner->currentToken() != Token::Semicolon)
+		{
+			block = parseBlock();
+			nodeFactory.setEndPositionFromNode(block);
+		}
+		else
+			m_scanner->next(); // just consume the ';'
+		bool const c_isConstructor = (_contractName && *header.name == *_contractName);
+		return nodeFactory.createNode<FunctionDefinition>(
+			header.name,
+			header.visibility,
+			c_isConstructor,
+			docstring,
+			header.parameters,
+			header.isDeclaredConst,
+			header.modifiers,
+			header.returnParameters,
+			header.isPayable,
+			block
+		);
 	}
 	else
-		m_scanner->next(); // just consume the ';'
-	bool const c_isConstructor = (_contractName && *name == *_contractName);
-	return nodeFactory.createNode<FunctionDefinition>(
-		name,
-		visibility,
-		c_isConstructor,
-		docstring,
-		parameters,
-		isDeclaredConst,
-		modifiers,
-		returnParameters,
-		isPayable,
-		block
-	);
+	{
+		// this has to be a state variable
+		ASTPointer<TypeName> type = nodeFactory.createNode<FunctionTypeName>(
+			header.parameters,
+			header.returnParameters,
+			header.visibility,
+			header.isDeclaredConst,
+			header.isPayable
+		);
+		type = parseTypeNameSuffix(type, nodeFactory);
+		VarDeclParserOptions options;
+		options.isStateVariable = true;
+		options.allowInitialValue = true;
+		auto node = parseVariableDeclaration(options, type);
+		expectToken(Token::Semicolon);
+		return node;
+	}
 }
 
 ASTPointer<StructDefinition> Parser::parseStructDefinition()
@@ -406,6 +448,8 @@ ASTPointer<EnumDefinition> Parser::parseEnumDefinition()
 		if (m_scanner->currentToken() != Token::Identifier)
 			fatalParserError(string("Expected Identifier after ','"));
 	}
+	if (members.size() == 0)
+		parserError({"enum with no members is not allowed."});
 
 	nodeFactory.markEndPosition();
 	expectToken(Token::RBrace);
@@ -609,6 +653,21 @@ ASTPointer<UserDefinedTypeName> Parser::parseUserDefinedTypeName()
 	return nodeFactory.createNode<UserDefinedTypeName>(identifierPath);
 }
 
+ASTPointer<TypeName> Parser::parseTypeNameSuffix(ASTPointer<TypeName> type, ASTNodeFactory& nodeFactory)
+{
+	while (m_scanner->currentToken() == Token::LBrack)
+	{
+		m_scanner->next();
+		ASTPointer<Expression> length;
+		if (m_scanner->currentToken() != Token::RBrack)
+			length = parseExpression();
+		nodeFactory.markEndPosition();
+		expectToken(Token::RBrack);
+		type = nodeFactory.createNode<ArrayTypeName>(type, length);
+	}
+	return type;
+}
+
 ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
 {
 	ASTNodeFactory nodeFactory(*this);
@@ -629,6 +688,8 @@ ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
 			fatalParserError(string("Expected explicit type name."));
 		m_scanner->next();
 	}
+	else if (token == Token::Function)
+		type = parseFunctionType();
 	else if (token == Token::Mapping)
 		type = parseMapping();
 	else if (token == Token::Identifier)
@@ -638,19 +699,23 @@ ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
 
 	if (type)
 		// Parse "[...]" postfixes for arrays.
-		while (m_scanner->currentToken() == Token::LBrack)
-		{
-			m_scanner->next();
-			ASTPointer<Expression> length;
-			if (m_scanner->currentToken() != Token::RBrack)
-				length = parseExpression();
-			nodeFactory.markEndPosition();
-			expectToken(Token::RBrack);
-			type = nodeFactory.createNode<ArrayTypeName>(type, length);
-		}
+		type = parseTypeNameSuffix(type, nodeFactory);
 	return type;
 }
 
+ASTPointer<FunctionTypeName> Parser::parseFunctionType()
+{
+	ASTNodeFactory nodeFactory(*this);
+	FunctionHeaderParserResult header = parseFunctionHeader(true, false);
+	return nodeFactory.createNode<FunctionTypeName>(
+		header.parameters,
+		header.returnParameters,
+		header.visibility,
+		header.isDeclaredConst,
+		header.isPayable
+	);
+}
+
 ASTPointer<Mapping> Parser::parseMapping()
 {
 	ASTNodeFactory nodeFactory(*this);
@@ -722,6 +787,8 @@ ASTPointer<Statement> Parser::parseStatement()
 		return parseIfStatement(docString);
 	case Token::While:
 		return parseWhileStatement(docString);
+	case Token::Do:
+		return parseDoWhileStatement(docString);
 	case Token::For:
 		return parseForStatement(docString);
 	case Token::LBrace:
@@ -816,9 +883,24 @@ ASTPointer<WhileStatement> Parser::parseWhileStatement(ASTPointer<ASTString> con
 	expectToken(Token::RParen);
 	ASTPointer<Statement> body = parseStatement();
 	nodeFactory.setEndPositionFromNode(body);
-	return nodeFactory.createNode<WhileStatement>(_docString, condition, body);
+	return nodeFactory.createNode<WhileStatement>(_docString, condition, body, false);
+}
+
+ASTPointer<WhileStatement> Parser::parseDoWhileStatement(ASTPointer<ASTString> const& _docString)
+{
+	ASTNodeFactory nodeFactory(*this);
+	expectToken(Token::Do);
+	ASTPointer<Statement> body = parseStatement();
+	expectToken(Token::While);
+	expectToken(Token::LParen);
+	ASTPointer<Expression> condition = parseExpression();
+	expectToken(Token::RParen);
+	nodeFactory.markEndPosition();
+	expectToken(Token::Semicolon);
+	return nodeFactory.createNode<WhileStatement>(_docString, condition, body, true);
 }
 
+
 ASTPointer<ForStatement> Parser::parseForStatement(ASTPointer<ASTString> const& _docString)
 {
 	ASTNodeFactory nodeFactory(*this);
@@ -1259,7 +1341,7 @@ Parser::LookAheadInfo Parser::peekStatementType() const
 	Token::Value token(m_scanner->currentToken());
 	bool mightBeTypeName = (Token::isElementaryTypeName(token) || token == Token::Identifier);
 
-	if (token == Token::Mapping || token == Token::Var)
+	if (token == Token::Mapping || token == Token::Function || token == Token::Var)
 		return LookAheadInfo::VariableDeclarationStatement;
 	if (mightBeTypeName)
 	{
diff --git a/libsolidity/parsing/Parser.h b/libsolidity/parsing/Parser.h
index 9c30cf60..9295a7fa 100644
--- a/libsolidity/parsing/Parser.h
+++ b/libsolidity/parsing/Parser.h
@@ -53,6 +53,18 @@ private:
 		bool allowLocationSpecifier = false;
 	};
 
+	/// This struct is shared for parsing a function header and a function type.
+	struct FunctionHeaderParserResult
+	{
+		ASTPointer<ASTString> name;
+		ASTPointer<ParameterList> parameters;
+		ASTPointer<ParameterList> returnParameters;
+		Declaration::Visibility visibility = Declaration::Visibility::Default;
+		bool isDeclaredConst = false;
+		bool isPayable = false;
+		std::vector<ASTPointer<ModifierInvocation>> modifiers;
+	};
+
 	///@{
 	///@name Parsing functions for the AST nodes
 	ASTPointer<PragmaDirective> parsePragmaDirective();
@@ -60,6 +72,8 @@ private:
 	ASTPointer<ContractDefinition> parseContractDefinition(bool _isLibrary);
 	ASTPointer<InheritanceSpecifier> parseInheritanceSpecifier();
 	Declaration::Visibility parseVisibilitySpecifier(Token::Value _token);
+	FunctionHeaderParserResult parseFunctionHeader(bool _forceEmptyName, bool _allowModifiers);
+	ASTPointer<ASTNode> parseFunctionDefinitionOrFunctionTypeStateVariable(ASTString const* _contractName);
 	ASTPointer<FunctionDefinition> parseFunctionDefinition(ASTString const* _contractName);
 	ASTPointer<StructDefinition> parseStructDefinition();
 	ASTPointer<EnumDefinition> parseEnumDefinition();
@@ -74,7 +88,9 @@ private:
 	ASTPointer<ModifierInvocation> parseModifierInvocation();
 	ASTPointer<Identifier> parseIdentifier();
 	ASTPointer<UserDefinedTypeName> parseUserDefinedTypeName();
+	ASTPointer<TypeName> parseTypeNameSuffix(ASTPointer<TypeName> type, ASTNodeFactory& nodeFactory);
 	ASTPointer<TypeName> parseTypeName(bool _allowVar);
+	ASTPointer<FunctionTypeName> parseFunctionType();
 	ASTPointer<Mapping> parseMapping();
 	ASTPointer<ParameterList> parseParameterList(
 		VarDeclParserOptions const& _options,
@@ -85,6 +101,7 @@ private:
 	ASTPointer<InlineAssembly> parseInlineAssembly(ASTPointer<ASTString> const& _docString = {});
 	ASTPointer<IfStatement> parseIfStatement(ASTPointer<ASTString> const& _docString);
 	ASTPointer<WhileStatement> parseWhileStatement(ASTPointer<ASTString> const& _docString);
+	ASTPointer<WhileStatement> parseDoWhileStatement(ASTPointer<ASTString> const& _docString);
 	ASTPointer<ForStatement> parseForStatement(ASTPointer<ASTString> const& _docString);
 	/// A "simple statement" can be a variable declaration statement or an expression statement.
 	ASTPointer<Statement> parseSimpleStatement(ASTPointer<ASTString> const& _docString);