Merge branch 'ethereum:develop' into develop

Author: nodoubtz

Changelog.md

@@ -1,7 +1,7 @@
 ### 0.8.29 (unreleased)
 
 Language Features:
- * Introduce syntax for specifying contract storage layout base.
+ * Allow relocating contract storage to an arbitrary location.
 
 
 Compiler Features:
@@ -16,6 +16,8 @@ Compiler Features:
 
 
 Bugfixes:
+ * Commandline Interface: Report StackTooDeep errors in compiler mode as proper errors instead of printing diagnostic information meant for internal compiler errors.
+ * Error Reporting: Fix error locations not being shown for source files with empty names.
  * General: Fix internal compiler error when requesting IR AST outputs for interfaces and abstract contracts.
  * Metadata: Fix custom cleanup sequence missing from metadata when other optimizer settings have default values.
  * SMTChecker: Fix internal compiler error when analyzing overflowing expressions or bitwise negation of unsigned types involving constants.
@@ -27,13 +29,19 @@ Bugfixes:
  * SMTChecker: Fix SMT logic error when translating invariants involving array store and select operations.
  * SMTChecker: Fix wrong encoding of string literals as arguments of ``ecrecover`` precompile.
  * Standard JSON Interface: Fix ``generatedSources`` and ``sourceMap`` being generated internally even when not requested.
+ * TypeChecker: Fix supurious compilation errors due to incorrect computation of contract storage size which erroneously included transient storage variables.
  * Yul: Fix internal compiler error when a code generation error should be reported instead.
+ * Yul Optimizer: Fix failing debug assertion due to dereferencing of an empty ``optional`` value.
 
 
 Build system:
  * Linux release builds are fully static again and no longer depend on ``glibc``.
  * Switch from C++17 to C++20 as the target standard.
 
+
+Solc-Js:
+ * The wrapper now requires at least nodejs v12.
+
 ### 0.8.28 (2024-10-09)
 
 Language Features:

libevmasm/GasMeter.cpp

@@ -263,12 +263,11 @@ GasMeter::GasConsumption GasMeter::memoryGas(int _stackPosOffset, int _stackPosS
 		}));
 }
 
-unsigned GasMeter::runGas(Instruction _instruction, langutil::EVMVersion _evmVersion)
+namespace
 {
-	if (_instruction == Instruction::JUMPDEST)
-		return 1;
-
-	switch (instructionInfo(_instruction, _evmVersion).gasPriceTier)
+std::optional<unsigned> gasCostForTier(Tier _tier)
+{
+	switch (_tier)
 	{
 	case Tier::Zero:        return GasCosts::tier0Gas;
 	case Tier::Base:        return GasCosts::tier1Gas;
@@ -286,10 +285,21 @@ unsigned GasMeter::runGas(Instruction _instruction, langutil::EVMVersion _evmVer
 
 	case Tier::Special:
 	case Tier::Invalid:
-		assertThrow(false, OptimizerException, "Invalid gas tier for instruction " + instructionInfo(_instruction, _evmVersion).name);
+		return std::nullopt;
 	}
 	util::unreachable();
 }
+}
+
+unsigned GasMeter::runGas(Instruction _instruction, langutil::EVMVersion _evmVersion)
+{
+	if (_instruction == Instruction::JUMPDEST)
+		return 1;
+
+	if (auto gasCost = gasCostForTier(instructionInfo(_instruction, _evmVersion).gasPriceTier))
+		return *gasCost;
+	solAssert(false, "Invalid gas tier for instruction " + instructionInfo(_instruction, _evmVersion).name);
+}
 
 unsigned GasMeter::pushGas(u256 _value, langutil::EVMVersion _evmVersion)
 {
@@ -299,6 +309,24 @@ unsigned GasMeter::pushGas(u256 _value, langutil::EVMVersion _evmVersion)
 	);
 }
 
