Fix auto const&

msooseth · msooseth · commit 73abbf894145 · 2026-04-01T14:23:05.000+02:00
diff --git a/libevmasm/ConstantOptimiser.cpp b/libevmasm/ConstantOptimiser.cpp
@@ -45,7 +45,7 @@ unsigned ConstantOptimisationMethod::optimiseConstants(
 			if (item.type() == Push)
 				pushes[item]++;
 		std::map<u256, AssemblyItems> pendingReplacements;
-		for (const auto& it: pushes)
+		for (auto const& it: pushes)
 		{
 			AssemblyItem const& item = it.first;
 			if (item.data() < 0x100)
diff --git a/libevmasm/ControlFlowGraph.cpp b/libevmasm/ControlFlowGraph.cpp
@@ -292,7 +292,7 @@ void ControlFlowGraph::gatherKnowledge()
 				}
 			}
 			else
-				for (const auto& tag: tags)
+				for (auto const& tag: tags)
 					addWorkQueueItem(item, BlockId(tag), state);
 		}
 		else if (block.begin <= pc && pc < block.end)
@@ -327,7 +327,7 @@ BasicBlocks ControlFlowGraph::rebuildCode()
 				pushes[ref]++;
 
 	std::set<BlockId> blocksToAdd;
-	for (const auto& it: m_blocks)
+	for (auto const& it: m_blocks)
 		blocksToAdd.insert(it.first);
 	std::set<BlockId> blocksAdded;
 	BasicBlocks blocks;
