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

Changelog.md

@@ -13,7 +13,22 @@ Compiler Features:
 Bugfixes:
 
 
-### 0.6.7 (unreleased)
+### 0.6.8 (unreleased)
+
+Language Features:
+
+
+
+Compiler Features:
+
+
+
+Bugfixes:
+
+
+
+
+### 0.6.7 (2020-05-04)
 
 Language Features:
  * Add support for EIP 165 interface identifiers with `type(I).interfaceId`.
@@ -22,6 +37,8 @@ Language Features:
 
 Compiler Features:
  * Optimizer: Simplify repeated AND and OR operations.
+ * Standard Json Input: Support the prefix ``file://`` in the field ``urls``.
+ * Add option to specify optimization steps to be performed by Yul optimizer with `--yul-optimizations` in the commandline interface or `optimizer.details.yulDetails.optimizerSteps` in standard-json.
 
 Bugfixes:
  * SMTChecker: Fix internal error when fixed points are used.
@@ -29,8 +46,8 @@ Bugfixes:
  * Type Checker: Disallow ``virtual`` and ``override`` for constructors.
  * Type Checker: Fix several internal errors by performing size and recursiveness checks of types before the full type checking.
  * Type Checker: Fix internal error when assigning to empty tuples.
+ * Type Checker: Fix internal error when applying unary operators to tuples with empty components.
  * Type Checker: Perform recursiveness check on structs declared at the file level.
- * Standard Json Input: Fix error when using prefix ``file://`` in the field ``urls``.
 
 Build System:
  * soltest.sh: ``SOLIDITY_BUILD_DIR`` is no longer relative to ``REPO_ROOT`` to allow for build directories outside of the source tree.

docs/bugs_by_version.json

@@ -1085,5 +1085,9 @@
     "0.6.6": {
         "bugs": [],
         "released": "2020-04-09"
+    },
+    "0.6.7": {
+        "bugs": [],
+        "released": "2020-05-04"
     }
 }

docs/contracts/abstract-contracts.rst

