Remove "using namespace" from header and move Instruction to dev::eth.

libevmasm/Assembly.h

@@ -68,10 +68,10 @@ class Assembly
 	void appendProgramSize() { append(AssemblyItem(PushProgramSize)); }
 	void appendLibraryAddress(std::string const& _identifier) { append(newPushLibraryAddress(_identifier)); }
 
-	AssemblyItem appendJump() { auto ret = append(newPushTag()); append(solidity::Instruction::JUMP); return ret; }
-	AssemblyItem appendJumpI() { auto ret = append(newPushTag()); append(solidity::Instruction::JUMPI); return ret; }
-	AssemblyItem appendJump(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(solidity::Instruction::JUMP); return ret; }
-	AssemblyItem appendJumpI(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(solidity::Instruction::JUMPI); return ret; }
+	AssemblyItem appendJump() { auto ret = append(newPushTag()); append(Instruction::JUMP); return ret; }
+	AssemblyItem appendJumpI() { auto ret = append(newPushTag()); append(Instruction::JUMPI); return ret; }
+	AssemblyItem appendJump(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(Instruction::JUMP); return ret; }
+	AssemblyItem appendJumpI(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(Instruction::JUMPI); return ret; }
 
 	/// Adds a subroutine to the code (in the data section) and pushes its size (via a tag)
 	/// on the stack. @returns the pushsub assembly item.

libevmasm/AssemblyItem.cpp