+unsigned GasMeter::swapGas(size_t _depth, langutil::EVMVersion _evmVersion)
+{
+	if (_depth <= 16)
+		return runGas(evmasm::swapInstruction(static_cast<unsigned>(_depth)), _evmVersion);
+	auto gasCost = gasCostForTier(instructionInfo(evmasm::Instruction::SWAPN, _evmVersion).gasPriceTier);
+	solAssert(gasCost.has_value(), "Expected gas cost for SWAPN to be defined.");
+	return *gasCost;
+}
+
+unsigned GasMeter::dupGas(size_t _depth, langutil::EVMVersion _evmVersion)
+{
+	if (_depth <= 16)
+		return runGas(evmasm::swapInstruction(static_cast<unsigned>(_depth)), _evmVersion);
+	auto gasCost = gasCostForTier(instructionInfo(evmasm::Instruction::DUPN, _evmVersion).gasPriceTier);
+	solAssert(gasCost.has_value(), "Expected gas cost for DUPN to be defined.");
+	return *gasCost;
+}
+
 u256 GasMeter::dataGas(bytes const& _data, bool _inCreation, langutil::EVMVersion _evmVersion)
 {
 	bigint gas = 0;
@@ -309,14 +337,14 @@ u256 GasMeter::dataGas(bytes const& _data, bool _inCreation, langutil::EVMVersio
 	}
 	else
 		gas = bigint(GasCosts::createDataGas) * _data.size();
-	assertThrow(gas < bigint(u256(-1)), OptimizerException, "Gas cost exceeds 256 bits.");
+	solAssert(gas < bigint(u256(-1)), "Gas cost exceeds 256 bits.");
 	return u256(gas);
 }
 
 
 u256 GasMeter::dataGas(uint64_t _length, bool _inCreation, langutil::EVMVersion _evmVersion)
 {
 	bigint gas = bigint(_length) * (_inCreation ? GasCosts::txDataNonZeroGas(_evmVersion) : GasCosts::createDataGas);
-	assertThrow(gas < bigint(u256(-1)), OptimizerException, "Gas cost exceeds 256 bits.");
+	solAssert(gas < bigint(u256(-1)), "Gas cost exceeds 256 bits.");
 	return u256(gas);
 }

libevmasm/GasMeter.h

@@ -226,9 +226,18 @@ class GasMeter
 	/// change with EVM versions)
 	static unsigned runGas(Instruction _instruction, langutil::EVMVersion _evmVersion);
 
-	/// @returns gas costs for push instructions (may change depending on EVM version)
+	/// @returns gas costs for the cheapest push instructions for the given @a _value
+	/// (may change depending on EVM version)
 	static unsigned pushGas(u256 _value, langutil::EVMVersion _evmVersion);
 
+	/// @returns gas costs for the cheapest swap instructions for the given @a _depth
+	/// (may change depending on EVM version)
+	static unsigned swapGas(size_t _depth, langutil::EVMVersion _evmVersion);
+
+	/// @returns gas costs for the cheapest dup instructions for the given @a _depth
+	/// (may change depending on EVM version)
+	static unsigned dupGas(size_t _depth, langutil::EVMVersion _evmVersion);
+
 	/// @returns the gas cost of the supplied data, depending whether it is in creation code, or not.
 	/// In case of @a _inCreation, the data is only sent as a transaction and is not stored, whereas
 	/// otherwise code will be stored and have to pay "createDataGas" cost.

liblangutil/ErrorReporter.cpp

@@ -23,6 +23,9 @@
 
 #include <liblangutil/ErrorReporter.h>
 #include <liblangutil/SourceLocation.h>
+
+#include <libsolutil/Exceptions.h>
+
 #include <range/v3/algorithm/find_if.hpp>
 #include <memory>
 
@@ -121,7 +124,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 		if (m_errorCount > c_maxErrorsAllowed)
 		{
 			m_errorList.push_back(std::make_shared<Error>(4013_error, Error::Type::Warning, "There are more than 256 errors. Aborting."));
-			BOOST_THROW_EXCEPTION(FatalError());
+			solThrow(FatalError, "There are more than 256 errors. Aborting.");
 		}
 	}
 
