Check base contracts for abi encoder compatibility

libsolidity/analysis/ContractLevelChecker.cpp

@@ -22,6 +22,7 @@
 #include <libsolidity/analysis/ContractLevelChecker.h>
 
 #include <libsolidity/ast/AST.h>
+#include <libsolidity/analysis/TypeChecker.h>
 #include <liblangutil/ErrorReporter.h>
 #include <boost/range/adaptor/reversed.hpp>
 
@@ -44,6 +45,7 @@ bool ContractLevelChecker::check(ContractDefinition const& _contract)
 	checkExternalTypeClashes(_contract);
 	checkHashCollisions(_contract);
 	checkLibraryRequirements(_contract);
+	checkBaseABICompatibility(_contract);
 
 	return Error::containsOnlyWarnings(m_errorReporter.errors());
 }
@@ -460,3 +462,50 @@ void ContractLevelChecker::checkLibraryRequirements(ContractDefinition const& _c
 		if (!var->isConstant())
 			m_errorReporter.typeError(var->location(), "Library cannot have non-constant state variables");
 }
+
+void ContractLevelChecker::checkBaseABICompatibility(ContractDefinition const& _contract)
+{
+	if (_contract.sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::ABIEncoderV2))
+		return;
+
+	if (_contract.isLibrary())
+	{
+		solAssert(
+			_contract.baseContracts().empty() || m_errorReporter.hasErrors(),
+			"Library is not allowed to inherit"
+		);
+		return;
+	}
+
+	SecondarySourceLocation errors;
+
+	// interfaceFunctionList contains all inherited functions as well
+	for (auto const& func: _contract.interfaceFunctionList())
+	{
+		solAssert(func.second->hasDeclaration(), "Function has no declaration?!");
+
+		if (!func.second->declaration().sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::ABIEncoderV2))
+			continue;
+
+		auto const& currentLoc = func.second->declaration().location();
+
+		for (TypePointer const& paramType: func.second->parameterTypes() + func.second->parameterTypes())
+			if (!TypeChecker::typeSupportedByOldABIEncoder(*paramType, false))
+			{
+				errors.append("Type only supported by the new experimental ABI encoder", currentLoc);
+				break;
+			}
+	}
+
+	if (!errors.infos.empty())
+		m_errorReporter.fatalTypeError(
+			_contract.location(),
+			errors,
+			std::string("Contract \"") +
+			_contract.name() +
+			"\" does not use the new experimental ABI encoder but wants to inherit from a contract " +
+			"which uses types that require it. " +
+			"Use \"pragma experimental ABIEncoderV2;\" for the inheriting contract as well to enable the feature."
+		);
+
+}

libsolidity/analysis/ContractLevelChecker.h

@@ -78,6 +78,8 @@ private:
 	void checkHashCollisions(ContractDefinition const& _contract);
 	/// Checks that all requirements for a library are fulfilled if this is a library.
 	void checkLibraryRequirements(ContractDefinition const& _contract);
+	/// Checks base contracts for ABI compatibility
+	void checkBaseABICompatibility(ContractDefinition const& _contract);
 
 	langutil::ErrorReporter& m_errorReporter;
 };

libsolidity/analysis/TypeChecker.cpp

@@ -45,10 +45,7 @@ using namespace dev;
 using namespace langutil;
 using namespace dev::solidity;
 
-namespace
-{
-
-bool typeSupportedByOldABIEncoder(Type const& _type, bool _isLibraryCall)
+bool TypeChecker::typeSupportedByOldABIEncoder(Type const& _type, bool _isLibraryCall)
 {
 	if (_isLibraryCall && _type.dataStoredIn(DataLocation::Storage))
 		return true;
@@ -64,9 +61,6 @@ bool typeSupportedByOldABIEncoder(Type const& _type, bool _isLibraryCall)
 	return true;
 }
 
-}
-
-
 bool TypeChecker::checkTypeRequirements(ASTNode const& _contract)
 {
 	_contract.accept(*this);
@@ -94,6 +88,7 @@ bool TypeChecker::visit(ContractDefinition const& _contract)
 	for (auto const& n: _contract.subNodes())
 		n->accept(*this);
 
+
 	return false;
 }
 

libsolidity/analysis/TypeChecker.h

@@ -63,6 +63,8 @@ public:
 	/// (this can happen for variables with non-explicit types before their types are resolved)
 	TypePointer const& type(VariableDeclaration const& _variable) const;
 
+	static bool typeSupportedByOldABIEncoder(Type const& _type, bool _isLibraryCall);
+
 private:
 
 	bool visit(ContractDefinition const& _contract) override;