@@ -52,3 +52,8 @@ facilitating patterns like the `Template method <https://en.wikipedia.org/wiki/T
 Abstract contracts are useful in the same way that defining methods
 in an interface is useful. It is a way for the designer of the
 abstract contract to say "any child of mine must implement this method".
+
+.. note::
+
+  Abstract contracts cannot override an implemented virtual function with an
+  unimplemented one.

docs/metadata.rst

@@ -82,8 +82,12 @@ explanatory purposes.
             deduplicate: false,
             cse: false,
             constantOptimizer: false,
-            yul: false,
+            yul: true,
-            yulDetails: {}
+            // Optional: Only present if "yul" is "true"
+            yulDetails: {
+              stackAllocation: false,
+              optimizerSteps: "dhfoDgvulfnTUtnIf..."
+            }
           }
         },
         metadata: {

docs/types/mapping-types.rst

@@ -138,8 +138,8 @@ the ``sum`` function iterates over to sum all the values.
             if (keyIndex > 0)
                 return true;
             else {
-                self.keys.push();
                 keyIndex = self.keys.length;
+                self.keys.push();
                 self.data[key].keyIndex = keyIndex + 1;
                 self.keys[keyIndex].key = key;
                 self.size++;

docs/using-the-compiler.rst

@@ -231,7 +231,10 @@ Input Description
             "yulDetails": {
               // Improve allocation of stack slots for variables, can free up stack slots early.
               // Activated by default if the Yul optimizer is activated.
-              "stackAllocation": true
+              "stackAllocation": true,
+              // Select optimization steps to be applied.
+              // Optional, the optimizer will use the default sequence if omitted.
+              "optimizerSteps": "dhfoDgvulfnTUtnIf..."
             }
           }
         },

docs/yul.rst

@@ -885,13 +885,6 @@ the ``dup`` and ``swap`` instructions as well as ``jump`` instructions, labels a
 | gaslimit()              |     | F | block gas limit of the current block                            |
 +-------------------------+-----+---+-----------------------------------------------------------------+
 
-There are three additional functions, ``datasize(x)``, ``dataoffset(x)`` and ``datacopy(t, f, l)``,
-which are used to access other parts of a Yul object.
-
-``datasize`` and ``dataoffset`` can only take string literals (the names of other objects)
-as arguments and return the size and offset in the data area, respectively.
-For the EVM, the ``datacopy`` function is equivalent to ``codecopy``.
-
 .. _yul-call-return-area:
 
 .. note::
@@ -903,6 +896,32 @@ For the EVM, the ``datacopy`` function is equivalent to ``codecopy``.
   The remaining bytes will retain their values as of before the call. If the call fails (it returns ``0``),
   nothing is written to that area, but you can still retrieve the failure data using ``returndatacopy``.
 
+
+In some internal dialects, there are additional functions:
+
+datasize, dataoffset, datacopy
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The functions ``datasize(x)``, ``dataoffset(x)`` and ``datacopy(t, f, l)``,
+are used to access other parts of a Yul object.
+
+``datasize`` and ``dataoffset`` can only take string literals (the names of other objects)
+as arguments and return the size and offset in the data area, respectively.
+For the EVM, the ``datacopy`` function is equivalent to ``codecopy``.
+
+
+setimmutable, loadimmutable
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The functions ``setimmutable("name", value)`` and ``loadimmutable("name")`` are
+used for the immutable mechanism in Solidity and do not nicely map to pur Yul.
+The function ``setimmutable`` assumes that the runtime code of a contract
+is currently copied to memory at offsot zero. The call to ``setimmutable("name", value)``
+will store ``value`` at all points in memory that contain a call to
+``loadimmutable("name")``.
+
+
+
 .. _yul-object:
 
 Specification of Yul Object
@@ -1015,3 +1034,56 @@ If you want to use Solidity in stand-alone Yul mode, you activate the optimizer
     solc --strict-assembly --optimize
 
 In Solidity mode, the Yul optimizer is activated together with the regular optimizer.
+
+Optimization step sequence
+--------------------------
+
+By default the Yul optimizer applies its predefined sequence of optimization steps to the generated assembly.
+You can override this sequence and supply your own using the `--yul-optimizations` option when compiling
+in Solidity mode:
+
+.. code-block:: sh
+
+    solc --optimize --ir-optimized --yul-optimizations 'dhfoD[xarrscLMcCTU]uljmul'
+
+By enclosing part of the sequence in square brackets (`[]`) you tell the optimizer to repeatedly
+apply that part until it no longer improves the size of the resulting assembly.
+You can use brackets multiple times in a single sequence but they cannot be nested.
+
+The following optimization steps are available:
+
+============ ===============================
+Abbreviation Full name
+============ ===============================
+f            `BlockFlattener`
+l            `CircularReferencesPruner`
+c            `CommonSubexpressionEliminator`
+C            `ConditionalSimplifier`
+U            `ConditionalUnsimplifier`
+n            `ControlFlowSimplifier`
+D            `DeadCodeEliminator`
+v            `EquivalentFunctionCombiner`
+e            `ExpressionInliner`
+j            `ExpressionJoiner`
+s            `ExpressionSimplifier`
+x            `ExpressionSplitter`
+I            `ForLoopConditionIntoBody`
+O            `ForLoopConditionOutOfBody`
+o            `ForLoopInitRewriter`
+i            `FullInliner`
+g            `FunctionGrouper`
+h            `FunctionHoister`
+T            `LiteralRematerialiser`
+L            `LoadResolver`
+M            `LoopInvariantCodeMotion`
+r            `RedundantAssignEliminator`
+m            `Rematerialiser`
+V            `SSAReverser`
+a            `SSATransform`
+t            `StructuralSimplifier`
+u            `UnusedPruner`
+d            `VarDeclInitializer`
+============ ===============================
+
+Some steps depend on properties ensured by `BlockFlattener`, `FunctionGrouper`, `ForLoopInitRewriter`.
+For this reason the Yul optimizer always applies them before applying any steps supplied by the user.

libsolidity/analysis/TypeChecker.cpp

@@ -1480,13 +1480,13 @@ bool TypeChecker::visit(UnaryOperation const& _operation)
 	TypePointer t = type(_operation.subExpression())->unaryOperatorResult(op);
 	if (!t)
 	{
-		m_errorReporter.typeError(
+		string description = "Unary operator " + string(TokenTraits::toString(op)) + " cannot be applied to type " + subExprType->toString();
-			_operation.location(),
+		if (modifying)
-			"Unary operator " +
+			// Cannot just report the error, ignore the unary operator, and continue,
-			string(TokenTraits::toString(op)) +
+			// because the sub-expression was already processed with requireLValue()
-			" cannot be applied to type " +
+			m_errorReporter.fatalTypeError(_operation.location(), description);
-			subExprType->toString()
+		else
-		);
+			m_errorReporter.typeError(_operation.location(), description);
 		t = subExprType;
 	}
 	_operation.annotation().type = t;

libsolidity/codegen/ContractCompiler.cpp

@@ -733,7 +733,10 @@ bool ContractCompiler::visit(InlineAssembly const& _inlineAssembly)
 						{
 						case Type::Category::Bool:
 						case Type::Category::Address:
-							solAssert(*type == *variable->annotation().type, "");
+							// Either both the literal and the variable are bools, or they are both addresses.
+							// If they are both bools, comparing category is the same as comparing the types.
+							// If they are both addresses, compare category so that payable/nonpayable is not compared.
+							solAssert(type->category() == variable->annotation().type->category(), "");
 							value = type->literalValue(literal);
 							break;
 						case Type::Category::StringLiteral:

libsolidity/codegen/ir/IRGenerationContext.cpp

@@ -22,6 +22,7 @@
 
 #include <libsolidity/codegen/YulUtilFunctions.h>
 #include <libsolidity/codegen/ABIFunctions.h>
+#include <libsolidity/codegen/CompilerUtils.h>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/ast/TypeProvider.h>
 
@@ -76,6 +77,36 @@ IRVariable const& IRGenerationContext::localVariable(VariableDeclaration const&
 	return m_localVariables.at(&_varDecl);
 }
 
+void IRGenerationContext::registerImmutableVariable(VariableDeclaration const& _variable)
+{
+	solAssert(_variable.immutable(), "Attempted to register a non-immutable variable as immutable.");
+	solUnimplementedAssert(
+		_variable.annotation().type->isValueType(),
+		"Only immutable variables of value type are supported."
+	);
+	solAssert(m_reservedMemory.has_value(), "Reserved memory has already been reset.");
+	m_immutableVariables[&_variable] = CompilerUtils::generalPurposeMemoryStart + *m_reservedMemory;
+	solAssert(_variable.annotation().type->memoryHeadSize() == 32, "Memory writes might overlap.");
+	*m_reservedMemory += _variable.annotation().type->memoryHeadSize();
+}
+
+size_t IRGenerationContext::immutableMemoryOffset(VariableDeclaration const& _variable) const
+{
+	solAssert(
+		m_immutableVariables.count(&_variable),
+		"Unknown immutable variable: " + _variable.name()
+	);
+	return m_immutableVariables.at(&_variable);
+}
+
+size_t IRGenerationContext::reservedMemory()
+{
+	solAssert(m_reservedMemory.has_value(), "Reserved memory was used before.");
+	size_t reservedMemory = *m_reservedMemory;
+	m_reservedMemory = std::nullopt;
+	return reservedMemory;
+}
+
 void IRGenerationContext::addStateVariable(
 	VariableDeclaration const& _declaration,
 	u256 _storageOffset,

libsolidity/codegen/ir/IRGenerationContext.h

@@ -81,6 +81,17 @@ public:
 	bool isLocalVariable(VariableDeclaration const& _varDecl) const { return m_localVariables.count(&_varDecl); }
 	IRVariable const& localVariable(VariableDeclaration const& _varDecl);
 
+	/// Registers an immutable variable of the contract.
+	/// Should only be called at construction time.
+	void registerImmutableVariable(VariableDeclaration const& _varDecl);
+	/// @returns the reserved memory for storing the value of the
+	/// immutable @a _variable during contract creation.
+	size_t immutableMemoryOffset(VariableDeclaration const& _variable) const;
+	/// @returns the reserved memory and resets it to mark it as used.
+	/// Intended to be used only once for initializing the free memory pointer
+	/// to after the area used for immutables.
+	size_t reservedMemory();
+
 	void addStateVariable(VariableDeclaration const& _varDecl, u256 _storageOffset, unsigned _byteOffset);
 	bool isStateVariable(VariableDeclaration const& _varDecl) const { return m_stateVariables.count(&_varDecl); }
 	std::pair<u256, unsigned> storageLocationOfVariable(VariableDeclaration const& _varDecl) const
@@ -123,6 +134,12 @@ private:
 	OptimiserSettings m_optimiserSettings;
 	ContractDefinition const* m_mostDerivedContract = nullptr;
 	std::map<VariableDeclaration const*, IRVariable> m_localVariables;
+	/// Memory offsets reserved for the values of immutable variables during contract creation.
+	/// This map is empty in the runtime context.
+	std::map<VariableDeclaration const*, size_t> m_immutableVariables;
+	/// Total amount of reserved memory. Reserved memory is used to store
+	/// immutable variables during contract creation.
+	std::optional<size_t> m_reservedMemory = {0};
 	/// Storage offsets of state variables
 	std::map<VariableDeclaration const*, std::pair<u256, unsigned>> m_stateVariables;
 	MultiUseYulFunctionCollector m_functions;

libsolidity/codegen/ir/IRGenerator.cpp

@@ -114,6 +114,8 @@ string IRGenerator::generate(
 	)");
 
 	resetContext(_contract);
+	for (VariableDeclaration const* var: ContractType(_contract).immutableVariables())
+		m_context.registerImmutableVariable(*var);
 
 	t("CreationObject", m_context.creationObjectName(_contract));
 	t("memoryInit", memoryInit());
@@ -142,6 +144,7 @@ string IRGenerator::generate(
 	t("subObjects", subObjectSources(m_context.subObjectsCreated()));
 
 	resetContext(_contract);
+	// Do not register immutables to avoid assignment.
 	t("RuntimeObject", m_context.runtimeObjectName(_contract));
 	t("dispatch", dispatchRoutine(_contract));
 	generateQueuedFunctions();
@@ -200,7 +203,6 @@ string IRGenerator::generateGetter(VariableDeclaration const& _varDecl)
 	Type const* type = _varDecl.annotation().type;
 
 	solAssert(!_varDecl.isConstant(), "");
-	solAssert(!_varDecl.immutable(), "");
 	solAssert(_varDecl.isStateVariable(), "");
 
 	if (auto const* mappingType = dynamic_cast<MappingType const*>(type))
@@ -254,17 +256,32 @@ string IRGenerator::generateGetter(VariableDeclaration const& _varDecl)
 		solUnimplementedAssert(type->isValueType(), "");
 
 		return m_context.functionCollector().createFunction(functionName, [&]() {
-			pair<u256, unsigned> slot_offset = m_context.storageLocationOfVariable(_varDecl);
+			if (_varDecl.immutable())
+			{
+				solUnimplementedAssert(type->sizeOnStack() == 1, "");
+				return Whiskers(R"(
+					function <functionName>() -> rval {
+						rval := loadimmutable("<id>")
+					}
+				)")
+				("functionName", functionName)
+				("id", to_string(_varDecl.id()))
+				.render();
+			}
+			else
+			{
+				pair<u256, unsigned> slot_offset = m_context.storageLocationOfVariable(_varDecl);
 
-			return Whiskers(R"(
+				return Whiskers(R"(
-				function <functionName>() -> rval {
+					function <functionName>() -> rval {
-					rval := <readStorage>(<slot>)
+						rval := <readStorage>(<slot>)
-				}
+					}
-			)")
+				)")
-			("functionName", functionName)
+				("functionName", functionName)
-			("readStorage", m_utils.readFromStorage(*type, slot_offset.second, false))
+				("readStorage", m_utils.readFromStorage(*type, slot_offset.second, false))
-			("slot", slot_offset.first.str())
+				("slot", slot_offset.first.str())
-			.render();
+				.render();
+			}
 		});
 	}
 }
@@ -325,7 +342,7 @@ string IRGenerator::initStateVariables(ContractDefinition const& _contract)
 {
 	IRGeneratorForStatements generator{m_context, m_utils};
 	for (VariableDeclaration const* variable: _contract.stateVariables())
-		if (!variable->isConstant() && !variable->immutable())
+		if (!variable->isConstant())
 			generator.initializeStateVar(*variable);
 
 	return generator.code();
@@ -391,10 +408,41 @@ void IRGenerator::generateImplicitConstructors(ContractDefinition const& _contra
 string IRGenerator::deployCode(ContractDefinition const& _contract)
 {
 	Whiskers t(R"X(
+		<#loadImmutables>
+			let <var> := mload(<memoryOffset>)
+		</loadImmutables>
+
 		codecopy(0, dataoffset("<object>"), datasize("<object>"))
+
+		<#storeImmutables>
+			setimmutable("<immutableName>", <var>)
+		</storeImmutables>
+
 		return(0, datasize("<object>"))
 	)X");
 	t("object", m_context.runtimeObjectName(_contract));
+
+	vector<map<string, string>> loadImmutables;
+	vector<map<string, string>> storeImmutables;
+
+	for (VariableDeclaration const* immutable: ContractType(_contract).immutableVariables())
+	{
+		solUnimplementedAssert(immutable->type()->isValueType(), "");
+		solUnimplementedAssert(immutable->type()->sizeOnStack() == 1, "");
+		string yulVar = m_context.newYulVariable();
+		loadImmutables.emplace_back(map<string, string>{
+			{"var"s, yulVar},
+			{"memoryOffset"s, to_string(m_context.immutableMemoryOffset(*immutable))}
+		});
+		storeImmutables.emplace_back(map<string, string>{
+			{"var"s, yulVar},
+			{"immutableName"s, to_string(immutable->id())}
+		});
+	}
+	t("loadImmutables", std::move(loadImmutables));
+	// reverse order to ease stack strain
+	reverse(storeImmutables.begin(), storeImmutables.end());
+	t("storeImmutables", std::move(storeImmutables));
 	return t.render();
 }
 
@@ -489,9 +537,9 @@ string IRGenerator::memoryInit()
 	// and thus can assume all memory to be zero, including the contents of
 	// the "zero memory area" (the position CompilerUtils::zeroPointer points to).
 	return
-		Whiskers{"mstore(<memPtr>, <generalPurposeStart>)"}
+		Whiskers{"mstore(<memPtr>, <freeMemoryStart>)"}
 		("memPtr", to_string(CompilerUtils::freeMemoryPointer))
-		("generalPurposeStart", to_string(CompilerUtils::generalPurposeMemoryStart))
+		("freeMemoryStart", to_string(CompilerUtils::generalPurposeMemoryStart + m_context.reservedMemory()))
 		.render();
 }
 

libsolidity/codegen/ir/IRGeneratorForStatements.cpp

@@ -140,20 +140,21 @@ string IRGeneratorForStatements::code() const
 
 void IRGeneratorForStatements::initializeStateVar(VariableDeclaration const& _varDecl)
 {
-	solAssert(m_context.isStateVariable(_varDecl), "Must be a state variable.");
+	solAssert(_varDecl.immutable() || m_context.isStateVariable(_varDecl), "Must be immutable or a state variable.");
 	solAssert(!_varDecl.isConstant(), "");
-	solAssert(!_varDecl.immutable(), "");
+	if (!_varDecl.value())
-	if (_varDecl.value())
+		return;
-	{
+
-		_varDecl.value()->accept(*this);
+	_varDecl.value()->accept(*this);
-		writeToLValue(IRLValue{
+	writeToLValue(
-			*_varDecl.annotation().type,
+		_varDecl.immutable() ?
-			IRLValue::Storage{
+		IRLValue{*_varDecl.annotation().type, IRLValue::Immutable{&_varDecl}} :
-				util::toCompactHexWithPrefix(m_context.storageLocationOfVariable(_varDecl).first),
+		IRLValue{*_varDecl.annotation().type, IRLValue::Storage{
-				m_context.storageLocationOfVariable(_varDecl).second
+			util::toCompactHexWithPrefix(m_context.storageLocationOfVariable(_varDecl).first),
-			}
+			m_context.storageLocationOfVariable(_varDecl).second
-		}, *_varDecl.value());
+		}},
-	}
+		*_varDecl.value()
+	);
 }
 
 void IRGeneratorForStatements::initializeLocalVar(VariableDeclaration const& _varDecl)
@@ -584,7 +585,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 	case FunctionType::Kind::Internal:
 	{
 		vector<string> args;
-		for (unsigned i = 0; i < arguments.size(); ++i)
+		for (size_t i = 0; i < arguments.size(); ++i)
 			if (functionType->takesArbitraryParameters())
 				args.emplace_back(IRVariable(*arguments[i]).commaSeparatedList());
 			else
@@ -730,6 +731,16 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 
 		break;
 	}
+	case FunctionType::Kind::Revert:
+	{
+		solAssert(arguments.size() == parameterTypes.size(), "");
+		if (arguments.empty())
+			m_code << "revert(0, 0)\n";
+		else
+			solUnimplementedAssert(false, "");
+
+		break;
+	}
 	// Array creation using new
 	case FunctionType::Kind::ObjectCreation:
 	{
@@ -818,15 +829,43 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 	{
 		break;
 	}
-	case FunctionType::Kind::GasLeft:
+	case FunctionType::Kind::AddMod:
+	case FunctionType::Kind::MulMod:
 	{
-		define(_functionCall) << "gas()\n";
+		static map<FunctionType::Kind, string> functions = {
+			{FunctionType::Kind::AddMod, "addmod"},
+			{FunctionType::Kind::MulMod, "mulmod"},
+		};
+		solAssert(functions.find(functionType->kind()) != functions.end(), "");
+		solAssert(arguments.size() == 3 && parameterTypes.size() == 3, "");
+
+		IRVariable modulus(m_context.newYulVariable(), *(parameterTypes[2]));
+		define(modulus, *arguments[2]);
+		Whiskers templ("if iszero(<modulus>) { invalid() }\n");
+		m_code << templ("modulus", modulus.name()).render();
+
+		string args;
+		for (size_t i = 0; i < 2; ++i)
+			args += expressionAsType(*arguments[i], *(parameterTypes[i])) + ", ";
+		args += modulus.name();
+		define(_functionCall) << functions[functionType->kind()] << "(" << args << ")\n";
 		break;
 	}
+	case FunctionType::Kind::GasLeft:
 	case FunctionType::Kind::Selfdestruct:
+	case FunctionType::Kind::BlockHash:
 	{
-		solAssert(arguments.size() == 1, "");
+		static map<FunctionType::Kind, string> functions = {
-		define(_functionCall) << "selfdestruct(" << expressionAsType(*arguments.front(), *parameterTypes.front()) << ")\n";
+			{FunctionType::Kind::GasLeft, "gas"},
+			{FunctionType::Kind::Selfdestruct, "selfdestruct"},
+			{FunctionType::Kind::BlockHash, "blockhash"},
+		};
+		solAssert(functions.find(functionType->kind()) != functions.end(), "");
+
+		string args;
+		for (size_t i = 0; i < arguments.size(); ++i)
+			args += (args.empty() ? "" : ", ") + expressionAsType(*arguments[i], *(parameterTypes[i]));
+		define(_functionCall) << functions[functionType->kind()] << "(" << args << ")\n";
 		break;
 	}
 	case FunctionType::Kind::Log0:
@@ -908,6 +947,34 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 
 		break;
 	}
+	case FunctionType::Kind::Send:
+	case FunctionType::Kind::Transfer:
+	{
+		solAssert(arguments.size() == 1 && parameterTypes.size() == 1, "");
+		string address{IRVariable(_functionCall.expression()).part("address").name()};
+		string value{expressionAsType(*arguments[0], *(parameterTypes[0]))};
+		Whiskers templ(R"(
+			let <gas> := 0
+			if iszero(<value>) { <gas> := <callStipend> }
+			let <success> := call(<gas>, <address>, <value>, 0, 0, 0, 0)
+			<?isTransfer>
+				if iszero(<success>) { <forwardingRevert>() }
+			</isTransfer>
+		)");
+		templ("gas", m_context.newYulVariable());
+		templ("callStipend", toString(evmasm::GasCosts::callStipend));
+		templ("address", address);
+		templ("value", value);
+		if (functionType->kind() == FunctionType::Kind::Transfer)
+			templ("success", m_context.newYulVariable());
+		else
+			templ("success", IRVariable(_functionCall).commaSeparatedList());
+		templ("isTransfer", functionType->kind() == FunctionType::Kind::Transfer);
+		templ("forwardingRevert", m_utils.forwardingRevertFunction());
+		m_code << templ.render();
+
+		break;
+	}
 	default:
 		solUnimplemented("FunctionKind " + toString(static_cast<int>(functionType->kind())) + " not yet implemented");
 	}
@@ -1479,8 +1546,12 @@ void IRGeneratorForStatements::handleVariableReference(
 	// If the value is visited twice, `defineExpression` is called twice on
 	// the same expression.
 	solUnimplementedAssert(!_variable.isConstant(), "");
-	solUnimplementedAssert(!_variable.immutable(), "");
+	if (_variable.isStateVariable() && _variable.immutable())
-	if (m_context.isLocalVariable(_variable))
+		setLValue(_referencingExpression, IRLValue{
+			*_variable.annotation().type,
+			IRLValue::Immutable{&_variable}
+		});
+	else if (m_context.isLocalVariable(_variable))
 		setLValue(_referencingExpression, IRLValue{
 			*_variable.annotation().type,
 			IRLValue::Stack{m_context.localVariable(_variable)}
@@ -1901,6 +1972,18 @@ void IRGeneratorForStatements::writeToLValue(IRLValue const& _lvalue, IRVariable
 				}
 			},
 			[&](IRLValue::Stack const& _stack) { assign(_stack.variable, _value); },
+			[&](IRLValue::Immutable const& _immutable)
+			{
+				solUnimplementedAssert(_lvalue.type.isValueType(), "");
+				solUnimplementedAssert(_lvalue.type.sizeOnStack() == 1, "");
+				solAssert(_lvalue.type == *_immutable.variable->type(), "");
+				size_t memOffset = m_context.immutableMemoryOffset(*_immutable.variable);
+
+				IRVariable prepared(m_context.newYulVariable(), _lvalue.type);
+				define(prepared, _value);
+
+				m_code << "mstore(" << to_string(memOffset) << ", " << prepared.commaSeparatedList() << ")\n";
+			},
 			[&](IRLValue::Tuple const& _tuple) {
 				auto components = std::move(_tuple.components);
 				for (size_t i = 0; i < components.size(); i++)
@@ -1956,6 +2039,12 @@ IRVariable IRGeneratorForStatements::readFromLValue(IRLValue const& _lvalue)
 		[&](IRLValue::Stack const& _stack) {
 			define(result, _stack.variable);
 		},
+		[&](IRLValue::Immutable const& _immutable) {
+			solUnimplementedAssert(_lvalue.type.isValueType(), "");
+			solUnimplementedAssert(_lvalue.type.sizeOnStack() == 1, "");
+			solAssert(_lvalue.type == *_immutable.variable->type(), "");
+			define(result) << "loadimmutable(\"" << to_string(_immutable.variable->id()) << "\")\n";
+		},
 		[&](IRLValue::Tuple const&) {
 			solAssert(false, "Attempted to read from tuple lvalue.");
 		}

libsolidity/codegen/ir/IRLValue.h

@@ -35,6 +35,10 @@ struct IRLValue
 	{
 		IRVariable variable;
 	};
+	struct Immutable
+	{
+		VariableDeclaration const* variable = nullptr;
+	};
 	struct Storage
 	{
 		std::string const slot;
@@ -59,7 +63,7 @@ struct IRLValue
 	{
 		std::vector<std::optional<IRLValue>> components;
 	};
-	std::variant<Stack, Storage, Memory, Tuple> kind;
+	std::variant<Stack, Immutable, Storage, Memory, Tuple> kind;
 };
 
-}
+}

libyul/AsmAnalysis.cpp

@@ -306,11 +306,15 @@ vector<YulString> AsmAnalyzer::operator()(FunctionCall const& _funCall)
 					_funCall.functionName.location,
 					"Function expects direct literals as arguments."
 				);
-			else if (!m_dataNames.count(std::get<Literal>(arg).value))
+			else if (
-				typeError(
+				_funCall.functionName.name.str() == "datasize" ||
-					_funCall.functionName.location,
+				_funCall.functionName.name.str() == "dataoffset"
-					"Unknown data object \"" + std::get<Literal>(arg).value.str() + "\"."
+			)
-				);
+				if (!m_dataNames.count(std::get<Literal>(arg).value))
+					typeError(
+						_funCall.functionName.location,
+						"Unknown data object \"" + std::get<Literal>(arg).value.str() + "\"."
+					);
 		}
 	}
 	std::reverse(argTypes.begin(), argTypes.end());

libyul/backends/evm/AbstractAssembly.h

@@ -105,6 +105,11 @@ public:
 	virtual void appendDataSize(SubID _sub) = 0;
 	/// Appends the given data to the assembly and returns its ID.
 	virtual SubID appendData(bytes const& _data) = 0;
+
+	/// Appends loading an immutable variable.
+	virtual void appendImmutable(std::string const& _identifier) = 0;
+	/// Appends an assignment to an immutable variable.
+	virtual void appendImmutableAssignment(std::string const& _identifier) = 0;
 };
 
 enum class IdentifierContext { LValue, RValue, VariableDeclaration };

libyul/backends/evm/AsmCodeGen.cpp

@@ -172,6 +172,16 @@ AbstractAssembly::SubID EthAssemblyAdapter::appendData(bytes const& _data)
 	return subID;
 }
 
+void EthAssemblyAdapter::appendImmutable(std::string const& _identifier)
+{
+	m_assembly.appendImmutable(_identifier);
+}
+
+void EthAssemblyAdapter::appendImmutableAssignment(std::string const& _identifier)
+{
+	m_assembly.appendImmutableAssignment(_identifier);
+}
+
 EthAssemblyAdapter::LabelID EthAssemblyAdapter::assemblyTagToIdentifier(evmasm::AssemblyItem const& _tag)
 {
 	u256 id = _tag.data();

libyul/backends/evm/AsmCodeGen.h

@@ -61,6 +61,9 @@ public:
 	void appendDataSize(SubID _sub) override;
 	SubID appendData(bytes const& _data) override;
 
+	void appendImmutable(std::string const& _identifier) override;
+	void appendImmutableAssignment(std::string const& _identifier) override;
+
 private:
 	static LabelID assemblyTagToIdentifier(evmasm::AssemblyItem const& _tag);
 

libyul/backends/evm/EVMAssembly.cpp

@@ -215,6 +215,16 @@ AbstractAssembly::SubID EVMAssembly::appendData(bytes const&)
 	yulAssert(false, "Data not implemented.");
 }
 
+void EVMAssembly::appendImmutable(std::string const&)
+{
+	yulAssert(false, "loadimmutable not implemented.");
+}
+
+void EVMAssembly::appendImmutableAssignment(std::string const&)
+{
+	yulAssert(false, "setimmutable not implemented.");
+}
+
 void EVMAssembly::updateReference(size_t pos, size_t size, u256 value)
 {
 	yulAssert(m_bytecode.size() >= size && pos <= m_bytecode.size() - size, "");

libyul/backends/evm/EVMAssembly.h

@@ -83,6 +83,9 @@ public:
 	void appendDataSize(SubID _sub) override;
 	SubID appendData(bytes const& _data) override;
 
+	void appendImmutable(std::string const& _identifier) override;
+	void appendImmutableAssignment(std::string const& _identifier) override;
+
 	/// Resolves references inside the bytecode and returns the linker object.
 	evmasm::LinkerObject finalize();
 

libyul/backends/evm/EVMCodeTransform.cpp

@@ -257,13 +257,9 @@ void CodeTransform::operator()(FunctionCall const& _call)
 	yulAssert(m_scope, "");
 
 	if (BuiltinFunctionForEVM const* builtin = m_dialect.builtin(_call.functionName.name))
-	{
+		builtin->generateCode(_call, m_assembly, m_builtinContext, [&](Expression const& _expression) {
-		builtin->generateCode(_call, m_assembly, m_builtinContext, [&]() {
+			visitExpression(_expression);
-			for (auto const& arg: _call.arguments | boost::adaptors::reversed)
-				visitExpression(arg);
-			m_assembly.setSourceLocation(_call.location);
 		});
-	}
 	else
 	{
 		m_assembly.setSourceLocation(_call.location);

libyul/backends/evm/EVMDialect.cpp

@@ -41,6 +41,20 @@ using namespace solidity::util;
 
 namespace
 {
+
+void visitArguments(
+	AbstractAssembly& _assembly,
+	FunctionCall const& _call,
+	function<void(Expression const&)> _visitExpression
+)
+{
+	for (auto const& arg: _call.arguments | boost::adaptors::reversed)
+		_visitExpression(arg);
+
+	_assembly.setSourceLocation(_call.location);
+}
+
+
 pair<YulString, BuiltinFunctionForEVM> createEVMFunction(
 	string const& _name,
 	evmasm::Instruction _instruction
@@ -58,12 +72,12 @@ pair<YulString, BuiltinFunctionForEVM> createEVMFunction(
 	f.literalArguments.reset();
 	f.instruction = _instruction;
 	f.generateCode = [_instruction](
-		FunctionCall const&,
+		FunctionCall const& _call,
 		AbstractAssembly& _assembly,
 		BuiltinContext&,
-		std::function<void()> _visitArguments
+		std::function<void(Expression const&)> _visitExpression
 	) {
-		_visitArguments();
+		visitArguments(_assembly, _call, _visitExpression);
 		_assembly.appendInstruction(_instruction);
 	};
 
@@ -76,7 +90,7 @@ pair<YulString, BuiltinFunctionForEVM> createFunction(
 	size_t _returns,
 	SideEffects _sideEffects,
 	vector<bool> _literalArguments,
-	std::function<void(FunctionCall const&, AbstractAssembly&, BuiltinContext&, std::function<void()>)> _generateCode
+	std::function<void(FunctionCall const&, AbstractAssembly&, BuiltinContext&, std::function<void(Expression const&)>)> _generateCode
 )
 {
 	solAssert(_literalArguments.size() == _params || _literalArguments.empty(), "");
@@ -116,7 +130,7 @@ map<YulString, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _evmVe
 			FunctionCall const& _call,
 			AbstractAssembly& _assembly,
 			BuiltinContext& _context,
-			function<void()>
+			std::function<void(Expression const&)>
 		) {
 			yulAssert(_context.currentObject, "No object available.");
 			yulAssert(_call.arguments.size() == 1, "");
@@ -137,7 +151,7 @@ map<YulString, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _evmVe
 			FunctionCall const& _call,
 			AbstractAssembly& _assembly,
 			BuiltinContext& _context,
-			std::function<void()>
+			std::function<void(Expression const&)>
 		) {
 			yulAssert(_context.currentObject, "No object available.");
 			yulAssert(_call.arguments.size() == 1, "");
@@ -161,21 +175,58 @@ map<YulString, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _evmVe
 			SideEffects{false, false, false, false, true},
 			{},
 			[](
-				FunctionCall const&,
+				FunctionCall const& _call,
 				AbstractAssembly& _assembly,
 				BuiltinContext&,
-				std::function<void()> _visitArguments
+				std::function<void(Expression const&)> _visitExpression
 			) {
-				_visitArguments();
+				visitArguments(_assembly, _call, _visitExpression);
 				_assembly.appendInstruction(evmasm::Instruction::CODECOPY);
 			}
 		));
+		builtins.emplace(createFunction(
+			"setimmutable",
+			2,
+			0,
+			SideEffects{false, false, false, false, true},
+			{true, false},
+			[](
+				FunctionCall const& _call,
+				AbstractAssembly& _assembly,
+				BuiltinContext&,
+				std::function<void(Expression const&)> _visitExpression
+			) {
+				solAssert(_call.arguments.size() == 2, "");
+
+				_visitExpression(_call.arguments[1]);
+				_assembly.setSourceLocation(_call.location);
+				YulString identifier = std::get<Literal>(_call.arguments.front()).value;
+				_assembly.appendImmutableAssignment(identifier.str());
+			}
+		));
+		builtins.emplace(createFunction(
+			"loadimmutable",
+			1,
+			1,
+			SideEffects{},
+			{true},
+			[](
+				FunctionCall const& _call,
+				AbstractAssembly& _assembly,
+				BuiltinContext&,
+				std::function<void(Expression const&)>
+			) {
+				solAssert(_call.arguments.size() == 1, "");
+				_assembly.appendImmutable(std::get<Literal>(_call.arguments.front()).value.str());
+			}
+		));
 	}
 	return builtins;
 }
 
 }
 
+
 EVMDialect::EVMDialect(langutil::EVMVersion _evmVersion, bool _objectAccess):
 	m_objectAccess(_objectAccess),
 	m_evmVersion(_evmVersion),
@@ -268,23 +319,23 @@ EVMDialectTyped::EVMDialectTyped(langutil::EVMVersion _evmVersion, bool _objectA
 	m_functions["popbool"_yulstring].name = "popbool"_yulstring;
 	m_functions["popbool"_yulstring].parameters = {"bool"_yulstring};
 	m_functions.insert(createFunction("bool_to_u256", 1, 1, {}, {}, [](
-		FunctionCall const&,
+		FunctionCall const& _call,
-		AbstractAssembly&,
+		AbstractAssembly& _assembly,
 		BuiltinContext&,
-		std::function<void()> _visitArguments
+		std::function<void(Expression const&)> _visitExpression
 	) {
-		_visitArguments();
+		visitArguments(_assembly, _call, _visitExpression);
 	}));
 	m_functions["bool_to_u256"_yulstring].parameters = {"bool"_yulstring};
 	m_functions["bool_to_u256"_yulstring].returns = {"u256"_yulstring};
 	m_functions.insert(createFunction("u256_to_bool", 1, 1, {}, {}, [](
-		FunctionCall const&,
+		FunctionCall const& _call,
 		AbstractAssembly& _assembly,
 		BuiltinContext&,
-		std::function<void()> _visitArguments
+		std::function<void(Expression const&)> _visitExpression
 	) {
 		// A value larger than 1 causes an invalid instruction.
-		_visitArguments();
+		visitArguments(_assembly, _call, _visitExpression);
 		_assembly.appendConstant(2);
 		_assembly.appendInstruction(evmasm::Instruction::DUP2);
 		_assembly.appendInstruction(evmasm::Instruction::LT);

libyul/backends/evm/EVMDialect.h

@@ -23,6 +23,7 @@
 #include <libyul/Dialect.h>
 
 #include <libyul/backends/evm/AbstractAssembly.h>
+#include <libyul/AsmData.h>
 #include <liblangutil/EVMVersion.h>
 
 #include <map>
@@ -49,9 +50,9 @@ struct BuiltinFunctionForEVM: public BuiltinFunction
 {
 	std::optional<evmasm::Instruction> instruction;
 	/// Function to generate code for the given function call and append it to the abstract
-	/// assembly. The fourth parameter is called to visit (and generate code for) the arguments
+	/// assembly. The fourth parameter is called to visit (and generate code for) the given
-	/// from right to left.
+	/// argument.
-	std::function<void(FunctionCall const&, AbstractAssembly&, BuiltinContext&, std::function<void()>)> generateCode;
+	std::function<void(FunctionCall const&, AbstractAssembly&, BuiltinContext&, std::function<void(Expression const&)>)> generateCode;
 };
 
 

libyul/backends/evm/NoOutputAssembly.cpp

@@ -19,10 +19,14 @@
  */
 
 #include <libyul/backends/evm/NoOutputAssembly.h>
+
 #include <libyul/Exceptions.h>
 
 #include <libevmasm/Instruction.h>
 
+#include <boost/range/adaptor/reversed.hpp>
+
+
 using namespace std;
 using namespace solidity;
 using namespace solidity::yul;
@@ -142,6 +146,17 @@ AbstractAssembly::SubID NoOutputAssembly::appendData(bytes const&)
 	return 1;
 }
 
+
+void NoOutputAssembly::appendImmutable(std::string const&)
+{
+	yulAssert(false, "loadimmutable not implemented.");
+}
+
+void NoOutputAssembly::appendImmutableAssignment(std::string const&)
+{
+	yulAssert(false, "setimmutable not implemented.");
+}
+
 NoOutputEVMDialect::NoOutputEVMDialect(EVMDialect const& _copyFrom):
 	EVMDialect(_copyFrom.evmVersion(), _copyFrom.providesObjectAccess())
 {
@@ -149,9 +164,11 @@ NoOutputEVMDialect::NoOutputEVMDialect(EVMDialect const& _copyFrom):
 	{
 		size_t parameters = fun.second.parameters.size();
 		size_t returns = fun.second.returns.size();
-		fun.second.generateCode = [=](FunctionCall const&, AbstractAssembly& _assembly, BuiltinContext&, std::function<void()> _visitArguments)
+		fun.second.generateCode = [=](FunctionCall const& _call, AbstractAssembly& _assembly, BuiltinContext&, std::function<void(Expression const&)> _visitExpression)
 		{
-			_visitArguments();
+			for (auto const& arg: _call.arguments | boost::adaptors::reversed)
+				_visitExpression(arg);
+
 			for (size_t i = 0; i < parameters; i++)
 				_assembly.appendInstruction(evmasm::Instruction::POP);
 

libyul/backends/evm/NoOutputAssembly.h

@@ -71,6 +71,9 @@ public:
 	void appendDataSize(SubID _sub) override;
 	SubID appendData(bytes const& _data) override;
 
+	void appendImmutable(std::string const& _identifier) override;
+	void appendImmutableAssignment(std::string const& _identifier) override;
+
 private:
 	bool m_evm15 = false; ///< if true, switch to evm1.5 mode
 	int m_stackHeight = 0;

test/cmdlineTests/standard_ir_requested/output.json

@@ -14,6 +14,7 @@ object \"C_6\" {
         constructor_C_6()
 
         codecopy(0, dataoffset(\"C_6_deployed\"), datasize(\"C_6_deployed\"))
+
         return(0, datasize(\"C_6_deployed\"))
 
         function constructor_C_6() {

test/cmdlineTests/yul_string_format_ascii/output.json

@@ -14,6 +14,7 @@ object \"C_10\" {
         constructor_C_10()
 
         codecopy(0, dataoffset(\"C_10_deployed\"), datasize(\"C_10_deployed\"))
+
         return(0, datasize(\"C_10_deployed\"))
 
         function constructor_C_10() {

test/cmdlineTests/yul_string_format_ascii_bytes32/output.json

@@ -14,6 +14,7 @@ object \"C_10\" {
         constructor_C_10()
 
         codecopy(0, dataoffset(\"C_10_deployed\"), datasize(\"C_10_deployed\"))
+
         return(0, datasize(\"C_10_deployed\"))
 
         function constructor_C_10() {

test/cmdlineTests/yul_string_format_ascii_bytes32_from_number/output.json

@@ -14,6 +14,7 @@ object \"C_10\" {
         constructor_C_10()
 
         codecopy(0, dataoffset(\"C_10_deployed\"), datasize(\"C_10_deployed\"))
+
         return(0, datasize(\"C_10_deployed\"))
 
         function constructor_C_10() {

test/cmdlineTests/yul_string_format_ascii_long/output.json

@@ -14,6 +14,7 @@ object \"C_10\" {
         constructor_C_10()
 
         codecopy(0, dataoffset(\"C_10_deployed\"), datasize(\"C_10_deployed\"))
+
         return(0, datasize(\"C_10_deployed\"))
 
         function constructor_C_10() {

test/cmdlineTests/yul_string_format_hex/output.json

@@ -14,6 +14,7 @@ object \"C_10\" {
         constructor_C_10()
 
         codecopy(0, dataoffset(\"C_10_deployed\"), datasize(\"C_10_deployed\"))
+
         return(0, datasize(\"C_10_deployed\"))
 
         function constructor_C_10() {

test/formal/opcodes.py

@@ -45,6 +45,9 @@ def AND(x, y):
 def OR(x, y):
 	return x | y
 
+def NOT(x):
+	return ~(x)
+
 def SHL(x, y):
 	return y << x
 

test/libsolidity/SolidityEndToEndTest.cpp

@@ -50,6 +50,7 @@ using namespace solidity::langutil;
 #define ALSO_VIA_YUL(CODE) \
 { \
 	{ CODE } \
+	reset(); \
 	m_compileViaYul = true; \
 	{ CODE } \
 }
@@ -1058,11 +1059,13 @@ BOOST_AUTO_TEST_CASE(send_ether)
 			}
 		}
 	)";
-	u256 amount(130);
+	ALSO_VIA_YUL(
-	compileAndRun(sourceCode, amount + 1);
+		u256 amount(250);
-	u160 address(23);
+		compileAndRun(sourceCode, amount + 1);
-	ABI_CHECK(callContractFunction("a(address,uint256)", address, amount), encodeArgs(1));
+		u160 address(23);
-	BOOST_CHECK_EQUAL(balanceAt(address), amount);
+		ABI_CHECK(callContractFunction("a(address,uint256)", address, amount), encodeArgs(1));
+		BOOST_CHECK_EQUAL(balanceAt(address), amount);
+	)
 }
 
 BOOST_AUTO_TEST_CASE(transfer_ether)
@@ -1088,17 +1091,19 @@ BOOST_AUTO_TEST_CASE(transfer_ether)
 			}
 		}
 	)";
-	compileAndRun(sourceCode, 0, "B");
+	ALSO_VIA_YUL(
-	u160 const nonPayableRecipient = m_contractAddress;
+		compileAndRun(sourceCode, 0, "B");
-	compileAndRun(sourceCode, 0, "C");
+		u160 const nonPayableRecipient = m_contractAddress;
-	u160 const oogRecipient = m_contractAddress;
+		compileAndRun(sourceCode, 0, "C");
-	compileAndRun(sourceCode, 20, "A");
+		u160 const oogRecipient = m_contractAddress;
-	u160 payableRecipient(23);
+		compileAndRun(sourceCode, 20, "A");
-	ABI_CHECK(callContractFunction("a(address,uint256)", payableRecipient, 10), encodeArgs(10));
+		u160 payableRecipient(23);
-	BOOST_CHECK_EQUAL(balanceAt(payableRecipient), 10);
+		ABI_CHECK(callContractFunction("a(address,uint256)", payableRecipient, 10), encodeArgs(10));
-	BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 10);
+		BOOST_CHECK_EQUAL(balanceAt(payableRecipient), 10);
-	ABI_CHECK(callContractFunction("b(address,uint256)", nonPayableRecipient, 10), encodeArgs());
+		BOOST_CHECK_EQUAL(balanceAt(m_contractAddress), 10);
-	ABI_CHECK(callContractFunction("b(address,uint256)", oogRecipient, 10), encodeArgs());
+		ABI_CHECK(callContractFunction("b(address,uint256)", nonPayableRecipient, 10), encodeArgs());
+		ABI_CHECK(callContractFunction("b(address,uint256)", oogRecipient, 10), encodeArgs());
+	)
 }
 
 BOOST_AUTO_TEST_CASE(uncalled_blockhash)

test/libsolidity/semanticTests/arithmetics/addmod_mulmod_zero.sol

@@ -18,6 +18,8 @@ contract C {
     }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // f(uint256): 0 -> FAILURE
 // g(uint256): 0 -> FAILURE

test/libsolidity/semanticTests/builtinFunctions/blockhash.sol

@@ -0,0 +1,17 @@
+contract C {
+    function f() public returns(bytes32) {
+        return blockhash(1);
+    }
+    function g() public returns(bytes32) {
+        return blockhash(2);
+    }
+    function h() public returns(bytes32) {
+        return blockhash(3);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f() -> 0x3737373737373737373737373737373737373737373737373737373737373738
+// g() -> 0x3737373737373737373737373737373737373737373737373737373737373739
+// h() -> 0x373737373737373737373737373737373737373737373737373737373737373a

test/libsolidity/semanticTests/constants/asm_address_constant_regression.sol

@@ -0,0 +1,12 @@
+// Test for regression of https://github.com/ethereum/solidity/issues/8406
+
+contract C {
+  address constant e = 0x1212121212121212121212121000002134593163;
+
+  function f() public returns (byte z) {
+    assembly { z := e }
+  }
+}
+
+// ----
+// f() -> 0x00

test/libsolidity/semanticTests/immutable/assign_at_declaration.sol

@@ -4,5 +4,7 @@ contract A {
 		return a;
 	}
 }
+// ====
+// compileViaYul: also
 // ----
 // f() -> 2

test/libsolidity/semanticTests/immutable/getter.sol

@@ -1,5 +1,7 @@
 contract C {
     uint immutable public x = 1;
 }
+// ====
+// compileViaYul: also
 // ----
 // x() -> 1

test/libsolidity/semanticTests/immutable/inheritance.sol

@@ -26,5 +26,7 @@ contract D is B, C {
 		return (a, b, c, d);
 	}
 }
+// ====
+// compileViaYul: also
 // ----
 // f() -> 4, 3, 2, 1

test/libsolidity/semanticTests/immutable/internal_function_pointer.sol

@@ -10,6 +10,8 @@ contract C {
 		return z();
 	}
 }
+// ====
+// compileViaYul: also
 // ----
 // f() -> 7
 // callZ() -> 7

test/libsolidity/semanticTests/immutable/stub.sol

@@ -9,5 +9,7 @@ contract C {
 		return (x+x,y);
 	}
 }
+// ====
+// compileViaYul: also
 // ----
 // f() -> 84, 23

test/libsolidity/semanticTests/immutable/use_scratch.sol

@@ -13,6 +13,8 @@ contract C {
 		return (x+x,y);
 	}
 }
+// ====
+// compileViaYul: also
 // ----
 // constructor(): 3 ->
 // f() -> 84, 23

test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_bitnot_tuple.sol

@@ -0,0 +1,9 @@
+contract C
+{
+    function f() public
+    {
+        int x = ~(0,);
+    }
+}
+// ----
+// TypeError: (60-64): Tuple component cannot be empty.

test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_dec_tuple.sol

@@ -0,0 +1,9 @@
+contract C
+{
+    function f() public
+    {
+        int x = --(,);
+    }
+}
+// ----
+// TypeError: (59-64): Unary operator -- cannot be applied to type tuple(,)

test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_delete_tuple.sol

@@ -0,0 +1,10 @@
+contract C
+{
+    function f() public
+    {
+        int x = delete (,0);
+    }
+}
+// ----
+// TypeError: (68-69): Expression has to be an lvalue.
+// TypeError: (59-70): Unary operator delete cannot be applied to type tuple(,int_const 0)

test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_inc_tuple.sol

@@ -0,0 +1,9 @@
+contract C
+{
+    function f() public
+    {
+        (int x) = ++(,);
+    }
+}
+// ----
+// TypeError: (61-66): Unary operator ++ cannot be applied to type tuple(,)

test/libsolidity/syntaxTests/iceRegressionTests/declarationUnaryTuple/declaration_unary_tuple.sol

@@ -0,0 +1,20 @@
+contract C
+{
+    function f() public
+    {
+        int x = +(0, 0);
+        int y = -(0, 0);
+        (int z) = ~(0, 0);
+        (int t) = !(0, 0);
+    }
+}
+// ----
+// SyntaxError: (59-66): Use of unary + is disallowed.
+// TypeError: (59-66): Unary operator + cannot be applied to type tuple(int_const 0,int_const 0)
+// TypeError: (51-66): Different number of components on the left hand side (1) than on the right hand side (2).
+// TypeError: (84-91): Unary operator - cannot be applied to type tuple(int_const 0,int_const 0)
+// TypeError: (76-91): Different number of components on the left hand side (1) than on the right hand side (2).
+// TypeError: (111-118): Unary operator ~ cannot be applied to type tuple(int_const 0,int_const 0)
+// TypeError: (101-118): Different number of components on the left hand side (1) than on the right hand side (2).
+// TypeError: (138-145): Unary operator ! cannot be applied to type tuple(int_const 0,int_const 0)
+// TypeError: (128-145): Different number of components on the left hand side (1) than on the right hand side (2).

test/libsolidity/syntaxTests/inlineAssembly/immutables.sol

@@ -0,0 +1,11 @@
+contract C {
+  function f() public pure {
+    assembly {
+      setimmutable("abc", 0)
+      loadimmutable("abc")
+    }
+  }
+}
+// ----
+// DeclarationError: (63-75): Function not found.
+// DeclarationError: (92-105): Function not found.

test/tools/ossfuzz/protoToYul.cpp

@@ -344,62 +344,102 @@ void ProtoConverter::visit(BinaryOp const& _x)
 	m_output << ")";
 }
 
-void ProtoConverter::visit(VarDecl const& _x)
+void ProtoConverter::scopeVariables(vector<string> const& _varNames)
 {
-	string varName = newVarName();
-	m_output << "let " << varName << " := ";
-	visit(_x.expr());
-	m_output << "\n";
 	// If we are inside a for-init block, there are two places
 	// where the visited vardecl may have been defined:
 	// - directly inside the for-init block
 	// - inside a block within the for-init block
-	// In the latter case, we don't scope extend.
+	// In the latter case, we don't scope extend. The flag
+	// m_forInitScopeExtEnabled (= true) indicates whether we are directly
+	// inside a for-init block e.g., for { let x } or (= false) inside a
+	// nested for-init block e.g., for { { let x } }
+	bool forInitScopeExtendVariable = m_inForInitScope && m_forInitScopeExtEnabled;
+
+	// There are four cases that are tackled here
+	// Case 1. We are inside a function definition and the variable declaration's
+	// scope needs to be extended.
+	// Case 2. We are inside a function definition but scope extension is disabled
+	// Case 3. We are inside global scope and scope extension is required
+	// Case 4. We are inside global scope but scope extension is disabled
 	if (m_inFunctionDef)
 	{
 		// Variables declared directly in for-init block
 		// are tracked separately because their scope
 		// extends beyond the block they are defined in
 		// to the rest of the for-loop statement.
-		if (m_inForInitScope && m_forInitScopeExtEnabled)
+		// Case 1
+		if (forInitScopeExtendVariable)
 		{
 			yulAssert(
 				!m_funcForLoopInitVars.empty() && !m_funcForLoopInitVars.back().empty(),
 				"Proto fuzzer: Invalid operation"
 			);
-			m_funcForLoopInitVars.back().back().push_back(varName);
+			for (auto const& varName: _varNames)
+				m_funcForLoopInitVars.back().back().push_back(varName);
 		}
+		// Case 2
 		else
 		{
 			yulAssert(
 				!m_funcVars.empty() && !m_funcVars.back().empty(),
 				"Proto fuzzer: Invalid operation"
 			);
-			m_funcVars.back().back().push_back(varName);
+			for (auto const& varName: _varNames)
+				m_funcVars.back().back().push_back(varName);
 		}
-
 	}
+	// If m_inFunctionDef is false, we are in global scope
 	else
 	{
-		if (m_inForInitScope && m_forInitScopeExtEnabled)
+		// Case 3
+		if (forInitScopeExtendVariable)
 		{
-			yulAssert(
+			yulAssert(!m_globalForLoopInitVars.empty(), "Proto fuzzer: Invalid operation");
-				!m_globalForLoopInitVars.empty(),
+
-				"Proto fuzzer: Invalid operation"
+			for (auto const& varName: _varNames)
-			);
+				m_globalForLoopInitVars.back().push_back(varName);
-			m_globalForLoopInitVars.back().push_back(varName);
 		}
+		// Case 4
 		else
 		{
-			yulAssert(
+			yulAssert(!m_globalVars.empty(), "Proto fuzzer: Invalid operation");
-				!m_globalVars.empty(),
+
-				"Proto fuzzer: Invalid operation"
+			for (auto const& varName: _varNames)
-			);
+				m_globalVars.back().push_back(varName);
-			m_globalVars.back().push_back(varName);
 		}
 	}
 }
 
+void ProtoConverter::visit(VarDecl const& _x)
+{
+	string varName = newVarName();
+	m_output << "let " << varName << " := ";
+	visit(_x.expr());
+	m_output << "\n";
+	scopeVariables({varName});
+}
+
+void ProtoConverter::visit(MultiVarDecl const& _x)
+{
+	m_output << "let ";
+	vector<string> varNames;
+	// We support up to 4 variables in a single
+	// declaration statement.
+	unsigned numVars = _x.num_vars() % 3 + 2;
+	string delimiter = "";
+	for (unsigned i = 0; i < numVars; i++)
+	{
+		string varName = newVarName();
+		varNames.push_back(varName);
+		m_output << delimiter << varName;
+		if (i == 0)
+			delimiter = ", ";
+	}
+	m_output << "\n";
+	scopeVariables(varNames);
+}
+
 void ProtoConverter::visit(TypedVarDecl const& _x)
 {
 	string varName = newVarName();
@@ -659,7 +699,7 @@ void ProtoConverter::visit(CopyFunc const& _x)
 	CopyFunc_CopyType type = _x.ct();
 
 	// datacopy() is valid only if we are inside
-	// a yul object.
+	// a Yul object.
 	if (type == CopyFunc::DATA && !m_isObject)
 		return;
 
@@ -1093,7 +1133,8 @@ void ProtoConverter::visit(ForStmt const& _x)
 	{
 		yulAssert(
 			!m_funcForLoopInitVars.empty() && !m_funcForLoopInitVars.back().empty(),
-			"Proto fuzzer: Invalid data structure");
+			"Proto fuzzer: Invalid data structure"
+		);
 		// Remove variables in for-init
 		m_funcForLoopInitVars.back().pop_back();
 	}
@@ -1361,6 +1402,9 @@ void ProtoConverter::visit(Statement const& _x)
 		if (m_inFunctionDef)
 			visit(_x.leave());
 		break;
+	case Statement::kMultidecl:
+		visit(_x.multidecl());
+		break;
 	case Statement::STMT_ONEOF_NOT_SET:
 		break;
 	}
@@ -1606,7 +1650,7 @@ void ProtoConverter::fillFunctionCallInput(unsigned _numInParams)
 	{
 		// Throw a 4-sided dice to choose whether to populate function input
 		// argument from a pseudo-randomly chosen slot in one of the following
-		// locations: calldata, memory, storage, or yul optimizer dictionary.
+		// locations: calldata, memory, storage, or Yul optimizer dictionary.
 		unsigned diceValue = counter() % 4;
 		// Pseudo-randomly choose one of the first ten 32-byte
 		// aligned slots.
@@ -1747,7 +1791,7 @@ void ProtoConverter::createFunctionDefAndCall(
 
 	yulAssert(
 		!m_inForInitScope,
-		"Proto fuzzer: Trying to create function call inside for-init block"
+		"Proto fuzzer: Trying to create function call inside a for-init block"
 	);
 	if (_x.force_call())
 		createFunctionCall(funcName, _numInParams, _numOutParams);
@@ -1837,7 +1881,7 @@ void ProtoConverter::visit(Program const& _x)
 	// Record EVM Version
 	m_evmVersion = evmVersionMapping(_x.ver());
 
-	// Program is either a yul object or a block of
+	// Program is either a Yul object or a block of
 	// statements.
 	switch (_x.program_oneof_case())
 	{
@@ -1854,7 +1898,7 @@ void ProtoConverter::visit(Program const& _x)
 		visit(_x.obj());
 		break;
 	case Program::PROGRAM_ONEOF_NOT_SET:
-		// {} is a trivial yul program
+		// {} is a trivial Yul program
 		m_output << "{}";
 		break;
 	}

test/tools/ossfuzz/protoToYul.h

@@ -68,7 +68,7 @@ private:
 	void visit(BinaryOp const&);
 
 	/// Visits a basic block optionally adding @a _funcParams to scope.
-	/// @param _block Reference to a basic block of yul statements.
+	/// @param _block Reference to a basic block of Yul statements.
 	/// @param _funcParams List of function parameter names, defaults to
 	/// an empty vector.
 	void visit(Block const& _block);
@@ -77,6 +77,7 @@ private:
 	void visit(VarRef const&);
 	void visit(Expression const&);
 	void visit(VarDecl const&);
+	void visit(MultiVarDecl const&);
 	void visit(TypedVarDecl const&);
 	void visit(UnaryOp const&);
 	void visit(AssignmentStatement const&);
@@ -196,7 +197,7 @@ private:
 	/// false otherwise
 	bool functionValid(FunctionCall_Returns _type, unsigned _numOutParams);
 
-	/// Converts protobuf function call to a yul function call and appends
+	/// Converts protobuf function call to a Yul function call and appends
 	/// it to output stream.
 	/// @param _x Protobuf function call
 	/// @param _name Function name
@@ -210,7 +211,7 @@ private:
 		bool _newLine = true
 	);
 
-	/// Prints a yul formatted variable declaration statement to the output
+	/// Prints a Yul formatted variable declaration statement to the output
 	/// stream.
 	/// Example 1: createVarDecls(0, 1, true) returns {"x_0"} and prints
 	///		let x_0 :=
@@ -235,21 +236,26 @@ private:
 	/// @return A vector of strings containing the printed variable names.
 	std::vector<std::string> createVars(unsigned _startIdx, unsigned _endIdx);
 
-	/// Print the yul syntax to make a call to a function named @a _funcName to
+	/// Manages scope of Yul variables
+	/// @param _varNames is a list of Yul variable names whose scope needs
+	/// to be tracked according to Yul scoping rules.
+	void scopeVariables(std::vector<std::string> const& _varNames);
+
+	/// Print the Yul syntax to make a call to a function named @a _funcName to
 	/// the output stream.
 	/// @param _funcName Name of the function to be called
 	/// @param _numInParams Number of input parameters in function signature
 	/// @param _numOutParams Number of output parameters in function signature
 	void createFunctionCall(std::string _funcName, unsigned _numInParams, unsigned _numOutParams);
 
-	/// Print the yul syntax to pass input arguments to a function that has
+	/// Print the Yul syntax to pass input arguments to a function that has
 	/// @a _numInParams number of input parameters to the output stream.
 	/// The input arguments are pseudo-randomly chosen from calldata, memory,
-	/// storage, or the yul optimizer hex dictionary.
+	/// storage, or the Yul optimizer hex dictionary.
 	/// @param _numInParams Number of input arguments to fill
 	void fillFunctionCallInput(unsigned _numInParams);
 
-	/// Print the yul syntax to save values returned by a function call
+	/// Print the Yul syntax to save values returned by a function call
 	/// to the output stream. The values are either stored to memory or
 	/// storage based on a simulated coin flip. The saved location is
 	/// decided pseudo-randomly.
@@ -266,7 +272,7 @@ private:
 
 	/// Build a tree of objects that contains the object/data
 	/// identifiers that are in scope in a given object.
-	/// @param _x root object of the yul protobuf specification.
+	/// @param _x root object of the Yul protobuf specification.
 	void buildObjectScopeTree(Object const& _x);
 
 	/// Returns a pseudo-random dictionary token.

test/tools/ossfuzz/yulProto.proto

@@ -21,6 +21,10 @@ message VarDecl {
   required Expression expr = 1;
 }
 
+message MultiVarDecl {
+  required uint32 num_vars = 1;
+}
+
 message LowLevelCall {
   enum Type {
     CALL = 0;
@@ -373,6 +377,7 @@ message Statement {
     FunctionDef         funcdef         = 16;
     PopStmt             pop             = 17;
     LeaveStmt           leave           = 18;
+    MultiVarDecl        multidecl       = 19;
   }
 }