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

Rename unctionType::bound() to unctionType::boundToType()

Browse Source
This commit is contained in:
wechman 2022-08-30 11:53:02 +02:00
parent c5640fb125
commit 697d279165
8 changed files with 44 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libsolidity/analysis/TypeChecker.cpp
View File

@ -3246,7 +3246,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
if (auto funType = dynamic_cast<FunctionType const*>(annotation.type))
{
solAssert(
!funType->bound() || exprType->isImplicitlyConvertibleTo(*funType->selfType()),
!funType->boundToType() || exprType->isImplicitlyConvertibleTo(*funType->selfType()),
"Function \"" + memberName + "\" cannot be called on an object of type " +
exprType->humanReadableName() + " (expected " + funType->selfType()->humanReadableName() + ")."
);
@ -3273,7 +3273,7 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
"Storage arrays with nested mappings do not support .push(<arg>)."
);
if (!funType->bound())
if (!funType->boundToType())
if (auto typeType = dynamic_cast<TypeType const*>(exprType))
{
auto contractType = dynamic_cast<ContractType const*>(typeType->actualType());

2
libsolidity/ast/TypeProvider.cpp
View File

@ -450,7 +450,7 @@ FunctionType const* TypeProvider::function(
)
{
// Can only use this constructor for "arbitraryParameters".
solAssert(!_options.valueSet && !_options.gasSet && !_options.saltSet && !_options.bound);
solAssert(!_options.valueSet && !_options.gasSet && !_options.saltSet && !_options.boundToType);
return createAndGet<FunctionType>(
_parameterTypes,
_returnParameterTypes,

32
libsolidity/ast/Types.cpp
View File

@ -3004,7 +3004,7 @@ FunctionTypePointer FunctionType::newExpressionType(ContractDefinition const& _c
vector<string> FunctionType::parameterNames() const
{
if (!bound())
if (!boundToType())
return m_parameterNames;
return vector<string>(m_parameterNames.cbegin() + 1, m_parameterNames.cend());
}
@ -3033,7 +3033,7 @@ TypePointers FunctionType::returnParameterTypesWithoutDynamicTypes() const
TypePointers FunctionType::parameterTypes() const
{
if (!bound())
if (!boundToType())
return m_parameterTypes;
return TypePointers(m_parameterTypes.cbegin() + 1, m_parameterTypes.cend());
}
@ -3098,7 +3098,7 @@ string FunctionType::richIdentifier() const
id += "value";
if (saltSet())
id += "salt";
if (bound())
if (boundToType())
id += "bound_to" + identifierList(selfType());
return id;
}
@ -3133,7 +3133,7 @@ BoolResult FunctionType::isImplicitlyConvertibleTo(Type const& _convertTo) const
FunctionType const& convertTo = dynamic_cast<FunctionType const&>(_convertTo);
// These two checks are duplicated in equalExcludingStateMutability, but are added here for error reporting.
if (convertTo.bound() != bound())
if (convertTo.boundToType() != boundToType())
return BoolResult::err("Bound functions can not be converted to non-bound functions.");
if (convertTo.kind() != kind())
@ -3174,10 +3174,10 @@ TypeResult FunctionType::binaryOperatorResult(Token _operator, Type const* _othe
else if (
kind() == Kind::External &&
sizeOnStack() == 2 &&
!bound() &&
!boundToType() &&
other.kind() == Kind::External &&
other.sizeOnStack() == 2 &&
!other.bound()
!other.boundToType()
)
return commonType(this, _other);
@ -3262,7 +3262,7 @@ bool FunctionType::nameable() const
{
return
(m_kind == Kind::Internal || m_kind == Kind::External) &&
!bound() &&
!boundToType() &&
!takesArbitraryParameters() &&
!gasSet() &&
!valueSet() &&
@ -3301,7 +3301,7 @@ vector<tuple<string, Type const*>> FunctionType::makeStackItems() const
break;
case Kind::ArrayPush:
case Kind::ArrayPop:
solAssert(bound(), "");
solAssert(boundToType(), "");
slots = {};
break;
default:
@ -3314,7 +3314,7 @@ vector<tuple<string, Type const*>> FunctionType::makeStackItems() const
slots.emplace_back("value", TypeProvider::uint256());
if (saltSet())
slots.emplace_back("salt", TypeProvider::fixedBytes(32));
if (bound())
if (boundToType())
slots.emplace_back("self", m_parameterTypes.front());
return slots;
}
@ -3475,7 +3475,7 @@ TypeResult FunctionType::interfaceType(bool /*_inLibrary*/) const
Type const* FunctionType::mobileType() const
{
if (valueSet() || gasSet() || saltSet() || bound())
if (valueSet() || gasSet() || saltSet() || boundToType())
return nullptr;
// return function without parameter names
@ -3496,8 +3496,8 @@ bool FunctionType::canTakeArguments(
Type const* _selfType
) const
{
solAssert(!bound() || _selfType, "");
if (bound() && !_selfType->isImplicitlyConvertibleTo(*selfType()))
solAssert(!boundToType() || _selfType, "");
if (boundToType() && !_selfType->isImplicitlyConvertibleTo(*selfType()))
return false;
TypePointers paramTypes = parameterTypes();
std::vector<std::string> const paramNames = parameterNames();
@ -3576,10 +3576,10 @@ bool FunctionType::equalExcludingStateMutability(FunctionType const& _other) con
if (gasSet() != _other.gasSet() || valueSet() != _other.valueSet() || saltSet() != _other.saltSet())
return false;
if (bound() != _other.bound())
if (boundToType() != _other.boundToType())
return false;
solAssert(!bound() || *selfType() == *_other.selfType(), "");
solAssert(!boundToType() || *selfType() == *_other.selfType(), "");
return true;
}
@ -3707,7 +3707,7 @@ FunctionTypePointer FunctionType::asBoundFunction() const
solAssert(!valueSet(), "");
solAssert(!saltSet(), "");
Options options = Options::fromFunctionType(*this);
options.bound = true;
options.boundToType = true;
return TypeProvider::function(
m_parameterTypes,
m_returnParameterTypes,
@ -3762,7 +3762,7 @@ FunctionTypePointer FunctionType::asExternallyCallableFunction(bool _inLibrary)
Type const* FunctionType::selfType() const
{
solAssert(bound(), "Function is not bound.");
solAssert(boundToType(), "Function is not bound.");
solAssert(m_parameterTypes.size() > 0, "Function has no self type.");
return m_parameterTypes.at(0);
}

10
libsolidity/ast/Types.h
View File

@ -1274,7 +1274,7 @@ public:
bool saltSet = false;
/// true iff the function is called as arg1.fun(arg2, ..., argn).
/// This is achieved through the "using for" directive.
bool bound = false;
bool boundToType = false;
static Options withArbitraryParameters()
{
@ -1289,7 +1289,7 @@ public:
result.gasSet = _type.gasSet();
result.valueSet = _type.valueSet();
result.saltSet = _type.saltSet();
result.bound = _type.bound();
result.boundToType = _type.boundToType();
return result;
}
};
@ -1324,7 +1324,7 @@ public:
)
{
// In this constructor, only the "arbitrary Parameters" option should be used.
solAssert(!bound() && !gasSet() && !valueSet() && !saltSet());
solAssert(!boundToType() && !gasSet() && !valueSet() && !saltSet());
}
/// Detailed constructor, use with care.
@ -1356,7 +1356,7 @@ public:
"Return parameter names list must match return parameter types list!"
);
solAssert(
!bound() || !m_parameterTypes.empty(),
!boundToType() || !m_parameterTypes.empty(),
"Attempted construction of bound function without self type"
);
}
@ -1473,7 +1473,7 @@ public:
bool gasSet() const { return m_options.gasSet; }
bool valueSet() const { return m_options.valueSet; }
bool saltSet() const { return m_options.saltSet; }
bool bound() const { return m_options.bound; }
bool boundToType() const { return m_options.boundToType; }
/// @returns a copy of this type, where gas or value are set manually. This will never set one
/// of the parameters to false.

20
libsolidity/codegen/ExpressionCompiler.cpp
View File

@ -683,7 +683,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
else
{
FunctionType const& function = *functionType;
if (function.bound())
if (function.boundToType())
solAssert(
function.kind() == FunctionType::Kind::DelegateCall ||
function.kind() == FunctionType::Kind::Internal ||
@ -708,7 +708,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
bool shortcutTaken = false;
if (auto identifier = dynamic_cast<Identifier const*>(&_functionCall.expression()))
{
solAssert(!function.bound(), "");
solAssert(!function.boundToType(), "");
if (auto functionDef = dynamic_cast<FunctionDefinition const*>(identifier->annotation().referencedDeclaration))
{
// Do not directly visit the identifier, because this way, we can avoid
@ -728,7 +728,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
}
unsigned parameterSize = CompilerUtils::sizeOnStack(function.parameterTypes());
if (function.bound())
if (function.boundToType())
{
// stack: arg2, ..., argn, label, arg1
unsigned depth = parameterSize + 1;
@ -977,7 +977,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
argumentType &&
functionType->kind() == FunctionType::Kind::External &&
argumentType->kind() == FunctionType::Kind::External &&
!argumentType->bound(),
!argumentType->boundToType(),
""
);
@ -1100,7 +1100,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
}
case FunctionType::Kind::ArrayPush:
{
solAssert(function.bound(), "");
solAssert(function.boundToType(), "");
_functionCall.expression().accept(*this);
if (function.parameterTypes().size() == 0)
@ -1166,7 +1166,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
case FunctionType::Kind::ArrayPop:
{
_functionCall.expression().accept(*this);
solAssert(function.bound(), "");
solAssert(function.boundToType(), "");
solAssert(function.parameterTypes().empty(), "");
ArrayType const* arrayType = dynamic_cast<ArrayType const*>(function.selfType());
solAssert(arrayType && arrayType->dataStoredIn(DataLocation::Storage), "");
@ -1550,7 +1550,7 @@ bool ExpressionCompiler::visit(MemberAccess const& _memberAccess)
// Check whether the member is a bound function.
ASTString const& member = _memberAccess.memberName();
if (auto funType = dynamic_cast<FunctionType const*>(_memberAccess.annotation().type))
if (funType->bound())
if (funType->boundToType())
{
acceptAndConvert(_memberAccess.expression(), *funType->selfType(), true);
if (funType->kind() == FunctionType::Kind::Internal)
@ -2641,14 +2641,14 @@ void ExpressionCompiler::appendExternalFunctionCall(
// function identifier [unless bare]
// contract address
unsigned selfSize = _functionType.bound() ? _functionType.selfType()->sizeOnStack() : 0;
unsigned selfSize = _functionType.boundToType() ? _functionType.selfType()->sizeOnStack() : 0;
unsigned gasValueSize = (_functionType.gasSet() ? 1u : 0u) + (_functionType.valueSet() ? 1u : 0u);
unsigned contractStackPos = m_context.currentToBaseStackOffset(1 + gasValueSize + selfSize + (_functionType.isBareCall() ? 0 : 1));
unsigned gasStackPos = m_context.currentToBaseStackOffset(gasValueSize);
unsigned valueStackPos = m_context.currentToBaseStackOffset(1);
// move self object to top
if (_functionType.bound())
if (_functionType.boundToType())
utils().moveToStackTop(gasValueSize, _functionType.selfType()->sizeOnStack());
auto funKind = _functionType.kind();
@ -2676,7 +2676,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
// Evaluate arguments.
TypePointers argumentTypes;
TypePointers parameterTypes = _functionType.parameterTypes();
if (_functionType.bound())
if (_functionType.boundToType())
{
argumentTypes.push_back(_functionType.selfType());
parameterTypes.insert(parameterTypes.begin(), _functionType.selfType());

2
libsolidity/codegen/LValue.cpp
View File

@ -321,7 +321,7 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc
_sourceType.isImplicitlyConvertibleTo(*m_dataType),
"function item stored but target is not implicitly convertible to source"
);
solAssert(!fun->bound(), "");
solAssert(!fun->boundToType(), "");
if (fun->kind() == FunctionType::Kind::External)
{
solAssert(fun->sizeOnStack() == 2, "");

16
libsolidity/codegen/ir/IRGeneratorForStatements.cpp
View File

@ -1039,7 +1039,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
solAssert(!functionType->takesArbitraryParameters());
vector<string> args;
if (functionType->bound())
if (functionType->boundToType())
args += IRVariable(_functionCall.expression()).part("self").stackSlots();
for (size_t i = 0; i < arguments.size(); ++i)
@ -1110,7 +1110,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
solAssert(
IRVariable(arg).type() == *functionType &&
functionType->kind() == FunctionType::Kind::External &&
!functionType->bound(),
!functionType->boundToType(),
""
);
define(indexedArgs.emplace_back(m_context.newYulVariable(), *TypeProvider::fixedBytes(32))) <<
@ -1439,7 +1439,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
}
case FunctionType::Kind::ArrayPop:
{
solAssert(functionType->bound());
solAssert(functionType->boundToType());
solAssert(functionType->parameterTypes().empty());
ArrayType const* arrayType = dynamic_cast<ArrayType const*>(functionType->selfType());
solAssert(arrayType);
@ -1643,7 +1643,7 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
solAssert(!_functionCall.annotation().tryCall);
solAssert(!functionType->valueSet());
solAssert(!functionType->gasSet());
solAssert(!functionType->bound());
solAssert(!functionType->boundToType());
static map<FunctionType::Kind, std::tuple<unsigned, size_t>> precompiles = {
{FunctionType::Kind::ECRecover, std::make_tuple(1, 0)},
@ -1709,7 +1709,7 @@ void IRGeneratorForStatements::endVisit(FunctionCallOptions const& _options)
setLocation(_options);
FunctionType const& previousType = dynamic_cast<FunctionType const&>(*_options.expression().annotation().type);
solUnimplementedAssert(!previousType.bound());
solUnimplementedAssert(!previousType.boundToType());
// Copy over existing values.
for (auto const& item: previousType.stackItems())
@ -1754,7 +1754,7 @@ void IRGeneratorForStatements::endVisit(MemberAccess const& _memberAccess)
auto memberFunctionType = dynamic_cast<FunctionType const*>(_memberAccess.annotation().type);
Type::Category objectCategory = _memberAccess.expression().annotation().type->category();
if (memberFunctionType && memberFunctionType->bound())
if (memberFunctionType && memberFunctionType->boundToType())
{
define(IRVariable(_memberAccess).part("self"), _memberAccess.expression());
solAssert(*_memberAccess.annotation().requiredLookup == VirtualLookup::Static);
@ -2592,7 +2592,7 @@ void IRGeneratorForStatements::appendExternalFunctionCall(
TypePointers parameterTypes = funType.parameterTypes();
TypePointers argumentTypes;
vector<string> argumentStrings;
if (funType.bound())
if (funType.boundToType())
{
parameterTypes.insert(parameterTypes.begin(), funType.selfType());
argumentTypes.emplace_back(funType.selfType());
@ -2741,7 +2741,7 @@ void IRGeneratorForStatements::appendBareCall(
{
FunctionType const& funType = dynamic_cast<FunctionType const&>(type(_functionCall.expression()));
solAssert(
!funType.bound() &&
!funType.boundToType() &&
!funType.takesArbitraryParameters() &&
_arguments.size() == 1 &&
funType.parameterTypes().size() == 1, ""

2
libsolidity/formal/SMTEncoder.cpp
View File

@ -3118,7 +3118,7 @@ vector<smtutil::Expression> SMTEncoder::symbolicArguments(FunctionCall const& _f
vector<ASTPointer<Expression const>> arguments = _funCall.sortedArguments();
auto functionParams = funDef->parameters();
unsigned firstParam = 0;
if (funType->bound())
if (funType->boundToType())
{
calledExpr = innermostTuple(*calledExpr);
auto const& boundFunction = dynamic_cast<MemberAccess const*>(calledExpr);