Merge pull request #858 from LefterisJP/sol_AutomaticAccessors

Solidity storage variable automatic accessors

alethzero/MainWin.cpp

@@ -1674,7 +1674,7 @@ string const Main::getFunctionHashes(dev::solidity::CompilerStack const &_compil
 	{
 		ret += it.first.abridged();
 		ret += " :";
-		ret += it.second->getName() + "\n";
+		ret += it.second.getName() + "\n";
 	}
 	return ret;
 }

libsolidity/AST.cpp

@@ -68,19 +68,23 @@ void ContractDefinition::checkTypeRequirements()
 	set<FixedHash<4>> hashes;
 	for (auto const& hashAndFunction: getInterfaceFunctionList())
 	{
-		FixedHash<4> const& hash = hashAndFunction.first;
+		FixedHash<4> const& hash = std::get<0>(hashAndFunction);
 		if (hashes.count(hash))
-			BOOST_THROW_EXCEPTION(createTypeError("Function signature hash collision for " +
-												  hashAndFunction.second->getCanonicalSignature()));
+			BOOST_THROW_EXCEPTION(createTypeError(
+									  std::string("Function signature hash collision for ") +
+									  std::get<1>(hashAndFunction)->getCanonicalSignature(std::get<2>(hashAndFunction)->getName())));
 		hashes.insert(hash);
 	}
 }
 
-map<FixedHash<4>, FunctionDefinition const*> ContractDefinition::getInterfaceFunctions() const
+map<FixedHash<4>, FunctionDescription> ContractDefinition::getInterfaceFunctions() const
 {
-	vector<pair<FixedHash<4>, FunctionDefinition const*>> exportedFunctionList = getInterfaceFunctionList();
-	map<FixedHash<4>, FunctionDefinition const*> exportedFunctions(exportedFunctionList.begin(),
-																   exportedFunctionList.end());
+	auto exportedFunctionList = getInterfaceFunctionList();
+
+	map<FixedHash<4>, FunctionDescription> exportedFunctions;
+	for (auto const& it: exportedFunctionList)
+		exportedFunctions.insert(make_pair(std::get<0>(it), FunctionDescription(std::get<1>(it), std::get<2>(it))));
+
 	solAssert(exportedFunctionList.size() == exportedFunctions.size(),
 			  "Hash collision at Function Definition Hash calculation");
 
@@ -134,20 +138,31 @@ void ContractDefinition::checkIllegalOverrides() const
 	}
 }
 
-vector<pair<FixedHash<4>, FunctionDefinition const*>> const& ContractDefinition::getInterfaceFunctionList() const
+vector<tuple<FixedHash<4>, std::shared_ptr<FunctionType const>, Declaration const*>> const& ContractDefinition::getInterfaceFunctionList() const
 {
 	if (!m_interfaceFunctionList)
 	{
 		set<string> functionsSeen;
-		m_interfaceFunctionList.reset(new vector<pair<FixedHash<4>, FunctionDefinition const*>>());
+		m_interfaceFunctionList.reset(new vector<tuple<FixedHash<4>, std::shared_ptr<FunctionType const>, Declaration const*>>());
 		for (ContractDefinition const* contract: getLinearizedBaseContracts())
+		{
 			for (ASTPointer<FunctionDefinition> const& f: contract->getDefinedFunctions())
 				if (f->isPublic() && !f->isConstructor() && functionsSeen.count(f->getName()) == 0)
 				{
 					functionsSeen.insert(f->getName());
 					FixedHash<4> hash(dev::sha3(f->getCanonicalSignature()));
-					m_interfaceFunctionList->push_back(make_pair(hash, f.get()));
+					m_interfaceFunctionList->push_back(make_tuple(hash, make_shared<FunctionType>(*f, false), f.get()));
+				}
+
+			for (ASTPointer<VariableDeclaration> const& v: contract->getStateVariables())
+				if (v->isPublic() && functionsSeen.count(v->getName()) == 0)
+				{
+					FunctionType ftype(*v);
+					functionsSeen.insert(v->getName());
+					FixedHash<4> hash(dev::sha3(ftype.getCanonicalSignature(v->getName())));
+					m_interfaceFunctionList->push_back(make_tuple(hash, make_shared<FunctionType>(*v), v.get()));
 				}
+		}
 	}
 	return *m_interfaceFunctionList;
 }
@@ -219,7 +234,7 @@ void FunctionDefinition::checkTypeRequirements()
 
 string FunctionDefinition::getCanonicalSignature() const
 {
-	return getName() + FunctionType(*this).getCanonicalSignature();
+	return FunctionType(*this).getCanonicalSignature(getName());
 }
 
 Declaration::LValueType VariableDeclaration::getLValueType() const
@@ -504,5 +519,103 @@ void Literal::checkTypeRequirements()
 		BOOST_THROW_EXCEPTION(createTypeError("Invalid literal value."));
 }
 
+std::string const& ParamDescription::getName() const
+{
+	return m_description.first;
+}
+
+std::string const& ParamDescription::getType() const
+{
+	return m_description.second;
+}
+
+ASTPointer<ASTString> FunctionDescription::getDocumentation() const
+{
+	auto function = dynamic_cast<FunctionDefinition const*>(m_description.second);
+	if (function)
+		return function->getDocumentation();
+
+	return ASTPointer<ASTString>();
+}
+
+string FunctionDescription::getSignature() const
+{
+	return m_description.first->getCanonicalSignature(m_description.second->getName());
+}
+
+string FunctionDescription::getName() const
+{
+	return m_description.second->getName();
+}
+
+bool FunctionDescription::isConstant() const
+{
+	auto function = dynamic_cast<FunctionDefinition const*>(m_description.second);
+	if (function)
+		return function->isDeclaredConst();
+
+	return true;
+}
+
+vector<ParamDescription> const FunctionDescription::getParameters() const
+{
+	auto function = dynamic_cast<FunctionDefinition const*>(m_description.second);
+	if (function)
+	{
+		vector<ParamDescription> paramsDescription;
+		for (auto const& param: function->getParameters())
+			paramsDescription.push_back(ParamDescription(param->getName(), param->getType()->toString()));
+
+		return paramsDescription;
+	}
+
+	// else for now let's assume no parameters to accessors
+	// LTODO: fix this for mapping types
+	return {};
+}
+
+vector<ParamDescription> const FunctionDescription::getReturnParameters() const
+{
+	auto function = dynamic_cast<FunctionDefinition const*>(m_description.second);
+	if (function)
+	{
+		vector<ParamDescription> paramsDescription;
+		for (auto const& param: function->getReturnParameters())
+			paramsDescription.push_back(ParamDescription(param->getName(), param->getType()->toString()));
+
+		return paramsDescription;
+	}
+
+	auto vardecl = dynamic_cast<VariableDeclaration const*>(m_description.second);
+	return {ParamDescription(vardecl->getName(), vardecl->getType()->toString())};
+}
+
+Declaration const* FunctionDescription::getDeclaration() const
+{
+	return m_description.second;
+}
+
+VariableDeclaration const* FunctionDescription::getVariableDeclaration() const
+{
+	return dynamic_cast<VariableDeclaration const*>(m_description.second);
+}
+
+FunctionDefinition const* FunctionDescription::getFunctionDefinition() const
+{
+	return dynamic_cast<FunctionDefinition const*>(m_description.second);
+}
+
+shared_ptr<FunctionType const> FunctionDescription::getFunctionTypeShared() const
+{
+	return m_description.first;
+}
+
+
+FunctionType const* FunctionDescription::getFunctionType() const
+{
+	return m_description.first.get();
+}
+
+
 }
 }

libsolidity/AST.h

@@ -156,6 +156,68 @@ private:
 	Declaration const* m_scope;
 };
 
