diff --git a/libsolidity/AST.cpp b/libsolidity/AST.cpp
index b07959b39..6028c07cf 100644
--- a/libsolidity/AST.cpp
+++ b/libsolidity/AST.cpp
@@ -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())
diff --git a/libsolidity/AST.h b/libsolidity/AST.h
index 8e8641c78..525907bf4 100755
--- a/libsolidity/AST.h
+++ b/libsolidity/AST.h
@@ -963,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.
@@ -979,6 +980,7 @@ public:
 private:
 	ASTPointer<Expression> m_expression;
 	std::vector<ASTPointer<Expression>> m_arguments;
+	std::vector<ASTPointer<ASTString>> m_names;
 };
 
 /**
diff --git a/libsolidity/ExpressionCompiler.cpp b/libsolidity/ExpressionCompiler.cpp
index 45e0e80b0..875e00bc2 100644
--- a/libsolidity/ExpressionCompiler.cpp
+++ b/libsolidity/ExpressionCompiler.cpp
@@ -195,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());
@@ -202,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())
 		{
diff --git a/libsolidity/Parser.cpp b/libsolidity/Parser.cpp
index cc75fc0a2..0ad7bd7ca 100644
--- a/libsolidity/Parser.cpp
+++ b/libsolidity/Parser.cpp
@@ -169,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);
 	}
@@ -332,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);
 	}
@@ -592,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();
@@ -601,7 +600,6 @@ ASTPointer<Expression> Parser::parseBinaryExpression(int _minPrecedence)
 			nodeFactory.setEndPositionFromNode(right);
 			expression = nodeFactory.createNode<BinaryOperation>(expression, op, right);
 		}
-	}
 	return expression;
 }
 
@@ -667,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:
@@ -723,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)
@@ -738,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()
 {
diff --git a/libsolidity/Parser.h b/libsolidity/Parser.h
index 388fd7a96..19e0af1aa 100644
--- a/libsolidity/Parser.h
+++ b/libsolidity/Parser.h
@@ -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();
 	///@}
 
 	///@{