Merge branch 'develop' into ethereumjs

libethereum/State.cpp

@@ -800,7 +800,7 @@ void State::completeMine()
 	ret.appendRaw(m_currentTxs);
 	ret.appendRaw(m_currentUncles);
 	ret.swapOut(m_currentBytes);
-	m_currentBlock.hash = sha3(m_currentBytes);
+	m_currentBlock.hash = sha3(RLP(m_currentBytes)[0].data());
 	cnote << "Mined " << m_currentBlock.hash.abridged() << "(parent: " << m_currentBlock.parentHash.abridged() << ")";
 
 	// Quickly reset the transactions.

libsolidity/AST.cpp

@@ -133,7 +133,7 @@ void ContractDefinition::checkIllegalOverrides() const
 			FunctionDefinition const*& override = functions[name];
 			if (!override)
 				override = function.get();
-			else if (override->isPublic() != function->isPublic() ||
+			else if (override->getVisibility() != function->getVisibility() ||
 					 override->isDeclaredConst() != function->isDeclaredConst() ||
 					 FunctionType(*override) != FunctionType(*function))
 				BOOST_THROW_EXCEPTION(override->createTypeError("Override changes extended function signature."));
@@ -475,6 +475,8 @@ void FunctionCall::checkTypeRequirements()
 		// number of non-mapping members
 		if (m_arguments.size() != 1)
 			BOOST_THROW_EXCEPTION(createTypeError("More than one argument for explicit type conversion."));
+		if (!m_names.empty())
+			BOOST_THROW_EXCEPTION(createTypeError("Type conversion can't allow named arguments."));
 		if (!m_arguments.front()->getType()->isExplicitlyConvertibleTo(*type.getActualType()))
 			BOOST_THROW_EXCEPTION(createTypeError("Explicit type conversion not allowed."));
 		m_type = type.getActualType();
@@ -487,9 +489,44 @@ void FunctionCall::checkTypeRequirements()
 		TypePointers const& parameterTypes = functionType->getParameterTypes();
 		if (parameterTypes.size() != m_arguments.size())
 			BOOST_THROW_EXCEPTION(createTypeError("Wrong argument count for function call."));
-		for (size_t i = 0; i < m_arguments.size(); ++i)
-			if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i]))
-				BOOST_THROW_EXCEPTION(createTypeError("Invalid type for argument in function call."));
+
+		if (m_names.empty())
+		{
+			for (size_t i = 0; i < m_arguments.size(); ++i)
+				if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i]))
+					BOOST_THROW_EXCEPTION(createTypeError("Invalid type for argument in function call."));
+		}
+		else
+		{
+			auto const& parameterNames = functionType->getParameterNames();
+			if (parameterNames.size() != m_names.size())
+				BOOST_THROW_EXCEPTION(createTypeError("Some argument names are missing."));
+
+			// check duplicate names
+			for (size_t i = 0; i < m_names.size(); i++) {
+				for (size_t j = i + 1; j < m_names.size(); j++) {
+					if (m_names[i] == m_names[j])
+						BOOST_THROW_EXCEPTION(createTypeError("Duplicate named argument."));
+				}
+			}
+
+			for (size_t i = 0; i < m_names.size(); i++) {
+				bool found = false;
+				for (size_t j = 0; j < parameterNames.size(); j++) {
+					if (parameterNames[j] == *m_names[i]) {
+						// check type convertible
+						if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[j]))
+							BOOST_THROW_EXCEPTION(createTypeError("Invalid type for argument in function call."));
+
+						found = true;
+						break;
+					}
+				}
+				if (!found)
+					BOOST_THROW_EXCEPTION(createTypeError("Named argument doesn't match function declaration."));
+			}
+		}
+
 		// @todo actually the return type should be an anonymous struct,
 		// but we change it to the type of the first return value until we have structs
 		if (functionType->getReturnParameterTypes().empty())

libsolidity/AST.h

@@ -133,12 +133,17 @@ class Declaration: public ASTNode
 {
 public:
 	enum class LValueType { NONE, LOCAL, STORAGE };
+	enum class Visibility { DEFAULT, PUBLIC, PROTECTED, PRIVATE };
 
-	Declaration(Location const& _location, ASTPointer<ASTString> const& _name):
-		ASTNode(_location), m_name(_name), m_scope(nullptr) {}
+	Declaration(Location const& _location, ASTPointer<ASTString> const& _name,
+				Visibility _visibility = Visibility::DEFAULT):
+		ASTNode(_location), m_name(_name), m_visibility(_visibility), m_scope(nullptr) {}
 
 	/// @returns the declared name.
 	ASTString const& getName() const { return *m_name; }
+	Visibility getVisibility() const { return m_visibility == Visibility::DEFAULT ? getDefaultVisibility() : m_visibility; }
+	bool isPublic() const { return getVisibility() == Visibility::PUBLIC; }
+
 	/// @returns the scope this declaration resides in. Can be nullptr if it is the global scope.
 	/// Available only after name and type resolution step.
 	Declaration const* getScope() const { return m_scope; }
@@ -151,8 +156,12 @@ public:
 	/// @returns the lvalue type of expressions referencing this declaration
 	virtual LValueType getLValueType() const { return LValueType::NONE; }
 
+protected:
+	virtual Visibility getDefaultVisibility() const { return Visibility::PUBLIC; }
+
 private:
 	ASTPointer<ASTString> m_name;
+	Visibility m_visibility;
 	Declaration const* m_scope;
 };
 
