Also check the object type for bound functions.

libsolidity/analysis/TypeChecker.cpp

@@ -1128,7 +1128,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 		for (auto it = possibleMembers.begin(); it != possibleMembers.end();)
 			if (
 				it->type->category() == Type::Category::Function &&
-				!dynamic_cast<FunctionType const&>(*it->type).canTakeArguments(*argumentTypes)
+				!dynamic_cast<FunctionType const&>(*it->type).canTakeArguments(*argumentTypes, exprType)
 			)
 				it = possibleMembers.erase(it);
 			else
@@ -1163,6 +1163,15 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 	auto& annotation = _memberAccess.annotation();
 	annotation.referencedDeclaration = possibleMembers.front().declaration;
 	annotation.type = possibleMembers.front().type;
+
+	if (auto funType = dynamic_cast<FunctionType const*>(annotation.type.get()))
+		if (funType->bound() && !exprType->isImplicitlyConvertibleTo(*funType->selfType()))
+			typeError(
+				_memberAccess.location(),
+				"Function \"" + memberName + "\" cannot be called on an object of type " +
+				exprType->toString() + " (expected " + funType->selfType()->toString() + ")"
+			);
+
 	if (exprType->category() == Type::Category::Struct)
 		annotation.isLValue = true;
 	else if (exprType->category() == Type::Category::Array)

libsolidity/ast/AST_accept.h

@@ -127,9 +127,9 @@ void UsingForDirective::accept(ASTVisitor& _visitor)
 {
 	if (_visitor.visit(*this))
 	{
-		if (m_libraryName)
+		m_libraryName->accept(_visitor);
-			m_libraryName->accept(_visitor);
+		if (m_typeName)
-		m_typeName->accept(_visitor);
+			m_typeName->accept(_visitor);
 	}
 	_visitor.endVisit(*this);
 }
@@ -138,9 +138,9 @@ void UsingForDirective::accept(ASTConstVisitor& _visitor) const
 {
 	if (_visitor.visit(*this))
 	{
-		if (m_libraryName)
+		m_libraryName->accept(_visitor);
-			m_libraryName->accept(_visitor);
+		if (m_typeName)
-		m_typeName->accept(_visitor);
+			m_typeName->accept(_visitor);
 	}
 	_visitor.endVisit(*this);
 }

libsolidity/ast/Types.cpp

@@ -1640,8 +1640,11 @@ MemberList::MemberMap FunctionType::nativeMembers(ContractDefinition const*) con
 	}
 }
 
-bool FunctionType::canTakeArguments(TypePointers const& _argumentTypes) const
+bool FunctionType::canTakeArguments(TypePointers const& _argumentTypes, TypePointer const& _selfType) const
 {
+	solAssert(!bound() || _selfType, "");
+	if (bound() && !_selfType->isImplicitlyConvertibleTo(*selfType()))
+		return false;
 	TypePointers paramTypes = parameterTypes();
 	if (takesArbitraryParameters())
 		return true;

libsolidity/ast/Types.h

@@ -829,7 +829,9 @@ public:
 
 	/// @returns true if this function can take the given argument types (possibly
 	/// after implicit conversion).
-	bool canTakeArguments(TypePointers const& _arguments) const;
+	/// @param _selfType if the function is bound, this has to be supplied and is the type of the
+	/// expression the function is called on.
+	bool canTakeArguments(TypePointers const& _arguments, TypePointer const& _selfType = TypePointer()) const;
 	/// @returns true if the types of parameters are equal (does't check return parameter types)
 	bool hasEqualArgumentTypes(FunctionType const& _other) const;
 

test/libsolidity/SolidityNameAndTypeResolution.cpp

@@ -2628,6 +2628,51 @@ BOOST_AUTO_TEST_CASE(using_for_by_name)
 	BOOST_CHECK(success(text));
 }
 
+BOOST_AUTO_TEST_CASE(using_for_mismatch)
+{
+	char const* text = R"(
+		library D { function double(bytes32 self) returns (uint) { return 2; } }
+		contract C {
+			using D for uint;
+			function f(uint a) returns (uint) {
+				return a.double();
+			}
+		}
+	)";
+	BOOST_CHECK(expectError(text) == Error::Type::TypeError);
+}
+
+BOOST_AUTO_TEST_CASE(using_for_not_used)
+{
+	// This is an error because the function is only bound to uint.
+	// Had it been bound to *, it would have worked.
+	char const* text = R"(
+		library D { function double(uint self) returns (uint) { return 2; } }
+		contract C {
+			using D for uint;
+			function f(uint16 a) returns (uint) {
+				return a.double();
+			}
+		}
+	)";
+	BOOST_CHECK(expectError(text) == Error::Type::TypeError);
+}
+
+BOOST_AUTO_TEST_CASE(using_for_arbitrary_mismatch)
+{
+	// Bound to a, but self type does not match.
+	char const* text = R"(
+		library D { function double(bytes32 self) returns (uint) { return 2; } }
+		contract C {
+			using D for *;
+			function f(uint a) returns (uint) {
+				return a.double();
+			}
+		}
+	)";
+	BOOST_CHECK(expectError(text) == Error::Type::TypeError);
+}
+
 BOOST_AUTO_TEST_CASE(bound_function_in_var)
 {
 	char const* text = R"(