Type checking for contract explicit storage base location

libsolidity/analysis/TypeChecker.cpp

@@ -22,6 +22,7 @@
  */
 
 #include <libsolidity/analysis/TypeChecker.h>
+#include <libsolidity/analysis/ConstantEvaluator.h>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/ast/ASTUtils.h>
 #include <libsolidity/ast/UserDefinableOperators.h>
@@ -46,6 +47,7 @@
 #include <range/v3/algorithm/count_if.hpp>
 #include <range/v3/view/drop_exactly.hpp>
 #include <range/v3/view/enumerate.hpp>
+#include <range/v3/view/reverse.hpp>
 #include <range/v3/view/zip.hpp>
 
 #include <memory>
@@ -231,6 +233,84 @@ bool TypeChecker::visit(ImportDirective const&)
 	return false;
 }
 
+void TypeChecker::endVisit(ContractDefinition const& _contract)
+{
+	for (auto const* ancestorContract: _contract.annotation().linearizedBaseContracts | ranges::views::reverse)
+		if (*ancestorContract != _contract && ancestorContract->storageBaseLocationExpression())
+		{
+			m_errorReporter.typeError(
+				8894_error,
+				_contract.location(),
+				SecondarySourceLocation().append(
+					"Storage base location was already specified here.",
+					ancestorContract->storageBaseLocationExpression()->location()
+				),
+				"Storage base location can only be specified in the most derived contract."
+			);
+			return;
+		}
+	if (ASTPointer<Expression> const baseLocation = _contract.storageBaseLocationExpression())
+	{
+		if (_contract.isLibrary() || _contract.abstract())
+			m_errorReporter.typeError(
+				7587_error,
+				baseLocation->location(),
+				"Storage base location cannot be specified for abstract contracts or libraries"
+			);
+
+		if (!*baseLocation->annotation().isPure)
+		{
+			// TODO: handle erc7201 as a builtin function ?
+			if (auto functionCall = dynamic_cast<FunctionCall const*>(baseLocation.get()))
+				if (
+					auto const* identifier = dynamic_cast<Identifier const*>(&functionCall->expression());
+					identifier && identifier->name() == "erc7201"
+				)
+					return;
+
+			m_errorReporter.typeError(
+				1139_error,
+				baseLocation->location(),
+				"The contract base location must be an expression that can be evaluated at compilation time."
+			);
+		}
+
+		auto const* expressionType = type(*baseLocation);
+		BoolResult result = expressionType->isImplicitlyConvertibleTo(*TypeProvider::uint256());
+		if (!result)
+		{
+			std::string errorMessage = "Contract storage base location ";
+			if (
+				auto const* rationalType = dynamic_cast<RationalNumberType const*>(expressionType);
+				rationalType && rationalType->isFractional()
+			)
+				errorMessage += "cannot be specified by a fractional number.";
+			else
+				errorMessage += "must be in range of type uint256. Current type is " + expressionType->humanReadableName();
+
+			m_errorReporter.typeErrorConcatenateDescriptions(
+				1763_error,
+				baseLocation->location(),
+				errorMessage,
+				result.message()
+			);
+			return;
+		}
+
+		if (auto const* rationalType = dynamic_cast<RationalNumberType const*>(expressionType))
+		{
+			solAssert(!rationalType->isFractional());
+			_contract.annotation().storageBaseLocationValue = u256(rationalType->value().numerator());
+		}
+		else
+			m_errorReporter.typeError(
+				6396_error,
+				baseLocation->location(),
+				"Only number literals are accepted in the expression specifying the contract base storage location."
+			);
+	}
+}
+
 void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
 {
 	auto base = dynamic_cast<ContractDefinition const*>(&dereference(_inheritance.name()));

libsolidity/analysis/TypeChecker.h

@@ -157,6 +157,7 @@ class TypeChecker: private ASTConstVisitor
 	void endVisit(ElementaryTypeNameExpression const& _expr) override;
 	void endVisit(Literal const& _literal) override;
 	void endVisit(UsingForDirective const& _usingForDirective) override;
+	void endVisit(ContractDefinition const& _contract) override;
 
 	void checkErrorAndEventParameters(CallableDeclaration const& _callable);
 

libsolidity/ast/AST.h

@@ -578,6 +578,10 @@ class ContractDefinition: public Declaration, public StructurallyDocumented, pub
 	/// Returns the ether receiver function or nullptr if no receive function was specified.
 	FunctionDefinition const* receiveFunction() const;
 
+	ASTPointer<Expression> const& storageBaseLocationExpression() const { return m_storageBaseLocationExpression; }
+
+	u256 storageBaseLocationValue() const { return annotation().storageBaseLocationValue; }
+
 	std::string fullyQualifiedName() const { return sourceUnitName() + ":" + name(); }
 
 	Type const* type() const override;

libsolidity/ast/ASTAnnotations.h

@@ -27,6 +27,7 @@
 #include <libsolidity/ast/ASTEnums.h>
 #include <libsolidity/ast/ExperimentalFeatures.h>
 
+#include <libsolutil/Numeric.h>
 #include <libsolutil/SetOnce.h>
 
 #include <map>
@@ -171,6 +172,8 @@ struct ContractDefinitionAnnotation: TypeDeclarationAnnotation, StructurallyDocu
 
 	// Per-contract map from function AST IDs to internal dispatch function IDs.
 	std::map<FunctionDefinition const*, uint64_t> internalFunctionIDs;
+
+	solidity::u256 storageBaseLocationValue;
 };
 
 struct CallableDeclarationAnnotation: DeclarationAnnotation

