Allow constants in custom storage layout expression

Author: matheusaaguiar

Changelog.md

@@ -3,8 +3,10 @@
 Language Features:
 
 Compiler Features:
+* Custom Storage Layout: the base slot expression can also be specified by constant variables.
 * ethdebug: Experimental support for instructions and source locations under EOF.
 
+
 Bugfixes:
 
 ### 0.8.30 (2025-05-07)

docs/contracts/custom-storage-layout.rst

@@ -23,7 +23,7 @@ As the above example shows, the specifier uses the ``layout at <base-slot-expres
 and is located in the header of a contract definition.
 
 The layout specifier can be placed either before or after the inheritance specifier, and can appear at most once.
-The ``base-slot-expression`` must be an :ref:`integer literal<rational_literals>` expression
+The ``base-slot-expression`` must be an :ref:`integer literal<rational_literals>` expression or a constant
 that can be evaluated at compilation time and yields a value in the range of ``uint256``.
 
 A custom layout cannot make contract's storage "wrap around".

libsolidity/analysis/PostTypeContractLevelChecker.cpp

@@ -23,6 +23,7 @@
 #include <libsolidity/analysis/PostTypeContractLevelChecker.h>
 
 #include <fmt/format.h>
+#include <libsolidity/analysis/ConstantEvaluator.h>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/ast/ASTUtils.h>
 #include <libsolidity/ast/TypeProvider.h>
@@ -101,29 +102,53 @@ void PostTypeContractLevelChecker::checkStorageLayoutSpecifier(ContractDefinitio
 	}
 
 	auto const* baseSlotExpressionType = type(baseSlotExpression);
-	auto const* rationalType = dynamic_cast<RationalNumberType const*>(baseSlotExpressionType);
-	if (!rationalType)
+	if (
+		!dynamic_cast<IntegerType const*>(baseSlotExpressionType) &&
+		!dynamic_cast<RationalNumberType const*>(baseSlotExpressionType)
+	)
 	{
 		m_errorReporter.typeError(
 			6396_error,
 			baseSlotExpression.location(),
-			"The base slot of the storage layout must evaluate to a rational number."
+			"The base slot of the storage layout must evaluate to an integer number."
 		);
 		return;
 	}
 
-	if (rationalType->isFractional())
+	rational baseSlotRationalValue;
+	if (auto const integerType = dynamic_cast<IntegerType const*>(baseSlotExpressionType))
 	{
-		m_errorReporter.typeError(
-			1763_error,
-			baseSlotExpression.location(),
-			"The base slot of the storage layout must evaluate to an integer."
-		);
-		return;
+		std::optional<ConstantEvaluator::TypedRational> typedRational = ConstantEvaluator::evaluate(m_errorReporter, baseSlotExpression);
+		if (!typedRational)
+		{
+			m_errorReporter.typeError(
+				1505_error,
+				baseSlotExpression.location(),
+				"The base slot expression contains elements that are not yet supported "
+				"by the internal constant evaluator and therefore cannot be evaluated at compilation time."
+			);
+			return;
+		}
+		baseSlotRationalValue = typedRational->value;
+	}
+	else
+	{
+		auto const* rationalType = dynamic_cast<RationalNumberType const*>(baseSlotExpressionType);
+		solAssert(rationalType);
+		if (rationalType->isFractional())
+		{
+			m_errorReporter.typeError(
+				1763_error,
+				baseSlotExpression.location(),
+				"The base slot of the storage layout must evaluate to an integer."
+			);
+			return;
+		}
+		baseSlotRationalValue = rationalType->value();
 	}
-	solAssert(rationalType->value().denominator() == 1);
 
-	bigint baseSlot = rationalType->value().numerator();
+	solAssert(baseSlotRationalValue.denominator() == 1);
+	bigint baseSlot = baseSlotRationalValue.numerator();
 	if (!(0 <= baseSlot && baseSlot <= std::numeric_limits<u256>::max()))
 	{
 		m_errorReporter.typeError(
@@ -137,7 +162,18 @@ void PostTypeContractLevelChecker::checkStorageLayoutSpecifier(ContractDefinitio
 		return;
 	}
 
-	solAssert(baseSlotExpressionType->isImplicitlyConvertibleTo(*TypeProvider::uint256()));
+	if (!baseSlotExpressionType->isImplicitlyConvertibleTo(*TypeProvider::uint256()))
+	{
+		m_errorReporter.typeError(
+			1481_error,
+			baseSlotExpression.location(),
+			fmt::format(
+				"The base slot expression type {} is not convertible to type uint256.",
+				baseSlotExpressionType->humanReadableName()
+			)
+		);
+		return;
+	}
 	storageLayoutSpecifier->annotation().baseSlot = u256(baseSlot);
 
 	bigint size = contractStorageSizeUpperBound(_contract, VariableDeclaration::Location::Unspecified);