@@ -330,16 +339,15 @@ class FunctionDefinition: public Declaration, public VariableScope, public Docum
 {
 public:
 	FunctionDefinition(Location const& _location, ASTPointer<ASTString> const& _name,
-					bool _isPublic,
-					bool _isConstructor,
+					Declaration::Visibility _visibility, bool _isConstructor,
 					ASTPointer<ASTString> const& _documentation,
 					ASTPointer<ParameterList> const& _parameters,
 					bool _isDeclaredConst,
 					std::vector<ASTPointer<ModifierInvocation>> const& _modifiers,
 					ASTPointer<ParameterList> const& _returnParameters,
 					ASTPointer<Block> const& _body):
-	Declaration(_location, _name), Documented(_documentation),
-	m_isPublic(_isPublic), m_isConstructor(_isConstructor),
+	Declaration(_location, _name, _visibility), Documented(_documentation),
+	m_isConstructor(_isConstructor),
 	m_parameters(_parameters),
 	m_isDeclaredConst(_isDeclaredConst),
 	m_functionModifiers(_modifiers),
@@ -350,7 +358,6 @@ public:
 	virtual void accept(ASTVisitor& _visitor) override;
 	virtual void accept(ASTConstVisitor& _visitor) const override;
 
-	bool isPublic() const { return m_isPublic; }
 	bool isConstructor() const { return m_isConstructor; }
 	bool isDeclaredConst() const { return m_isDeclaredConst; }
 	std::vector<ASTPointer<ModifierInvocation>> const& getModifiers() const { return m_functionModifiers; }
@@ -371,7 +378,6 @@ public:
 	std::string getCanonicalSignature() const;
 
 private:
-	bool m_isPublic;
 	bool m_isConstructor;
 	ASTPointer<ParameterList> m_parameters;
 	bool m_isDeclaredConst;
@@ -388,10 +394,10 @@ class VariableDeclaration: public Declaration
 {
 public:
 	VariableDeclaration(Location const& _location, ASTPointer<TypeName> const& _type,
-						ASTPointer<ASTString> const& _name, bool _isPublic, bool _isStateVar = false,
-						bool _isIndexed = false):
-		Declaration(_location, _name), m_typeName(_type),
-		m_isPublic(_isPublic), m_isStateVariable(_isStateVar), m_isIndexed(_isIndexed) {}
+						ASTPointer<ASTString> const& _name, Visibility _visibility,
+						bool _isStateVar = false, bool _isIndexed = false):
+		Declaration(_location, _name, _visibility), m_typeName(_type),
+		m_isStateVariable(_isStateVar), m_isIndexed(_isIndexed) {}
 	virtual void accept(ASTVisitor& _visitor) override;
 	virtual void accept(ASTConstVisitor& _visitor) const override;
 
@@ -404,13 +410,14 @@ public:
 
 	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; }
 	bool isIndexed() const { return m_isIndexed; }
 
+protected:
+	Visibility getDefaultVisibility() const override { return Visibility::PROTECTED; }
+
 private:
 	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
 	bool m_isIndexed;                   ///< Whether this is an indexed variable (used by events).
 
@@ -956,14 +963,15 @@ class FunctionCall: public Expression
 {
 public:
 	FunctionCall(Location const& _location, ASTPointer<Expression> const& _expression,
-				 std::vector<ASTPointer<Expression>> const& _arguments):
-		Expression(_location), m_expression(_expression), m_arguments(_arguments) {}
+				 std::vector<ASTPointer<Expression>> const& _arguments, std::vector<ASTPointer<ASTString>> const& _names):
+		Expression(_location), m_expression(_expression), m_arguments(_arguments), m_names(_names) {}
 	virtual void accept(ASTVisitor& _visitor) override;
 	virtual void accept(ASTConstVisitor& _visitor) const override;
 	virtual void checkTypeRequirements() override;
 
 	Expression const& getExpression() const { return *m_expression; }
 	std::vector<ASTPointer<Expression const>> getArguments() const { return {m_arguments.begin(), m_arguments.end()}; }
+	std::vector<ASTPointer<ASTString>> const& getNames() const { return m_names; }
 
 	/// Returns true if this is not an actual function call, but an explicit type conversion
 	/// or constructor call.
@@ -972,6 +980,7 @@ public:
 private:
 	ASTPointer<Expression> m_expression;
 	std::vector<ASTPointer<Expression>> m_arguments;