@@ -131,13 +134,13 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
 void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, SecondarySourceLocation const& _secondaryLocation, std::string const& _description)
 {
 	error(_error, _type, _location, _secondaryLocation, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
+	solThrow(FatalError, _description);
 }
 
 void ErrorReporter::fatalError(ErrorId _error, Error::Type _type, SourceLocation const& _location, std::string const& _description)
 {
 	error(_error, _type, _location, _description);
-	BOOST_THROW_EXCEPTION(FatalError());
+	solThrow(FatalError, _description);
 }
 
 ErrorList const& ErrorReporter::errors() const

liblangutil/SourceReferenceFormatter.cpp

@@ -114,11 +114,11 @@ AnsiColorized SourceReferenceFormatter::diagColored() const
 
 void SourceReferenceFormatter::printSourceLocation(SourceReference const& _ref)
 {
-	if (_ref.sourceName.empty())
-		return; // Nothing we can print here
-
 	if (_ref.position.line < 0)
 	{
+		if (_ref.sourceName.empty())
+			return; // Nothing we can print here
+
 		frameColored() << "-->";
 		m_stream << ' ' << _ref.sourceName << '\n';
 		return; // No line available, nothing else to print

libsolc/libsolc.cpp

@@ -63,7 +63,7 @@ std::string takeOverAllocation(char const* _data)
 	abort();
 }
 
-/// Resizes a std::std::string to the proper length based on the occurrence of a zero terminator.
+/// Resizes a std::string to the proper length based on the occurrence of a zero terminator.
 void truncateCString(std::string& _data)
 {
 	size_t pos = _data.find('\0');

libsolidity/analysis/ContractLevelChecker.cpp

@@ -23,13 +23,15 @@
 #include <libsolidity/analysis/ContractLevelChecker.h>
 
 #include <libsolidity/ast/AST.h>
+#include <libsolidity/ast/ASTUtils.h>
 #include <libsolidity/ast/TypeProvider.h>
 #include <libsolidity/analysis/TypeChecker.h>
 #include <libsolutil/FunctionSelector.h>
 #include <liblangutil/ErrorReporter.h>
 
 #include <fmt/format.h>
 
+#include <range/v3/algorithm/find_if.hpp>
 #include <range/v3/view/reverse.hpp>
 
 using namespace solidity;
@@ -97,10 +99,44 @@ bool ContractLevelChecker::check(ContractDefinition const& _contract)
 	checkBaseABICompatibility(_contract);
 	checkPayableFallbackWithoutReceive(_contract);
 	checkStorageSize(_contract);
+	checkStorageLayoutSpecifier(_contract);
 
 	return !Error::containsErrors(m_errorReporter.errors());
 }
 
+void ContractLevelChecker::checkStorageLayoutSpecifier(ContractDefinition const& _contract)
+{
+	if (_contract.storageLayoutSpecifier())
+	{
+		solAssert(!_contract.isLibrary() && !_contract.isInterface());
+
+		if (_contract.abstract())
+			m_errorReporter.typeError(
+				7587_error,
+				_contract.storageLayoutSpecifier()->location(),
+				"Storage layout cannot be specified for abstract contracts."
+			);
+	}
+
+	for (auto const& baseContractSpecifier: _contract.baseContracts())
+	{
+		auto const* baseContract = dynamic_cast<ContractDefinition const*>(
+			baseContractSpecifier->name().annotation().referencedDeclaration
+		);
+
+		solAssert(baseContract);
+		if (baseContract->storageLayoutSpecifier())
+			m_errorReporter.typeError(
+				8894_error,
+				baseContractSpecifier->location(),
+				SecondarySourceLocation().append(
+					"Custom storage layout defined here:",
+					baseContract->storageLayoutSpecifier()->location()
+				),
+				"Cannot inherit from a contract with a custom storage layout."
+			);
+	}
+}
 void ContractLevelChecker::checkDuplicateFunctions(ContractDefinition const& _contract)
 {
 	/// Checks that two functions with the same name defined in this contract have different
@@ -555,16 +591,16 @@ void ContractLevelChecker::checkPayableFallbackWithoutReceive(ContractDefinition
 
 void ContractLevelChecker::checkStorageSize(ContractDefinition const& _contract)
 {
-	bigint size = 0;
-	for (ContractDefinition const* contract: _contract.annotation().linearizedBaseContracts | ranges::views::reverse)
-		for (VariableDeclaration const* variable: contract->stateVariables())
-			if (!(variable->isConstant() || variable->immutable()))
-			{
-				size += variable->annotation().type->storageSizeUpperBound();
-				if (size >= bigint(1) << 256)
-				{
-					m_errorReporter.typeError(7676_error, _contract.location(), "Contract requires too much storage.");
-					break;
-				}
-			}
+	using enum VariableDeclaration::Location;
+	for (VariableDeclaration::Location location: {Unspecified, Transient})
+	{
+		bigint size = contractStorageSizeUpperBound(_contract, location);
+		if (size >= bigint(1) << 256)
+		{
+			if (location == Unspecified)
+				m_errorReporter.typeError(7676_error, _contract.location(), "Contract requires too much storage.");
+			else
+				m_errorReporter.typeError(5026_error, _contract.location(), "Contract requires too much transient storage.");
+		}
+	}
 }

libsolidity/analysis/ContractLevelChecker.h

@@ -88,8 +88,10 @@ class ContractLevelChecker
 
 	/// Warns if the contract has a payable fallback, but no receive ether function.
 	void checkPayableFallbackWithoutReceive(ContractDefinition const& _contract);
-	/// Error if the contract requires too much storage
+	/// Error if the contract requires too much storage or transient storage
 	void checkStorageSize(ContractDefinition const& _contract);
+	/// Checks if the storage layout specifier is properly assigned in the inheritance tree and not applied to an abstract contract
+	void checkStorageLayoutSpecifier(ContractDefinition const& _contract);
 
 	OverrideChecker m_overrideChecker;
 	langutil::ErrorReporter& m_errorReporter;

libsolidity/analysis/ControlFlowBuilder.h

@@ -137,7 +137,7 @@ class ControlFlowBuilder: private ASTConstVisitor, private yul::ASTWalker
 	}
 
 	/// Merges the control flow of @a _nodes to @a _endNode.
-	/// If @a _endNode is nullptr, a new node is creates and used as end node.
+	/// If @a _endNode is nullptr, a new node is created and used as end node.
 	/// Sets the merge destination as current node.
 	/// Note: @a _endNode may be one of the nodes in @a _nodes.
 	template<typename C>

libsolidity/analysis/NameAndTypeResolver.cpp

@@ -61,9 +61,14 @@ bool NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit, ASTNode
 	{
 		DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errorReporter, m_globalContext, _currentScope);
 	}
-	catch (langutil::FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		return false;
 	}
 	return true;
@@ -135,9 +140,14 @@ bool NameAndTypeResolver::resolveNamesAndTypes(SourceUnit& _source)
 				return false;
 		}
 	}
-	catch (langutil::FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		return false;
 	}
 	return true;
@@ -150,9 +160,14 @@ bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
 		m_scopes[nullptr]->registerDeclaration(_declaration, false, true);
 		solAssert(_declaration.scope() == nullptr, "Updated declaration outside global scope.");
 	}
-	catch (langutil::FatalError const& error)
+	catch (FatalError const&)
 	{
-		solAssert(m_errorReporter.hasErrors(), "Unreported fatal error: "s + error.what());
+		if (!m_errorReporter.hasErrors())
+		{
+			std::cerr << "Unreported fatal error:" << std::endl;
+			std::cerr << boost::current_exception_diagnostic_information() << std::endl;
+			solAssert(false, "Unreported fatal error.");
+		}
 		return false;
 	}
 	return true;