test/libsolidity/syntaxTests/contractBaseLocation/abstract_contract.sol

@@ -0,0 +1,4 @@
+abstract contract C layout at 0x123 {
+}
+// ----
+// TypeError 7587: (30-35): Storage base location cannot be specified for abstract contracts or libraries

test/libsolidity/syntaxTests/contractBaseLocation/layout_already_specified_in_ancestor_contract_.sol

@@ -0,0 +1,8 @@
+contract A layout at 0x1234 {}
+
+contract B is A {}
+
+contract C is B layout at 0xABCD {}
+// ----
+// TypeError 8894: (32-50): Storage base location can only be specified in the most derived contract.
+// TypeError 8894: (52-87): Storage base location can only be specified in the most derived contract.

test/libsolidity/syntaxTests/contractBaseLocation/layout_fractional_number.sol

@@ -0,0 +1,3 @@
+contract A layout at 3/2 {}
+// ----
+// TypeError 1763: (21-24): Contract storage base location cannot be specified by a fractional number.

test/libsolidity/syntaxTests/contractBaseLocation/layout_not_specified_in_most_derived_contract_copy.sol

@@ -0,0 +1,8 @@
+contract A layout at 0x1234 {}
+
+contract B is A {}
+
+contract C is B {}
+// ----
+// TypeError 8894: (32-50): Storage base location can only be specified in the most derived contract.
+// TypeError 8894: (52-70): Storage base location can only be specified in the most derived contract.

test/libsolidity/syntaxTests/contractBaseLocation/layout_specification_constant_in_expression.sol

@@ -1,3 +1,4 @@
 uint constant X = 42;
 contract C layout at 0xffff * (50 - X) { }
 // ----
+// TypeError 6396: (43-60): Only number literals are accepted in the expression specifying the contract base storage location.

test/libsolidity/syntaxTests/contractBaseLocation/layout_specified_by_expression_not_pure.sol

@@ -0,0 +1,5 @@
+function f(uint x) returns (uint) { return x + 1; }
+contract A layout at f(2) {}
+// ----
+// TypeError 1139: (73-77): The contract base location must be an expression that can be evaluated at compilation time.
+// TypeError 6396: (73-77): Only number literals are accepted in the expression specifying the contract base storage location.

test/libsolidity/syntaxTests/contractBaseLocation/library.sol

@@ -0,0 +1,5 @@
+library L layout at 0x123 {
+    function f() public pure { }
+}
+// ----
+// TypeError 7587: (20-25): Storage base location cannot be specified for abstract contracts or libraries

test/libsolidity/syntaxTests/contractBaseLocation/simple_layout.sol

@@ -1,4 +1,4 @@
 contract A layout at 0x1234 {}
 contract B layout at 1024 {}
-contract C layout at "C" {}
+contract C layout at 0 {}
 // ----