cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Also check the object type for bound functions.

Browse Source
This commit is contained in:
chriseth 2015-11-27 22:24:00 +01:00
parent 93b3237c6a
commit f9e52c9db1
5 changed files with 68 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
libsolidity/analysis/TypeChecker.cpp
View File

@ -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)

4
libsolidity/ast/AST_accept.h
View File

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

5
libsolidity/ast/Types.cpp
View File

@ -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;

4
libsolidity/ast/Types.h
View File

@ -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;

45
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -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"(