diff --git a/libsolidity/analysis/ControlFlowBuilder.cpp b/libsolidity/analysis/ControlFlowBuilder.cpp
@@ -427,7 +427,7 @@ bool ControlFlowBuilder::visit(Return const& _return)
 	{
 		appendControlFlow(*_return.expression());
 		// Returns with return expression are considered to be assignments to the return parameters.
-		for (const auto& returnParameter: _return.annotation().functionReturnParameters->parameters())
+		for (auto const& returnParameter: _return.annotation().functionReturnParameters->parameters())
 			m_currentNode->variableOccurrences.emplace_back(
 				*returnParameter,
 				VariableOccurrence::Kind::Assignment,
diff --git a/libsolidity/analysis/DeclarationContainer.cpp b/libsolidity/analysis/DeclarationContainer.cpp
@@ -204,7 +204,7 @@ void DeclarationContainer::populateHomonyms(std::back_insert_iterator<Homonyms>
 	for (DeclarationContainer const* innerContainer: m_innerContainers)
 		innerContainer->populateHomonyms(_it);
 
-	for (const auto& [name, location]: m_homonymCandidates)
+	for (auto const& [name, location]: m_homonymCandidates)
 	{
 		ResolvingSettings settings;
 		settings.recursive = true;
diff --git a/libsolidity/analysis/NameAndTypeResolver.cpp b/libsolidity/analysis/NameAndTypeResolver.cpp
@@ -250,7 +250,7 @@ void NameAndTypeResolver::warnHomonymDeclarations() const
 	DeclarationContainer::Homonyms homonyms;
 	m_scopes.at(nullptr)->populateHomonyms(back_inserter(homonyms));
 
-	for (const auto& [innerLocation, outerDeclarations]: homonyms)
+	for (auto const& [innerLocation, outerDeclarations]: homonyms)
 	{
 		solAssert(innerLocation && !outerDeclarations.empty(), "");
 
diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp
@@ -358,7 +358,7 @@ bool SyntaxChecker::visit(UnaryOperation const& _operation)
 bool SyntaxChecker::visit(InlineAssembly const& _inlineAssembly)
 {
 	if (_inlineAssembly.flags())
-		for (const auto& flag: *_inlineAssembly.flags())
+		for (auto const& flag: *_inlineAssembly.flags())
 		{
 			if (*flag == "memory-safe")
 			{
diff --git a/libsolidity/codegen/ContractCompiler.cpp b/libsolidity/codegen/ContractCompiler.cpp
@@ -1349,7 +1349,7 @@ bool ContractCompiler::visit(VariableDeclarationStatement const& _variableDeclar
 
 	// Local variable slots are reserved when their declaration is visited,
 	// and freed in the end of their scope.
-	for (const auto& decl: _variableDeclarationStatement.declarations())
+	for (auto const& decl: _variableDeclarationStatement.declarations())
 		if (decl)
 			appendStackVariableInitialisation(*decl, !_variableDeclarationStatement.initialValue());
 
diff --git a/libsolidity/codegen/ir/IRGeneratorForStatements.cpp b/libsolidity/codegen/ir/IRGeneratorForStatements.cpp
@@ -1168,7 +1168,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 		{
 			auto const& errorConstructorCall = dynamic_cast<FunctionCall const&>(*arguments[1]);
 			appendCode() << m_utils.requireWithErrorFunction(errorConstructorCall) << "(" <<IRVariable(*arguments[0]).name();
-			for (const auto& argument: errorConstructorCall.arguments())
+			for (auto const& argument: errorConstructorCall.arguments())
 				if (argument->annotation().type->sizeOnStack() > 0)
 					appendCode() << ", " << IRVariable(*argument).commaSeparatedList();
 			appendCode() << ")\n";
@@ -1215,7 +1215,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 			if (type(*arguments[1]).category() == Type::Category::Tuple)
 			{
 				auto const& tupleExpression = dynamic_cast<TupleExpression const&>(*arguments[1]);
-				for (const auto& component: tupleExpression.components())
+				for (auto const& component: tupleExpression.components())
 					argumentsOfEncodeFunction.push_back(component);
 			}
 			else
diff --git a/libsolidity/experimental/analysis/Analysis.cpp b/libsolidity/experimental/analysis/Analysis.cpp
@@ -172,7 +172,7 @@ bool Analysis::check(std::vector<std::shared_ptr<SourceUnit const>> const& _sour
 
 	return std::apply([&](auto... _indexTuple) {
 		return ([&](auto&& _step) {
-			for (const auto& source: _sourceUnits)
+			for (auto const& source: _sourceUnits)
 				if (!_step.analyze(*source))
 					return false;
 			return true;
diff --git a/libsolidity/experimental/analysis/TypeInference.cpp b/libsolidity/experimental/analysis/TypeInference.cpp
@@ -229,7 +229,7 @@ bool TypeInference::visit(TypeClassDefinition const& _typeClassDefinition)
 
 	auto& typeMembersAnnotation = annotation().members[typeConstructor(&_typeClassDefinition)];
 
-	for (const auto& subNode: _typeClassDefinition.subNodes())
+	for (auto const& subNode: _typeClassDefinition.subNodes())
 	{
 		subNode->accept(*this);
 		auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(subNode.get());
@@ -246,7 +246,7 @@ bool TypeInference::visit(TypeClassDefinition const& _typeClassDefinition)
 
 	annotation().typeClassFunctions[typeClass] = std::move(functionTypes);
 
-	for (const auto& [functionName, functionType]: functionTypes)
+	for (auto const& [functionName, functionType]: functionTypes)
 	{
 		TypeEnvironmentHelpers const helper{*m_env};
 		auto typeVars = helper.typeVars(functionType);
@@ -614,7 +614,7 @@ void TypeInference::endVisit(TupleExpression const& _tupleExpression)
 	case ExpressionContext::Sort:
 	{
 		Type const type = m_typeSystem.freshTypeVariable({});
-		for (const auto& componentType: componentTypes)
+		for (auto const& componentType: componentTypes)
 			unify(type, componentType, _tupleExpression.location());
 		expressionAnnotation.type = type;
 		break;
@@ -693,7 +693,7 @@ bool TypeInference::visit(TypeClassInstantiation const& _typeClassInstantiation)
 
 	std::map<std::string, Type> functionTypes;
 
-	for (const auto& subNode: _typeClassInstantiation.subNodes())
+	for (auto const& subNode: _typeClassInstantiation.subNodes())
 	{
 		auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(subNode.get());
 		solAssert(functionDefinition);
@@ -710,7 +710,7 @@ bool TypeInference::visit(TypeClassInstantiation const& _typeClassInstantiation)
 	solAssert(std::holds_alternative<TypeVariable>(m_typeSystem.typeClassVariable(typeClass)));
 	TypeVariable classVar = std::get<TypeVariable>(m_typeSystem.typeClassVariable(typeClass));
 
-	for (const auto& [name, classFunctionType]: classFunctions)
+	for (auto const& [name, classFunctionType]: classFunctions)
 	{
 		if (!functionTypes.count(name))
 		{
@@ -860,7 +860,7 @@ void TypeInference::endVisit(FunctionCall const& _functionCall)
 
 	TypeSystemHelpers const helper{m_typeSystem};
 	std::vector<Type> argTypes;
-	for (const auto& arg: _functionCall.arguments())
+	for (auto const& arg: _functionCall.arguments())
 	{
 		switch (m_expressionContext)
 		{
@@ -1125,7 +1125,7 @@ void TypeInference::unify(Type _a, Type _b, langutil::SourceLocation _location)
 					if (helper.isTypeConstant(sortMismatch->type))
 					{
 						TypeConstructor const constructor = std::get<0>(helper.destTypeConstant(sortMismatch->type));
-						for (const auto& typeClass: sortMismatch->sort.classes)
+						for (auto const& typeClass: sortMismatch->sort.classes)
 						{
 							if (auto const* instantiation = util::valueOrDefault(typeClassInstantiations(m_analysis, typeClass), constructor, nullptr))
 							{
diff --git a/libsolidity/experimental/ast/Type.cpp b/libsolidity/experimental/ast/Type.cpp
@@ -40,7 +40,7 @@ bool Sort::operator==(Sort const& _rhs) const
 
 bool Sort::operator<=(Sort const& _rhs) const
 {
-	for (const auto& c: classes)
+	for (auto const& c: classes)
 		if (!_rhs.classes.count(c))
 			return false;
 	return true;
diff --git a/libsolidity/experimental/ast/TypeSystemHelper.cpp b/libsolidity/experimental/ast/TypeSystemHelper.cpp
@@ -276,7 +276,7 @@ std::vector<experimental::Type> TypeEnvironmentHelpers::typeVars(Type _type) con
 	auto typeVarsImpl = [&](Type _type, auto _recurse) -> void {
 		std::visit(util::GenericVisitor{
 			[&](TypeConstant const& _type) {
-				for (const auto& arg: _type.arguments)
+				for (auto const& arg: _type.arguments)
 					_recurse(arg, _recurse);
 			},
 			[&](TypeVariable const& _var) {
@@ -341,7 +341,7 @@ std::string TypeSystemHelpers::sortToString(Sort _sort) const
 	{
 		std::stringstream stream;
 		stream << "(";
-		for (const auto& typeClass: _sort.classes | ranges::views::drop_last(1))
+		for (auto const& typeClass: _sort.classes | ranges::views::drop_last(1))
 			stream << typeSystem.typeClassName(typeClass) << ", ";
 		stream << typeSystem.typeClassName(*_sort.classes.rbegin()) << ")";
 		return stream.str();
@@ -358,7 +358,7 @@ std::string TypeEnvironmentHelpers::canonicalTypeName(Type _type) const
 			if (!_type.arguments.empty())
 			{
 				stream << "$";
-				for (const auto& type: _type.arguments | ranges::views::drop_last(1))
+				for (auto const& type: _type.arguments | ranges::views::drop_last(1))
 					stream << canonicalTypeName(type) << "$";
 				stream << canonicalTypeName(_type.arguments.back());
 				stream << "$";
@@ -389,7 +389,7 @@ std::string TypeEnvironmentHelpers::typeToString(Type const& _type) const
 			auto tupleTypes = TypeSystemHelpers{env.typeSystem()}.destTupleType(_arguments.back());
 			std::string result = "(";
 			result += typeToString(_arguments.front());
-			for (const auto& type: tupleTypes)
+			for (auto const& type: tupleTypes)
 				result += ", " + typeToString(type);
 			result += ")";
 			return result;
@@ -404,7 +404,7 @@ std::string TypeEnvironmentHelpers::typeToString(Type const& _type) const
 			if (!_type.arguments.empty())
 			{
 				stream << "(";
-				for (const auto& type: _type.arguments | ranges::views::drop_last(1))
+				for (auto const& type: _type.arguments | ranges::views::drop_last(1))
 					stream << typeToString(type) << ", ";
 				stream << typeToString(_type.arguments.back());
 				stream << ")";
@@ -429,7 +429,7 @@ std::string TypeEnvironmentHelpers::typeToString(Type const& _type) const
 				break;
 			default:
 				stream << ":(";
-				for (const auto& typeClass: _type.sort().classes | ranges::views::drop_last(1))
+				for (auto const& typeClass: _type.sort().classes | ranges::views::drop_last(1))
 					stream << env.typeSystem().typeClassName(typeClass) << ", ";
 				stream << env.typeSystem().typeClassName(*_type.sort().classes.rbegin());
 				stream << ")";
diff --git a/libsolidity/experimental/codegen/IRGenerationContext.h b/libsolidity/experimental/codegen/IRGenerationContext.h
@@ -38,7 +38,7 @@ struct IRGenerationContext
 	void enqueueFunctionDefinition(FunctionDefinition const* _functionDefinition, Type _type)
 	{
 		QueuedFunction const queue{_functionDefinition, env->resolve(_type)};
-		for (const auto& type: generatedFunctions[_functionDefinition])
+		for (auto const& type: generatedFunctions[_functionDefinition])
 			if (env->typeEquals(type, _type))
 				return;
 		functionQueue.emplace_back(queue);
diff --git a/libsolidity/experimental/codegen/IRGenerator.cpp b/libsolidity/experimental/codegen/IRGenerator.cpp
@@ -149,7 +149,7 @@ std::string IRGenerator::generate(FunctionDefinition const& _function, Type _typ
 		}
 	}
 	code << "{\n";
-	for (const auto& _statement: _function.body().statements())
+	for (auto const& _statement: _function.body().statements())
 	{
 		IRGeneratorForStatements statementGenerator{m_context};
 		code << statementGenerator.generate(*_statement);
diff --git a/libsolidity/experimental/codegen/IRGeneratorForStatements.cpp b/libsolidity/experimental/codegen/IRGeneratorForStatements.cpp
@@ -324,7 +324,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 	m_code << IRNames::function(*m_context.env, *functionDefinition, functionType) << "(";
 	auto const& arguments = _functionCall.arguments();
 	if (arguments.size() > 1)
-		for (const auto& arg: arguments | ranges::views::drop_last(1))
+		for (auto const& arg: arguments | ranges::views::drop_last(1))
 			m_code << IRNames::localVariable(*arg) << ", ";
 	if (!arguments.empty())
 		m_code << IRNames::localVariable(*arguments.back());
diff --git a/libsolidity/formal/BMC.cpp b/libsolidity/formal/BMC.cpp
@@ -708,7 +708,7 @@ void BMC::inlineFunctionCall(
 	if (visitedFunction(_funDef))
 	{
 		auto const& returnParams = _funDef->returnParameters();
-		for (const auto& param: returnParams)
+		for (auto const& param: returnParams)
 		{
 			m_context.newValue(*param);
 			m_context.setUnknownValue(*param);
diff --git a/libsolidity/formal/CHC.cpp b/libsolidity/formal/CHC.cpp
@@ -1012,7 +1012,7 @@ void CHC::externalFunctionCall(FunctionCall const& _funCall)
 
 	auto function = functionCallToDefinition(_funCall, currentScopeContract(), m_currentContract);
 	if (function)
-		for (const auto& var: function->returnParameters())
+		for (auto const& var: function->returnParameters())
 			m_context.variable(*var)->increaseIndex();
 
 	// If we see a low level call in trusted mode,
@@ -1445,9 +1445,9 @@ void CHC::defineInterfacesAndSummaries(SourceUnit const& _source)
 			auto const& resolved = contractFunctions(*contract);
 			for (auto const* function: contractFunctionsWithoutVirtual(*contract) + allFreeFunctions())
 			{
-				for (const auto& var: function->parameters())
+				for (auto const& var: function->parameters())
 					createVariable(*var);
-				for (const auto& var: function->returnParameters())
+				for (auto const& var: function->returnParameters())
 					createVariable(*var);
 				for (auto const* var: localVariablesIncludingModifiers(*function, contract))
 					createVariable(*var);
@@ -1856,7 +1856,7 @@ smtutil::Expression CHC::predicate(
 	args += std::vector<smtutil::Expression>{state().state()};
 	args += currentStateVariables(*contract);
 
-	for (const auto& var: _funDef->parameters() + _funDef->returnParameters())
+	for (auto const& var: _funDef->parameters() + _funDef->returnParameters())
 	{
 		if (m_context.knownVariable(*var))
 			m_context.variable(*var)->increaseIndex();
diff --git a/libsolidity/formal/ModelChecker.cpp b/libsolidity/formal/ModelChecker.cpp
@@ -63,7 +63,7 @@ void ModelChecker::checkRequestedSourcesAndContracts(std::vector<std::shared_ptr
 {
 	std::map<std::string, std::set<std::string>> exist;
 	for (auto const& source: _sources)
-		for (const auto& node: source->nodes())
+		for (auto const& node: source->nodes())
 			if (auto contract = std::dynamic_pointer_cast<ContractDefinition>(node))
 				exist[contract->sourceUnitName()].insert(contract->name());
 
@@ -97,7 +97,7 @@ void ModelChecker::analyze(SourceUnit const& _source)
 	if (_source.annotation().experimentalFeatures.count(ExperimentalFeature::SMTChecker))
 	{
 		PragmaDirective const* smtPragma = nullptr;
-		for (const auto& node: _source.nodes())
+		for (auto const& node: _source.nodes())
 			if (auto pragma = std::dynamic_pointer_cast<PragmaDirective>(node))
 				if (
 					pragma->literals().size() >= 2 &&
diff --git a/libsolidity/formal/SMTEncoder.cpp b/libsolidity/formal/SMTEncoder.cpp
@@ -2980,7 +2980,7 @@ std::vector<VariableDeclaration const*> SMTEncoder::tryCatchVariables(FunctionDe
 			if (_catchClause.parameters())
 			{
 				auto const& params = _catchClause.parameters()->parameters();
-				for (const auto& param: params)
+				for (auto const& param: params)
 					vars.push_back(param.get());
 			}
 
@@ -3004,7 +3004,7 @@ std::vector<VariableDeclaration const*> SMTEncoder::modifiersVariables(FunctionD
 
 	std::vector<VariableDeclaration const*> vars;
 	std::set<ModifierDefinition const*> visited;
-	for (const auto& invok: _function.modifiers())
+	for (auto const& invok: _function.modifiers())
 	{
 		if (!invok)
 			continue;
@@ -3093,7 +3093,7 @@ std::map<ContractDefinition const*, std::vector<ASTPointer<frontend::Expression>
 	for (auto contract: _contract.annotation().linearizedBaseContracts)
 	{
 		/// Collect base contracts and potential constructor arguments.
-		for (const auto& specifier: contract->baseContracts())
+		for (auto const& specifier: contract->baseContracts())
 		{
 			solAssert(specifier, "");
 			auto const& base = dynamic_cast<ContractDefinition const&>(*specifier->name().annotation().referencedDeclaration);
@@ -3102,7 +3102,7 @@ std::map<ContractDefinition const*, std::vector<ASTPointer<frontend::Expression>
 		}
 		/// Collect base constructor arguments given as constructor modifiers.
 		if (auto constructor = contract->constructor())
-			for (const auto& mod: constructor->modifiers())
+			for (auto const& mod: constructor->modifiers())
 			{
 				auto decl = mod->name().annotation().referencedDeclaration;
 				if (auto base = dynamic_cast<ContractDefinition const*>(decl))
@@ -3197,7 +3197,7 @@ void SMTEncoder::createReturnedExpressions(FunctionDefinition const* _funDef, Ex
 		return;
 
 	auto const& returnParams = _funDef->returnParameters();
-	for (const auto& param: returnParams)
+	for (auto const& param: returnParams)
 		createVariable(*param);
 	auto returnValues = applyMap(returnParams, [this](auto const& param) -> std::optional<smtutil::Expression> {
 		solAssert(param && m_context.knownVariable(*param), "");
@@ -3252,7 +3252,7 @@ smtutil::Expression SMTEncoder::constantExpr(Expression const& _expr, VariableDe
 void SMTEncoder::collectFreeFunctions(std::set<SourceUnit const*, ASTNode::CompareByID> const& _sources)
 {
 	for (auto source: _sources)
-		for (const auto& node: source->nodes())
+		for (auto const& node: source->nodes())
 			if (auto function = dynamic_cast<FunctionDefinition const*>(node.get()))
 				m_freeFunctions.insert(function);
 			else if (
@@ -3268,7 +3268,7 @@ void SMTEncoder::collectFreeFunctions(std::set<SourceUnit const*, ASTNode::Compa
 void SMTEncoder::createFreeConstants(std::set<SourceUnit const*, ASTNode::CompareByID> const& _sources)
 {
 	for (auto source: _sources)
-		for (const auto& node: source->nodes())
+		for (auto const& node: source->nodes())
 			if (auto var = dynamic_cast<VariableDeclaration const*>(node.get()))
 				createVariable(*var);
 			else if (
diff --git a/libsolidity/formal/SymbolicState.cpp b/libsolidity/formal/SymbolicState.cpp
@@ -280,7 +280,7 @@ void SymbolicState::prepareForSourceUnit(SourceUnit const& _source, bool _storag
 	{
 		abiCalls += SMTEncoder::collectABICalls(source);
 		bytesConcatCalls += SMTEncoder::collectBytesConcatCalls(source);
-		for (const auto& node: source->nodes())
+		for (auto const& node: source->nodes())
 			if (auto contract = dynamic_cast<ContractDefinition const*>(node.get()))
 				contracts.insert(contract);
 	}
diff --git a/libsolidity/formal/SymbolicTypes.cpp b/libsolidity/formal/SymbolicTypes.cpp
@@ -179,7 +179,7 @@ SortPointer smtSort(frontend::Type const& _type)
 		{
 			solAssert(!structType->recursive(), "");
 			auto const& structMembers = structType->structDefinition().members();
-			for (const auto& member: structMembers)
+			for (auto const& member: structMembers)
 				members.emplace_back(tupleName + "_accessor_" + member->name());
 			sorts = smtSortAbstractFunction(applyMap(
 				structMembers,
diff --git a/libsolidity/interface/StorageLayout.cpp b/libsolidity/interface/StorageLayout.cpp
@@ -36,7 +36,7 @@ Json StorageLayout::generate(ContractDefinition const& _contractDef, DataLocatio
 	solAssert(contractType, "");
 
 	Json variables = Json::array();
-	for (const auto& [var, slot, offset]: contractType->linearizedStateVariables(_location))
+	for (auto const& [var, slot, offset]: contractType->linearizedStateVariables(_location))
 		variables.emplace_back(generate(*var, slot, offset));
 
 	Json layout;
diff --git a/libyul/backends/evm/StackLayoutGenerator.cpp b/libyul/backends/evm/StackLayoutGenerator.cpp
diff --git a/libyul/optimiser/StackCompressor.cpp b/libyul/optimiser/StackCompressor.cpp
diff --git a/test/evmc/evmc.hpp b/test/evmc/evmc.hpp
diff --git a/test/evmc/mocked_host.hpp b/test/evmc/mocked_host.hpp
diff --git a/test/libsolidity/FunctionDependencyGraphTest.cpp b/test/libsolidity/FunctionDependencyGraphTest.cpp
diff --git a/test/libyul/ssa/StackShufflerTest.cpp b/test/libyul/ssa/StackShufflerTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ unsigned ConstantOptimisationMethod::optimiseConstants(`
`45`	`45`	`if (item.type() == Push)`
`46`	`46`	`pushes[item]++;`
`47`	`47`	`std::map<u256, AssemblyItems> pendingReplacements;`
`48`		`- for (const auto& it: pushes)`
	`48`	`+ for (auto const& it: pushes)`
`49`	`49`	`{`
`50`	`50`	`AssemblyItem const& item = it.first;`
`51`	`51`	`if (item.data() < 0x100)`
Original file line number	Diff line number	Diff line change
`@@ -292,7 +292,7 @@ void ControlFlowGraph::gatherKnowledge()`
`292`	`292`	`}`
`293`	`293`	`}`
`294`	`294`	`else`
`295`		`- for (const auto& tag: tags)`
	`295`	`+ for (auto const& tag: tags)`
`296`	`296`	`addWorkQueueItem(item, BlockId(tag), state);`
`297`	`297`	`}`
`298`	`298`	`else if (block.begin <= pc && pc < block.end)`
`@@ -327,7 +327,7 @@ BasicBlocks ControlFlowGraph::rebuildCode()`
`327`	`327`	`pushes[ref]++;`
`328`	`328`
`329`	`329`	`std::set<BlockId> blocksToAdd;`
`330`		`- for (const auto& it: m_blocks)`
	`330`	`+ for (auto const& it: m_blocks)`
`331`	`331`	`blocksToAdd.insert(it.first);`
`332`	`332`	`std::set<BlockId> blocksAdded;`
`333`	`333`	`BasicBlocks blocks;`
Original file line number	Diff line number	Diff line change
`@@ -427,7 +427,7 @@ bool ControlFlowBuilder::visit(Return const& _return)`
`427`	`427`	`{`
`428`	`428`	`appendControlFlow(*_return.expression());`
`429`	`429`	`// Returns with return expression are considered to be assignments to the return parameters.`
`430`		`- for (const auto& returnParameter: _return.annotation().functionReturnParameters->parameters())`
	`430`	`+ for (auto const& returnParameter: _return.annotation().functionReturnParameters->parameters())`
`431`	`431`	`m_currentNode->variableOccurrences.emplace_back(`
`432`	`432`	`*returnParameter,`
`433`	`433`	`VariableOccurrence::Kind::Assignment,`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ void DeclarationContainer::populateHomonyms(std::back_insert_iterator<Homonyms>`
`204`	`204`	`for (DeclarationContainer const* innerContainer: m_innerContainers)`
`205`	`205`	`innerContainer->populateHomonyms(_it);`
`206`	`206`
`207`		`- for (const auto& [name, location]: m_homonymCandidates)`
	`207`	`+ for (auto const& [name, location]: m_homonymCandidates)`
`208`	`208`	`{`
`209`	`209`	`ResolvingSettings settings;`
`210`	`210`	`settings.recursive = true;`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ void NameAndTypeResolver::warnHomonymDeclarations() const`
`250`	`250`	`DeclarationContainer::Homonyms homonyms;`
`251`	`251`	`m_scopes.at(nullptr)->populateHomonyms(back_inserter(homonyms));`
`252`	`252`
`253`		`- for (const auto& [innerLocation, outerDeclarations]: homonyms)`
	`253`	`+ for (auto const& [innerLocation, outerDeclarations]: homonyms)`
`254`	`254`	`{`
`255`	`255`	`solAssert(innerLocation && !outerDeclarations.empty(), "");`
`256`	`256`
Original file line number	Diff line number	Diff line change
`@@ -358,7 +358,7 @@ bool SyntaxChecker::visit(UnaryOperation const& _operation)`
`358`	`358`	`bool SyntaxChecker::visit(InlineAssembly const& _inlineAssembly)`
`359`	`359`	`{`
`360`	`360`	`if (_inlineAssembly.flags())`
`361`		`- for (const auto& flag: *_inlineAssembly.flags())`
	`361`	`+ for (auto const& flag: *_inlineAssembly.flags())`
`362`	`362`	`{`
`363`	`363`	`if (*flag == "memory-safe")`
`364`	`364`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1168,7 +1168,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)`
`1168`	`1168`	`{`
`1169`	`1169`	`auto const& errorConstructorCall = dynamic_cast<FunctionCall const&>(*arguments[1]);`
`1170`	`1170`	`appendCode() << m_utils.requireWithErrorFunction(errorConstructorCall) << "(" <<IRVariable(*arguments[0]).name();`
`1171`		`- for (const auto& argument: errorConstructorCall.arguments())`
	`1171`	`+ for (auto const& argument: errorConstructorCall.arguments())`
`1172`	`1172`	`if (argument->annotation().type->sizeOnStack() > 0)`
`1173`	`1173`	`appendCode() << ", " << IRVariable(*argument).commaSeparatedList();`
`1174`	`1174`	`appendCode() << ")\n";`
`@@ -1215,7 +1215,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)`
`1215`	`1215`	`if (type(*arguments[1]).category() == Type::Category::Tuple)`
`1216`	`1216`	`{`
`1217`	`1217`	`auto const& tupleExpression = dynamic_cast<TupleExpression const&>(*arguments[1]);`
`1218`		`- for (const auto& component: tupleExpression.components())`
	`1218`	`+ for (auto const& component: tupleExpression.components())`
`1219`	`1219`	`argumentsOfEncodeFunction.push_back(component);`
`1220`	`1220`	`}`
`1221`	`1221`	`else`
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ bool TypeInference::visit(TypeClassDefinition const& _typeClassDefinition)`
`229`	`229`
`230`	`230`	`auto& typeMembersAnnotation = annotation().members[typeConstructor(&_typeClassDefinition)];`
`231`	`231`
`232`		`- for (const auto& subNode: _typeClassDefinition.subNodes())`
	`232`	`+ for (auto const& subNode: _typeClassDefinition.subNodes())`
`233`	`233`	`{`
`234`	`234`	`subNode->accept(*this);`
`235`	`235`	`auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(subNode.get());`
`@@ -246,7 +246,7 @@ bool TypeInference::visit(TypeClassDefinition const& _typeClassDefinition)`
`246`	`246`
`247`	`247`	`annotation().typeClassFunctions[typeClass] = std::move(functionTypes);`
`248`	`248`
`249`		`- for (const auto& [functionName, functionType]: functionTypes)`
	`249`	`+ for (auto const& [functionName, functionType]: functionTypes)`
`250`	`250`	`{`
`251`	`251`	`TypeEnvironmentHelpers const helper{*m_env};`
`252`	`252`	`auto typeVars = helper.typeVars(functionType);`
`@@ -614,7 +614,7 @@ void TypeInference::endVisit(TupleExpression const& _tupleExpression)`
`614`	`614`	`case ExpressionContext::Sort:`
`615`	`615`	`{`
`616`	`616`	`Type const type = m_typeSystem.freshTypeVariable({});`
`617`		`- for (const auto& componentType: componentTypes)`
	`617`	`+ for (auto const& componentType: componentTypes)`
`618`	`618`	`unify(type, componentType, _tupleExpression.location());`
`619`	`619`	`expressionAnnotation.type = type;`
`620`	`620`	`break;`
`@@ -693,7 +693,7 @@ bool TypeInference::visit(TypeClassInstantiation const& _typeClassInstantiation)`
`693`	`693`
`694`	`694`	`std::map<std::string, Type> functionTypes;`
`695`	`695`
`696`		`- for (const auto& subNode: _typeClassInstantiation.subNodes())`
	`696`	`+ for (auto const& subNode: _typeClassInstantiation.subNodes())`
`697`	`697`	`{`
`698`	`698`	`auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(subNode.get());`
`699`	`699`	`solAssert(functionDefinition);`
`@@ -710,7 +710,7 @@ bool TypeInference::visit(TypeClassInstantiation const& _typeClassInstantiation)`
`710`	`710`	`solAssert(std::holds_alternative<TypeVariable>(m_typeSystem.typeClassVariable(typeClass)));`
`711`	`711`	`TypeVariable classVar = std::get<TypeVariable>(m_typeSystem.typeClassVariable(typeClass));`
`712`	`712`
`713`		`- for (const auto& [name, classFunctionType]: classFunctions)`
	`713`	`+ for (auto const& [name, classFunctionType]: classFunctions)`
`714`	`714`	`{`
`715`	`715`	`if (!functionTypes.count(name))`
`716`	`716`	`{`
`@@ -860,7 +860,7 @@ void TypeInference::endVisit(FunctionCall const& _functionCall)`
`860`	`860`
`861`	`861`	`TypeSystemHelpers const helper{m_typeSystem};`
`862`	`862`	`std::vector<Type> argTypes;`
`863`		`- for (const auto& arg: _functionCall.arguments())`
	`863`	`+ for (auto const& arg: _functionCall.arguments())`
`864`	`864`	`{`
`865`	`865`	`switch (m_expressionContext)`
`866`	`866`	`{`
`@@ -1125,7 +1125,7 @@ void TypeInference::unify(Type _a, Type _b, langutil::SourceLocation _location)`
`1125`	`1125`	`if (helper.isTypeConstant(sortMismatch->type))`
`1126`	`1126`	`{`
`1127`	`1127`	`TypeConstructor const constructor = std::get<0>(helper.destTypeConstant(sortMismatch->type));`
`1128`		`- for (const auto& typeClass: sortMismatch->sort.classes)`
	`1128`	`+ for (auto const& typeClass: sortMismatch->sort.classes)`
`1129`	`1129`	`{`
`1130`	`1130`	`if (auto const* instantiation = util::valueOrDefault(typeClassInstantiations(m_analysis, typeClass), constructor, nullptr))`
`1131`	`1131`	`{`