@@ -231,7 +231,7 @@ ostream& dev::eth::operator<<(ostream& _out, AssemblyItem const& _item)
 	{
 	case Operation:
 		_out << " " << instructionInfo(_item.instruction()).name;
-		if (_item.instruction() == solidity::Instruction::JUMP || _item.instruction() == solidity::Instruction::JUMPI)
+		if (_item.instruction() == Instruction::JUMP || _item.instruction() == Instruction::JUMPI)
 			_out << "\t" << _item.getJumpTypeAsString();
 		break;
 	case Push:

libevmasm/AssemblyItem.h

@@ -21,14 +21,13 @@
 
 #pragma once
 
-#include <iostream>
-#include <sstream>
-#include <libdevcore/Common.h>
-#include <libdevcore/Assertions.h>
 #include <libevmasm/Instruction.h>
+#include <libevmasm/Exceptions.h>
 #include <liblangutil/SourceLocation.h>
-#include "Exceptions.h"
-using namespace dev::solidity;
+#include <libdevcore/Common.h>
+#include <libdevcore/Assertions.h>
+#include <iostream>
+#include <sstream>
 
 namespace dev
 {
@@ -59,7 +58,7 @@ class AssemblyItem
 
 	AssemblyItem(u256 _push, langutil::SourceLocation _location = langutil::SourceLocation()):
 		AssemblyItem(Push, std::move(_push), std::move(_location)) { }
-	AssemblyItem(solidity::Instruction _i, langutil::SourceLocation _location = langutil::SourceLocation()):
+	AssemblyItem(Instruction _i, langutil::SourceLocation _location = langutil::SourceLocation()):
 		m_type(Operation),
 		m_instruction(_i),
 		m_location(std::move(_location))

libevmasm/Instruction.cpp

@@ -19,17 +19,18 @@
  * @date 2014
  */
 
-#include "./Instruction.h"
+#include <libevmasm/Instruction.h>
 
-#include <algorithm>
-#include <functional>
 #include <libdevcore/Common.h>
 #include <libdevcore/CommonIO.h>
+#include <algorithm>
+#include <functional>
+
 using namespace std;
 using namespace dev;
-using namespace dev::solidity;
+using namespace dev::eth;
 
-std::map<std::string, Instruction> const dev::solidity::c_instructions =
+std::map<std::string, Instruction> const dev::eth::c_instructions =
 {
 	{ "STOP", Instruction::STOP },
 	{ "ADD", Instruction::ADD },
@@ -317,7 +318,7 @@ static std::map<Instruction, InstructionInfo> const c_instructionInfo =
 	{ Instruction::SELFDESTRUCT,	{ "SELFDESTRUCT",		0, 1, 0, true, Tier::Special } }
 };
 
-void dev::solidity::eachInstruction(
+void dev::eth::eachInstruction(
 	bytes const& _mem,
 	function<void(Instruction,u256 const&)> const& _onInstruction
 )
@@ -346,7 +347,7 @@ void dev::solidity::eachInstruction(
 	}
 }
 
-string dev::solidity::disassemble(bytes const& _mem)
+string dev::eth::disassemble(bytes const& _mem)
 {
 	stringstream ret;
 	eachInstruction(_mem, [&](Instruction _instr, u256 const& _data) {
@@ -363,7 +364,7 @@ string dev::solidity::disassemble(bytes const& _mem)
 	return ret.str();
 }
 
-InstructionInfo dev::solidity::instructionInfo(Instruction _inst)
+InstructionInfo dev::eth::instructionInfo(Instruction _inst)
 {
 	try
 	{
@@ -375,7 +376,7 @@ InstructionInfo dev::solidity::instructionInfo(Instruction _inst)
 	}
 }
 
-bool dev::solidity::isValidInstruction(Instruction _inst)
+bool dev::eth::isValidInstruction(Instruction _inst)
 {
 	return !!c_instructionInfo.count(_inst);
 }

libevmasm/Instruction.h

@@ -21,14 +21,14 @@
 
 #pragma once
 
-#include <functional>
+#include <libevmasm/Exceptions.h>
 #include <libdevcore/Common.h>
 #include <libdevcore/Assertions.h>
-#include "Exceptions.h"
+#include <functional>
 
 namespace dev
 {
-namespace solidity
+namespace eth
 {
 
 DEV_SIMPLE_EXCEPTION(InvalidDeposit);

libevmasm/RuleList.h

@@ -21,19 +21,20 @@
 
 #pragma once
 
-#include <vector>
-#include <functional>
-
-#include <boost/multiprecision/detail/min_max.hpp>
 
 #include <libevmasm/Instruction.h>
 #include <libevmasm/SimplificationRule.h>
 
 #include <libdevcore/CommonData.h>
 
+#include <boost/multiprecision/detail/min_max.hpp>
+
+#include <vector>
+#include <functional>
+
 namespace dev
 {
-namespace solidity
+namespace eth
 {
 
 template <class S> S divWorkaround(S const& _a, S const& _b)

libevmasm/SemanticInformation.cpp

@@ -96,14 +96,14 @@ bool SemanticInformation::isDupInstruction(AssemblyItem const& _item)
 {
 	if (_item.type() != Operation)
 		return false;
-	return solidity::isDupInstruction(_item.instruction());
+	return dev::eth::isDupInstruction(_item.instruction());
 }
 
 bool SemanticInformation::isSwapInstruction(AssemblyItem const& _item)
 {
 	if (_item.type() != Operation)
 		return false;
-	return solidity::isSwapInstruction(_item.instruction());
+	return dev::eth::isSwapInstruction(_item.instruction());
 }
 
 bool SemanticInformation::isJumpInstruction(AssemblyItem const& _item)

libevmasm/SemanticInformation.h

@@ -53,13 +53,13 @@ struct SemanticInformation
 	/// @returns true if the instruction can be moved or copied (together with its arguments)
 	/// without altering the semantics. This means it cannot depend on storage or memory,
 	/// cannot have any side-effects, but it can depend on a call-constant state of the blockchain.
-	static bool movable(solidity::Instruction _instruction);
+	static bool movable(Instruction _instruction);
 	/// @returns true if the given instruction modifies memory.
-	static bool invalidatesMemory(solidity::Instruction _instruction);
+	static bool invalidatesMemory(Instruction _instruction);
 	/// @returns true if the given instruction modifies storage (even indirectly).
-	static bool invalidatesStorage(solidity::Instruction _instruction);
-	static bool invalidInPureFunctions(solidity::Instruction _instruction);
-	static bool invalidInViewFunctions(solidity::Instruction _instruction);
+	static bool invalidatesStorage(Instruction _instruction);
+	static bool invalidInPureFunctions(Instruction _instruction);
+	static bool invalidInViewFunctions(Instruction _instruction);
 };
 
 }

libevmasm/SimplificationRule.h

@@ -24,7 +24,7 @@
 
 namespace dev
 {
-namespace solidity
+namespace eth
 {
 
 /**

liblll/CodeFragment.cpp

@@ -41,6 +41,7 @@
 
 using namespace std;
 using namespace dev;
+using namespace dev::eth;
 using namespace dev::lll;
 
 void CodeFragment::finalise(CompilerState const& _cs)
@@ -66,7 +67,7 @@ bool validAssemblyInstruction(string us)
 	auto it = c_instructions.find(us);
 	return !(
 		it == c_instructions.end() ||
-		solidity::isPushInstruction(it->second)
+		isPushInstruction(it->second)
 	);
 }
 
@@ -76,10 +77,10 @@ bool validFunctionalInstruction(string us)
 	auto it = c_instructions.find(us);
 	return !(
 		it == c_instructions.end() ||
-		solidity::isPushInstruction(it->second) ||
-		solidity::isDupInstruction(it->second) ||
-		solidity::isSwapInstruction(it->second) ||
-		it->second == solidity::Instruction::JUMPDEST
+		isPushInstruction(it->second) ||
+		isDupInstruction(it->second) ||
+		isSwapInstruction(it->second) ||
+		it->second == Instruction::JUMPDEST
 	);
 }
 }

libsolidity/analysis/NameAndTypeResolver.cpp

@@ -241,7 +241,7 @@ vector<Declaration const*> NameAndTypeResolver::cleanedDeclarations(
 
 void NameAndTypeResolver::warnVariablesNamedLikeInstructions()
 {
-	for (auto const& instruction: c_instructions)
+	for (auto const& instruction: dev::eth::c_instructions)
 	{
 		string const instructionName{boost::algorithm::to_lower_copy(instruction.first)};
 		auto declarations = nameFromCurrentScope(instructionName, true);

libsolidity/analysis/ViewPureChecker.cpp

@@ -108,11 +108,11 @@ class AssemblyViewPureChecker: public boost::static_visitor<void>
 
 private:
 	std::function<void(StateMutability, SourceLocation const&)> m_reportMutability;
-	void checkInstruction(SourceLocation _location, solidity::Instruction _instruction)
+	void checkInstruction(SourceLocation _location, dev::eth::Instruction _instruction)
 	{
 		if (eth::SemanticInformation::invalidInViewFunctions(_instruction))
 			m_reportMutability(StateMutability::NonPayable, _location);
-		else if (_instruction == Instruction::CALLVALUE)
+		else if (_instruction == dev::eth::Instruction::CALLVALUE)
 			m_reportMutability(StateMutability::Payable, _location);
 		else if (eth::SemanticInformation::invalidInPureFunctions(_instruction))
 			m_reportMutability(StateMutability::View, _location);

libsolidity/codegen/ArrayUtils.cpp

@@ -32,8 +32,9 @@
 
 using namespace std;
 using namespace dev;
+using namespace dev::eth;
 using namespace langutil;
-using namespace solidity;
+using namespace dev::solidity;
 
 void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType const& _sourceType) const
 {

libsolidity/codegen/CompilerContext.cpp

@@ -53,11 +53,9 @@
 
 using namespace std;
 using namespace langutil;
-
-namespace dev
-{
-namespace solidity
-{
+using namespace dev::eth;
+using namespace dev;
+using namespace dev::solidity;
 
 void CompilerContext::addStateVariable(
 	VariableDeclaration const& _declaration,
@@ -554,6 +552,3 @@ void CompilerContext::FunctionCompilationQueue::startFunction(Declaration const&
 		m_functionsToCompile.pop();
 	m_alreadyCompiledFunctions.insert(&_function);
 }
-
-}
-}

libsolidity/codegen/CompilerContext.h

@@ -203,7 +203,7 @@ class CompilerContext
 
 	/// Append elements to the current instruction list and adjust @a m_stackOffset.
 	CompilerContext& operator<<(eth::AssemblyItem const& _item) { m_asm->append(_item); return *this; }
-	CompilerContext& operator<<(Instruction _instruction) { m_asm->append(_instruction); return *this; }
+	CompilerContext& operator<<(dev::eth::Instruction _instruction) { m_asm->append(_instruction); return *this; }
 	CompilerContext& operator<<(u256 const& _value) { m_asm->append(_value); return *this; }
 	CompilerContext& operator<<(bytes const& _data) { m_asm->append(_data); return *this; }
 

libsolidity/codegen/CompilerUtils.cpp

@@ -31,11 +31,9 @@
 
 using namespace std;
 using namespace langutil;
-
-namespace dev
-{
-namespace solidity
-{
+using namespace dev;
+using namespace dev::eth;
+using namespace dev::solidity;
 
 unsigned const CompilerUtils::dataStartOffset = 4;
 size_t const CompilerUtils::freeMemoryPointer = 64;
@@ -1414,6 +1412,3 @@ unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWords)
 
 	return numBytes;
 }
-
-}
-}

libsolidity/codegen/ContractCompiler.cpp

@@ -39,6 +39,7 @@
 using namespace std;
 using namespace dev;
 using namespace langutil;
+using namespace dev::eth;
 using namespace dev::solidity;
 
 namespace

libsolidity/codegen/ExpressionCompiler.cpp

@@ -39,11 +39,10 @@
 
 using namespace std;
 using namespace langutil;
+using namespace dev;
+using namespace dev::eth;
+using namespace dev::solidity;
 
-namespace dev
-{
-namespace solidity
-{
 
 void ExpressionCompiler::compile(Expression const& _expression)
 {
@@ -2269,6 +2268,3 @@ CompilerUtils ExpressionCompiler::utils()
 {
 	return CompilerUtils(m_context);
 }
-
-}
-}

libsolidity/codegen/LValue.cpp

@@ -29,8 +29,9 @@
 
 using namespace std;
 using namespace dev;
+using namespace dev::eth;
+using namespace dev::solidity;
 using namespace langutil;
-using namespace solidity;
 
 
 StackVariable::StackVariable(CompilerContext& _compilerContext, VariableDeclaration const& _declaration):

libsolidity/interface/StandardCompiler.cpp

@@ -239,7 +239,7 @@ Json::Value collectEVMObject(eth::LinkerObject const& _object, string const* _so
 {
 	Json::Value output = Json::objectValue;
 	output["object"] = _object.toHex();
-	output["opcodes"] = solidity::disassemble(_object.bytecode);
+	output["opcodes"] = dev::eth::disassemble(_object.bytecode);
 	output["sourceMap"] = _sourceMap ? *_sourceMap : "";
 	output["linkReferences"] = formatLinkReferences(_object.linkReferences);
 	return output;