Merge pull request #13428 from ethereum/qualify-move

Add std:: qualifier to move() calls

Author: Leo

libevmasm/Assembly.cpp

@@ -52,7 +52,7 @@ AssemblyItem const& Assembly::append(AssemblyItem _i)
 {
 	assertThrow(m_deposit >= 0, AssemblyException, "Stack underflow.");
 	m_deposit += static_cast<int>(_i.deposit());
-	m_items.emplace_back(move(_i));
+	m_items.emplace_back(std::move(_i));
 	if (!m_items.back().location().isValid() && m_currentSourceLocation.isValid())
 		m_items.back().setLocation(m_currentSourceLocation);
 	m_items.back().m_modifierDepth = m_currentModifierDepth;
@@ -254,7 +254,7 @@ Json::Value Assembly::assemblyJSON(map<string, unsigned> const& _sourceIndices,
 		if (!data.empty())
 			jsonItem["value"] = data;
 		jsonItem["source"] = sourceIndex;
-		code.append(move(jsonItem));
+		code.append(std::move(jsonItem));
 
 		if (item.type() == AssemblyItemType::Tag)
 		{
@@ -265,7 +265,7 @@ Json::Value Assembly::assemblyJSON(map<string, unsigned> const& _sourceIndices,
 			jumpdest["source"] = sourceIndex;
 			if (item.m_modifierDepth != 0)
 				jumpdest["modifierDepth"] = static_cast<int>(item.m_modifierDepth);
-			code.append(move(jumpdest));
+			code.append(std::move(jumpdest));
 		}
 	}
 	if (_includeSourceList)
@@ -464,7 +464,7 @@ map<u256, u256> const& Assembly::optimiseInternal(
 			}
 			if (optimisedItems.size() < m_items.size())
 			{
-				m_items = move(optimisedItems);
+				m_items = std::move(optimisedItems);
 				count++;
 			}
 		}
@@ -478,7 +478,7 @@ map<u256, u256> const& Assembly::optimiseInternal(
 			*this
 		);
 
-	m_tagReplacements = move(tagReplacements);
+	m_tagReplacements = std::move(tagReplacements);
 	return *m_tagReplacements;
 }
 

libevmasm/CommonSubexpressionEliminator.cpp

@@ -48,8 +48,8 @@ vector<AssemblyItem> CommonSubexpressionEliminator::getOptimizedItems()
 	{
 		m_breakingItem = nullptr;
 		m_storeOperations.clear();
-		m_initialState = move(nextInitialState);
-		m_state = move(nextState);
+		m_initialState = std::move(nextInitialState);
+		m_state = std::move(nextState);
 	});
 
 	map<int, Id> initialStackContents;

libevmasm/ConstantOptimiser.cpp

@@ -244,8 +244,8 @@ AssemblyItems ComputeMethod::findRepresentation(u256 const& _value)
 			bigint newGas = gasNeeded(newRoutine);
 			if (newGas < bestGas)
 			{
-				bestGas = move(newGas);
-				routine = move(newRoutine);
+				bestGas = std::move(newGas);
+				routine = std::move(newRoutine);
 			}
 		}
 		return routine;

libevmasm/ControlFlowGraph.cpp

@@ -236,12 +236,12 @@ void ControlFlowGraph::gatherKnowledge()
 		item.state = _state->copy();
 		item.blocksSeen = _currentItem.blocksSeen;
 		item.blocksSeen.insert(_currentItem.blockId);
-		workQueue.push_back(move(item));
+		workQueue.push_back(std::move(item));
 	};
 
 	while (!workQueue.empty())
 	{
-		WorkQueueItem item = move(workQueue.back());
+		WorkQueueItem item = std::move(workQueue.back());
 		workQueue.pop_back();
 		//@todo we might have to do something like incrementing the sequence number for each JUMPDEST
 		assertThrow(!!item.blockId, OptimizerException, "");

libevmasm/Inliner.cpp

@@ -257,7 +257,7 @@ void Inliner::optimise()
 						if (auto exitItem = shouldInline(*tag, nextItem, *inlinableBlock))
 						{
 							newItems += inlinableBlock->items | ranges::views::drop_last(1);
-							newItems.emplace_back(move(*exitItem));
+							newItems.emplace_back(std::move(*exitItem));
 
 							// We are removing one push tag to the block we inline.
 							--inlinableBlock->pushTagCount;
@@ -277,5 +277,5 @@ void Inliner::optimise()
 		newItems.emplace_back(item);
 	}
 
-	m_items = move(newItems);
+	m_items = std::move(newItems);
 }

libevmasm/KnownState.cpp

@@ -252,7 +252,7 @@ void KnownState::reduceToCommonKnowledge(KnownState const& _other, bool _combine
 		map<int, Id> shiftedStack;
 		for (auto const& stackElement: m_stackElements)
 			shiftedStack[stackElement.first - stackDiff] = stackElement.second;
-		m_stackElements = move(shiftedStack);
+		m_stackElements = std::move(shiftedStack);
 		m_stackHeight = _other.m_stackHeight;
 	}
 
@@ -333,7 +333,7 @@ KnownState::StoreOperation KnownState::storeInStorage(
 	for (auto const& storageItem: m_storageContent)
 		if (m_expressionClasses->knownToBeDifferent(storageItem.first, _slot) || storageItem.second == _value)
 			storageContents.insert(storageItem);
-	m_storageContent = move(storageContents);
+	m_storageContent = std::move(storageContents);
 
 	AssemblyItem item(Instruction::SSTORE, _location);
 	Id id = m_expressionClasses->find(item, {_slot, _value}, true, m_sequenceNumber);
@@ -365,7 +365,7 @@ KnownState::StoreOperation KnownState::storeInMemory(Id _slot, Id _value, Source
 	for (auto const& memoryItem: m_memoryContent)
 		if (m_expressionClasses->knownToBeDifferentBy32(memoryItem.first, _slot))
 			memoryContents.insert(memoryItem);
-	m_memoryContent = move(memoryContents);
+	m_memoryContent = std::move(memoryContents);
 
 	AssemblyItem item(Instruction::MSTORE, _location);
 	Id id = m_expressionClasses->find(item, {_slot, _value}, true, m_sequenceNumber);

libevmasm/PathGasMeter.cpp

@@ -44,7 +44,7 @@ GasMeter::GasConsumption PathGasMeter::estimateMax(
 	auto path = make_unique<GasPath>();
 	path->index = _startIndex;
 	path->state = _state->copy();
-	queue(move(path));
+	queue(std::move(path));
 
 	GasMeter::GasConsumption gas;
 	while (!m_queue.empty() && !gas.isInfinite)
@@ -60,14 +60,14 @@ void PathGasMeter::queue(std::unique_ptr<GasPath>&& _newPath)
 	)
 		return;
 	m_highestGasUsagePerJumpdest[_newPath->index] = _newPath->gas;
-	m_queue[_newPath->index] = move(_newPath);
+	m_queue[_newPath->index] = std::move(_newPath);
 }
 
 GasMeter::GasConsumption PathGasMeter::handleQueueItem()
 {
 	assertThrow(!m_queue.empty(), OptimizerException, "");
 
-	unique_ptr<GasPath> path = move(m_queue.rbegin()->second);
+	unique_ptr<GasPath> path = std::move(m_queue.rbegin()->second);
 	m_queue.erase(--m_queue.end());
 
 	shared_ptr<KnownState> state = path->state;
@@ -129,7 +129,7 @@ GasMeter::GasConsumption PathGasMeter::handleQueueItem()
 			newPath->largestMemoryAccess = meter.largestMemoryAccess();
 			newPath->state = state->copy();
 			newPath->visitedJumpdests = path->visitedJumpdests;
-			queue(move(newPath));
+			queue(std::move(newPath));
 		}
 
 		if (branchStops)

libsmtutil/CHCSmtLib2Interface.cpp

@@ -44,7 +44,7 @@ CHCSmtLib2Interface::CHCSmtLib2Interface(
 ):
 	CHCSolverInterface(_queryTimeout),
 	m_smtlib2(make_unique<SMTLib2Interface>(_queryResponses, _smtCallback, m_queryTimeout)),
-	m_queryResponses(move(_queryResponses)),
+	m_queryResponses(std::move(_queryResponses)),
 	m_smtCallback(_smtCallback)
 {
 	reset();
@@ -195,7 +195,7 @@ void CHCSmtLib2Interface::declareFunction(string const& _name, SortPointer const
 
 void CHCSmtLib2Interface::write(string _data)
 {
-	m_accumulatedOutput += move(_data) + "\n";
+	m_accumulatedOutput += std::move(_data) + "\n";
 }
 
 string CHCSmtLib2Interface::querySolver(string const& _input)

libsmtutil/SMTLib2Interface.cpp

@@ -45,8 +45,8 @@ SMTLib2Interface::SMTLib2Interface(
 	optional<unsigned> _queryTimeout
 ):
 	SolverInterface(_queryTimeout),
-	m_queryResponses(move(_queryResponses)),
-	m_smtCallback(move(_smtCallback))
+	m_queryResponses(std::move(_queryResponses)),
+	m_smtCallback(std::move(_smtCallback))
 {
 	reset();
 }
@@ -264,7 +264,7 @@ string SMTLib2Interface::toSmtLibSort(vector<SortPointer> const& _sorts)
 void SMTLib2Interface::write(string _data)
 {
 	smtAssert(!m_accumulatedOutput.empty(), "");
-	m_accumulatedOutput.back() += move(_data) + "\n";
+	m_accumulatedOutput.back() += std::move(_data) + "\n";
 }
 
 string SMTLib2Interface::checkSatAndGetValuesCommand(vector<Expression> const& _expressionsToEvaluate)

libsmtutil/SMTPortfolio.cpp

@@ -41,7 +41,7 @@ SMTPortfolio::SMTPortfolio(
 	SolverInterface(_queryTimeout)
 {
 	if (_enabledSolvers.smtlib2)
-		m_solvers.emplace_back(make_unique<SMTLib2Interface>(move(_smtlib2Responses), move(_smtCallback), m_queryTimeout));
+		m_solvers.emplace_back(make_unique<SMTLib2Interface>(std::move(_smtlib2Responses), std::move(_smtCallback), m_queryTimeout));
 #ifdef HAVE_Z3
 	if (_enabledSolvers.z3 && Z3Interface::available())
 		m_solvers.emplace_back(make_unique<Z3Interface>(m_queryTimeout));