+
+/**
+ * Generic Parameter description used by @see FunctionDescription to return
+ * a descripton of its parameters.
+ */
+struct ParamDescription
+{
+	ParamDescription(std::string const& _name, std::string const& _type):
+		m_description(_name, _type){}
+
+	std::string const& getName() const;
+	std::string const& getType() const;
+
+	std::pair<std::string, std::string> m_description;
+};
+
+
+/**
+ * Generic function description able to describe both normal functions and
+ * functions that should be made as accessors to state variables
+ */
+struct FunctionDescription
+{
+	FunctionDescription(std::shared_ptr<FunctionType const> _type, Declaration const* _decl):
+		m_description(_type, _decl){}
+
+	/// constructor for a constructor's function definition. Used only inside mix.
+	FunctionDescription(Declaration const* _def):
+	m_description(nullptr, _def){}
+
+	FunctionDescription():
+		m_description(nullptr, nullptr){}
+
+	/// @returns the natspec documentation of the function if existing. Accessor (for now) don't have natspec doc
+	ASTPointer<ASTString> getDocumentation() const;
+	/// @returns the canonical signature of the function
+	std::string getSignature() const;
+	/// @returns the name of the function, basically that of the declaration
+	std::string getName() const;
+	/// @returns whether the function is constant. IF it's an accessor this is always true
+	bool isConstant() const;
+	/// @returns the argument parameters of the function
+	std::vector<ParamDescription> const getParameters() const;
+	/// @returns the return parameters of the function
+	std::vector<ParamDescription> const getReturnParameters() const;
+	/// @returns a generic Declaration AST Node pointer which can be either a FunctionDefinition or a VariableDeclaration
+	Declaration const* getDeclaration() const;
+	/// @returns the VariableDeclaration AST Node pointer or nullptr if it's not a VariableDeclaration
+	VariableDeclaration const* getVariableDeclaration() const;
+	/// @returns the FunctionDefinition AST Node pointer or nullptr if it's not a FunctionDefinition
+	FunctionDefinition const* getFunctionDefinition() const;
+	/// @returns a created shared pointer with the type of the function
+	std::shared_ptr<FunctionType> makeFunctionType() const;
+	/// @returns a pointer to the function type
+	FunctionType const* getFunctionType() const;
+	/// @returns a shared pointer to the function type
+	std::shared_ptr<FunctionType const> getFunctionTypeShared() const;
+
+	std::pair<std::shared_ptr<FunctionType const>, Declaration const*> m_description;
+};
+
+
 /**
  * Definition of a contract. This is the only AST nodes where child nodes are not visited in
  * document order. It first visits all struct declarations, then all variable declarations and
@@ -202,7 +264,7 @@ public:
 
 	/// @returns a map of canonical function signatures to FunctionDefinitions
 	/// as intended for use by the ABI.
-	std::map<FixedHash<4>, FunctionDefinition const*> getInterfaceFunctions() const;
+	std::map<FixedHash<4>, FunctionDescription> getInterfaceFunctions() const;
 
 	/// List of all (direct and indirect) base contracts in order from derived to base, including
 	/// the contract itself. Available after name resolution
@@ -215,7 +277,7 @@ public:
 private:
 	void checkIllegalOverrides() const;
 
-	std::vector<std::pair<FixedHash<4>, FunctionDefinition const*>> const& getInterfaceFunctionList() const;
+	std::vector<std::tuple<FixedHash<4>, std::shared_ptr<FunctionType const>, Declaration const*>> const& getInterfaceFunctionList() const;
 
 	std::vector<ASTPointer<InheritanceSpecifier>> m_baseContracts;
 	std::vector<ASTPointer<StructDefinition>> m_definedStructs;
@@ -225,7 +287,7 @@ private:
 	ASTPointer<ASTString> m_documentation;
 
 	std::vector<ContractDefinition const*> m_linearizedBaseContracts;
-	mutable std::unique_ptr<std::vector<std::pair<FixedHash<4>, FunctionDefinition const*>>> m_interfaceFunctionList;
+	mutable std::unique_ptr<std::vector<std::tuple<FixedHash<4>, std::shared_ptr<FunctionType const>, Declaration const*>>> m_interfaceFunctionList;
 };
 
 class InheritanceSpecifier: public ASTNode
@@ -372,8 +434,8 @@ class VariableDeclaration: public Declaration
 {
 public:
 	VariableDeclaration(Location const& _location, ASTPointer<TypeName> const& _type,
-						ASTPointer<ASTString> const& _name):
-		Declaration(_location, _name), m_typeName(_type) {}
+							ASTPointer<ASTString> const& _name, bool _isPublic, bool _isStateVar = false):
+	Declaration(_location, _name), m_typeName(_type), m_isPublic(_isPublic), m_isStateVariable(_isStateVar) {}
 	virtual void accept(ASTVisitor& _visitor) override;
 	virtual void accept(ASTConstVisitor& _visitor) const override;
 
@@ -385,9 +447,15 @@ public:
 	void setType(std::shared_ptr<Type const> const& _type) { m_type = _type; }
 
 	virtual LValueType getLValueType() const override;
+	bool isLocalVariable() const { return !!dynamic_cast<FunctionDefinition const*>(getScope()); }
+	bool isPublic() const { return m_isPublic; }
+	bool isStateVariable() const { return m_isStateVariable; }
+
 
 private:
-	ASTPointer<TypeName> m_typeName; ///< can be empty ("var")
+	ASTPointer<TypeName> m_typeName;    ///< can be empty ("var")
+	bool m_isPublic;                    ///< Whether there is an accessor for it or not
+	bool m_isStateVariable;             ///< Whether or not this is a contract state variable
 
 	std::shared_ptr<Type const> m_type; ///< derived type, initially empty
 };
@@ -1076,5 +1144,6 @@ private:
 
 /// @}
 
+
 }
 }

libsolidity/Compiler.cpp

@@ -46,16 +46,27 @@ void Compiler::compileContract(ContractDefinition const& _contract,
 		for (ASTPointer<FunctionDefinition> const& function: contract->getDefinedFunctions())
 			if (!function->isConstructor())
 				m_context.addFunction(*function);
+
+		for (ASTPointer<VariableDeclaration> const& vardecl: contract->getStateVariables())
+			if (vardecl->isPublic())
+				m_context.addFunction(*vardecl);
+
 		for (ASTPointer<ModifierDefinition> const& modifier: contract->getFunctionModifiers())
 			m_context.addModifier(*modifier);
 	}
 
 	appendFunctionSelector(_contract);
 	for (ContractDefinition const* contract: _contract.getLinearizedBaseContracts())
+	{
 		for (ASTPointer<FunctionDefinition> const& function: contract->getDefinedFunctions())
 			if (!function->isConstructor())
 				function->accept(*this);
 
+		for (ASTPointer<VariableDeclaration> const& vardecl: contract->getStateVariables())
+			if (vardecl->isPublic())
+				generateAccessorCode(*vardecl);
+	}
+
 	// Swap the runtime context with the creation-time context
 	swap(m_context, m_runtimeContext);
 	initializeContext(_contract, _contracts);
@@ -177,13 +188,14 @@ void Compiler::appendConstructorCall(FunctionDefinition const& _constructor)
 	unsigned argumentSize = 0;
 	for (ASTPointer<VariableDeclaration> const& var: _constructor.getParameters())
 		argumentSize += CompilerUtils::getPaddedSize(var->getType()->getCalldataEncodedSize());
+
 	if (argumentSize > 0)
 	{
 		m_context << u256(argumentSize);
 		m_context.appendProgramSize();
 		m_context << u256(CompilerUtils::dataStartOffset); // copy it to byte four as expected for ABI calls
 		m_context << eth::Instruction::CODECOPY;
-		appendCalldataUnpacker(_constructor, true);
+		appendCalldataUnpacker(FunctionType(_constructor).getParameterTypes(), true);
 	}
 	m_context.appendJumpTo(m_context.getFunctionEntryLabel(_constructor));
 	m_context << returnTag;
@@ -201,7 +213,7 @@ set<FunctionDefinition const*> Compiler::getFunctionsCalled(set<ASTNode const*>
 
 void Compiler::appendFunctionSelector(ContractDefinition const& _contract)
 {
-	map<FixedHash<4>, FunctionDefinition const*> interfaceFunctions = _contract.getInterfaceFunctions();
+	map<FixedHash<4>, FunctionDescription> interfaceFunctions = _contract.getInterfaceFunctions();
 	map<FixedHash<4>, const eth::AssemblyItem> callDataUnpackerEntryPoints;
 
 	// retrieve the function signature hash from the calldata
@@ -209,7 +221,6 @@ void Compiler::appendFunctionSelector(ContractDefinition const& _contract)
 	CompilerUtils(m_context).loadFromMemory(0, 4, false, true);
 
 	// stack now is: 1 0 <funhash>
-	// for (auto it = interfaceFunctions.cbegin(); it != interfaceFunctions.cend(); ++it)
 	for (auto const& it: interfaceFunctions)
 	{
 		callDataUnpackerEntryPoints.insert(std::make_pair(it.first, m_context.newTag()));
@@ -220,29 +231,28 @@ void Compiler::appendFunctionSelector(ContractDefinition const& _contract)
 
 	for (auto const& it: interfaceFunctions)
 	{
-		FunctionDefinition const& function = *it.second;
+		FunctionType const* functionType = it.second.getFunctionType();
 		m_context << callDataUnpackerEntryPoints.at(it.first);
 		eth::AssemblyItem returnTag = m_context.pushNewTag();
-		appendCalldataUnpacker(function);
-		m_context.appendJumpTo(m_context.getFunctionEntryLabel(function));
+		appendCalldataUnpacker(functionType->getParameterTypes());
+		m_context.appendJumpTo(m_context.getFunctionEntryLabel(*it.second.getDeclaration()));
 		m_context << returnTag;
-		appendReturnValuePacker(function);
+		appendReturnValuePacker(functionType->getReturnParameterTypes());
 	}
 }
 
-unsigned Compiler::appendCalldataUnpacker(FunctionDefinition const& _function, bool _fromMemory)
+unsigned Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, bool _fromMemory)
 {
 	// We do not check the calldata size, everything is zero-padded.
 	unsigned dataOffset = CompilerUtils::dataStartOffset; // the 4 bytes of the function hash signature
 	//@todo this can be done more efficiently, saving some CALLDATALOAD calls
-	for (ASTPointer<VariableDeclaration> const& var: _function.getParameters())
+	for (TypePointer const& type: _typeParameters)
 	{
-		unsigned const c_numBytes = var->getType()->getCalldataEncodedSize();
+		unsigned const c_numBytes = type->getCalldataEncodedSize();
 		if (c_numBytes > 32)
 			BOOST_THROW_EXCEPTION(CompilerError()
-								  << errinfo_sourceLocation(var->getLocation())
-								  << errinfo_comment("Type " + var->getType()->toString() + " not yet supported."));
-		bool const c_leftAligned = var->getType()->getCategory() == Type::Category::STRING;
+								  << errinfo_comment("Type " + type->toString() + " not yet supported."));
+		bool const c_leftAligned = type->getCategory() == Type::Category::STRING;
 		bool const c_padToWords = true;
 		dataOffset += CompilerUtils(m_context).loadFromMemory(dataOffset, c_numBytes, c_leftAligned,
 															  !_fromMemory, c_padToWords);
@@ -250,26 +260,26 @@ unsigned Compiler::appendCalldataUnpacker(FunctionDefinition const& _function, b
 	return dataOffset;
 }
 
-void Compiler::appendReturnValuePacker(FunctionDefinition const& _function)
+void Compiler::appendReturnValuePacker(TypePointers const& _typeParameters)
 {
 	//@todo this can be also done more efficiently
 	unsigned dataOffset = 0;
-	vector<ASTPointer<VariableDeclaration>> const& parameters = _function.getReturnParameters();
-	unsigned stackDepth = CompilerUtils(m_context).getSizeOnStack(parameters);
-	for (unsigned i = 0; i < parameters.size(); ++i)
+	unsigned stackDepth = 0;
+	for (TypePointer const& type: _typeParameters)
+		stackDepth += type->getSizeOnStack();
+
+	for (TypePointer const& type: _typeParameters)
 	{
-		Type const& paramType = *parameters[i]->getType();
-		unsigned numBytes = paramType.getCalldataEncodedSize();
+		unsigned numBytes = type->getCalldataEncodedSize();
 		if (numBytes > 32)
 			BOOST_THROW_EXCEPTION(CompilerError()
-								  << errinfo_sourceLocation(parameters[i]->getLocation())
-								  << errinfo_comment("Type " + paramType.toString() + " not yet supported."));
-		CompilerUtils(m_context).copyToStackTop(stackDepth, paramType);
-		ExpressionCompiler::appendTypeConversion(m_context, paramType, paramType, true);
-		bool const c_leftAligned = paramType.getCategory() == Type::Category::STRING;
+								  << errinfo_comment("Type " + type->toString() + " not yet supported."));
+		CompilerUtils(m_context).copyToStackTop(stackDepth, *type);
+		ExpressionCompiler::appendTypeConversion(m_context, *type, *type, true);
+		bool const c_leftAligned = type->getCategory() == Type::Category::STRING;
 		bool const c_padToWords = true;
 		dataOffset += CompilerUtils(m_context).storeInMemory(dataOffset, numBytes, c_leftAligned, c_padToWords);
-		stackDepth -= paramType.getSizeOnStack();
+		stackDepth -= type->getSizeOnStack();
 	}
 	// note that the stack is not cleaned up here
 	m_context << u256(dataOffset) << u256(0) << eth::Instruction::RETURN;
@@ -282,6 +292,21 @@ void Compiler::registerStateVariables(ContractDefinition const& _contract)
 			m_context.addStateVariable(*variable);
 }
 
+void Compiler::generateAccessorCode(VariableDeclaration const& _varDecl)
+{
+	m_context.startNewFunction();
+	m_breakTags.clear();
+	m_continueTags.clear();
+
+	m_context << m_context.getFunctionEntryLabel(_varDecl);
+	ExpressionCompiler::appendStateVariableAccessor(m_context, _varDecl);
+
+	unsigned sizeOnStack = _varDecl.getType()->getSizeOnStack();
+	solAssert(sizeOnStack <= 15, "Illegal variable stack size detected");
+	m_context << eth::dupInstruction(sizeOnStack + 1);
+	m_context << eth::Instruction::JUMP;
+}
+
 bool Compiler::visit(FunctionDefinition const& _function)
 {
 	//@todo to simplify this, the calling convention could by changed such that

libsolidity/Compiler.h

@@ -56,13 +56,15 @@ private:
 					std::function<FunctionDefinition const*(std::string const&)> const& _resolveFunctionOverride,
 					std::function<ModifierDefinition const*(std::string const&)> const& _resolveModifierOverride);
 	void appendFunctionSelector(ContractDefinition const& _contract);
-	/// Creates code that unpacks the arguments for the given function, from memory if
-	/// @a _fromMemory is true, otherwise from call data. @returns the size of the data in bytes.
-	unsigned appendCalldataUnpacker(FunctionDefinition const& _function, bool _fromMemory = false);
-	void appendReturnValuePacker(FunctionDefinition const& _function);
+	/// Creates code that unpacks the arguments for the given function represented by a vector of TypePointers.
+	/// From memory if @a _fromMemory is true, otherwise from call data. @returns the size of the data in bytes.
+	unsigned appendCalldataUnpacker(TypePointers const& _typeParameters, bool _fromMemory = false);
+	void appendReturnValuePacker(TypePointers const& _typeParameters);
 
 	void registerStateVariables(ContractDefinition const& _contract);
 
+	void generateAccessorCode(VariableDeclaration const& _varDecl);
+
 	virtual bool visit(FunctionDefinition const& _function) override;
 	virtual bool visit(IfStatement const& _ifStatement) override;
 	virtual bool visit(WhileStatement const& _whileStatement) override;

libsolidity/CompilerContext.cpp

@@ -59,11 +59,11 @@ void CompilerContext::addAndInitializeVariable(VariableDeclaration const& _decla
 		*this << u256(0);
 }
 
-void CompilerContext::addFunction(FunctionDefinition const& _function)
+void CompilerContext::addFunction(Declaration const& _decl)
 {
 	eth::AssemblyItem tag(m_asm.newTag());
-	m_functionEntryLabels.insert(make_pair(&_function, tag));
-	m_virtualFunctionEntryLabels.insert(make_pair(_function.getName(), tag));
+	m_functionEntryLabels.insert(make_pair(&_decl, tag));
+	m_virtualFunctionEntryLabels.insert(make_pair(_decl.getName(), tag));
 }
 
 void CompilerContext::addModifier(ModifierDefinition const& _modifier)
@@ -83,9 +83,9 @@ bool CompilerContext::isLocalVariable(Declaration const* _declaration) const
 	return m_localVariables.count(_declaration);
 }
 
-eth::AssemblyItem CompilerContext::getFunctionEntryLabel(FunctionDefinition const& _function) const
+eth::AssemblyItem CompilerContext::getFunctionEntryLabel(Declaration const& _declaration) const
 {
-	auto res = m_functionEntryLabels.find(&_function);
+	auto res = m_functionEntryLabels.find(&_declaration);
 	solAssert(res != m_functionEntryLabels.end(), "Function entry label not found.");
 	return res->second.tag();
 }

libsolidity/CompilerContext.h

@@ -44,7 +44,7 @@ public:
 	void startNewFunction() { m_localVariables.clear(); m_asm.setDeposit(0); }
 	void addVariable(VariableDeclaration const& _declaration, unsigned _offsetToCurrent = 0);
 	void addAndInitializeVariable(VariableDeclaration const& _declaration);
-	void addFunction(FunctionDefinition const& _function);
+	void addFunction(Declaration const& _decl);
 	/// Adds the given modifier to the list by name if the name is not present already.
 	void addModifier(ModifierDefinition const& _modifier);
 
@@ -58,7 +58,7 @@ public:
 	bool isLocalVariable(Declaration const* _declaration) const;
 	bool isStateVariable(Declaration const* _declaration) const { return m_stateVariables.count(_declaration) != 0; }
 
-	eth::AssemblyItem getFunctionEntryLabel(FunctionDefinition const& _function) const;
+	eth::AssemblyItem getFunctionEntryLabel(Declaration const& _declaration) const;
 	/// @returns the entry label of the given function and takes overrides into account.
 	eth::AssemblyItem getVirtualFunctionEntryLabel(FunctionDefinition const& _function) const;
 	ModifierDefinition const& getFunctionModifier(std::string const& _name) const;
@@ -115,9 +115,9 @@ private:
 	u256 m_stateVariablesSize = 0;
 	/// Storage offsets of state variables
 	std::map<Declaration const*, u256> m_stateVariables;
-	/// Positions of local variables on the stack.
+	/// Offsets of local variables on the stack (relative to stack base).
 	std::map<Declaration const*, unsigned> m_localVariables;
-	/// Labels pointing to the entry points of funcitons.
+	/// Labels pointing to the entry points of functions.
 	std::map<Declaration const*, eth::AssemblyItem> m_functionEntryLabels;
 	/// Labels pointing to the entry points of function overrides.
 	std::map<std::string, eth::AssemblyItem> m_virtualFunctionEntryLabels;

libsolidity/ExpressionCompiler.cpp

@@ -48,6 +48,12 @@ void ExpressionCompiler::appendTypeConversion(CompilerContext& _context, Type co
 	compiler.appendTypeConversion(_typeOnStack, _targetType, _cleanupNeeded);
 }
 
+void ExpressionCompiler::appendStateVariableAccessor(CompilerContext& _context, VariableDeclaration const& _varDecl, bool _optimize)
+{
+	ExpressionCompiler compiler(_context, _optimize);
+	compiler.appendStateVariableAccessor(_varDecl);
+}
+
 bool ExpressionCompiler::visit(Assignment const& _assignment)
 {
 	_assignment.getRightHandSide().accept(*this);
@@ -789,6 +795,13 @@ unsigned ExpressionCompiler::appendArgumentCopyToMemory(TypePointers const& _typ
 	return length;
 }
 
+void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& _varDecl)
+{
+	m_currentLValue.fromStateVariable(_varDecl, _varDecl.getType());
+	solAssert(m_currentLValue.isInStorage(), "");
+	m_currentLValue.retrieveValueFromStorage(_varDecl.getType(), true);
+}
+
 ExpressionCompiler::LValue::LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType,
 								   unsigned _baseStackOffset):
 	m_context(&_compilerContext), m_type(_type), m_baseStackOffset(_baseStackOffset)
@@ -816,21 +829,7 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
 		break;
 	}
 	case STORAGE:
-		if (!_expression.getType()->isValueType())
-			break; // no distinction between value and reference for non-value types
-		if (!_remove)
-			*m_context << eth::Instruction::DUP1;
-		if (m_size == 1)
-			*m_context << eth::Instruction::SLOAD;
-		else
-			for (unsigned i = 0; i < m_size; ++i)
-			{
-				*m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD << eth::Instruction::SWAP1;
-				if (i + 1 < m_size)
-					*m_context << u256(1) << eth::Instruction::ADD;
-				else
-					*m_context << eth::Instruction::POP;
-			}
+		retrieveValueFromStorage(_expression.getType(), _remove);
 		break;
 	case MEMORY:
 		if (!_expression.getType()->isValueType())
@@ -845,6 +844,25 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
 	}
 }
 
+void ExpressionCompiler::LValue::retrieveValueFromStorage(TypePointer const& _type, bool _remove) const
+{
+	if (!_type->isValueType())
+		return; // no distinction between value and reference for non-value types
+	if (!_remove)
+		*m_context << eth::Instruction::DUP1;
+	if (m_size == 1)
+		*m_context << eth::Instruction::SLOAD;
+	else
+		for (unsigned i = 0; i < m_size; ++i)
+		{
+			*m_context << eth::Instruction::DUP1 << eth::Instruction::SLOAD << eth::Instruction::SWAP1;
+			if (i + 1 < m_size)
+				*m_context << u256(1) << eth::Instruction::ADD;
+			else
+				*m_context << eth::Instruction::POP;
+		}
+}
+
 void ExpressionCompiler::LValue::storeValue(Expression const& _expression, bool _move) const
 {
 	switch (m_type)
@@ -951,6 +969,14 @@ void ExpressionCompiler::LValue::retrieveValueIfLValueNotRequested(Expression co
 	}
 }
 
+void ExpressionCompiler::LValue::fromStateVariable(Declaration const& _varDecl, TypePointer const& _type)
+{
+	m_type = STORAGE;
+	solAssert(_type->getStorageSize() <= numeric_limits<unsigned>::max(), "The storage size of " + _type->toString() + " should fit in an unsigned");
+	*m_context << m_context->getStorageLocationOfVariable(_varDecl);
+	m_size = unsigned(_type->getStorageSize());
+}
+
 void ExpressionCompiler::LValue::fromIdentifier(Identifier const& _identifier, Declaration const& _declaration)
 {
 	if (m_context->isLocalVariable(&_declaration))
@@ -961,10 +987,7 @@ void ExpressionCompiler::LValue::fromIdentifier(Identifier const& _identifier, D
 	}
 	else if (m_context->isStateVariable(&_declaration))
 	{
-		m_type = STORAGE;
-		solAssert(_identifier.getType()->getStorageSize() <= numeric_limits<unsigned>::max(), "The storage size of " + _identifier.getType()->toString() + " should fit in unsigned");
-		m_size = unsigned(_identifier.getType()->getStorageSize());
-		*m_context << m_context->getStorageLocationOfVariable(_declaration);
+		fromStateVariable(_declaration, _identifier.getType());
 	}
 	else
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_sourceLocation(_identifier.getLocation())

libsolidity/ExpressionCompiler.h

@@ -53,6 +53,8 @@ public:
 	/// Appends code to remove dirty higher order bits in case of an implicit promotion to a wider type.
 	static void appendTypeConversion(CompilerContext& _context, Type const& _typeOnStack,
 									 Type const& _targetType, bool _cleanupNeeded = false);
+	/// Appends code for a State Variable accessor function
+	static void appendStateVariableAccessor(CompilerContext& _context, VariableDeclaration const& _varDecl, bool _optimize = false);
 
 private:
 	explicit ExpressionCompiler(CompilerContext& _compilerContext, bool _optimize = false):
@@ -95,6 +97,9 @@ private:
 	unsigned appendArgumentCopyToMemory(TypePointers const& _functionType, std::vector<ASTPointer<Expression const>> const& _arguments,
 										unsigned _memoryOffset = 0);
 
+	/// Appends code for a State Variable accessor function
+	void appendStateVariableAccessor(VariableDeclaration const& _varDecl);
+
 	/**
 	 * Helper class to store and retrieve lvalues to and from various locations.
 	 * All types except STACK store a reference in a slot on the stack, STACK just
@@ -111,6 +116,8 @@ private:
 		/// Set type according to the declaration and retrieve the reference.
 		/// @a _expression is the current expression
 		void fromIdentifier(Identifier const& _identifier, Declaration const& _declaration);
+		/// Convenience function to set type for a state variable and retrieve the reference
+		void fromStateVariable(Declaration const& _varDecl, TypePointer const& _type);
 		void reset() { m_type = NONE; m_baseStackOffset = 0; m_size = 0; }
 
 		bool isValid() const { return m_type != NONE; }
@@ -125,6 +132,8 @@ private:
 		/// also removes the reference from the stack (note that is does not reset the type to @a NONE).
 		/// @a _expression is the current expression, used for error reporting.
 		void retrieveValue(Expression const& _expression, bool _remove = false) const;
+		/// Convenience function to retrieve Value from Storage. Specific version of @ref retrieveValue
+		void retrieveValueFromStorage(TypePointer const& _type, bool _remove = false) const;
 		/// Stores a value (from the stack directly beneath the reference, which is assumed to
 		/// be on the top of the stack, if any) in the lvalue and removes the reference.
 		/// Also removes the stored value from the stack if @a _move is

libsolidity/InterfaceHandler.cpp

@@ -45,23 +45,23 @@ std::unique_ptr<std::string> InterfaceHandler::getABIInterface(ContractDefinitio
 		Json::Value inputs(Json::arrayValue);
 		Json::Value outputs(Json::arrayValue);
 
-		auto populateParameters = [](std::vector<ASTPointer<VariableDeclaration>> const& _vars)
+		auto populateParameters = [](vector<ParamDescription> const& _params)
 		{
 			Json::Value params(Json::arrayValue);
-			for (ASTPointer<VariableDeclaration> const& var: _vars)
+			for (auto const& param: _params)
 			{
 				Json::Value input;
-				input["name"] = var->getName();
-				input["type"] = var->getType()->toString();
+				input["name"] = param.getName();
+				input["type"] = param.getType();
 				params.append(input);
 			}
 			return params;
 		};
 
-		method["name"] = it.second->getName();
-		method["constant"] = it.second->isDeclaredConst();
-		method["inputs"] = populateParameters(it.second->getParameters());
-		method["outputs"] = populateParameters(it.second->getReturnParameters());
+		method["name"] = it.second.getName();
+		method["constant"] = it.second.isConstant();
+		method["inputs"] = populateParameters(it.second.getParameters());
+		method["outputs"] = populateParameters(it.second.getReturnParameters());
 		methods.append(method);
 	}
 	return std::unique_ptr<std::string>(new std::string(m_writer.write(methods)));
@@ -72,17 +72,16 @@ unique_ptr<string> InterfaceHandler::getABISolidityInterface(ContractDefinition
 	string ret = "contract " + _contractDef.getName() + "{";
 	for (auto const& it: _contractDef.getInterfaceFunctions())
 	{
-		FunctionDefinition const* f = it.second;
-		auto populateParameters = [](vector<ASTPointer<VariableDeclaration>> const& _vars)
+		auto populateParameters = [](vector<ParamDescription> const& _params)
 		{
 			string r = "";
-			for (ASTPointer<VariableDeclaration> const& var: _vars)
-				r += (r.size() ? "," : "(") + var->getType()->toString() + " " + var->getName();
+			for (auto const& param: _params)
+				r += (r.size() ? "," : "(") + param.getType() + " " + param.getName();
 			return r.size() ? r + ")" : "()";
 		};
-		ret += "function " + f->getName() + populateParameters(f->getParameters()) + (f->isDeclaredConst() ? "constant " : "");
-		if (f->getReturnParameters().size())
-			ret += "returns" + populateParameters(f->getReturnParameters());
+		ret += "function " + it.second.getName() + populateParameters(it.second.getParameters()) + (it.second.isConstant() ? "constant " : "");
+		if (it.second.getReturnParameters().size())
+			ret += "returns" + populateParameters(it.second.getReturnParameters());
 		else if (ret.back() == ' ')
 			ret.pop_back();
 		ret += "{}";
@@ -98,7 +97,7 @@ std::unique_ptr<std::string> InterfaceHandler::getUserDocumentation(ContractDefi
 	for (auto const& it: _contractDef.getInterfaceFunctions())
 	{
 		Json::Value user;
-		auto strPtr = it.second->getDocumentation();
+		auto strPtr = it.second.getDocumentation();
 		if (strPtr)
 		{
 			resetUser();
@@ -106,7 +105,7 @@ std::unique_ptr<std::string> InterfaceHandler::getUserDocumentation(ContractDefi
 			if (!m_notice.empty())
 			{// since @notice is the only user tag if missing function should not appear
 				user["notice"] = Json::Value(m_notice);
-				methods[it.second->getCanonicalSignature()] = user;
+				methods[it.second.getSignature()] = user;
 			}
 		}
 	}
@@ -139,7 +138,7 @@ std::unique_ptr<std::string> InterfaceHandler::getDevDocumentation(ContractDefin
 	for (auto const& it: _contractDef.getInterfaceFunctions())
 	{
 		Json::Value method;
-		auto strPtr = it.second->getDocumentation();
+		auto strPtr = it.second.getDocumentation();
 		if (strPtr)
 		{
 			resetDev();
@@ -162,7 +161,7 @@ std::unique_ptr<std::string> InterfaceHandler::getDevDocumentation(ContractDefin
 				method["return"] = m_return;
 
 			if (!method.empty()) // add the function, only if we have any documentation to add
-				methods[it.second->getCanonicalSignature()] = method;
+				methods[it.second.getSignature()] = method;
 		}
 	}
 	doc["methods"] = methods;

libsolidity/Parser.cpp

@@ -150,7 +150,7 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
 				 Token::isElementaryTypeName(currentToken))
 		{
 			bool const allowVar = false;
-			stateVariables.push_back(parseVariableDeclaration(allowVar));
+			stateVariables.push_back(parseVariableDeclaration(allowVar, visibilityIsPublic, true));
 			expectToken(Token::SEMICOLON);
 		}
 		else if (currentToken == Token::MODIFIER)
@@ -245,12 +245,12 @@ ASTPointer<StructDefinition> Parser::parseStructDefinition()
 	return nodeFactory.createNode<StructDefinition>(name, members);
 }
 
-ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(bool _allowVar)
+ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(bool _allowVar, bool _isPublic, bool _isStateVariable)
 {
 	ASTNodeFactory nodeFactory(*this);
 	ASTPointer<TypeName> type = parseTypeName(_allowVar);
 	nodeFactory.markEndPosition();
-	return nodeFactory.createNode<VariableDeclaration>(type, expectIdentifierToken());
+	return nodeFactory.createNode<VariableDeclaration>(type, expectIdentifierToken(), _isPublic, _isStateVariable);
 }
 
 ASTPointer<ModifierDefinition> Parser::parseModifierDefinition()

libsolidity/Parser.h

@@ -52,7 +52,7 @@ private:
 	ASTPointer<InheritanceSpecifier> parseInheritanceSpecifier();
 	ASTPointer<FunctionDefinition> parseFunctionDefinition(bool _isPublic, ASTString const* _contractName);
 	ASTPointer<StructDefinition> parseStructDefinition();
-	ASTPointer<VariableDeclaration> parseVariableDeclaration(bool _allowVar);
+	ASTPointer<VariableDeclaration> parseVariableDeclaration(bool _allowVar, bool _isPublic = false, bool _isStateVar = false);
 	ASTPointer<ModifierDefinition> parseModifierDefinition();
 	ASTPointer<ModifierInvocation> parseModifierInvocation();
 	ASTPointer<Identifier> parseIdentifier();

libsolidity/Types.cpp

@@ -489,7 +489,7 @@ MemberList const& ContractType::getMembers() const
 		map<string, shared_ptr<Type const>> members(IntegerType::AddressMemberList.begin(),
 													IntegerType::AddressMemberList.end());
 		for (auto const& it: m_contract.getInterfaceFunctions())
-			members[it.second->getName()] = make_shared<FunctionType>(*it.second, false);
+			members[it.second.getName()] = it.second.getFunctionTypeShared();
 		m_members.reset(new MemberList(members));
 	}
 	return *m_members;
@@ -511,9 +511,9 @@ shared_ptr<FunctionType const> const& ContractType::getConstructorType() const
 u256 ContractType::getFunctionIdentifier(string const& _functionName) const
 {
 	auto interfaceFunctions = m_contract.getInterfaceFunctions();
-	for (auto it = interfaceFunctions.cbegin(); it != interfaceFunctions.cend(); ++it)
-		if (it->second->getName() == _functionName)
-			return FixedHash<4>::Arith(it->first);
+	for (auto const& it: m_contract.getInterfaceFunctions())
+		if (it.second.getName() == _functionName)
+			return FixedHash<4>::Arith(it.first);
 
 	return Invalid256;
 }
@@ -582,15 +582,42 @@ FunctionType::FunctionType(FunctionDefinition const& _function, bool _isInternal
 	m_location(_isInternal ? Location::INTERNAL : Location::EXTERNAL)
 {
 	TypePointers params;
+	vector<string> paramNames;
 	TypePointers retParams;
+	vector<string> retParamNames;
 	params.reserve(_function.getParameters().size());
+	paramNames.reserve(_function.getParameters().size());
 	for (ASTPointer<VariableDeclaration> const& var: _function.getParameters())
+	{
+		paramNames.push_back(var->getName());
 		params.push_back(var->getType());
+	}
 	retParams.reserve(_function.getReturnParameters().size());
+	retParamNames.reserve(_function.getReturnParameters().size());
 	for (ASTPointer<VariableDeclaration> const& var: _function.getReturnParameters())
+	{
+		retParamNames.push_back(var->getName());
 		retParams.push_back(var->getType());
+	}
+	swap(params, m_parameterTypes);
+	swap(paramNames, m_parameterNames);
+	swap(retParams, m_returnParameterTypes);
+	swap(retParamNames, m_returnParameterNames);
+}
+
+FunctionType::FunctionType(VariableDeclaration const& _varDecl):
+	m_location(Location::EXTERNAL)
+{
+	TypePointers params({});
+	vector<string> paramNames({});
+	TypePointers retParams({_varDecl.getType()});
+	vector<string> retParamNames({ _varDecl.getName()});
+	// for now, no input parameters LTODO: change for some things like mapping
+
 	swap(params, m_parameterTypes);
+	swap(paramNames, m_parameterNames);
 	swap(retParams, m_returnParameterTypes);
+	swap(retParamNames, m_returnParameterNames);
 }
 
 bool FunctionType::operator==(Type const& _other) const
@@ -672,9 +699,9 @@ MemberList const& FunctionType::getMembers() const
 	}
 }
 
-string FunctionType::getCanonicalSignature() const
+string FunctionType::getCanonicalSignature(std::string const& _name) const
 {
-	string ret = "(";
+	string ret = _name + "(";
 
 	for (auto it = m_parameterTypes.cbegin(); it != m_parameterTypes.cend(); ++it)
 		ret += (*it)->toString() + (it + 1 == m_parameterTypes.cend() ? "" : ",");

libsolidity/Types.h

@@ -353,6 +353,7 @@ public:
 
 	virtual Category getCategory() const override { return Category::FUNCTION; }
 	explicit FunctionType(FunctionDefinition const& _function, bool _isInternal = true);
+	explicit FunctionType(VariableDeclaration const& _varDecl);
 	FunctionType(strings const& _parameterTypes, strings const& _returnParameterTypes,
 				 Location _location = Location::INTERNAL):
 		FunctionType(parseElementaryTypeVector(_parameterTypes), parseElementaryTypeVector(_returnParameterTypes),
@@ -364,7 +365,9 @@ public:
 		m_location(_location), m_gasSet(_gasSet), m_valueSet(_valueSet) {}
 
 	TypePointers const& getParameterTypes() const { return m_parameterTypes; }
+	std::vector<std::string> const& getParameterNames() const { return m_parameterNames; }
 	TypePointers const& getReturnParameterTypes() const { return m_returnParameterTypes; }
+	std::vector<std::string> const& getReturnParameterNames() const { return m_returnParameterNames; }
 
 	virtual bool operator==(Type const& _other) const override;
 	virtual std::string toString() const override;
@@ -375,7 +378,7 @@ public:
 	virtual MemberList const& getMembers() const override;
 
 	Location const& getLocation() const { return m_location; }
-	std::string getCanonicalSignature() const;
+	std::string getCanonicalSignature(std::string const& _name) const;
 
 	bool gasSet() const { return m_gasSet; }
 	bool valueSet() const { return m_valueSet; }
@@ -389,6 +392,8 @@ private:
 
 	TypePointers m_parameterTypes;
 	TypePointers m_returnParameterTypes;
+	std::vector<std::string> m_parameterNames;
+	std::vector<std::string> m_returnParameterNames;
 	Location const m_location;
 	bool const m_gasSet = false; ///< true iff the gas value to be used is on the stack
 	bool const m_valueSet = false; ///< true iff the value to be sent is on the stack

mix/QBasicNodeDefinition.h

@@ -38,6 +38,7 @@ public:
 	QBasicNodeDefinition(): QObject() {}
 	~QBasicNodeDefinition() {}
 	QBasicNodeDefinition(solidity::Declaration const* _d): QObject(), m_name(QString::fromStdString(_d->getName())) {}
+	QBasicNodeDefinition(std::string const& _name): QObject(), m_name(QString::fromStdString(_name)) {}
 	/// Get the name of the node.
 	QString name() const { return m_name; }
 

mix/QContractDefinition.cpp

@@ -34,13 +34,13 @@ using namespace dev::mix;
 QContractDefinition::QContractDefinition(dev::solidity::ContractDefinition const* _contract): QBasicNodeDefinition(_contract)
 {
 	if (_contract->getConstructor() != nullptr)
-		m_constructor = new QFunctionDefinition(_contract->getConstructor(), -1);
+	{
+		FunctionDescription desc(_contract->getConstructor());
+		m_constructor = new QFunctionDefinition(desc);
+	}
 	else
 		m_constructor = new QFunctionDefinition();
 
-	auto interfaceFunctions = _contract->getInterfaceFunctions();
-	unsigned i = 0;
-	for (auto it = interfaceFunctions.cbegin(); it != interfaceFunctions.cend(); ++it, ++i)
-		m_functions.append(new QFunctionDefinition(it->second, i));
-}
+	for (auto const& it: _contract->getInterfaceFunctions())
+		m_functions.append(new QFunctionDefinition(it.second));}
 

mix/QFunctionDefinition.cpp

@@ -21,19 +21,36 @@
 
 #include <libsolidity/AST.h>
 #include <libdevcrypto/SHA3.h>
+#include <libdevcore/Exceptions.h>
 #include "QVariableDeclaration.h"
 #include "QFunctionDefinition.h"
 
 using namespace dev::solidity;
 using namespace dev::mix;
 
-QFunctionDefinition::QFunctionDefinition(dev::solidity::FunctionDefinition const* _f, int _index): QBasicNodeDefinition(_f), m_index(_index), m_hash(dev::sha3(_f->getCanonicalSignature()))
+QFunctionDefinition::QFunctionDefinition(dev::solidity::FunctionDescription const& _f): QBasicNodeDefinition(_f.getDeclaration()), m_hash(dev::sha3(_f.getSignature()))
 {
-	std::vector<std::shared_ptr<VariableDeclaration>> parameters = _f->getParameterList().getParameters();
-	for (unsigned i = 0; i < parameters.size(); i++)
-		m_parameters.append(new QVariableDeclaration(parameters.at(i).get()));
+	FunctionDefinition const* funcDef;
+	VariableDeclaration const* varDecl;
+	if ((funcDef = _f.getFunctionDefinition()))
+	{
+		std::vector<std::shared_ptr<VariableDeclaration>> parameters = funcDef->getParameterList().getParameters();
+		for (unsigned i = 0; i < parameters.size(); i++)
+			m_parameters.append(new QVariableDeclaration(parameters.at(i).get()));
 
-	std::vector<std::shared_ptr<VariableDeclaration>> returnParameters = _f->getReturnParameters();
-	for (unsigned i = 0; i < returnParameters.size(); i++)
-		m_returnParameters.append(new QVariableDeclaration(returnParameters.at(i).get()));
+		std::vector<std::shared_ptr<VariableDeclaration>> returnParameters = funcDef->getReturnParameters();
+		for (unsigned i = 0; i < returnParameters.size(); i++)
+			m_returnParameters.append(new QVariableDeclaration(returnParameters.at(i).get()));
+	}
+	else
+	{
+		if (!(varDecl = _f.getVariableDeclaration()))
+			BOOST_THROW_EXCEPTION(Exception() << errinfo_comment("Malformed FunctionDescription. Should never happen."));
+
+		// only the return parameter for now.
+		// TODO: change this for other state variables like mapping and maybe abstract this inside solidity and not here
+		auto returnParams = _f.getReturnParameters();
+		m_returnParameters.append(new QVariableDeclaration(returnParams[0]));
+
+	}
 }

mix/QFunctionDefinition.h

@@ -36,19 +36,16 @@ class QFunctionDefinition: public QBasicNodeDefinition
 {
 	Q_OBJECT
 	Q_PROPERTY(QQmlListProperty<dev::mix::QVariableDeclaration> parameters READ parameters)
-	Q_PROPERTY(int index READ index)
 
 public:
 	QFunctionDefinition() {}
-	QFunctionDefinition(solidity::FunctionDefinition const* _f, int _index);
+	QFunctionDefinition(solidity::FunctionDescription const& _f);
 	/// Get all input parameters of this function.
 	QList<QVariableDeclaration*> const& parametersList() const { return m_parameters; }
 	/// Get all input parameters of this function as QML property.
 	QQmlListProperty<QVariableDeclaration> parameters() const { return QQmlListProperty<QVariableDeclaration>(const_cast<QFunctionDefinition*>(this), const_cast<QFunctionDefinition*>(this)->m_parameters); }
 	/// Get all return parameters of this function.
 	QList<QVariableDeclaration*> returnParameters() const { return m_returnParameters; }
-	/// Get the index of this function on the contract ABI.
-	int index() const { return m_index; }
 	/// Get the hash of this function declaration on the contract ABI.
 	FixedHash<4> hash() const { return m_hash; }
 

mix/QVariableDeclaration.h

@@ -37,6 +37,7 @@ class QVariableDeclaration: public QBasicNodeDefinition
 public:
 	QVariableDeclaration() {}
 	QVariableDeclaration(solidity::VariableDeclaration const* _v): QBasicNodeDefinition(_v), m_type(QString::fromStdString(_v->getType()->toString())) {}
+	QVariableDeclaration(solidity::ParamDescription const& _v): QBasicNodeDefinition(_v.getName()), m_type(QString::fromStdString(_v.getType())) {}
 	QString type() const { return m_type; }
 private:
 	QString m_type;

test/SolidityEndToEndTest.cpp

@@ -882,6 +882,43 @@ BOOST_AUTO_TEST_CASE(constructor)
 	testSolidityAgainstCpp("get(uint256)", get, u256(7));
 }
 
+BOOST_AUTO_TEST_CASE(simple_accessor)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  uint256 data;\n"
+							 "  function test() {\n"
+							 "    data = 8;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("data()") == encodeArgs(8));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_elementary_accessors)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  uint256 data;\n"
+							 "  string6 name;\n"
+							 "  hash a_hash;\n"
+							 "  address an_address;\n"
+							 "  function test() {\n"
+							 "    data = 8;\n"
+							 "    name = \"Celina\";\n"
+							 "    a_hash = sha3(123);\n"
+							 "    an_address = address(0x1337);\n"
+							 "    super_secret_data = 42;\n"
+							 "  }\n"
+							 "  private:"
+							 "  uint256 super_secret_data;"
+							 "}\n";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("data()") == encodeArgs(8));
+	BOOST_CHECK(callContractFunction("name()") == encodeArgs("Celina"));
+	BOOST_CHECK(callContractFunction("a_hash()") == encodeArgs(dev::sha3(toBigEndian(u256(123)))));
+	BOOST_CHECK(callContractFunction("an_address()") == encodeArgs(toBigEndian(u160(0x1337))));
+	BOOST_CHECK(!(callContractFunction("super_secret_data()") == encodeArgs(42)));
+}
+
 BOOST_AUTO_TEST_CASE(balance)
 {
 	char const* sourceCode = "contract test {\n"

test/SolidityNameAndTypeResolution.cpp

@@ -23,12 +23,15 @@
 #include <string>
 
 #include <libdevcore/Log.h>
+#include <libdevcrypto/SHA3.h>
 #include <libsolidity/Scanner.h>
 #include <libsolidity/Parser.h>
 #include <libsolidity/NameAndTypeResolver.h>
 #include <libsolidity/Exceptions.h>
 #include <boost/test/unit_test.hpp>
 
+using namespace std;
+
 namespace dev
 {
 namespace solidity
@@ -38,6 +41,7 @@ namespace test
 
 namespace
 {
+
 ASTPointer<SourceUnit> parseTextAndResolveNames(std::string const& _source)
 {
 	Parser parser;
@@ -53,6 +57,48 @@ ASTPointer<SourceUnit> parseTextAndResolveNames(std::string const& _source)
 
 	return sourceUnit;
 }
+
+ASTPointer<SourceUnit> parseTextAndResolveNamesWithChecks(std::string const& _source)
+{
+	Parser parser;
+	ASTPointer<SourceUnit> sourceUnit;
+	try
+	{
+		sourceUnit = parser.parse(std::make_shared<Scanner>(CharStream(_source)));
+		NameAndTypeResolver resolver({});
+		resolver.registerDeclarations(*sourceUnit);
+		for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
+			if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+				resolver.resolveNamesAndTypes(*contract);
+		for (ASTPointer<ASTNode> const& node: sourceUnit->getNodes())
+			if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
+				resolver.checkTypeRequirements(*contract);
+	}
+	catch(boost::exception const& _e)
+	{
+		auto msg = std::string("Parsing text and resolving names failed with: \n") + boost::diagnostic_information(_e);
+		BOOST_FAIL(msg);
+	}
+	return sourceUnit;
+}
+
+static ContractDefinition const* retrieveContract(ASTPointer<SourceUnit> _source, unsigned index)
+{
+	ContractDefinition* contract;
+	unsigned counter = 0;
+	for (ASTPointer<ASTNode> const& node: _source->getNodes())
+		if ((contract = dynamic_cast<ContractDefinition*>(node.get())) && counter == index)
+			return contract;
+
+	return NULL;
+}
+
+static FunctionDescription const& retrieveFunctionBySignature(ContractDefinition const* _contract,
+															  std::string const& _signature)
+{
+	FixedHash<4> hash(dev::sha3(_signature));
+	return _contract->getInterfaceFunctions()[hash];
+}
 }
 
 BOOST_AUTO_TEST_SUITE(SolidityNameAndTypeResolution)
@@ -63,7 +109,7 @@ BOOST_AUTO_TEST_CASE(smoke_test)
 					   "  uint256 stateVariable1;\n"
 					   "  function fun(uint256 arg1) { var x; uint256 y; }"
 					   "}\n";
-	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
+	BOOST_CHECK_NO_THROW(parseTextAndResolveNamesWithChecks(text));
 }
 
 BOOST_AUTO_TEST_CASE(double_stateVariable_declaration)
@@ -584,6 +630,56 @@ BOOST_AUTO_TEST_CASE(modifier_returns_value)
 	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
 }
 
+BOOST_AUTO_TEST_CASE(state_variable_accessors)
+{
+	char const* text = "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "uint256 foo;\n"
+					   "}\n";
+
+	ASTPointer<SourceUnit> source;
+	ContractDefinition const* contract;
+	BOOST_CHECK_NO_THROW(source = parseTextAndResolveNamesWithChecks(text));
+	BOOST_REQUIRE((contract = retrieveContract(source, 0)) != nullptr);
+	FunctionDescription function = retrieveFunctionBySignature(contract, "foo()");
+	BOOST_CHECK_MESSAGE(function.getDeclaration() != nullptr, "Could not find the accessor function");
+	auto returnParams = function.getReturnParameters();
+	BOOST_CHECK_EQUAL(returnParams.at(0).getType(), "uint256");
+	BOOST_CHECK(function.isConstant());
+}
+
+BOOST_AUTO_TEST_CASE(function_clash_with_state_variable_accessor)
+{
+	char const* text = "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "uint256 foo;\n"
+					   "   function foo() {}\n"
+					   "}\n";
+	BOOST_CHECK_THROW(parseTextAndResolveNames(text), DeclarationError);
+}
+
+BOOST_AUTO_TEST_CASE(private_state_variable)
+{
+	char const* text = "contract test {\n"
+					   "  function fun() {\n"
+					   "    uint64(2);\n"
+					   "  }\n"
+					   "private:\n"
+					   "uint256 foo;\n"
+					   "}\n";
+
+	ASTPointer<SourceUnit> source;
+	ContractDefinition const* contract;
+	BOOST_CHECK_NO_THROW(source = parseTextAndResolveNamesWithChecks(text));
+	BOOST_CHECK((contract = retrieveContract(source, 0)) != nullptr);
+	FunctionDescription function = retrieveFunctionBySignature(contract, "foo()");
+	BOOST_CHECK_MESSAGE(function.getDeclaration() == nullptr, "Accessor function of a private variable should not exist");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/SolidityParser.cpp

@@ -66,6 +66,14 @@ ASTPointer<ContractDefinition> parseTextExplainError(std::string const& _source)
 	}
 }
 
+static void checkFunctionNatspec(ASTPointer<FunctionDefinition> _function,
+								 std::string const& _expectedDoc)
+{
+	auto doc = _function->getDocumentation();
+	BOOST_CHECK_MESSAGE(doc != nullptr, "Function does not have Natspec Doc as expected");
+	BOOST_CHECK_EQUAL(*doc, _expectedDoc);
+}
+
 }
 
 
@@ -121,14 +129,16 @@ BOOST_AUTO_TEST_CASE(function_natspec_documentation)
 	ASTPointer<ContractDefinition> contract;
 	ASTPointer<FunctionDefinition> function;
 	char const* text = "contract test {\n"
-					   "  uint256 stateVar;\n"
+					   "  private:\n"
+	                   "  uint256 stateVar;\n"
+	                   "  public:\n"
 					   "  /// This is a test function\n"
 					   "  function functionName(hash hashin) returns (hash hashout) {}\n"
 					   "}\n";
 	BOOST_REQUIRE_NO_THROW(contract = parseText(text));
 	auto functions = contract->getDefinedFunctions();
 	BOOST_REQUIRE_NO_THROW(function = functions.at(0));
-	BOOST_CHECK_EQUAL(*function->getDocumentation(), "This is a test function");
+	checkFunctionNatspec(function, "This is a test function");
 }
 
 BOOST_AUTO_TEST_CASE(function_normal_comments)
@@ -144,7 +154,7 @@ BOOST_AUTO_TEST_CASE(function_normal_comments)
 	auto functions = contract->getDefinedFunctions();
 	BOOST_REQUIRE_NO_THROW(function = functions.at(0));
 	BOOST_CHECK_MESSAGE(function->getDocumentation() == nullptr,
-						"Should not have gotten a Natspect comment for this function");
+						"Should not have gotten a Natspecc comment for this function");
 }
 
 BOOST_AUTO_TEST_CASE(multiple_functions_natspec_documentation)
@@ -152,7 +162,9 @@ BOOST_AUTO_TEST_CASE(multiple_functions_natspec_documentation)
 	ASTPointer<ContractDefinition> contract;
 	ASTPointer<FunctionDefinition> function;
 	char const* text = "contract test {\n"
+					   "  private:\n"
 					   "  uint256 stateVar;\n"
+					   "  public:\n"
 					   "  /// This is test function 1\n"
 					   "  function functionName1(hash hashin) returns (hash hashout) {}\n"
 					   "  /// This is test function 2\n"
@@ -166,17 +178,17 @@ BOOST_AUTO_TEST_CASE(multiple_functions_natspec_documentation)
 	auto functions = contract->getDefinedFunctions();
 
 	BOOST_REQUIRE_NO_THROW(function = functions.at(0));
-	BOOST_CHECK_EQUAL(*function->getDocumentation(), "This is test function 1");
+	checkFunctionNatspec(function, "This is test function 1");
 
 	BOOST_REQUIRE_NO_THROW(function = functions.at(1));
-	BOOST_CHECK_EQUAL(*function->getDocumentation(), "This is test function 2");
+	checkFunctionNatspec(function, "This is test function 2");
 
 	BOOST_REQUIRE_NO_THROW(function = functions.at(2));
 	BOOST_CHECK_MESSAGE(function->getDocumentation() == nullptr,
 						"Should not have gotten natspec comment for functionName3()");
 
 	BOOST_REQUIRE_NO_THROW(function = functions.at(3));
-	BOOST_CHECK_EQUAL(*function->getDocumentation(), "This is test function 4");
+	checkFunctionNatspec(function, "This is test function 4");
 }
 
 BOOST_AUTO_TEST_CASE(multiline_function_documentation)
@@ -193,9 +205,8 @@ BOOST_AUTO_TEST_CASE(multiline_function_documentation)
 	auto functions = contract->getDefinedFunctions();
 
 	BOOST_REQUIRE_NO_THROW(function = functions.at(0));
-	BOOST_CHECK_EQUAL(*function->getDocumentation(),
-					  "This is a test function\n"
-					  " and it has 2 lines");
+	checkFunctionNatspec(function, "This is a test function\n"
+						 " and it has 2 lines");
 }
 
 BOOST_AUTO_TEST_CASE(natspec_comment_in_function_body)
@@ -211,7 +222,6 @@ BOOST_AUTO_TEST_CASE(natspec_comment_in_function_body)
 					   "    mapping(address=>hash) d;\n"
 					   "    string name = \"Solidity\";"
 					   "  }\n"
-					   "  uint256 stateVar;\n"
 					   "  /// This is a test function\n"
 					   "  /// and it has 2 lines\n"
 					   "  function fun(hash hashin) returns (hash hashout) {}\n"
@@ -220,12 +230,11 @@ BOOST_AUTO_TEST_CASE(natspec_comment_in_function_body)
 	auto functions = contract->getDefinedFunctions();
 
 	BOOST_REQUIRE_NO_THROW(function = functions.at(0));
-	BOOST_CHECK_EQUAL(*function->getDocumentation(), "fun1 description");
+	checkFunctionNatspec(function, "fun1 description");
 
 	BOOST_REQUIRE_NO_THROW(function = functions.at(1));
-	BOOST_CHECK_EQUAL(*function->getDocumentation(),
-					  "This is a test function\n"
-					  " and it has 2 lines");
+	checkFunctionNatspec(function, "This is a test function\n"
+						 " and it has 2 lines");
 }
 
 BOOST_AUTO_TEST_CASE(natspec_docstring_between_keyword_and_signature)