+	std::vector<ASTPointer<ASTString>> m_names;
 };
 
 /**

libsolidity/Compiler.cpp

@@ -240,10 +240,6 @@ bool Compiler::visit(VariableDeclaration const& _variableDeclaration)
 	m_context << m_context.getFunctionEntryLabel(_variableDeclaration);
 	ExpressionCompiler::appendStateVariableAccessor(m_context, _variableDeclaration);
 
-	unsigned sizeOnStack = _variableDeclaration.getType()->getSizeOnStack();
-	solAssert(sizeOnStack <= 15, "Stack too deep.");
-	m_context << eth::dupInstruction(sizeOnStack + 1) << eth::Instruction::JUMP;
-
 	return false;
 }
 

libsolidity/ExpressionCompiler.cpp

@@ -22,6 +22,7 @@
 
 #include <utility>
 #include <numeric>
+#include <boost/range/adaptor/reversed.hpp>
 #include <libdevcore/Common.h>
 #include <libdevcrypto/SHA3.h>
 #include <libsolidity/AST.h>
@@ -194,6 +195,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 	{
 		//@todo struct construction
 		solAssert(_functionCall.getArguments().size() == 1, "");
+		solAssert(_functionCall.getNames().empty(), "");
 		Expression const& firstArgument = *_functionCall.getArguments().front();
 		firstArgument.accept(*this);
 		appendTypeConversion(*firstArgument.getType(), *_functionCall.getType());
@@ -201,8 +203,26 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
 	else
 	{
 		FunctionType const& function = dynamic_cast<FunctionType const&>(*_functionCall.getExpression().getType());
-		vector<ASTPointer<Expression const>> arguments = _functionCall.getArguments();
-		solAssert(arguments.size() == function.getParameterTypes().size(), "");
+		TypePointers const& parameterTypes = function.getParameterTypes();
+		vector<ASTPointer<Expression const>> const& callArguments = _functionCall.getArguments();
+		vector<ASTPointer<ASTString>> const& callArgumentNames = _functionCall.getNames();
+		solAssert(callArguments.size() == parameterTypes.size(), "");
+
+		vector<ASTPointer<Expression const>> arguments;
+		if (callArgumentNames.empty())
+			// normal arguments
+			arguments = callArguments;
+		else
+			// named arguments
+			for (auto const& parameterName: function.getParameterNames())
+			{
+				bool found = false;
+				for (size_t j = 0; j < callArgumentNames.size() && !found; j++)
+					if ((found = (parameterName == *callArgumentNames[j])))
+						// we found the actual parameter position
+						arguments.push_back(callArguments[j]);
+				solAssert(found, "");
+			}
 
 		switch (function.getLocation())
 		{
@@ -823,26 +843,58 @@ unsigned ExpressionCompiler::appendArgumentCopyToMemory(TypePointers const& _typ
 	return length;
 }
 
-unsigned ExpressionCompiler::appendExpressionCopyToMemory(Type const& _expectedType,
-														  Expression const& _expression, unsigned _memoryOffset)
+unsigned ExpressionCompiler::appendTypeConversionAndMoveToMemory(Type const& _expectedType, Type const& _type,
+																 Location const& _location, unsigned _memoryOffset)
 {
-	_expression.accept(*this);
-	appendTypeConversion(*_expression.getType(), _expectedType, true);
+	appendTypeConversion(_type, _expectedType, true);
 	unsigned const c_numBytes = CompilerUtils::getPaddedSize(_expectedType.getCalldataEncodedSize());
 	if (c_numBytes == 0 || c_numBytes > 32)
 		BOOST_THROW_EXCEPTION(CompilerError()
-							  << errinfo_sourceLocation(_expression.getLocation())
+							  << errinfo_sourceLocation(_location)
 							  << errinfo_comment("Type " + _expectedType.toString() + " not yet supported."));
 	bool const c_leftAligned = _expectedType.getCategory() == Type::Category::STRING;
 	bool const c_padToWords = true;
 	return CompilerUtils(m_context).storeInMemory(_memoryOffset, c_numBytes, c_leftAligned, c_padToWords);
 }
 
+unsigned ExpressionCompiler::appendExpressionCopyToMemory(Type const& _expectedType,
+														  Expression const& _expression,
+														  unsigned _memoryOffset)
+{
+	_expression.accept(*this);
+	return appendTypeConversionAndMoveToMemory(_expectedType, *_expression.getType(), _expression.getLocation(), _memoryOffset);
+}
+
 void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& _varDecl)
 {
-	m_currentLValue.fromStateVariable(_varDecl, _varDecl.getType());
-	solAssert(m_currentLValue.isInStorage(), "");
-	m_currentLValue.retrieveValue(_varDecl.getType(), Location(), true);
+	FunctionType thisType(_varDecl);
+	solAssert(thisType.getReturnParameterTypes().size() == 1, "");
+	TypePointer const& resultType = thisType.getReturnParameterTypes().front();
+	unsigned sizeOnStack;
+
+	unsigned length = 0;
+	TypePointers const& params = thisType.getParameterTypes();
+	// move arguments to memory
+	for (TypePointer const& param: boost::adaptors::reverse(params))
+		length += appendTypeConversionAndMoveToMemory(*param, *param, Location(), length);
+
+	// retrieve the position of the mapping
+	m_context << m_context.getStorageLocationOfVariable(_varDecl);
+
+	for (TypePointer const& param: params)
+	{
+		// move offset to memory
+		CompilerUtils(m_context).storeInMemory(length);
+		unsigned argLen = CompilerUtils::getPaddedSize(param->getCalldataEncodedSize());
+		length -= argLen;
+		m_context << u256(argLen + 32) << u256(length) << eth::Instruction::SHA3;
+	}
+
+	m_currentLValue = LValue(m_context, LValue::STORAGE, *resultType);
+	m_currentLValue.retrieveValue(resultType, Location(), true);
+	sizeOnStack = resultType->getSizeOnStack();
+	solAssert(sizeOnStack <= 15, "Stack too deep.");
+	m_context << eth::dupInstruction(sizeOnStack + 1) << eth::Instruction::JUMP;
 }
 
 ExpressionCompiler::LValue::LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType,

libsolidity/ExpressionCompiler.h

@@ -97,6 +97,10 @@ private:
 	unsigned appendArgumentCopyToMemory(TypePointers const& _types,
 										std::vector<ASTPointer<Expression const>> const& _arguments,
 										unsigned _memoryOffset = 0);
+	/// Appends code that copies a type to memory.
+	/// @returns the number of bytes copied to memory
+	unsigned appendTypeConversionAndMoveToMemory(Type const& _expectedType, Type const& _type,
+												 Location const& _location, unsigned _memoryOffset = 0);
 	/// Appends code that evaluates a single expression and copies it to memory (with optional offset).
 	/// @returns the number of bytes copied to memory
 	unsigned appendExpressionCopyToMemory(Type const& _expectedType, Expression const& _expression,

libsolidity/Parser.cpp

@@ -131,27 +131,19 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
 		}
 		while (m_scanner->getCurrentToken() == Token::COMMA);
 	expectToken(Token::LBRACE);
-	bool visibilityIsPublic = true;
 	while (true)
 	{
 		Token::Value currentToken = m_scanner->getCurrentToken();
 		if (currentToken == Token::RBRACE)
 			break;
-		else if (currentToken == Token::PUBLIC || currentToken == Token::PRIVATE)
-		{
-			visibilityIsPublic = (m_scanner->getCurrentToken() == Token::PUBLIC);
-			m_scanner->next();
-			expectToken(Token::COLON);
-		}
 		else if (currentToken == Token::FUNCTION)
-			functions.push_back(parseFunctionDefinition(visibilityIsPublic, name.get()));
+			functions.push_back(parseFunctionDefinition(name.get()));
 		else if (currentToken == Token::STRUCT)
 			structs.push_back(parseStructDefinition());
 		else if (currentToken == Token::IDENTIFIER || currentToken == Token::MAPPING ||
 				 Token::isElementaryTypeName(currentToken))
 		{
 			VarDeclParserOptions options;
-			options.isPublic = visibilityIsPublic;
 			options.isStateVariable = true;
 			stateVariables.push_back(parseVariableDeclaration(options));
 			expectToken(Token::SEMICOLON);
@@ -177,7 +169,7 @@ ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
 	if (m_scanner->getCurrentToken() == Token::LPAREN)
 	{
 		m_scanner->next();
-		arguments = parseFunctionCallArguments();
+		arguments = parseFunctionCallListArguments();
 		nodeFactory.markEndPosition();
 		expectToken(Token::RPAREN);
 	}
@@ -186,7 +178,22 @@ ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
 	return nodeFactory.createNode<InheritanceSpecifier>(name, arguments);
 }
 
-ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic, ASTString const* _contractName)
+Declaration::Visibility Parser::parseVisibilitySpecifier(Token::Value _token)
+{
+	Declaration::Visibility visibility;
+	if (_token == Token::PUBLIC)
+		visibility = Declaration::Visibility::PUBLIC;
+	else if (_token == Token::PROTECTED)
+		visibility = Declaration::Visibility::PROTECTED;
+	else if (_token == Token::PRIVATE)
+		visibility = Declaration::Visibility::PRIVATE;
+	else
+		solAssert(false, "Invalid visibility specifier.");
+	m_scanner->next();
+	return visibility;
+}
+
+ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const* _contractName)
 {
 	ASTNodeFactory nodeFactory(*this);
 	ASTPointer<ASTString> docstring;
@@ -201,16 +208,24 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic, A
 		name = expectIdentifierToken();
 	ASTPointer<ParameterList> parameters(parseParameterList());
 	bool isDeclaredConst = false;
+	Declaration::Visibility visibility(Declaration::Visibility::DEFAULT);
 	vector<ASTPointer<ModifierInvocation>> modifiers;
 	while (true)
 	{
-		if (m_scanner->getCurrentToken() == Token::CONST)
+		Token::Value token = m_scanner->getCurrentToken();
+		if (token == Token::CONST)
 		{
 			isDeclaredConst = true;
 			m_scanner->next();
 		}
-		else if (m_scanner->getCurrentToken() == Token::IDENTIFIER)
+		else if (token == Token::IDENTIFIER)
 			modifiers.push_back(parseModifierInvocation());
+		else if (Token::isVisibilitySpecifier(token))
+		{
+			if (visibility != Declaration::Visibility::DEFAULT)
+				BOOST_THROW_EXCEPTION(createParserError("Multiple visibility specifiers."));
+			visibility = parseVisibilitySpecifier(token);
+		}
 		else
 			break;
 	}
@@ -226,7 +241,7 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(bool _isPublic, A
 	ASTPointer<Block> block = parseBlock();
 	nodeFactory.setEndPositionFromNode(block);
 	bool const c_isConstructor = (_contractName && *name == *_contractName);
-	return nodeFactory.createNode<FunctionDefinition>(name, _isPublic, c_isConstructor, docstring,
+	return nodeFactory.createNode<FunctionDefinition>(name, visibility, c_isConstructor, docstring,
 													  parameters, isDeclaredConst, modifiers,
 													  returnParameters, block);
 }
@@ -253,14 +268,18 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(VarDeclParserOp
 	ASTNodeFactory nodeFactory(*this);
 	ASTPointer<TypeName> type = parseTypeName(_options.allowVar);
 	bool isIndexed = false;
-	if (_options.allowIndexed && m_scanner->getCurrentToken() == Token::INDEXED)
+	Token::Value token = m_scanner->getCurrentToken();
+	if (_options.allowIndexed && token == Token::INDEXED)
 	{
 		isIndexed = true;
 		m_scanner->next();
 	}
+	Declaration::Visibility visibility(Declaration::Visibility::DEFAULT);
+	if (_options.isStateVariable && Token::isVisibilitySpecifier(token))
+		visibility = parseVisibilitySpecifier(token);
 	nodeFactory.markEndPosition();
 	return nodeFactory.createNode<VariableDeclaration>(type, expectIdentifierToken(),
-													   _options.isPublic, _options.isStateVariable,
+													   visibility, _options.isStateVariable,
 													   isIndexed);
 }
 
@@ -313,7 +332,7 @@ ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
 	if (m_scanner->getCurrentToken() == Token::LPAREN)
 	{
 		m_scanner->next();
-		arguments = parseFunctionCallArguments();
+		arguments = parseFunctionCallListArguments();
 		nodeFactory.markEndPosition();
 		expectToken(Token::RPAREN);
 	}
@@ -573,7 +592,6 @@ ASTPointer<Expression> Parser::parseBinaryExpression(int _minPrecedence)
 	ASTPointer<Expression> expression = parseUnaryExpression();
 	int precedence = Token::precedence(m_scanner->getCurrentToken());
 	for (; precedence >= _minPrecedence; --precedence)
-	{
 		while (Token::precedence(m_scanner->getCurrentToken()) == precedence)
 		{
 			Token::Value op = m_scanner->getCurrentToken();
@@ -582,7 +600,6 @@ ASTPointer<Expression> Parser::parseBinaryExpression(int _minPrecedence)
 			nodeFactory.setEndPositionFromNode(right);
 			expression = nodeFactory.createNode<BinaryOperation>(expression, op, right);
 		}
-	}
 	return expression;
 }
 
@@ -648,10 +665,12 @@ ASTPointer<Expression> Parser::parseLeftHandSideExpression()
 		case Token::LPAREN:
 		{
 			m_scanner->next();
-			vector<ASTPointer<Expression>> arguments = parseFunctionCallArguments();
+			vector<ASTPointer<Expression>> arguments;
+			vector<ASTPointer<ASTString>> names;
+			std::tie(arguments, names) = parseFunctionCallArguments();
 			nodeFactory.markEndPosition();
 			expectToken(Token::RPAREN);
-			expression = nodeFactory.createNode<FunctionCall>(expression, arguments);
+			expression = nodeFactory.createNode<FunctionCall>(expression, arguments, names);
 		}
 		break;
 		default:
@@ -704,7 +723,7 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
 	return expression;
 }
 
-vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments()
+vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments()
 {
 	vector<ASTPointer<Expression>> arguments;
 	if (m_scanner->getCurrentToken() != Token::RPAREN)
@@ -719,6 +738,32 @@ vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments()
 	return arguments;
 }
 
+pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::parseFunctionCallArguments()
+{
+	pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> ret;
+	Token::Value token = m_scanner->getCurrentToken();
+	if (token == Token::LBRACE)
+	{
+		// call({arg1 : 1, arg2 : 2 })
+		expectToken(Token::LBRACE);
+		while (m_scanner->getCurrentToken() != Token::RBRACE)
+		{
+			ret.second.push_back(expectIdentifierToken());
+			expectToken(Token::COLON);
+			ret.first.push_back(parseExpression());
+
+			if (m_scanner->getCurrentToken() == Token::COMMA)
+				expectToken(Token::COMMA);
+			else
+				break;
+		}
+		expectToken(Token::RBRACE);
+	}
+	else
+		ret.first = parseFunctionCallListArguments();
+	return ret;
+}
+
 
 bool Parser::peekVariableDefinition()
 {

libsolidity/Parser.h

@@ -48,7 +48,6 @@ private:
 	struct VarDeclParserOptions {
 		VarDeclParserOptions() {}
 		bool allowVar = false;
-		bool isPublic = false;
 		bool isStateVariable = false;
 		bool allowIndexed = false;
 	};
@@ -58,7 +57,8 @@ private:
 	ASTPointer<ImportDirective> parseImportDirective();
 	ASTPointer<ContractDefinition> parseContractDefinition();
 	ASTPointer<InheritanceSpecifier> parseInheritanceSpecifier();
-	ASTPointer<FunctionDefinition> parseFunctionDefinition(bool _isPublic, ASTString const* _contractName);
+	Declaration::Visibility parseVisibilitySpecifier(Token::Value _token);
+	ASTPointer<FunctionDefinition> parseFunctionDefinition(ASTString const* _contractName);
 	ASTPointer<StructDefinition> parseStructDefinition();
 	ASTPointer<VariableDeclaration> parseVariableDeclaration(VarDeclParserOptions const& _options = VarDeclParserOptions());
 	ASTPointer<ModifierDefinition> parseModifierDefinition();
@@ -81,7 +81,8 @@ private:
 	ASTPointer<Expression> parseUnaryExpression();
 	ASTPointer<Expression> parseLeftHandSideExpression();
 	ASTPointer<Expression> parsePrimaryExpression();
-	std::vector<ASTPointer<Expression>> parseFunctionCallArguments();
+	std::vector<ASTPointer<Expression>> parseFunctionCallListArguments();
+	std::pair<std::vector<ASTPointer<Expression>>, std::vector<ASTPointer<ASTString>>> parseFunctionCallArguments();
 	///@}
 
 	///@{

libsolidity/Token.h

@@ -165,6 +165,7 @@ namespace solidity
 	K(NEW, "new", 0)                                                   \
 	K(PUBLIC, "public", 0)                                             \
 	K(PRIVATE, "private", 0)                                           \
+	K(PROTECTED, "protected", 0)                                       \
 	K(RETURN, "return", 0)                                             \
 	K(RETURNS, "returns", 0)                                           \
 	K(STRUCT, "struct", 0)                                             \
@@ -376,6 +377,7 @@ public:
 	static bool isUnaryOp(Value op) { return (NOT <= op && op <= DELETE) || op == ADD || op == SUB; }
 	static bool isCountOp(Value op) { return op == INC || op == DEC; }
 	static bool isShiftOp(Value op) { return (SHL <= op) && (op <= SHR); }
+	static bool isVisibilitySpecifier(Value op) { return op == PUBLIC || op == PRIVATE || op == PROTECTED; }
 
 	// Returns a string corresponding to the JS token string
 	// (.e., "<" for the token LT) or NULL if the token doesn't

libsolidity/Types.cpp

@@ -621,11 +621,24 @@ FunctionType::FunctionType(FunctionDefinition const& _function, bool _isInternal
 FunctionType::FunctionType(VariableDeclaration const& _varDecl):
 	m_location(Location::EXTERNAL), m_isConstant(true), m_declaration(&_varDecl)
 {
-	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
+	TypePointers params;
+	vector<string> paramNames;
+	TypePointers retParams;
+	vector<string> retParamNames;
+	TypePointer varDeclType = _varDecl.getType();
+	auto mappingType = dynamic_cast<MappingType const*>(varDeclType.get());
+	auto returnType = varDeclType;
+
+	while (mappingType != nullptr)
+	{
+		params.push_back(mappingType->getKeyType());
+		paramNames.push_back("");
+		returnType = mappingType->getValueType();
+		mappingType = dynamic_cast<MappingType const*>(mappingType->getValueType().get());
+	}
+
+	retParams.push_back(returnType);
+	retParamNames.push_back("");
 
 	swap(params, m_parameterTypes);
 	swap(paramNames, m_parameterNames);

libsolidity/grammar.txt

@@ -1,14 +1,15 @@
 ContractDefinition = 'contract' Identifier
                      ( 'is' InheritanceSpecifier (',' InheritanceSpecifier )* )?
                      '{' ContractPart* '}'
-ContractPart = VariableDeclaration ';' | StructDefinition | ModifierDefinition |
-               FunctionDefinition | 'public:' | 'private:'
+ContractPart = StateVariableDeclaration | StructDefinition | ModifierDefinition | FunctionDefinition
 
 InheritanceSpecifier = Identifier ( '(' Expression ( ',' Expression )* ')' )?
 StructDefinition = 'struct' Identifier '{'
                      ( VariableDeclaration (';' VariableDeclaration)* )? '}
+StateVariableDeclaration = TypeName ( 'public' | 'protected' | 'private' )? Identifier ';'
 ModifierDefinition = 'modifier' Identifier ParameterList? Block
-FunctionDefinition = 'function' Identifier ParameterList ( Identifier | 'constant' )*
+FunctionDefinition = 'function' Identifier ParameterList
+                     ( Identifier | 'constant' | 'public' | 'protected' | 'private' )*
                      ( 'returns' ParameterList )? Block
 ParameterList = '(' ( VariableDeclaration (',' VariableDeclaration)* )? ')'
 // semantic restriction: mappings and structs (recursively) containing mappings

mix/qml/StateDialog.qml

@@ -33,9 +33,10 @@ Window {
 			transactionsModel.append(item.transactions[t]);
 			stateTransactions.push(item.transactions[t]);
 		}
-		isDefault = setDefault;
 		visible = true;
+		isDefault = setDefault;
 		titleField.focus = true;
+		defaultCheckBox.enabled = !isDefault;
 	}
 
 	function close() {
@@ -167,6 +168,7 @@ Window {
 					onClicked: transactionsModel.editTransaction(index)
 				}
 				ToolButton {
+					visible: index >= 0 ? !transactionsModel.get(index).executeConstructor : false
 					text: qsTr("Delete");
 					Layout.fillHeight: true
 					onClicked: transactionsModel.deleteTransaction(index)

mix/qml/StateList.qml

@@ -48,6 +48,7 @@ Rectangle {
 					onClicked: list.model.editState(index);
 				}
 				ToolButton {
+					visible: list.model.count - 1 != index
 					text: qsTr("Delete");
 					Layout.fillHeight: true
 					onClicked: list.model.deleteState(index);

mix/qml/StateListModel.qml

@@ -8,7 +8,7 @@ import "js/QEtherHelper.js" as QEtherHelper
 
 Item {
 
-	property int defaultStateIndex: -1
+	property int defaultStateIndex: 0
 	property alias model: stateListModel
 	property var stateList: []
 
@@ -105,20 +105,7 @@ Item {
 			stateListModel.clear();
 			stateList = [];
 		}
-		onProjectLoading: {
-			if (!projectData.states)
-				projectData.states = [];
-			if (projectData.defaultStateIndex !== undefined)
-				defaultStateIndex = projectData.defaultStateIndex;
-			else
-				defaultStateIndex = -1;
-			var items = projectData.states;
-			for(var i = 0; i < items.length; i++) {
-				var item = fromPlainStateItem(items[i]);
-				stateListModel.append(item);
-				stateList.push(item);
-			}
-		}
+		onProjectLoading: stateListModel.loadStatesFromProject(projectData);
 		onProjectSaving: {
 			projectData.states = []
 			for(var i = 0; i < stateListModel.count; i++) {
@@ -149,7 +136,8 @@ Item {
 				stateList.push(item);
 				stateListModel.append(item);
 			}
-
+			if (stateDialog.isDefault)
+				stateListModel.defaultStateChanged();
 			stateListModel.save();
 		}
 	}
@@ -161,6 +149,9 @@ Item {
 	ListModel {
 		id: stateListModel
 
+		signal defaultStateChanged;
+		signal stateListModelReady;
+
 		function defaultTransactionItem() {
 			return {
 				value: QEtherHelper.createEther("100", QEther.Wei),
@@ -199,7 +190,7 @@ Item {
 
 		function addState() {
 			var item = createDefaultState();
-			stateDialog.open(stateListModel.count, item, defaultStateIndex === -1);
+			stateDialog.open(stateListModel.count, item, false);
 		}
 
 		function editState(index) {
@@ -220,12 +211,37 @@ Item {
 			stateListModel.remove(index);
 			stateList.splice(index, 1);
 			if (index === defaultStateIndex)
-				defaultStateIndex = -1;
+			{
+				defaultStateIndex = 0;
+				defaultStateChanged();
+			}
 			save();
 		}
 
 		function save() {
 			projectModel.saveProject();
 		}
+
+		function defaultStateName()
+		{
+			return stateList[defaultStateIndex].title;
+		}
+
+		function loadStatesFromProject(projectData)
+		{
+			if (!projectData.states)
+				projectData.states = [];
+			if (projectData.defaultStateIndex !== undefined)
+				defaultStateIndex = projectData.defaultStateIndex;
+			else
+				defaultStateIndex = 0;
+			var items = projectData.states;
+			for(var i = 0; i < items.length; i++) {
+				var item = fromPlainStateItem(items[i]);
+				stateListModel.append(item);
+				stateList.push(item);
+			}
+			stateListModelReady();
+		}
 	}
 }

mix/qml/main.qml

@@ -34,7 +34,7 @@ ApplicationWindow {
 			MenuItem { action: exitAppAction }
 		}
 		Menu {
-			title: qsTr("Debug")
+			title: qsTr("Deploy")
 			MenuItem { action: debugRunAction }
 			MenuItem { action: mineAction }
 			MenuSeparator {}
@@ -89,9 +89,22 @@ ApplicationWindow {
 		onTriggered: clientModel.mine();
 		enabled: codeModel.hasContract && !clientModel.running
 	}
+
+	Connections {
+		target: projectModel.stateListModel
+
+		function updateRunLabel()
+		{
+			debugRunAction.text = qsTr("Deploy") + " \"" + projectModel.stateListModel.defaultStateName() + "\"";
+		}
+
+		onDefaultStateChanged: updateRunLabel()
+		onStateListModelReady: updateRunLabel()
+	}
+
 	Action {
 		id: debugRunAction
-		text: qsTr("Run")
+		text: qsTr("Deploy")
 		shortcut: "F5"
 		onTriggered: mainContent.startQuickDebugging()
 		enabled: codeModel.hasContract && !clientModel.running

test/SolidityEndToEndTest.cpp

@@ -885,7 +885,7 @@ BOOST_AUTO_TEST_CASE(constructor)
 BOOST_AUTO_TEST_CASE(simple_accessor)
 {
 	char const* sourceCode = "contract test {\n"
-							 "  uint256 data;\n"
+							 "  uint256 public data;\n"
 							 "  function test() {\n"
 							 "    data = 8;\n"
 							 "  }\n"
@@ -897,10 +897,10 @@ BOOST_AUTO_TEST_CASE(simple_accessor)
 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"
+							 "  uint256 public data;\n"
+							 "  string6 public name;\n"
+							 "  hash public a_hash;\n"
+							 "  address public an_address;\n"
 							 "  function test() {\n"
 							 "    data = 8;\n"
 							 "    name = \"Celina\";\n"
@@ -908,7 +908,6 @@ BOOST_AUTO_TEST_CASE(multiple_elementary_accessors)
 							 "    an_address = address(0x1337);\n"
 							 "    super_secret_data = 42;\n"
 							 "  }\n"
-							 "  private:"
 							 "  uint256 super_secret_data;"
 							 "}\n";
 	compileAndRun(sourceCode);
@@ -919,6 +918,27 @@ BOOST_AUTO_TEST_CASE(multiple_elementary_accessors)
 	BOOST_CHECK(callContractFunction("super_secret_data()") == bytes());
 }
 
+BOOST_AUTO_TEST_CASE(complex_accessors)
+{
+	char const* sourceCode = "contract test {\n"
+							 "  mapping(uint256 => string4) to_string_map;\n"
+							 "  mapping(uint256 => bool) to_bool_map;\n"
+							 "  mapping(uint256 => uint256) to_uint_map;\n"
+							 "  mapping(uint256 => mapping(uint256 => uint256)) to_multiple_map;\n"
+							 "  function test() {\n"
+							 "    to_string_map[42] = \"24\";\n"
+							 "    to_bool_map[42] = false;\n"
+							 "    to_uint_map[42] = 12;\n"
+							 "    to_multiple_map[42][23] = 31;\n"
+							 "  }\n"
+							 "}\n";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("to_string_map(uint256)", 42) == encodeArgs("24"));
+	BOOST_CHECK(callContractFunction("to_bool_map(uint256)", 42) == encodeArgs(false));
+	BOOST_CHECK(callContractFunction("to_uint_map(uint256)", 42) == encodeArgs(12));
+	BOOST_CHECK(callContractFunction("to_multiple_map(uint256,uint256)", 42, 23) == encodeArgs(31));
+}
+
 BOOST_AUTO_TEST_CASE(balance)
 {
 	char const* sourceCode = "contract test {\n"
@@ -1490,8 +1510,7 @@ BOOST_AUTO_TEST_CASE(functions_called_by_constructor)
 				setName("abc");
 			}
 			function getName() returns (string3 ret) { return name; }
-		private:
-			function setName(string3 _name) { name = _name; }
+			function setName(string3 _name) private { name = _name; }
 		})";
 	compileAndRun(sourceCode);
 	BOOST_REQUIRE(callContractFunction("getName()") == encodeArgs("abc"));

test/SolidityNameAndTypeResolution.cpp

@@ -467,6 +467,24 @@ BOOST_AUTO_TEST_CASE(illegal_override_indirect)
 	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
 }
 
+BOOST_AUTO_TEST_CASE(illegal_override_visibility)
+{
+	char const* text = R"(
+		contract B { function f() protected {} }
+		contract C is B { function f() public {} }
+	)";
+	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
+}
+
+BOOST_AUTO_TEST_CASE(illegal_override_constness)
+{
+	char const* text = R"(
+		contract B { function f() constant {} }
+		contract C is B { function f() {} }
+	)";
+	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
+}
+
 BOOST_AUTO_TEST_CASE(complex_inheritance)
 {
 	char const* text = R"(
@@ -636,7 +654,9 @@ BOOST_AUTO_TEST_CASE(state_variable_accessors)
 					   "  function fun() {\n"
 					   "    uint64(2);\n"
 					   "  }\n"
-					   "uint256 foo;\n"
+					   "uint256 public foo;\n"
+					   "mapping(uint=>string4) public map;\n"
+					   "mapping(uint=>mapping(uint=>string4)) public multiple_map;\n"
 					   "}\n";
 
 	ASTPointer<SourceUnit> source;
@@ -644,10 +664,27 @@ BOOST_AUTO_TEST_CASE(state_variable_accessors)
 	BOOST_CHECK_NO_THROW(source = parseTextAndResolveNamesWithChecks(text));
 	BOOST_REQUIRE((contract = retrieveContract(source, 0)) != nullptr);
 	FunctionTypePointer function = retrieveFunctionBySignature(contract, "foo()");
-	BOOST_REQUIRE(function->hasDeclaration());
+	BOOST_REQUIRE(function && function->hasDeclaration());
 	auto returnParams = function->getReturnParameterTypeNames();
 	BOOST_CHECK_EQUAL(returnParams.at(0), "uint256");
 	BOOST_CHECK(function->isConstant());
+
+	function = retrieveFunctionBySignature(contract, "map(uint256)");
+	BOOST_REQUIRE(function && function->hasDeclaration());
+	auto params = function->getParameterTypeNames();
+	BOOST_CHECK_EQUAL(params.at(0), "uint256");
+	returnParams = function->getReturnParameterTypeNames();
+	BOOST_CHECK_EQUAL(returnParams.at(0), "string4");
+	BOOST_CHECK(function->isConstant());
+
+	function = retrieveFunctionBySignature(contract, "multiple_map(uint256,uint256)");
+	BOOST_REQUIRE(function && function->hasDeclaration());
+	params = function->getParameterTypeNames();
+	BOOST_CHECK_EQUAL(params.at(0), "uint256");
+	BOOST_CHECK_EQUAL(params.at(1), "uint256");
+	returnParams = function->getReturnParameterTypeNames();
+	BOOST_CHECK_EQUAL(returnParams.at(0), "string4");
+	BOOST_CHECK(function->isConstant());
 }
 
 BOOST_AUTO_TEST_CASE(function_clash_with_state_variable_accessor)
@@ -668,16 +705,19 @@ BOOST_AUTO_TEST_CASE(private_state_variable)
 					   "  function fun() {\n"
 					   "    uint64(2);\n"
 					   "  }\n"
-					   "private:\n"
-					   "uint256 foo;\n"
+					   "uint256 private foo;\n"
+					   "uint256 protected bar;\n"
 					   "}\n";
 
 	ASTPointer<SourceUnit> source;
 	ContractDefinition const* contract;
 	BOOST_CHECK_NO_THROW(source = parseTextAndResolveNamesWithChecks(text));
 	BOOST_CHECK((contract = retrieveContract(source, 0)) != nullptr);
-	FunctionTypePointer function = retrieveFunctionBySignature(contract, "foo()");
+	FunctionTypePointer function;
+	function = retrieveFunctionBySignature(contract, "foo()");
 	BOOST_CHECK_MESSAGE(function == nullptr, "Accessor function of a private variable should not exist");
+	function = retrieveFunctionBySignature(contract, "bar()");
+	BOOST_CHECK_MESSAGE(function == nullptr, "Accessor function of a protected variable should not exist");
 }
 
 BOOST_AUTO_TEST_CASE(fallback_function)
@@ -780,6 +820,54 @@ BOOST_AUTO_TEST_CASE(multiple_events_argument_clash)
 	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
 }
 
+BOOST_AUTO_TEST_CASE(access_to_default_function_visibility)
+{
+	char const* text = R"(
+		contract c {
+			function f() {}
+		}
+		contract d {
+			function g() { c(0).f(); }
+		})";
+	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
+}
+
+BOOST_AUTO_TEST_CASE(access_to_protected_function)
+{
+	char const* text = R"(
+		contract c {
+			function f() protected {}
+		}
+		contract d {
+			function g() { c(0).f(); }
+		})";
+	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
+}
+
+BOOST_AUTO_TEST_CASE(access_to_default_state_variable_visibility)
+{
+	char const* text = R"(
+		contract c {
+			uint a;
+		}
+		contract d {
+			function g() { c(0).a(); }
+		})";
+	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
+}
+
+BOOST_AUTO_TEST_CASE(access_to_protected_state_variable)
+{
+	char const* text = R"(
+		contract c {
+			uint public a;
+		}
+		contract d {
+			function g() { c(0).a(); }
+		})";
+	BOOST_CHECK_NO_THROW(parseTextAndResolveNames(text));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }

test/SolidityParser.cpp

@@ -129,9 +129,7 @@ BOOST_AUTO_TEST_CASE(function_natspec_documentation)
 	ASTPointer<ContractDefinition> contract;
 	ASTPointer<FunctionDefinition> function;
 	char const* text = "contract test {\n"
-					   "  private:\n"
-	                   "  uint256 stateVar;\n"
-	                   "  public:\n"
+					   "  uint256 stateVar;\n"
 					   "  /// This is a test function\n"
 					   "  function functionName(hash hashin) returns (hash hashout) {}\n"
 					   "}\n";
@@ -162,9 +160,7 @@ 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"
@@ -621,6 +617,31 @@ BOOST_AUTO_TEST_CASE(event_arguments_indexed)
 	BOOST_CHECK_NO_THROW(parseText(text));
 }
 
+BOOST_AUTO_TEST_CASE(visibility_specifiers)
+{
+	char const* text = R"(
+		contract c {
+			uint private a;
+			uint protected b;
+			uint public c;
+			uint d;
+			function f() {}
+			function f_priv() private {}
+			function f_public() public {}
+			function f_protected() protected {}
+		})";
+	BOOST_CHECK_NO_THROW(parseText(text));
+}
+
+BOOST_AUTO_TEST_CASE(multiple_visibility_specifiers)
+{
+	char const* text = R"(
+		contract c {
+			uint private protected a;
+		})";
+	BOOST_CHECK_THROW(parseText(text), ParserError);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }