2014-10-13 16:22:15 +00:00
|
|
|
/*
|
2019-02-13 15:56:46 +00:00
|
|
|
This file is part of solidity.
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2019-02-13 15:56:46 +00:00
|
|
|
solidity is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2019-02-13 15:56:46 +00:00
|
|
|
solidity is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2019-02-13 15:56:46 +00:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with solidity. If not, see <http://www.gnu.org/licenses/>.
|
2014-10-13 16:22:15 +00:00
|
|
|
*/
|
2020-07-17 14:54:12 +00:00
|
|
|
// SPDX-License-Identifier: GPL-3.0
|
2014-10-13 16:22:15 +00:00
|
|
|
/**
|
|
|
|
* @author Christian <c@ethdev.com>
|
|
|
|
* @date 2014
|
|
|
|
* Solidity data types
|
|
|
|
*/
|
|
|
|
|
2015-10-20 22:21:52 +00:00
|
|
|
#include <libsolidity/ast/Types.h>
|
2017-01-19 12:18:56 +00:00
|
|
|
|
|
|
|
#include <libsolidity/ast/AST.h>
|
2019-04-15 13:33:39 +00:00
|
|
|
#include <libsolidity/ast/TypeProvider.h>
|
2017-01-19 12:18:56 +00:00
|
|
|
|
2020-11-18 16:54:30 +00:00
|
|
|
#include <libsolidity/analysis/ConstantEvaluator.h>
|
|
|
|
|
2020-01-06 10:52:23 +00:00
|
|
|
#include <libsolutil/Algorithms.h>
|
|
|
|
#include <libsolutil/CommonData.h>
|
|
|
|
#include <libsolutil/CommonIO.h>
|
2020-10-12 14:36:48 +00:00
|
|
|
#include <libsolutil/FunctionSelector.h>
|
2020-01-06 10:52:23 +00:00
|
|
|
#include <libsolutil/Keccak256.h>
|
|
|
|
#include <libsolutil/UTF8.h>
|
2017-01-19 12:18:56 +00:00
|
|
|
|
2018-12-17 14:33:15 +00:00
|
|
|
#include <boost/algorithm/string.hpp>
|
|
|
|
#include <boost/algorithm/string/classification.hpp>
|
2017-01-19 12:18:56 +00:00
|
|
|
#include <boost/algorithm/string/join.hpp>
|
2017-03-15 11:12:41 +00:00
|
|
|
#include <boost/algorithm/string/predicate.hpp>
|
2018-12-17 14:33:15 +00:00
|
|
|
#include <boost/algorithm/string/replace.hpp>
|
2018-05-22 15:20:40 +00:00
|
|
|
#include <boost/algorithm/string/split.hpp>
|
2018-12-17 14:33:15 +00:00
|
|
|
#include <boost/range/algorithm/copy.hpp>
|
2017-01-19 12:18:56 +00:00
|
|
|
|
2021-01-11 17:14:23 +00:00
|
|
|
#include <range/v3/view/enumerate.hpp>
|
2021-03-31 18:03:04 +00:00
|
|
|
#include <range/v3/view/reverse.hpp>
|
2021-08-24 08:37:26 +00:00
|
|
|
#include <range/v3/view/tail.hpp>
|
2021-04-08 12:08:14 +00:00
|
|
|
#include <range/v3/view/transform.hpp>
|
2021-01-11 17:14:23 +00:00
|
|
|
|
2017-01-19 12:18:56 +00:00
|
|
|
#include <limits>
|
2020-09-15 23:06:54 +00:00
|
|
|
#include <unordered_set>
|
2020-04-01 03:04:29 +00:00
|
|
|
#include <utility>
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2014-11-04 12:24:35 +00:00
|
|
|
using namespace std;
|
2019-12-11 16:31:36 +00:00
|
|
|
using namespace solidity;
|
|
|
|
using namespace solidity::langutil;
|
|
|
|
using namespace solidity::frontend;
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2018-03-26 17:48:20 +00:00
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
|
|
|
/// Checks whether _mantissa * (10 ** _expBase10) fits into 4096 bits.
|
|
|
|
bool fitsPrecisionBase10(bigint const& _mantissa, uint32_t _expBase10)
|
|
|
|
{
|
|
|
|
double const log2Of10AwayFromZero = 3.3219280948873624;
|
|
|
|
return fitsPrecisionBaseX(_mantissa, log2Of10AwayFromZero, _expBase10);
|
|
|
|
}
|
|
|
|
|
2018-11-30 09:39:21 +00:00
|
|
|
/// Checks whether _value fits into IntegerType _type.
|
2019-03-11 12:36:30 +00:00
|
|
|
BoolResult fitsIntegerType(bigint const& _value, IntegerType const& _type)
|
2018-11-30 09:39:21 +00:00
|
|
|
{
|
2019-03-11 12:36:30 +00:00
|
|
|
if (_value < 0 && !_type.isSigned())
|
2019-02-27 17:21:53 +00:00
|
|
|
return BoolResult::err("Cannot implicitly convert signed literal to unsigned type.");
|
2019-03-11 12:36:30 +00:00
|
|
|
|
|
|
|
if (_type.minValue() > _value || _value > _type.maxValue())
|
2019-02-27 17:21:53 +00:00
|
|
|
return BoolResult::err("Literal is too large to fit in " + _type.toString(false) + ".");
|
2019-03-11 12:36:30 +00:00
|
|
|
|
|
|
|
return true;
|
2018-11-30 09:39:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Checks whether _value fits into _bits bits when having 1 bit as the sign bit
|
|
|
|
/// if _signed is true.
|
|
|
|
bool fitsIntoBits(bigint const& _value, unsigned _bits, bool _signed)
|
|
|
|
{
|
2020-10-26 09:59:08 +00:00
|
|
|
return fitsIntegerType(
|
|
|
|
_value,
|
|
|
|
*TypeProvider::integer(
|
|
|
|
_bits,
|
|
|
|
_signed ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned
|
|
|
|
)
|
|
|
|
);
|
2018-11-30 09:39:21 +00:00
|
|
|
}
|
|
|
|
|
2019-12-11 16:31:36 +00:00
|
|
|
util::Result<TypePointers> transformParametersToExternal(TypePointers const& _parameters, bool _inLibrary)
|
2019-04-04 16:28:53 +00:00
|
|
|
{
|
|
|
|
TypePointers transformed;
|
|
|
|
|
|
|
|
for (auto const& type: _parameters)
|
|
|
|
{
|
2020-07-08 20:08:50 +00:00
|
|
|
if (!type)
|
|
|
|
return util::Result<TypePointers>::err("Type information not present.");
|
2021-03-22 16:12:05 +00:00
|
|
|
else if (Type const* ext = type->interfaceType(_inLibrary).get())
|
2019-04-04 16:28:53 +00:00
|
|
|
transformed.push_back(ext);
|
|
|
|
else
|
2019-12-11 16:31:36 +00:00
|
|
|
return util::Result<TypePointers>::err("Parameter should have external type.");
|
2019-04-04 16:28:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return transformed;
|
|
|
|
}
|
|
|
|
|
2018-03-26 17:48:20 +00:00
|
|
|
}
|
|
|
|
|
2021-02-08 12:33:39 +00:00
|
|
|
MemberList::Member::Member(Declaration const* _declaration, Type const* _type):
|
2021-02-23 10:30:34 +00:00
|
|
|
Member(_declaration, _type, _declaration->name())
|
|
|
|
{}
|
|
|
|
|
|
|
|
MemberList::Member::Member(Declaration const* _declaration, Type const* _type, string _name):
|
|
|
|
name(move(_name)),
|
2021-02-08 12:33:39 +00:00
|
|
|
type(_type),
|
|
|
|
declaration(_declaration)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
void Type::clearCache() const
|
|
|
|
{
|
|
|
|
m_members.clear();
|
2020-02-06 13:05:25 +00:00
|
|
|
m_stackItems.reset();
|
2020-02-04 16:08:55 +00:00
|
|
|
m_stackSize.reset();
|
2019-04-15 13:33:39 +00:00
|
|
|
}
|
|
|
|
|
2015-03-13 18:48:24 +00:00
|
|
|
void StorageOffsets::computeOffsets(TypePointers const& _types)
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2015-03-13 18:48:24 +00:00
|
|
|
bigint slotOffset = 0;
|
|
|
|
unsigned byteOffset = 0;
|
|
|
|
map<size_t, pair<u256, unsigned>> offsets;
|
|
|
|
for (size_t i = 0; i < _types.size(); ++i)
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
Type const* type = _types[i];
|
2015-03-13 18:48:24 +00:00
|
|
|
if (!type->canBeStored())
|
|
|
|
continue;
|
2015-08-31 16:44:29 +00:00
|
|
|
if (byteOffset + type->storageBytes() > 32)
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2015-03-13 18:48:24 +00:00
|
|
|
// would overflow, go to next slot
|
2015-03-13 09:52:34 +00:00
|
|
|
++slotOffset;
|
2015-03-13 18:48:24 +00:00
|
|
|
byteOffset = 0;
|
|
|
|
}
|
2020-05-28 02:32:46 +00:00
|
|
|
solAssert(slotOffset < bigint(1) << 256 ,"Object too large for storage.");
|
2015-03-13 18:48:24 +00:00
|
|
|
offsets[i] = make_pair(u256(slotOffset), byteOffset);
|
2015-08-31 16:44:29 +00:00
|
|
|
solAssert(type->storageSize() >= 1, "Invalid storage size.");
|
|
|
|
if (type->storageSize() == 1 && byteOffset + type->storageBytes() <= 32)
|
|
|
|
byteOffset += type->storageBytes();
|
2015-03-13 18:48:24 +00:00
|
|
|
else
|
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
slotOffset += type->storageSize();
|
2015-03-13 18:48:24 +00:00
|
|
|
byteOffset = 0;
|
|
|
|
}
|
2015-03-13 09:52:34 +00:00
|
|
|
}
|
2015-03-13 18:48:24 +00:00
|
|
|
if (byteOffset > 0)
|
|
|
|
++slotOffset;
|
2020-05-28 02:32:46 +00:00
|
|
|
solAssert(slotOffset < bigint(1) << 256, "Object too large for storage.");
|
2015-03-13 18:48:24 +00:00
|
|
|
m_storageSize = u256(slotOffset);
|
|
|
|
swap(m_offsets, offsets);
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
pair<u256, unsigned> const* StorageOffsets::offset(size_t _index) const
|
2015-03-13 18:48:24 +00:00
|
|
|
{
|
|
|
|
if (m_offsets.count(_index))
|
|
|
|
return &m_offsets.at(_index);
|
2015-03-13 09:52:34 +00:00
|
|
|
else
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-11-25 13:23:35 +00:00
|
|
|
void MemberList::combine(MemberList const & _other)
|
|
|
|
{
|
|
|
|
m_memberTypes += _other.m_memberTypes;
|
|
|
|
}
|
|
|
|
|
2016-02-18 12:29:02 +00:00
|
|
|
pair<u256, unsigned> const* MemberList::memberStorageOffset(string const& _name) const
|
2015-03-13 18:48:24 +00:00
|
|
|
{
|
2020-05-13 17:53:36 +00:00
|
|
|
StorageOffsets const& offsets = storageOffsets();
|
|
|
|
|
2021-01-11 17:14:23 +00:00
|
|
|
for (auto&& [index, member]: m_memberTypes | ranges::views::enumerate)
|
|
|
|
if (member.name == _name)
|
2020-05-13 17:53:36 +00:00
|
|
|
return offsets.offset(index);
|
2015-03-13 18:48:24 +00:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
u256 const& MemberList::storageSize() const
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2020-05-13 17:53:36 +00:00
|
|
|
return storageOffsets().storageSize();
|
|
|
|
}
|
|
|
|
|
|
|
|
StorageOffsets const& MemberList::storageOffsets() const {
|
|
|
|
return m_storageOffsets.init([&]{
|
|
|
|
TypePointers memberTypes;
|
|
|
|
memberTypes.reserve(m_memberTypes.size());
|
|
|
|
for (auto const& member: m_memberTypes)
|
|
|
|
memberTypes.push_back(member.type);
|
|
|
|
|
|
|
|
StorageOffsets storageOffsets;
|
|
|
|
storageOffsets.computeOffsets(memberTypes);
|
|
|
|
|
|
|
|
return storageOffsets;
|
|
|
|
});
|
2015-03-13 09:52:34 +00:00
|
|
|
}
|
|
|
|
|
2017-01-19 12:18:56 +00:00
|
|
|
/// Helper functions for type identifier
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
|
|
|
string parenthesizeIdentifier(string const& _internal)
|
|
|
|
{
|
2018-02-24 00:13:34 +00:00
|
|
|
return "(" + _internal + ")";
|
2017-01-19 12:18:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class Range>
|
|
|
|
string identifierList(Range const&& _list)
|
|
|
|
{
|
2018-02-24 00:13:34 +00:00
|
|
|
return parenthesizeIdentifier(boost::algorithm::join(_list, ","));
|
2017-01-19 12:18:56 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
string richIdentifier(Type const* _type)
|
2017-01-19 12:18:56 +00:00
|
|
|
{
|
2018-02-24 00:13:34 +00:00
|
|
|
return _type ? _type->richIdentifier() : "";
|
2017-01-19 12:18:56 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
string identifierList(vector<Type const*> const& _list)
|
2017-01-19 12:18:56 +00:00
|
|
|
{
|
2021-04-08 12:08:14 +00:00
|
|
|
return identifierList(_list | ranges::views::transform(richIdentifier));
|
2017-01-19 12:18:56 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
string identifierList(Type const* _type)
|
2017-01-19 12:18:56 +00:00
|
|
|
{
|
2018-02-24 00:13:34 +00:00
|
|
|
return parenthesizeIdentifier(richIdentifier(_type));
|
2017-01-19 12:18:56 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
string identifierList(Type const* _type1, Type const* _type2)
|
2017-01-19 12:18:56 +00:00
|
|
|
{
|
|
|
|
TypePointers list;
|
|
|
|
list.push_back(_type1);
|
|
|
|
list.push_back(_type2);
|
|
|
|
return identifierList(list);
|
|
|
|
}
|
|
|
|
|
|
|
|
string parenthesizeUserIdentifier(string const& _internal)
|
|
|
|
{
|
2018-02-24 00:13:34 +00:00
|
|
|
return parenthesizeIdentifier(_internal);
|
2017-01-19 12:18:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-02-23 17:27:27 +00:00
|
|
|
string Type::escapeIdentifier(string const& _identifier)
|
|
|
|
{
|
|
|
|
string ret = _identifier;
|
2018-02-24 00:13:34 +00:00
|
|
|
// FIXME: should be _$$$_
|
|
|
|
boost::algorithm::replace_all(ret, "$", "$$$");
|
2018-02-23 17:27:27 +00:00
|
|
|
boost::algorithm::replace_all(ret, ",", "_$_");
|
|
|
|
boost::algorithm::replace_all(ret, "(", "$_");
|
|
|
|
boost::algorithm::replace_all(ret, ")", "_$");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-08-07 21:29:21 +00:00
|
|
|
string Type::identifier() const
|
|
|
|
{
|
|
|
|
string ret = escapeIdentifier(richIdentifier());
|
|
|
|
solAssert(ret.find_first_of("0123456789") != 0, "Identifier cannot start with a number.");
|
|
|
|
solAssert(
|
|
|
|
ret.find_first_not_of("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMONPQRSTUVWXYZ_$") == string::npos,
|
|
|
|
"Identifier contains invalid characters."
|
|
|
|
);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* Type::commonType(Type const* _a, Type const* _b)
|
2014-12-18 17:53:43 +00:00
|
|
|
{
|
2016-10-21 10:30:58 +00:00
|
|
|
if (!_a || !_b)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2017-02-16 10:45:06 +00:00
|
|
|
else if (_a->mobileType() && _b->isImplicitlyConvertibleTo(*_a->mobileType()))
|
2016-10-26 13:57:42 +00:00
|
|
|
return _a->mobileType();
|
2017-02-16 10:45:06 +00:00
|
|
|
else if (_b->mobileType() && _a->isImplicitlyConvertibleTo(*_b->mobileType()))
|
2016-10-26 13:57:42 +00:00
|
|
|
return _b->mobileType();
|
2014-12-18 17:53:43 +00:00
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2014-12-18 17:53:43 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList const& Type::members(ASTNode const* _currentScope) const
|
2015-11-25 13:23:35 +00:00
|
|
|
{
|
|
|
|
if (!m_members[_currentScope])
|
|
|
|
{
|
2020-06-15 17:11:03 +00:00
|
|
|
solAssert(
|
|
|
|
_currentScope == nullptr ||
|
|
|
|
dynamic_cast<SourceUnit const*>(_currentScope) ||
|
|
|
|
dynamic_cast<ContractDefinition const*>(_currentScope),
|
|
|
|
"");
|
2015-11-25 13:23:35 +00:00
|
|
|
MemberList::MemberMap members = nativeMembers(_currentScope);
|
|
|
|
if (_currentScope)
|
2016-04-26 23:02:10 +00:00
|
|
|
members += boundFunctions(*this, *_currentScope);
|
2019-11-27 16:24:21 +00:00
|
|
|
m_members[_currentScope] = make_unique<MemberList>(move(members));
|
2015-11-25 13:23:35 +00:00
|
|
|
}
|
|
|
|
return *m_members[_currentScope];
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* Type::fullEncodingType(bool _inLibraryCall, bool _encoderV2, bool) const
|
2018-07-18 13:46:23 +00:00
|
|
|
{
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* encodingType = mobileType();
|
2018-07-18 13:46:23 +00:00
|
|
|
if (encodingType)
|
|
|
|
encodingType = encodingType->interfaceType(_inLibraryCall);
|
|
|
|
if (encodingType)
|
|
|
|
encodingType = encodingType->encodingType();
|
2018-08-08 23:24:52 +00:00
|
|
|
// Structs are fine in the following circumstances:
|
2019-01-24 12:52:06 +00:00
|
|
|
// - ABIv2 or,
|
2018-08-08 23:24:52 +00:00
|
|
|
// - storage struct for a library
|
2020-05-13 08:25:46 +00:00
|
|
|
if (_inLibraryCall && encodingType && encodingType->dataStoredIn(DataLocation::Storage))
|
2018-08-08 23:24:52 +00:00
|
|
|
return encodingType;
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* baseType = encodingType;
|
2019-04-15 13:33:39 +00:00
|
|
|
while (auto const* arrayType = dynamic_cast<ArrayType const*>(baseType))
|
2020-09-17 13:02:29 +00:00
|
|
|
{
|
2018-08-08 23:24:52 +00:00
|
|
|
baseType = arrayType->baseType();
|
2020-09-17 13:02:29 +00:00
|
|
|
|
|
|
|
auto const* baseArrayType = dynamic_cast<ArrayType const*>(baseType);
|
|
|
|
if (!_encoderV2 && baseArrayType && baseArrayType->isDynamicallySized())
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2020-09-17 13:02:29 +00:00
|
|
|
}
|
|
|
|
if (!_encoderV2 && dynamic_cast<StructType const*>(baseType))
|
|
|
|
return nullptr;
|
|
|
|
|
2018-07-18 13:46:23 +00:00
|
|
|
return encodingType;
|
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap Type::boundFunctions(Type const& _type, ASTNode const& _scope)
|
2015-11-25 13:23:35 +00:00
|
|
|
{
|
2020-06-15 17:11:03 +00:00
|
|
|
vector<UsingForDirective const*> usingForDirectives;
|
|
|
|
if (auto const* sourceUnit = dynamic_cast<SourceUnit const*>(&_scope))
|
|
|
|
usingForDirectives += ASTNode::filteredNodes<UsingForDirective>(sourceUnit->nodes());
|
|
|
|
else if (auto const* contract = dynamic_cast<ContractDefinition const*>(&_scope))
|
2020-07-01 14:21:52 +00:00
|
|
|
usingForDirectives +=
|
|
|
|
contract->usingForDirectives() +
|
|
|
|
ASTNode::filteredNodes<UsingForDirective>(contract->sourceUnit().nodes());
|
2020-06-15 17:11:03 +00:00
|
|
|
else
|
|
|
|
solAssert(false, "");
|
|
|
|
|
2015-11-25 13:23:35 +00:00
|
|
|
// Normalise data location of type.
|
2020-05-26 15:23:49 +00:00
|
|
|
DataLocation typeLocation = DataLocation::Storage;
|
|
|
|
if (auto refType = dynamic_cast<ReferenceType const*>(&_type))
|
|
|
|
typeLocation = refType->location();
|
|
|
|
|
2015-11-25 13:23:35 +00:00
|
|
|
set<Declaration const*> seenFunctions;
|
|
|
|
MemberList::MemberMap members;
|
2020-06-15 17:11:03 +00:00
|
|
|
|
|
|
|
for (UsingForDirective const* ufd: usingForDirectives)
|
|
|
|
{
|
|
|
|
// Convert both types to pointers for comparison to see if the `using for`
|
|
|
|
// directive applies.
|
|
|
|
// Further down, we check more detailed for each function if `_type` is
|
|
|
|
// convertible to the function parameter type.
|
|
|
|
if (ufd->typeName() &&
|
|
|
|
*TypeProvider::withLocationIfReference(typeLocation, &_type, true) !=
|
|
|
|
*TypeProvider::withLocationIfReference(
|
|
|
|
typeLocation,
|
|
|
|
ufd->typeName()->annotation().type,
|
|
|
|
true
|
2020-06-11 10:55:30 +00:00
|
|
|
)
|
2020-06-15 17:11:03 +00:00
|
|
|
)
|
|
|
|
continue;
|
|
|
|
auto const& library = dynamic_cast<ContractDefinition const&>(
|
|
|
|
*ufd->libraryName().annotation().referencedDeclaration
|
|
|
|
);
|
|
|
|
for (FunctionDefinition const* function: library.definedFunctions())
|
|
|
|
{
|
2020-08-03 14:35:13 +00:00
|
|
|
if (!function->isOrdinary() || !function->isVisibleAsLibraryMember() || seenFunctions.count(function))
|
2015-11-25 13:23:35 +00:00
|
|
|
continue;
|
2020-06-15 17:11:03 +00:00
|
|
|
seenFunctions.insert(function);
|
|
|
|
if (function->parameters().empty())
|
|
|
|
continue;
|
|
|
|
FunctionTypePointer fun =
|
|
|
|
dynamic_cast<FunctionType const&>(*function->typeViaContractName()).asBoundFunction();
|
|
|
|
if (_type.isImplicitlyConvertibleTo(*fun->selfType()))
|
2021-02-08 12:33:39 +00:00
|
|
|
members.emplace_back(function, fun);
|
2015-11-25 13:23:35 +00:00
|
|
|
}
|
2020-06-15 17:11:03 +00:00
|
|
|
}
|
|
|
|
|
2015-11-25 13:23:35 +00:00
|
|
|
return members;
|
|
|
|
}
|
2014-11-20 09:19:43 +00:00
|
|
|
|
2018-09-05 15:59:55 +00:00
|
|
|
AddressType::AddressType(StateMutability _stateMutability):
|
|
|
|
m_stateMutability(_stateMutability)
|
|
|
|
{
|
|
|
|
solAssert(m_stateMutability == StateMutability::Payable || m_stateMutability == StateMutability::NonPayable, "");
|
|
|
|
}
|
|
|
|
|
2018-09-03 15:45:58 +00:00
|
|
|
string AddressType::richIdentifier() const
|
|
|
|
{
|
2018-09-05 15:59:55 +00:00
|
|
|
if (m_stateMutability == StateMutability::Payable)
|
|
|
|
return "t_address_payable";
|
|
|
|
else
|
|
|
|
return "t_address";
|
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult AddressType::isImplicitlyConvertibleTo(Type const& _other) const
|
2018-09-05 15:59:55 +00:00
|
|
|
{
|
|
|
|
if (_other.category() != category())
|
|
|
|
return false;
|
|
|
|
AddressType const& other = dynamic_cast<AddressType const&>(_other);
|
|
|
|
|
|
|
|
return other.m_stateMutability <= m_stateMutability;
|
2018-09-03 15:45:58 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult AddressType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2018-09-03 15:45:58 +00:00
|
|
|
{
|
2020-11-09 09:10:30 +00:00
|
|
|
if ((_convertTo.category() == category()) || isImplicitlyConvertibleTo(_convertTo))
|
2019-09-04 15:45:12 +00:00
|
|
|
return true;
|
|
|
|
else if (auto const* contractType = dynamic_cast<ContractType const*>(&_convertTo))
|
2018-09-05 15:59:55 +00:00
|
|
|
return (m_stateMutability >= StateMutability::Payable) || !contractType->isPayable();
|
2020-12-15 11:43:59 +00:00
|
|
|
else if (m_stateMutability == StateMutability::NonPayable)
|
|
|
|
{
|
|
|
|
if (auto integerType = dynamic_cast<IntegerType const*>(&_convertTo))
|
|
|
|
return (!integerType->isSigned() && integerType->numBits() == 160);
|
|
|
|
else if (auto fixedBytesType = dynamic_cast<FixedBytesType const*>(&_convertTo))
|
|
|
|
return (fixedBytesType->numBytes() == 20);
|
|
|
|
}
|
2020-11-09 09:10:30 +00:00
|
|
|
|
|
|
|
return false;
|
2018-09-03 15:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
string AddressType::toString(bool) const
|
2018-09-05 15:59:55 +00:00
|
|
|
{
|
|
|
|
if (m_stateMutability == StateMutability::Payable)
|
|
|
|
return "address payable";
|
|
|
|
else
|
|
|
|
return "address";
|
|
|
|
}
|
|
|
|
|
|
|
|
string AddressType::canonicalName() const
|
2018-09-03 15:45:58 +00:00
|
|
|
{
|
|
|
|
return "address";
|
|
|
|
}
|
|
|
|
|
|
|
|
u256 AddressType::literalValue(Literal const* _literal) const
|
|
|
|
{
|
|
|
|
solAssert(_literal, "");
|
|
|
|
solAssert(_literal->value().substr(0, 2) == "0x", "");
|
2018-10-01 12:36:57 +00:00
|
|
|
return u256(_literal->valueWithoutUnderscores());
|
2018-09-03 15:45:58 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult AddressType::unaryOperatorResult(Token _operator) const
|
2018-09-03 15:45:58 +00:00
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
return _operator == Token::Delete ? TypeProvider::emptyTuple() : nullptr;
|
2018-09-03 15:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
TypeResult AddressType::binaryOperatorResult(Token _operator, Type const* _other) const
|
2018-09-03 15:45:58 +00:00
|
|
|
{
|
2018-10-22 14:48:21 +00:00
|
|
|
if (!TokenTraits::isCompareOp(_operator))
|
2019-02-27 17:21:53 +00:00
|
|
|
return TypeResult::err("Arithmetic operations on addresses are not supported. Convert to integer first before using them.");
|
2018-09-03 15:45:58 +00:00
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
return Type::commonType(this, _other);
|
2018-09-03 15:45:58 +00:00
|
|
|
}
|
|
|
|
|
2018-09-05 15:59:55 +00:00
|
|
|
bool AddressType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (_other.category() != category())
|
|
|
|
return false;
|
|
|
|
AddressType const& other = dynamic_cast<AddressType const&>(_other);
|
|
|
|
return other.m_stateMutability == m_stateMutability;
|
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap AddressType::nativeMembers(ASTNode const*) const
|
2018-09-03 15:45:58 +00:00
|
|
|
{
|
2018-09-05 15:59:55 +00:00
|
|
|
MemberList::MemberMap members = {
|
2019-04-15 16:10:43 +00:00
|
|
|
{"balance", TypeProvider::uint256()},
|
2020-09-24 16:28:14 +00:00
|
|
|
{"code", TypeProvider::array(DataLocation::Memory)},
|
2020-09-24 17:45:40 +00:00
|
|
|
{"codehash", TypeProvider::fixedBytes(32)},
|
2019-04-17 11:40:50 +00:00
|
|
|
{"call", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareCall, false, StateMutability::Payable)},
|
|
|
|
{"callcode", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareCallCode, false, StateMutability::Payable)},
|
|
|
|
{"delegatecall", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareDelegateCall, false, StateMutability::NonPayable)},
|
|
|
|
{"staticcall", TypeProvider::function(strings{"bytes memory"}, strings{"bool", "bytes memory"}, FunctionType::Kind::BareStaticCall, false, StateMutability::View)}
|
2018-09-03 15:45:58 +00:00
|
|
|
};
|
2018-09-05 15:59:55 +00:00
|
|
|
if (m_stateMutability == StateMutability::Payable)
|
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
members.emplace_back(MemberList::Member{"send", TypeProvider::function(strings{"uint"}, strings{"bool"}, FunctionType::Kind::Send, false, StateMutability::NonPayable)});
|
|
|
|
members.emplace_back(MemberList::Member{"transfer", TypeProvider::function(strings{"uint"}, strings(), FunctionType::Kind::Transfer, false, StateMutability::NonPayable)});
|
2018-09-05 15:59:55 +00:00
|
|
|
}
|
|
|
|
return members;
|
2018-09-03 15:45:58 +00:00
|
|
|
}
|
|
|
|
|
2017-08-29 00:01:47 +00:00
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
2018-10-22 14:48:21 +00:00
|
|
|
bool isValidShiftAndAmountType(Token _operator, Type const& _shiftAmountType)
|
2016-12-06 22:45:17 +00:00
|
|
|
{
|
|
|
|
// Disable >>> here.
|
|
|
|
if (_operator == Token::SHR)
|
|
|
|
return false;
|
|
|
|
else if (IntegerType const* otherInt = dynamic_cast<decltype(otherInt)>(&_shiftAmountType))
|
2020-05-11 22:06:25 +00:00
|
|
|
return !otherInt->isSigned();
|
2016-12-06 22:45:17 +00:00
|
|
|
else if (RationalNumberType const* otherRat = dynamic_cast<decltype(otherRat)>(&_shiftAmountType))
|
2018-03-22 04:20:50 +00:00
|
|
|
return !otherRat->isFractional() && otherRat->integerType() && !otherRat->integerType()->isSigned();
|
2016-12-06 22:45:17 +00:00
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-08-29 00:01:47 +00:00
|
|
|
}
|
|
|
|
|
2018-04-30 21:56:30 +00:00
|
|
|
IntegerType::IntegerType(unsigned _bits, IntegerType::Modifier _modifier):
|
2014-10-22 22:24:07 +00:00
|
|
|
m_bits(_bits), m_modifier(_modifier)
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2016-02-18 12:29:02 +00:00
|
|
|
solAssert(
|
|
|
|
m_bits > 0 && m_bits <= 256 && m_bits % 8 == 0,
|
2019-12-11 16:31:36 +00:00
|
|
|
"Invalid bit number for integer type: " + util::toString(m_bits)
|
2017-09-26 21:46:33 +00:00
|
|
|
);
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string IntegerType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-09-03 15:45:58 +00:00
|
|
|
return "t_" + string(isSigned() ? "" : "u") + "int" + to_string(numBits());
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2016-02-18 22:39:11 +00:00
|
|
|
if (_convertTo.category() == category())
|
2016-05-10 10:42:38 +00:00
|
|
|
{
|
2016-02-18 22:39:11 +00:00
|
|
|
IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
|
2021-01-04 11:06:03 +00:00
|
|
|
// disallowing unsigned to signed conversion of different bits
|
|
|
|
if (isSigned() != convertTo.isSigned())
|
|
|
|
return false;
|
|
|
|
else if (convertTo.m_bits < m_bits)
|
2016-02-18 22:39:11 +00:00
|
|
|
return false;
|
|
|
|
else
|
2021-01-04 11:06:03 +00:00
|
|
|
return true;
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
else if (_convertTo.category() == Category::FixedPoint)
|
|
|
|
{
|
|
|
|
FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo);
|
2018-09-03 15:45:58 +00:00
|
|
|
return maxValue() <= convertTo.maxIntegerValue() && minValue() >= convertTo.minIntegerValue();
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
2014-10-13 16:22:15 +00:00
|
|
|
else
|
2016-02-18 22:39:11 +00:00
|
|
|
return false;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2020-11-09 09:10:30 +00:00
|
|
|
if (isImplicitlyConvertibleTo(_convertTo))
|
|
|
|
return true;
|
|
|
|
else if (auto integerType = dynamic_cast<IntegerType const*>(&_convertTo))
|
|
|
|
return (numBits() == integerType->numBits()) || (isSigned() == integerType->isSigned());
|
2020-12-15 11:43:59 +00:00
|
|
|
else if (auto addressType = dynamic_cast<AddressType const*>(&_convertTo))
|
|
|
|
return
|
|
|
|
(addressType->stateMutability() != StateMutability::Payable) &&
|
|
|
|
!isSigned() &&
|
|
|
|
(numBits() == 160);
|
2020-11-09 09:10:30 +00:00
|
|
|
else if (auto fixedBytesType = dynamic_cast<FixedBytesType const*>(&_convertTo))
|
|
|
|
return (!isSigned() && (numBits() == fixedBytesType->numBytes() * 8));
|
|
|
|
else if (dynamic_cast<EnumType const*>(&_convertTo))
|
|
|
|
return true;
|
|
|
|
else if (auto fixedPointType = dynamic_cast<FixedPointType const*>(&_convertTo))
|
|
|
|
return (isSigned() == fixedPointType->isSigned()) && (numBits() == fixedPointType->numBits());
|
|
|
|
|
|
|
|
return false;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult IntegerType::unaryOperatorResult(Token _operator) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2015-01-06 18:08:24 +00:00
|
|
|
// "delete" is ok for all integer types
|
2015-02-09 13:00:12 +00:00
|
|
|
if (_operator == Token::Delete)
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeResult{TypeProvider::emptyTuple()};
|
2020-09-16 16:29:18 +00:00
|
|
|
// unary negation only on signed types
|
|
|
|
else if (_operator == Token::Sub)
|
|
|
|
return isSigned() ? TypeResult{this} : TypeResult::err("Unary negation is only allowed for signed integers.");
|
|
|
|
else if (_operator == Token::Inc || _operator == Token::Dec || _operator == Token::BitNot)
|
2019-04-15 13:33:39 +00:00
|
|
|
return TypeResult{this};
|
2015-01-06 18:08:24 +00:00
|
|
|
else
|
2019-02-27 17:21:53 +00:00
|
|
|
return TypeResult::err("");
|
2014-10-20 10:41:56 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool IntegerType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-10-20 10:41:56 +00:00
|
|
|
return false;
|
|
|
|
IntegerType const& other = dynamic_cast<IntegerType const&>(_other);
|
|
|
|
return other.m_bits == m_bits && other.m_modifier == m_modifier;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string IntegerType::toString(bool) const
|
2014-10-16 15:57:27 +00:00
|
|
|
{
|
2015-03-05 15:54:55 +00:00
|
|
|
string prefix = isSigned() ? "int" : "uint";
|
2019-12-11 16:31:36 +00:00
|
|
|
return prefix + util::toString(m_bits);
|
2014-10-16 15:57:27 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 16:24:37 +00:00
|
|
|
u256 IntegerType::min() const
|
|
|
|
{
|
|
|
|
if (isSigned())
|
|
|
|
return s2u(s256(minValue()));
|
|
|
|
else
|
|
|
|
return u256(minValue());
|
|
|
|
}
|
|
|
|
|
|
|
|
u256 IntegerType::max() const
|
|
|
|
{
|
|
|
|
if (isSigned())
|
|
|
|
return s2u(s256(maxValue()));
|
|
|
|
else
|
|
|
|
return u256(maxValue());
|
|
|
|
}
|
|
|
|
|
2017-07-06 09:05:05 +00:00
|
|
|
bigint IntegerType::minValue() const
|
|
|
|
{
|
|
|
|
if (isSigned())
|
|
|
|
return -(bigint(1) << (m_bits - 1));
|
|
|
|
else
|
|
|
|
return bigint(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bigint IntegerType::maxValue() const
|
|
|
|
{
|
|
|
|
if (isSigned())
|
|
|
|
return (bigint(1) << (m_bits - 1)) - 1;
|
|
|
|
else
|
|
|
|
return (bigint(1) << m_bits) - 1;
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
TypeResult IntegerType::binaryOperatorResult(Token _operator, Type const* _other) const
|
2014-12-18 17:53:43 +00:00
|
|
|
{
|
2016-05-13 03:10:49 +00:00
|
|
|
if (
|
|
|
|
_other->category() != Category::RationalNumber &&
|
|
|
|
_other->category() != Category::FixedPoint &&
|
|
|
|
_other->category() != category()
|
|
|
|
)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isShiftOp(_operator))
|
2016-12-05 17:40:50 +00:00
|
|
|
{
|
|
|
|
// Shifts are not symmetric with respect to the type
|
2016-12-06 22:45:17 +00:00
|
|
|
if (isValidShiftAndAmountType(_operator, *_other))
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2016-12-06 22:45:17 +00:00
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-12-05 17:40:50 +00:00
|
|
|
}
|
2019-07-07 15:53:03 +00:00
|
|
|
else if (Token::Exp == _operator)
|
|
|
|
{
|
|
|
|
if (auto otherIntType = dynamic_cast<IntegerType const*>(_other))
|
|
|
|
{
|
|
|
|
if (otherIntType->isSigned())
|
|
|
|
return TypeResult::err("Exponentiation power is not allowed to be a signed integer type.");
|
|
|
|
}
|
|
|
|
else if (dynamic_cast<FixedPointType const*>(_other))
|
|
|
|
return nullptr;
|
2020-05-12 07:06:21 +00:00
|
|
|
else if (auto rationalNumberType = dynamic_cast<RationalNumberType const*>(_other))
|
|
|
|
{
|
|
|
|
if (rationalNumberType->isFractional())
|
|
|
|
return TypeResult::err("Exponent is fractional.");
|
|
|
|
if (!rationalNumberType->integerType())
|
|
|
|
return TypeResult::err("Exponent too large.");
|
2020-08-26 18:50:13 +00:00
|
|
|
if (rationalNumberType->isNegative())
|
|
|
|
return TypeResult::err("Exponentiation power is not allowed to be a negative integer literal.");
|
2020-05-12 07:06:21 +00:00
|
|
|
}
|
2019-07-07 15:53:03 +00:00
|
|
|
return this;
|
|
|
|
}
|
2016-12-05 17:40:50 +00:00
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
auto commonType = Type::commonType(this, _other); //might be an integer or fixed point
|
2014-12-18 17:53:43 +00:00
|
|
|
if (!commonType)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-05-13 05:38:41 +00:00
|
|
|
|
2014-12-28 12:35:58 +00:00
|
|
|
// All integer types can be compared
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isCompareOp(_operator))
|
2014-12-28 12:35:58 +00:00
|
|
|
return commonType;
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isBooleanOp(_operator))
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2015-03-09 12:49:53 +00:00
|
|
|
return commonType;
|
2014-12-18 17:53:43 +00:00
|
|
|
}
|
|
|
|
|
2018-04-30 21:50:27 +00:00
|
|
|
FixedPointType::FixedPointType(unsigned _totalBits, unsigned _fractionalDigits, FixedPointType::Modifier _modifier):
|
2016-12-22 18:20:03 +00:00
|
|
|
m_totalBits(_totalBits), m_fractionalDigits(_fractionalDigits), m_modifier(_modifier)
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
|
|
|
solAssert(
|
2018-05-01 05:58:04 +00:00
|
|
|
8 <= m_totalBits && m_totalBits <= 256 && m_totalBits % 8 == 0 && m_fractionalDigits <= 80,
|
2018-04-30 21:50:27 +00:00
|
|
|
"Invalid bit number(s) for fixed type: " +
|
2019-12-11 16:31:36 +00:00
|
|
|
util::toString(_totalBits) + "x" + util::toString(_fractionalDigits)
|
2016-12-22 18:20:03 +00:00
|
|
|
);
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string FixedPointType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-08-08 14:26:30 +00:00
|
|
|
return "t_" + string(isSigned() ? "" : "u") + "fixed" + to_string(m_totalBits) + "x" + to_string(m_fractionalDigits);
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult FixedPointType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
|
|
|
if (_convertTo.category() == category())
|
|
|
|
{
|
|
|
|
FixedPointType const& convertTo = dynamic_cast<FixedPointType const&>(_convertTo);
|
2019-03-11 12:36:30 +00:00
|
|
|
if (convertTo.fractionalDigits() < m_fractionalDigits)
|
2019-02-27 17:21:53 +00:00
|
|
|
return BoolResult::err("Too many fractional digits.");
|
2019-03-11 12:36:30 +00:00
|
|
|
if (convertTo.numBits() < m_totalBits)
|
2016-02-18 22:39:11 +00:00
|
|
|
return false;
|
|
|
|
else
|
2017-07-12 13:44:27 +00:00
|
|
|
return convertTo.maxIntegerValue() >= maxIntegerValue() && convertTo.minIntegerValue() <= minIntegerValue();
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
2016-05-05 22:47:08 +00:00
|
|
|
return false;
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult FixedPointType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2018-09-03 15:45:58 +00:00
|
|
|
return _convertTo.category() == category() || _convertTo.category() == Category::Integer;
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult FixedPointType::unaryOperatorResult(Token _operator) const
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2019-11-11 16:09:59 +00:00
|
|
|
switch (_operator)
|
2017-08-09 22:16:58 +00:00
|
|
|
{
|
|
|
|
case Token::Delete:
|
|
|
|
// "delete" is ok for all fixed types
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeResult{TypeProvider::emptyTuple()};
|
2017-08-09 22:16:58 +00:00
|
|
|
case Token::Add:
|
|
|
|
case Token::Sub:
|
|
|
|
case Token::Inc:
|
|
|
|
case Token::Dec:
|
|
|
|
// for fixed, we allow +, -, ++ and --
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2017-08-09 22:16:58 +00:00
|
|
|
default:
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2017-08-09 22:16:58 +00:00
|
|
|
}
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool FixedPointType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (_other.category() != category())
|
|
|
|
return false;
|
|
|
|
FixedPointType const& other = dynamic_cast<FixedPointType const&>(_other);
|
2016-12-22 18:20:03 +00:00
|
|
|
return other.m_totalBits == m_totalBits && other.m_fractionalDigits == m_fractionalDigits && other.m_modifier == m_modifier;
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
string FixedPointType::toString(bool) const
|
|
|
|
{
|
|
|
|
string prefix = isSigned() ? "fixed" : "ufixed";
|
2019-12-11 16:31:36 +00:00
|
|
|
return prefix + util::toString(m_totalBits) + "x" + util::toString(m_fractionalDigits);
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
|
2017-07-12 13:44:27 +00:00
|
|
|
bigint FixedPointType::maxIntegerValue() const
|
|
|
|
{
|
|
|
|
bigint maxValue = (bigint(1) << (m_totalBits - (isSigned() ? 1 : 0))) - 1;
|
2018-05-04 04:18:34 +00:00
|
|
|
return maxValue / boost::multiprecision::pow(bigint(10), m_fractionalDigits);
|
2017-07-12 13:44:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bigint FixedPointType::minIntegerValue() const
|
|
|
|
{
|
|
|
|
if (isSigned())
|
|
|
|
{
|
|
|
|
bigint minValue = -(bigint(1) << (m_totalBits - (isSigned() ? 1 : 0)));
|
2018-05-04 04:18:34 +00:00
|
|
|
return minValue / boost::multiprecision::pow(bigint(10), m_fractionalDigits);
|
2017-07-12 13:44:27 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return bigint(0);
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
TypeResult FixedPointType::binaryOperatorResult(Token _operator, Type const* _other) const
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
auto commonType = Type::commonType(this, _other);
|
2016-02-18 22:39:11 +00:00
|
|
|
|
|
|
|
if (!commonType)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-02-18 22:39:11 +00:00
|
|
|
|
|
|
|
// All fixed types can be compared
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isCompareOp(_operator))
|
2016-02-18 22:39:11 +00:00
|
|
|
return commonType;
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isBitOp(_operator) || TokenTraits::isBooleanOp(_operator) || _operator == Token::Exp)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-02-18 22:39:11 +00:00
|
|
|
return commonType;
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
IntegerType const* FixedPointType::asIntegerType() const
|
2018-04-19 23:00:05 +00:00
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::integer(numBits(), isSigned() ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned);
|
2018-04-19 23:00:05 +00:00
|
|
|
}
|
|
|
|
|
2017-03-15 11:18:29 +00:00
|
|
|
tuple<bool, rational> RationalNumberType::parseRational(string const& _value)
|
2015-07-14 15:43:13 +00:00
|
|
|
{
|
2017-03-15 11:18:29 +00:00
|
|
|
rational value;
|
2015-07-14 15:43:13 +00:00
|
|
|
try
|
|
|
|
{
|
2017-03-15 11:18:29 +00:00
|
|
|
auto radixPoint = find(_value.begin(), _value.end(), '.');
|
|
|
|
|
|
|
|
if (radixPoint != _value.end())
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2016-04-12 17:36:34 +00:00
|
|
|
if (
|
2017-03-15 11:18:29 +00:00
|
|
|
!all_of(radixPoint + 1, _value.end(), ::isdigit) ||
|
|
|
|
!all_of(_value.begin(), radixPoint, ::isdigit)
|
2016-04-12 17:36:34 +00:00
|
|
|
)
|
2016-10-20 09:33:17 +00:00
|
|
|
return make_tuple(false, rational(0));
|
2017-03-15 11:18:29 +00:00
|
|
|
|
|
|
|
// Only decimal notation allowed here, leading zeros would switch to octal.
|
2016-05-10 10:42:38 +00:00
|
|
|
auto fractionalBegin = find_if_not(
|
2017-03-15 11:18:29 +00:00
|
|
|
radixPoint + 1,
|
|
|
|
_value.end(),
|
2016-02-18 22:39:11 +00:00
|
|
|
[](char const& a) { return a == '0'; }
|
|
|
|
);
|
2016-04-12 17:36:34 +00:00
|
|
|
|
2017-03-15 11:18:29 +00:00
|
|
|
rational numerator;
|
|
|
|
rational denominator(1);
|
|
|
|
|
|
|
|
denominator = bigint(string(fractionalBegin, _value.end()));
|
2016-02-18 22:39:11 +00:00
|
|
|
denominator /= boost::multiprecision::pow(
|
2017-03-15 11:18:29 +00:00
|
|
|
bigint(10),
|
2019-12-12 23:39:29 +00:00
|
|
|
static_cast<unsigned>(distance(radixPoint + 1, _value.end()))
|
2016-02-18 22:39:11 +00:00
|
|
|
);
|
2017-03-15 11:18:29 +00:00
|
|
|
numerator = bigint(string(_value.begin(), radixPoint));
|
|
|
|
value = numerator + denominator;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
value = bigint(_value);
|
|
|
|
return make_tuple(true, value);
|
|
|
|
}
|
|
|
|
catch (...)
|
|
|
|
{
|
|
|
|
return make_tuple(false, rational(0));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-12 17:36:34 +00:00
|
|
|
tuple<bool, rational> RationalNumberType::isValidLiteral(Literal const& _literal)
|
2015-07-14 15:43:13 +00:00
|
|
|
{
|
2017-03-15 12:50:34 +00:00
|
|
|
rational value;
|
2015-07-14 15:43:13 +00:00
|
|
|
try
|
|
|
|
{
|
2018-10-02 13:31:55 +00:00
|
|
|
ASTString valueString = _literal.valueWithoutUnderscores();
|
2017-02-14 14:24:25 +00:00
|
|
|
|
2018-08-03 14:13:52 +00:00
|
|
|
auto expPoint = find(valueString.begin(), valueString.end(), 'e');
|
|
|
|
if (expPoint == valueString.end())
|
|
|
|
expPoint = find(valueString.begin(), valueString.end(), 'E');
|
|
|
|
|
|
|
|
if (boost::starts_with(valueString, "0x"))
|
2017-03-15 11:16:44 +00:00
|
|
|
{
|
|
|
|
// process as hex
|
2017-10-25 08:12:07 +00:00
|
|
|
value = bigint(valueString);
|
2017-03-15 11:16:44 +00:00
|
|
|
}
|
2018-08-03 14:13:52 +00:00
|
|
|
else if (expPoint != valueString.end())
|
2017-02-14 14:24:25 +00:00
|
|
|
{
|
2018-07-11 13:30:54 +00:00
|
|
|
// Parse mantissa and exponent. Checks numeric limit.
|
2018-08-03 14:13:52 +00:00
|
|
|
tuple<bool, rational> mantissa = parseRational(string(valueString.begin(), expPoint));
|
2017-02-14 14:24:25 +00:00
|
|
|
|
2018-07-11 13:30:54 +00:00
|
|
|
if (!get<0>(mantissa))
|
2017-02-14 14:24:25 +00:00
|
|
|
return make_tuple(false, rational(0));
|
2018-07-11 13:30:54 +00:00
|
|
|
value = get<1>(mantissa);
|
2017-02-14 14:24:25 +00:00
|
|
|
|
2018-07-11 13:30:54 +00:00
|
|
|
// 0E... is always zero.
|
|
|
|
if (value == 0)
|
|
|
|
return make_tuple(true, rational(0));
|
2018-03-26 17:48:20 +00:00
|
|
|
|
2018-08-03 14:13:52 +00:00
|
|
|
bigint exp = bigint(string(expPoint + 1, valueString.end()));
|
2018-03-26 17:48:20 +00:00
|
|
|
|
2018-07-11 13:30:54 +00:00
|
|
|
if (exp > numeric_limits<int32_t>::max() || exp < numeric_limits<int32_t>::min())
|
2017-03-15 11:18:29 +00:00
|
|
|
return make_tuple(false, rational(0));
|
2018-07-11 13:30:54 +00:00
|
|
|
|
|
|
|
uint32_t expAbs = bigint(abs(exp)).convert_to<uint32_t>();
|
2017-03-15 12:50:34 +00:00
|
|
|
|
2017-02-14 16:36:22 +00:00
|
|
|
if (exp < 0)
|
2017-02-14 17:25:04 +00:00
|
|
|
{
|
2018-03-26 17:48:20 +00:00
|
|
|
if (!fitsPrecisionBase10(abs(value.denominator()), expAbs))
|
|
|
|
return make_tuple(false, rational(0));
|
2017-03-15 12:50:34 +00:00
|
|
|
value /= boost::multiprecision::pow(
|
2017-02-14 16:36:22 +00:00
|
|
|
bigint(10),
|
2018-03-26 17:48:20 +00:00
|
|
|
expAbs
|
2017-02-14 16:36:22 +00:00
|
|
|
);
|
2017-02-14 17:25:04 +00:00
|
|
|
}
|
2018-03-26 17:48:20 +00:00
|
|
|
else if (exp > 0)
|
|
|
|
{
|
|
|
|
if (!fitsPrecisionBase10(abs(value.numerator()), expAbs))
|
|
|
|
return make_tuple(false, rational(0));
|
2017-03-15 12:50:34 +00:00
|
|
|
value *= boost::multiprecision::pow(
|
2017-02-14 16:36:22 +00:00
|
|
|
bigint(10),
|
2018-03-26 17:48:20 +00:00
|
|
|
expAbs
|
2017-02-14 16:36:22 +00:00
|
|
|
);
|
2018-03-26 17:48:20 +00:00
|
|
|
}
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-03-15 11:18:29 +00:00
|
|
|
// parse as rational number
|
2018-08-03 14:13:52 +00:00
|
|
|
tuple<bool, rational> tmp = parseRational(valueString);
|
2017-03-15 11:18:29 +00:00
|
|
|
if (!get<0>(tmp))
|
|
|
|
return tmp;
|
|
|
|
value = get<1>(tmp);
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
}
|
2016-04-12 17:36:34 +00:00
|
|
|
catch (...)
|
2015-02-06 12:38:10 +00:00
|
|
|
{
|
2016-04-12 17:36:34 +00:00
|
|
|
return make_tuple(false, rational(0));
|
2015-02-06 12:38:10 +00:00
|
|
|
}
|
2016-05-05 22:47:08 +00:00
|
|
|
switch (_literal.subDenomination())
|
|
|
|
{
|
|
|
|
case Literal::SubDenomination::None:
|
|
|
|
case Literal::SubDenomination::Wei:
|
|
|
|
case Literal::SubDenomination::Second:
|
|
|
|
break;
|
2020-06-18 15:09:24 +00:00
|
|
|
case Literal::SubDenomination::Gwei:
|
|
|
|
value *= bigint("1000000000");
|
|
|
|
break;
|
2016-05-05 22:47:08 +00:00
|
|
|
case Literal::SubDenomination::Ether:
|
2017-03-15 12:50:34 +00:00
|
|
|
value *= bigint("1000000000000000000");
|
2016-05-05 22:47:08 +00:00
|
|
|
break;
|
|
|
|
case Literal::SubDenomination::Minute:
|
2017-03-15 12:50:34 +00:00
|
|
|
value *= bigint("60");
|
2016-05-05 22:47:08 +00:00
|
|
|
break;
|
|
|
|
case Literal::SubDenomination::Hour:
|
2017-03-15 12:50:34 +00:00
|
|
|
value *= bigint("3600");
|
2016-05-05 22:47:08 +00:00
|
|
|
break;
|
|
|
|
case Literal::SubDenomination::Day:
|
2017-03-15 12:50:34 +00:00
|
|
|
value *= bigint("86400");
|
2016-05-05 22:47:08 +00:00
|
|
|
break;
|
|
|
|
case Literal::SubDenomination::Week:
|
2017-03-15 12:50:34 +00:00
|
|
|
value *= bigint("604800");
|
2016-05-05 22:47:08 +00:00
|
|
|
break;
|
|
|
|
case Literal::SubDenomination::Year:
|
2017-03-15 12:50:34 +00:00
|
|
|
value *= bigint("31536000");
|
2016-05-05 22:47:08 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-03-15 12:50:34 +00:00
|
|
|
return make_tuple(true, value);
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult RationalNumberType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2018-06-24 02:15:25 +00:00
|
|
|
switch (_convertTo.category())
|
|
|
|
{
|
|
|
|
case Category::Integer:
|
2015-03-10 17:22:19 +00:00
|
|
|
{
|
2016-05-10 12:30:24 +00:00
|
|
|
if (isFractional())
|
2016-04-12 17:36:34 +00:00
|
|
|
return false;
|
2017-08-22 12:55:28 +00:00
|
|
|
IntegerType const& targetType = dynamic_cast<IntegerType const&>(_convertTo);
|
2018-11-30 09:39:21 +00:00
|
|
|
return fitsIntegerType(m_value.numerator(), targetType);
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
2018-06-24 02:15:25 +00:00
|
|
|
case Category::FixedPoint:
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2018-11-30 09:39:21 +00:00
|
|
|
FixedPointType const& targetType = dynamic_cast<FixedPointType const&>(_convertTo);
|
|
|
|
// Store a negative number into an unsigned.
|
|
|
|
if (isNegative() && !targetType.isSigned())
|
|
|
|
return false;
|
|
|
|
if (!isFractional())
|
|
|
|
return (targetType.minIntegerValue() <= m_value) && (m_value <= targetType.maxIntegerValue());
|
|
|
|
rational value = m_value * pow(bigint(10), targetType.fractionalDigits());
|
|
|
|
// Need explicit conversion since truncation will occur.
|
|
|
|
if (value.denominator() != 1)
|
|
|
|
return false;
|
|
|
|
return fitsIntoBits(value.numerator(), targetType.numBits(), targetType.isSigned());
|
2015-03-10 17:22:19 +00:00
|
|
|
}
|
2018-06-24 02:15:25 +00:00
|
|
|
case Category::FixedBytes:
|
2018-08-06 12:59:37 +00:00
|
|
|
return (m_value == rational(0)) || (m_compatibleBytesType && *m_compatibleBytesType == _convertTo);
|
2018-06-24 02:15:25 +00:00
|
|
|
default:
|
|
|
|
return false;
|
2015-06-04 16:06:06 +00:00
|
|
|
}
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult RationalNumberType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2018-08-06 12:59:37 +00:00
|
|
|
if (isImplicitlyConvertibleTo(_convertTo))
|
|
|
|
return true;
|
2020-09-23 10:29:00 +00:00
|
|
|
|
|
|
|
auto category = _convertTo.category();
|
|
|
|
if (category == Category::FixedBytes)
|
2018-08-06 12:59:37 +00:00
|
|
|
return false;
|
2020-12-15 11:43:59 +00:00
|
|
|
else if (auto addressType = dynamic_cast<AddressType const*>(&_convertTo))
|
|
|
|
return (m_value == 0) ||
|
|
|
|
((addressType->stateMutability() != StateMutability::Payable) &&
|
|
|
|
!isNegative() &&
|
|
|
|
!isFractional() &&
|
|
|
|
integerType() &&
|
|
|
|
(integerType()->numBits() <= 160));
|
2020-10-26 09:59:08 +00:00
|
|
|
else if (category == Category::Integer)
|
|
|
|
return false;
|
2020-11-06 16:39:44 +00:00
|
|
|
else if (auto enumType = dynamic_cast<EnumType const*>(&_convertTo))
|
|
|
|
if (isNegative() || isFractional() || m_value >= enumType->numberOfMembers())
|
|
|
|
return false;
|
2020-09-23 10:29:00 +00:00
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* mobType = mobileType();
|
2020-09-23 10:29:00 +00:00
|
|
|
return (mobType && mobType->isExplicitlyConvertibleTo(_convertTo));
|
|
|
|
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult RationalNumberType::unaryOperatorResult(Token _operator) const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2020-11-18 16:54:30 +00:00
|
|
|
if (optional<rational> value = ConstantEvaluator::evaluateUnaryOperator(_operator, m_value))
|
|
|
|
return TypeResult{TypeProvider::rationalNumber(*value)};
|
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
TypeResult RationalNumberType::binaryOperatorResult(Token _operator, Type const* _other) const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2016-05-10 10:42:38 +00:00
|
|
|
if (_other->category() == Category::Integer || _other->category() == Category::FixedPoint)
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2020-05-19 15:53:39 +00:00
|
|
|
if (isFractional())
|
|
|
|
return TypeResult::err("Fractional literals not supported.");
|
|
|
|
else if (!integerType())
|
|
|
|
return TypeResult::err("Literal too large.");
|
|
|
|
|
|
|
|
// Shift and exp are not symmetric, so it does not make sense to swap
|
|
|
|
// the types as below. As an exception, we always use uint here.
|
|
|
|
if (TokenTraits::isShiftOp(_operator))
|
|
|
|
{
|
|
|
|
if (!isValidShiftAndAmountType(_operator, *_other))
|
|
|
|
return nullptr;
|
|
|
|
return isNegative() ? TypeProvider::int256() : TypeProvider::uint256();
|
|
|
|
}
|
|
|
|
else if (Token::Exp == _operator)
|
|
|
|
{
|
|
|
|
if (auto const* otherIntType = dynamic_cast<IntegerType const*>(_other))
|
|
|
|
{
|
|
|
|
if (otherIntType->isSigned())
|
|
|
|
return TypeResult::err("Exponentiation power is not allowed to be a signed integer type.");
|
|
|
|
}
|
|
|
|
else if (dynamic_cast<FixedPointType const*>(_other))
|
|
|
|
return TypeResult::err("Exponent is fractional.");
|
|
|
|
|
|
|
|
return isNegative() ? TypeProvider::int256() : TypeProvider::uint256();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
auto commonType = Type::commonType(this, _other);
|
|
|
|
if (!commonType)
|
|
|
|
return nullptr;
|
|
|
|
return commonType->binaryOperatorResult(_operator, _other);
|
|
|
|
}
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
2015-08-31 16:44:29 +00:00
|
|
|
else if (_other->category() != category())
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2014-12-19 10:31:17 +00:00
|
|
|
|
2016-03-29 20:08:51 +00:00
|
|
|
RationalNumberType const& other = dynamic_cast<RationalNumberType const&>(*_other);
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isCompareOp(_operator))
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2018-07-10 07:18:59 +00:00
|
|
|
// Since we do not have a "BoolConstantType", we have to do the actual comparison
|
2016-05-10 10:42:38 +00:00
|
|
|
// at runtime and convert to mobile typse first. Such a comparison is not a very common
|
|
|
|
// use-case and will be optimized away.
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* thisMobile = mobileType();
|
|
|
|
Type const* otherMobile = other.mobileType();
|
2016-05-10 10:42:38 +00:00
|
|
|
if (!thisMobile || !otherMobile)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-05-10 10:42:38 +00:00
|
|
|
return thisMobile->binaryOperatorResult(_operator, otherMobile);
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
2020-11-18 16:54:30 +00:00
|
|
|
else if (optional<rational> value = ConstantEvaluator::evaluateBinaryOperator(_operator, m_value, other.m_value))
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2018-03-26 17:48:20 +00:00
|
|
|
// verify that numerator and denominator fit into 4096 bit after every operation
|
2020-11-18 16:54:30 +00:00
|
|
|
if (value->numerator() != 0 && max(boost::multiprecision::msb(abs(value->numerator())), boost::multiprecision::msb(abs(value->denominator()))) > 4096)
|
2019-02-27 17:21:53 +00:00
|
|
|
return TypeResult::err("Precision of rational constants is limited to 4096 bits.");
|
2018-03-26 17:48:20 +00:00
|
|
|
|
2020-11-18 16:54:30 +00:00
|
|
|
return TypeResult{TypeProvider::rationalNumber(*value)};
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
2020-11-18 16:54:30 +00:00
|
|
|
else
|
|
|
|
return nullptr;
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string RationalNumberType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-08-07 01:40:39 +00:00
|
|
|
// rational seemingly will put the sign always on the numerator,
|
|
|
|
// but let just make it deterministic here.
|
|
|
|
bigint numerator = abs(m_value.numerator());
|
|
|
|
bigint denominator = abs(m_value.denominator());
|
|
|
|
if (m_value < 0)
|
|
|
|
return "t_rational_minus_" + numerator.str() + "_by_" + denominator.str();
|
|
|
|
else
|
|
|
|
return "t_rational_" + numerator.str() + "_by_" + denominator.str();
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2016-03-29 20:08:51 +00:00
|
|
|
bool RationalNumberType::operator==(Type const& _other) const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-12-19 10:31:17 +00:00
|
|
|
return false;
|
2016-03-29 20:08:51 +00:00
|
|
|
RationalNumberType const& other = dynamic_cast<RationalNumberType const&>(_other);
|
2016-02-18 22:39:11 +00:00
|
|
|
return m_value == other.m_value;
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2019-12-11 16:31:36 +00:00
|
|
|
string RationalNumberType::bigintToReadableString(bigint const& _num)
|
2017-12-19 15:45:04 +00:00
|
|
|
{
|
|
|
|
string str = _num.str();
|
2018-02-13 10:43:47 +00:00
|
|
|
if (str.size() > 32)
|
2017-12-19 15:45:04 +00:00
|
|
|
{
|
2020-06-02 13:42:46 +00:00
|
|
|
size_t omitted = str.size() - 8;
|
2018-02-13 10:43:47 +00:00
|
|
|
str = str.substr(0, 4) + "...(" + to_string(omitted) + " digits omitted)..." + str.substr(str.size() - 4, 4);
|
2017-12-19 15:45:04 +00:00
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2018-02-13 10:43:47 +00:00
|
|
|
string RationalNumberType::toString(bool) const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2016-05-10 12:30:24 +00:00
|
|
|
if (!isFractional())
|
2018-02-13 10:43:47 +00:00
|
|
|
return "int_const " + bigintToReadableString(m_value.numerator());
|
2017-12-19 15:45:04 +00:00
|
|
|
|
2018-02-13 10:43:47 +00:00
|
|
|
string numerator = bigintToReadableString(m_value.numerator());
|
|
|
|
string denominator = bigintToReadableString(m_value.denominator());
|
|
|
|
return "rational_const " + numerator + " / " + denominator;
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2016-03-29 20:08:51 +00:00
|
|
|
u256 RationalNumberType::literalValue(Literal const*) const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2016-05-10 11:31:10 +00:00
|
|
|
// We ignore the literal and hope that the type was correctly determined to represent
|
|
|
|
// its value.
|
|
|
|
|
2015-02-04 15:37:54 +00:00
|
|
|
u256 value;
|
2018-05-22 15:20:40 +00:00
|
|
|
bigint shiftedValue;
|
2016-05-05 22:47:08 +00:00
|
|
|
|
2016-05-10 12:30:24 +00:00
|
|
|
if (!isFractional())
|
2016-05-10 11:31:10 +00:00
|
|
|
shiftedValue = m_value.numerator();
|
|
|
|
else
|
2016-05-05 22:47:08 +00:00
|
|
|
{
|
|
|
|
auto fixed = fixedPointType();
|
2018-09-21 16:06:25 +00:00
|
|
|
solAssert(fixed, "Rational number cannot be represented as fixed point type.");
|
2020-06-02 13:42:46 +00:00
|
|
|
unsigned fractionalDigits = fixed->fractionalDigits();
|
2018-05-04 04:18:34 +00:00
|
|
|
shiftedValue = m_value.numerator() * boost::multiprecision::pow(bigint(10), fractionalDigits) / m_value.denominator();
|
2016-05-05 22:47:08 +00:00
|
|
|
}
|
2016-05-10 11:31:10 +00:00
|
|
|
|
2014-12-19 10:31:17 +00:00
|
|
|
// we ignore the literal and hope that the type was correctly determined
|
2018-09-21 16:06:25 +00:00
|
|
|
solAssert(shiftedValue <= u256(-1), "Number constant too large.");
|
2016-04-08 06:19:20 +00:00
|
|
|
solAssert(shiftedValue >= -(bigint(1) << 255), "Number constant too small.");
|
2015-02-04 15:37:54 +00:00
|
|
|
|
2017-03-10 01:04:26 +00:00
|
|
|
if (m_value >= rational(0))
|
2016-04-08 06:19:20 +00:00
|
|
|
value = u256(shiftedValue);
|
2014-12-19 10:31:17 +00:00
|
|
|
else
|
2016-04-12 17:36:34 +00:00
|
|
|
value = s2u(s256(shiftedValue));
|
2015-02-04 15:37:54 +00:00
|
|
|
return value;
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* RationalNumberType::mobileType() const
|
2015-02-06 12:42:51 +00:00
|
|
|
{
|
2016-05-10 12:30:24 +00:00
|
|
|
if (!isFractional())
|
2016-05-10 08:26:53 +00:00
|
|
|
return integerType();
|
|
|
|
else
|
|
|
|
return fixedPointType();
|
2015-02-06 12:42:51 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
IntegerType const* RationalNumberType::integerType() const
|
2014-12-19 10:31:17 +00:00
|
|
|
{
|
2016-05-10 12:30:24 +00:00
|
|
|
solAssert(!isFractional(), "integerType() called for fractional number.");
|
|
|
|
bigint value = m_value.numerator();
|
2014-12-19 10:31:17 +00:00
|
|
|
bool negative = (value < 0);
|
|
|
|
if (negative) // convert to positive number of same bit requirements
|
2016-02-18 22:39:11 +00:00
|
|
|
value = ((0 - value) - 1) << 1;
|
2014-12-19 10:31:17 +00:00
|
|
|
if (value > u256(-1))
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2014-12-19 10:31:17 +00:00
|
|
|
else
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::integer(
|
2019-12-11 16:31:36 +00:00
|
|
|
max(util::bytesRequired(value), 1u) * 8,
|
2015-06-03 14:14:23 +00:00
|
|
|
negative ? IntegerType::Modifier::Signed : IntegerType::Modifier::Unsigned
|
|
|
|
);
|
2014-12-19 10:31:17 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
FixedPointType const* RationalNumberType::fixedPointType() const
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2016-03-18 20:03:26 +00:00
|
|
|
bool negative = (m_value < 0);
|
2016-12-22 18:20:03 +00:00
|
|
|
unsigned fractionalDigits = 0;
|
2016-05-10 11:31:10 +00:00
|
|
|
rational value = abs(m_value); // We care about the sign later.
|
2018-05-22 15:20:40 +00:00
|
|
|
rational maxValue = negative ?
|
2016-05-10 12:57:29 +00:00
|
|
|
rational(bigint(1) << 255, 1):
|
|
|
|
rational((bigint(1) << 256) - 1, 1);
|
2016-04-12 17:36:34 +00:00
|
|
|
|
2016-12-22 18:20:03 +00:00
|
|
|
while (value * 10 <= maxValue && value.denominator() != 1 && fractionalDigits < 80)
|
2016-02-18 22:39:11 +00:00
|
|
|
{
|
2016-12-22 18:20:03 +00:00
|
|
|
value *= 10;
|
|
|
|
fractionalDigits++;
|
2016-04-08 06:19:20 +00:00
|
|
|
}
|
2018-05-22 15:20:40 +00:00
|
|
|
|
2016-04-11 23:12:11 +00:00
|
|
|
if (value > maxValue)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
|
|
|
|
2017-07-12 13:44:27 +00:00
|
|
|
// This means we round towards zero for positive and negative values.
|
2016-05-05 22:47:08 +00:00
|
|
|
bigint v = value.numerator() / value.denominator();
|
2018-08-08 12:46:17 +00:00
|
|
|
|
|
|
|
if (negative && v != 0)
|
2016-05-10 11:31:10 +00:00
|
|
|
// modify value to satisfy bit requirements for negative numbers:
|
|
|
|
// add one bit for sign and decrement because negative numbers can be larger
|
2016-05-05 22:47:08 +00:00
|
|
|
v = (v - 1) << 1;
|
2016-05-10 12:07:11 +00:00
|
|
|
|
2016-05-05 22:47:08 +00:00
|
|
|
if (v > u256(-1))
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-05-10 12:07:11 +00:00
|
|
|
|
2019-12-11 16:31:36 +00:00
|
|
|
unsigned totalBits = max(util::bytesRequired(v), 1u) * 8;
|
2016-05-10 12:07:11 +00:00
|
|
|
solAssert(totalBits <= 256, "");
|
2016-05-05 22:47:08 +00:00
|
|
|
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::fixedPoint(
|
2016-12-22 18:20:03 +00:00
|
|
|
totalBits, fractionalDigits,
|
2016-04-11 23:12:11 +00:00
|
|
|
negative ? FixedPointType::Modifier::Signed : FixedPointType::Modifier::Unsigned
|
|
|
|
);
|
2016-02-18 22:39:11 +00:00
|
|
|
}
|
|
|
|
|
2015-07-07 23:13:56 +00:00
|
|
|
StringLiteralType::StringLiteralType(Literal const& _literal):
|
2015-08-31 16:44:29 +00:00
|
|
|
m_value(_literal.value())
|
2015-07-07 23:13:56 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2020-04-01 03:04:29 +00:00
|
|
|
StringLiteralType::StringLiteralType(string _value):
|
|
|
|
m_value{std::move(_value)}
|
2019-04-15 13:33:39 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult StringLiteralType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2015-07-07 23:13:56 +00:00
|
|
|
{
|
|
|
|
if (auto fixedBytes = dynamic_cast<FixedBytesType const*>(&_convertTo))
|
2020-09-23 15:31:17 +00:00
|
|
|
{
|
|
|
|
if (static_cast<size_t>(fixedBytes->numBytes()) < m_value.size())
|
|
|
|
return BoolResult::err("Literal is larger than the type.");
|
|
|
|
return true;
|
|
|
|
}
|
2015-07-07 23:13:56 +00:00
|
|
|
else if (auto arrayType = dynamic_cast<ArrayType const*>(&_convertTo))
|
2020-09-23 14:04:22 +00:00
|
|
|
{
|
|
|
|
size_t invalidSequence;
|
|
|
|
if (arrayType->isString() && !util::validateUTF8(value(), invalidSequence))
|
|
|
|
return BoolResult::err(
|
|
|
|
"Contains invalid UTF-8 sequence at position " +
|
|
|
|
util::toString(invalidSequence) +
|
|
|
|
"."
|
|
|
|
);
|
2015-09-23 15:26:17 +00:00
|
|
|
return
|
2020-09-16 10:11:06 +00:00
|
|
|
arrayType->location() != DataLocation::CallData &&
|
2015-09-23 15:26:17 +00:00
|
|
|
arrayType->isByteArray() &&
|
2020-09-23 14:04:22 +00:00
|
|
|
!(arrayType->dataStoredIn(DataLocation::Storage) && arrayType->isPointer());
|
|
|
|
}
|
2015-07-07 23:13:56 +00:00
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string StringLiteralType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
|
|
|
// Since we have to return a valid identifier and the string itself may contain
|
|
|
|
// anything, we hash it.
|
2019-12-11 16:31:36 +00:00
|
|
|
return "t_stringliteral_" + util::toHex(util::keccak256(m_value).asBytes());
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2019-02-13 15:22:42 +00:00
|
|
|
bool StringLiteralType::operator==(Type const& _other) const
|
2015-07-07 23:13:56 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2015-07-07 23:13:56 +00:00
|
|
|
return false;
|
|
|
|
return m_value == dynamic_cast<StringLiteralType const&>(_other).m_value;
|
|
|
|
}
|
|
|
|
|
2016-08-05 09:48:09 +00:00
|
|
|
std::string StringLiteralType::toString(bool) const
|
|
|
|
{
|
2020-09-23 12:53:56 +00:00
|
|
|
auto isPrintableASCII = [](string const& s)
|
|
|
|
{
|
|
|
|
for (auto c: s)
|
|
|
|
{
|
|
|
|
if (static_cast<unsigned>(c) <= 0x1f || static_cast<unsigned>(c) >= 0x7f)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
};
|
2016-08-05 17:27:44 +00:00
|
|
|
|
2020-09-23 14:04:22 +00:00
|
|
|
return isPrintableASCII(m_value) ?
|
2020-09-23 12:53:56 +00:00
|
|
|
("literal_string \"" + m_value + "\"") :
|
|
|
|
("literal_string hex\"" + util::toHex(util::asBytes(m_value)) + "\"");
|
2016-08-05 09:48:09 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* StringLiteralType::mobileType() const
|
2015-07-07 23:13:56 +00:00
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::stringMemory();
|
2015-07-07 23:13:56 +00:00
|
|
|
}
|
|
|
|
|
2018-05-01 05:58:04 +00:00
|
|
|
FixedBytesType::FixedBytesType(unsigned _bytes): m_bytes(_bytes)
|
2014-12-09 17:46:18 +00:00
|
|
|
{
|
2018-04-30 11:23:30 +00:00
|
|
|
solAssert(
|
|
|
|
m_bytes > 0 && m_bytes <= 32,
|
2019-12-11 16:31:36 +00:00
|
|
|
"Invalid byte number for fixed bytes type: " + util::toString(m_bytes)
|
2018-04-30 11:23:30 +00:00
|
|
|
);
|
2014-12-09 17:46:18 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult FixedBytesType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-12-09 17:46:18 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_convertTo.category() != category())
|
2014-12-09 17:46:18 +00:00
|
|
|
return false;
|
2015-03-05 15:54:55 +00:00
|
|
|
FixedBytesType const& convertTo = dynamic_cast<FixedBytesType const&>(_convertTo);
|
2014-12-09 17:46:18 +00:00
|
|
|
return convertTo.m_bytes >= m_bytes;
|
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult FixedBytesType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2015-01-23 16:36:12 +00:00
|
|
|
{
|
2020-11-09 09:10:30 +00:00
|
|
|
if (_convertTo.category() == category())
|
|
|
|
return true;
|
|
|
|
else if (auto integerType = dynamic_cast<IntegerType const*>(&_convertTo))
|
|
|
|
return (!integerType->isSigned() && integerType->numBits() == numBytes() * 8);
|
2020-12-15 11:43:59 +00:00
|
|
|
else if (auto addressType = dynamic_cast<AddressType const*>(&_convertTo))
|
|
|
|
return
|
|
|
|
(addressType->stateMutability() != StateMutability::Payable) &&
|
|
|
|
(numBytes() == 20);
|
2020-11-09 09:10:30 +00:00
|
|
|
else if (auto fixedPointType = dynamic_cast<FixedPointType const*>(&_convertTo))
|
|
|
|
return fixedPointType->numBits() == numBytes() * 8;
|
|
|
|
|
|
|
|
return false;
|
2015-01-23 16:36:12 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult FixedBytesType::unaryOperatorResult(Token _operator) const
|
2015-03-05 15:54:55 +00:00
|
|
|
{
|
|
|
|
// "delete" and "~" is okay for FixedBytesType
|
|
|
|
if (_operator == Token::Delete)
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeResult{TypeProvider::emptyTuple()};
|
2015-03-05 15:54:55 +00:00
|
|
|
else if (_operator == Token::BitNot)
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2015-03-05 15:54:55 +00:00
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2015-03-05 15:54:55 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
TypeResult FixedBytesType::binaryOperatorResult(Token _operator, Type const* _other) const
|
2015-03-05 15:54:55 +00:00
|
|
|
{
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isShiftOp(_operator))
|
2016-12-05 17:40:50 +00:00
|
|
|
{
|
2016-12-06 22:45:17 +00:00
|
|
|
if (isValidShiftAndAmountType(_operator, *_other))
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2016-12-06 22:45:17 +00:00
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-12-05 17:40:50 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
auto commonType = dynamic_cast<FixedBytesType const*>(Type::commonType(this, _other));
|
2015-03-05 15:54:55 +00:00
|
|
|
if (!commonType)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2015-03-05 15:54:55 +00:00
|
|
|
|
|
|
|
// FixedBytes can be compared and have bitwise operators applied to them
|
2018-10-22 14:48:21 +00:00
|
|
|
if (TokenTraits::isCompareOp(_operator) || TokenTraits::isBitOp(_operator))
|
2018-05-07 22:31:34 +00:00
|
|
|
return TypeResult(commonType);
|
2015-03-05 15:54:55 +00:00
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2015-03-05 15:54:55 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap FixedBytesType::nativeMembers(ASTNode const*) const
|
2016-02-03 20:34:24 +00:00
|
|
|
{
|
2019-04-15 16:10:43 +00:00
|
|
|
return MemberList::MemberMap{MemberList::Member{"length", TypeProvider::uint(8)}};
|
2016-02-03 20:34:24 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string FixedBytesType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-08-08 14:26:30 +00:00
|
|
|
return "t_bytes" + to_string(m_bytes);
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2015-03-05 15:54:55 +00:00
|
|
|
bool FixedBytesType::operator==(Type const& _other) const
|
2014-12-09 17:46:18 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-12-09 17:46:18 +00:00
|
|
|
return false;
|
2015-03-05 15:54:55 +00:00
|
|
|
FixedBytesType const& other = dynamic_cast<FixedBytesType const&>(_other);
|
2014-12-09 17:46:18 +00:00
|
|
|
return other.m_bytes == m_bytes;
|
|
|
|
}
|
|
|
|
|
2014-12-19 10:31:17 +00:00
|
|
|
u256 BoolType::literalValue(Literal const* _literal) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2014-12-19 10:31:17 +00:00
|
|
|
solAssert(_literal, "");
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_literal->token() == Token::TrueLiteral)
|
2014-10-30 00:20:32 +00:00
|
|
|
return u256(1);
|
2015-08-31 16:44:29 +00:00
|
|
|
else if (_literal->token() == Token::FalseLiteral)
|
2014-10-30 00:20:32 +00:00
|
|
|
return u256(0);
|
2014-10-20 10:41:56 +00:00
|
|
|
else
|
2017-07-19 01:19:00 +00:00
|
|
|
solAssert(false, "Bool type constructed from non-boolean literal.");
|
2014-10-20 10:41:56 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult BoolType::unaryOperatorResult(Token _operator) const
|
2015-01-14 12:52:03 +00:00
|
|
|
{
|
2015-02-09 13:00:12 +00:00
|
|
|
if (_operator == Token::Delete)
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::emptyTuple();
|
2019-04-15 13:33:39 +00:00
|
|
|
else if (_operator == Token::Not)
|
|
|
|
return this;
|
|
|
|
else
|
|
|
|
return nullptr;
|
2015-01-14 12:52:03 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
TypeResult BoolType::binaryOperatorResult(Token _operator, Type const* _other) const
|
2014-12-18 17:53:43 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (category() != _other->category())
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2018-04-27 09:35:58 +00:00
|
|
|
if (_operator == Token::Equal || _operator == Token::NotEqual || _operator == Token::And || _operator == Token::Or)
|
2015-01-06 17:55:31 +00:00
|
|
|
return _other;
|
2014-12-18 17:53:43 +00:00
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Type const* ContractType::encodingType() const
|
|
|
|
{
|
|
|
|
if (isSuper())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (isPayable())
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::payableAddress();
|
2019-04-15 13:33:39 +00:00
|
|
|
else
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::address();
|
2014-12-18 17:53:43 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult ContractType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2014-11-20 17:33:23 +00:00
|
|
|
{
|
2019-11-19 12:07:32 +00:00
|
|
|
if (m_super)
|
|
|
|
return false;
|
|
|
|
|
2015-01-07 21:54:56 +00:00
|
|
|
if (*this == _convertTo)
|
2014-11-20 17:33:23 +00:00
|
|
|
return true;
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_convertTo.category() == Category::Contract)
|
2015-01-19 22:34:49 +00:00
|
|
|
{
|
2020-09-06 20:41:49 +00:00
|
|
|
auto const& targetContractType = dynamic_cast<ContractType const&>(_convertTo);
|
|
|
|
if (targetContractType.isSuper())
|
|
|
|
return false;
|
|
|
|
|
2015-09-16 14:56:30 +00:00
|
|
|
auto const& bases = contractDefinition().annotation().linearizedBaseContracts;
|
2018-06-19 19:32:03 +00:00
|
|
|
return find(
|
2020-09-06 20:15:38 +00:00
|
|
|
bases.begin(),
|
|
|
|
bases.end(),
|
2020-09-06 20:41:49 +00:00
|
|
|
&targetContractType.contractDefinition()
|
2018-06-19 19:32:03 +00:00
|
|
|
) != bases.end();
|
2015-01-19 22:34:49 +00:00
|
|
|
}
|
2014-11-20 17:33:23 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult ContractType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2015-01-07 21:54:56 +00:00
|
|
|
{
|
2019-11-19 12:07:32 +00:00
|
|
|
if (m_super)
|
|
|
|
return false;
|
|
|
|
|
2018-09-05 15:59:55 +00:00
|
|
|
if (auto const* addressType = dynamic_cast<AddressType const*>(&_convertTo))
|
|
|
|
return isPayable() || (addressType->stateMutability() < StateMutability::Payable);
|
2019-11-19 12:07:32 +00:00
|
|
|
|
2018-09-05 15:59:55 +00:00
|
|
|
return isImplicitlyConvertibleTo(_convertTo);
|
2015-01-07 21:54:56 +00:00
|
|
|
}
|
|
|
|
|
2017-07-09 01:42:42 +00:00
|
|
|
bool ContractType::isPayable() const
|
|
|
|
{
|
2019-09-09 16:22:02 +00:00
|
|
|
auto receiveFunction = m_contract.receiveFunction();
|
2017-07-09 01:42:42 +00:00
|
|
|
auto fallbackFunction = m_contract.fallbackFunction();
|
2019-09-09 16:22:02 +00:00
|
|
|
return receiveFunction || (fallbackFunction && fallbackFunction->isPayable());
|
2017-07-09 01:42:42 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult ContractType::unaryOperatorResult(Token _operator) const
|
2015-01-14 12:52:03 +00:00
|
|
|
{
|
2018-03-16 15:06:40 +00:00
|
|
|
if (isSuper())
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
|
|
|
else if (_operator == Token::Delete)
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::emptyTuple();
|
2019-04-15 13:33:39 +00:00
|
|
|
else
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2020-09-15 23:06:54 +00:00
|
|
|
vector<Type const*> CompositeType::fullDecomposition() const
|
|
|
|
{
|
|
|
|
vector<Type const*> res = {this};
|
|
|
|
unordered_set<string> seen = {richIdentifier()};
|
|
|
|
for (size_t k = 0; k < res.size(); ++k)
|
|
|
|
if (auto composite = dynamic_cast<CompositeType const*>(res[k]))
|
|
|
|
for (Type const* next: composite->decomposition())
|
|
|
|
if (seen.count(next->richIdentifier()) == 0)
|
|
|
|
{
|
|
|
|
seen.insert(next->richIdentifier());
|
|
|
|
res.push_back(next);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
Type const* ReferenceType::withLocation(DataLocation _location, bool _isPointer) const
|
|
|
|
{
|
|
|
|
return TypeProvider::withLocation(this, _location, _isPointer);
|
2015-01-14 12:52:03 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult ReferenceType::unaryOperatorResult(Token _operator) const
|
2015-06-26 17:14:26 +00:00
|
|
|
{
|
|
|
|
if (_operator != Token::Delete)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2015-06-26 17:14:26 +00:00
|
|
|
// delete can be used on everything except calldata references or storage pointers
|
|
|
|
// (storage references are ok)
|
|
|
|
switch (location())
|
|
|
|
{
|
|
|
|
case DataLocation::CallData:
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2015-06-26 17:14:26 +00:00
|
|
|
case DataLocation::Memory:
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::emptyTuple();
|
2015-06-26 17:14:26 +00:00
|
|
|
case DataLocation::Storage:
|
2020-03-13 11:50:14 +00:00
|
|
|
return isPointer() ? nullptr : TypeProvider::emptyTuple();
|
2015-06-26 17:14:26 +00:00
|
|
|
}
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2015-06-26 17:14:26 +00:00
|
|
|
}
|
|
|
|
|
2020-03-13 11:50:14 +00:00
|
|
|
bool ReferenceType::isPointer() const
|
|
|
|
{
|
|
|
|
if (m_location == DataLocation::Storage)
|
|
|
|
return m_isPointer;
|
|
|
|
else
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* ReferenceType::copyForLocationIfReference(Type const* _type) const
|
2015-06-09 12:26:08 +00:00
|
|
|
{
|
2019-04-17 11:25:03 +00:00
|
|
|
return TypeProvider::withLocationIfReference(m_location, _type);
|
2015-06-09 12:26:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
string ReferenceType::stringForReferencePart() const
|
|
|
|
{
|
|
|
|
switch (m_location)
|
|
|
|
{
|
2015-06-17 10:01:39 +00:00
|
|
|
case DataLocation::Storage:
|
2020-03-13 11:50:14 +00:00
|
|
|
return string("storage ") + (isPointer() ? "pointer" : "ref");
|
2015-06-17 10:01:39 +00:00
|
|
|
case DataLocation::CallData:
|
2015-06-09 12:26:08 +00:00
|
|
|
return "calldata";
|
2015-06-17 10:01:39 +00:00
|
|
|
case DataLocation::Memory:
|
2015-06-09 12:26:08 +00:00
|
|
|
return "memory";
|
|
|
|
}
|
2015-06-12 08:48:47 +00:00
|
|
|
solAssert(false, "");
|
|
|
|
return "";
|
2015-06-09 12:26:08 +00:00
|
|
|
}
|
|
|
|
|
2017-01-17 09:47:44 +00:00
|
|
|
string ReferenceType::identifierLocationSuffix() const
|
|
|
|
{
|
|
|
|
string id;
|
2018-05-23 04:31:20 +00:00
|
|
|
switch (location())
|
|
|
|
{
|
|
|
|
case DataLocation::Storage:
|
2017-01-17 09:47:44 +00:00
|
|
|
id += "_storage";
|
2018-05-23 04:31:20 +00:00
|
|
|
break;
|
|
|
|
case DataLocation::Memory:
|
2017-01-17 09:47:44 +00:00
|
|
|
id += "_memory";
|
2018-05-23 04:31:20 +00:00
|
|
|
break;
|
|
|
|
case DataLocation::CallData:
|
2017-01-17 09:47:44 +00:00
|
|
|
id += "_calldata";
|
2018-05-23 04:31:20 +00:00
|
|
|
break;
|
|
|
|
}
|
2017-01-17 09:47:44 +00:00
|
|
|
if (isPointer())
|
|
|
|
id += "_ptr";
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
ArrayType::ArrayType(DataLocation _location, bool _isString):
|
|
|
|
ReferenceType(_location),
|
|
|
|
m_arrayKind(_isString ? ArrayKind::String : ArrayKind::Bytes),
|
2019-04-17 11:40:50 +00:00
|
|
|
m_baseType{TypeProvider::byte()}
|
2019-04-15 13:33:39 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void ArrayType::clearCache() const
|
|
|
|
{
|
|
|
|
Type::clearCache();
|
|
|
|
|
|
|
|
m_interfaceType.reset();
|
|
|
|
m_interfaceType_library.reset();
|
|
|
|
}
|
|
|
|
|
2019-02-13 15:22:42 +00:00
|
|
|
BoolResult ArrayType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2015-02-10 08:00:50 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_convertTo.category() != category())
|
2015-02-27 13:50:06 +00:00
|
|
|
return false;
|
|
|
|
auto& convertTo = dynamic_cast<ArrayType const&>(_convertTo);
|
2015-05-28 14:20:50 +00:00
|
|
|
if (convertTo.isByteArray() != isByteArray() || convertTo.isString() != isString())
|
2015-02-27 13:50:06 +00:00
|
|
|
return false;
|
2015-06-09 12:26:08 +00:00
|
|
|
// memory/calldata to storage can be converted, but only to a direct storage reference
|
2015-06-17 10:01:39 +00:00
|
|
|
if (convertTo.location() == DataLocation::Storage && location() != DataLocation::Storage && convertTo.isPointer())
|
2015-02-27 13:50:06 +00:00
|
|
|
return false;
|
2015-06-17 10:01:39 +00:00
|
|
|
if (convertTo.location() == DataLocation::CallData && location() != convertTo.location())
|
2015-06-09 12:26:08 +00:00
|
|
|
return false;
|
2015-06-17 10:01:39 +00:00
|
|
|
if (convertTo.location() == DataLocation::Storage && !convertTo.isPointer())
|
2015-06-09 12:26:08 +00:00
|
|
|
{
|
|
|
|
// Less restrictive conversion, since we need to copy anyway.
|
2015-08-31 16:44:29 +00:00
|
|
|
if (!baseType()->isImplicitlyConvertibleTo(*convertTo.baseType()))
|
2015-06-09 12:26:08 +00:00
|
|
|
return false;
|
|
|
|
if (convertTo.isDynamicallySized())
|
|
|
|
return true;
|
2015-08-31 16:44:29 +00:00
|
|
|
return !isDynamicallySized() && convertTo.length() >= length();
|
2015-06-09 12:26:08 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-06-23 12:55:33 +00:00
|
|
|
// Conversion to storage pointer or to memory, we de not copy element-for-element here, so
|
|
|
|
// require that the base type is the same, not only convertible.
|
|
|
|
// This disallows assignment of nested dynamic arrays from storage to memory for now.
|
|
|
|
if (
|
2019-04-15 13:33:39 +00:00
|
|
|
*TypeProvider::withLocationIfReference(location(), baseType()) !=
|
|
|
|
*TypeProvider::withLocationIfReference(location(), convertTo.baseType())
|
2015-06-23 12:55:33 +00:00
|
|
|
)
|
2015-06-09 12:26:08 +00:00
|
|
|
return false;
|
|
|
|
if (isDynamicallySized() != convertTo.isDynamicallySized())
|
|
|
|
return false;
|
|
|
|
// We also require that the size is the same.
|
2015-08-31 16:44:29 +00:00
|
|
|
if (!isDynamicallySized() && length() != convertTo.length())
|
2015-06-09 12:26:08 +00:00
|
|
|
return false;
|
2015-02-27 13:50:06 +00:00
|
|
|
return true;
|
2015-06-09 12:26:08 +00:00
|
|
|
}
|
2015-02-10 08:00:50 +00:00
|
|
|
}
|
|
|
|
|
2019-02-13 15:22:42 +00:00
|
|
|
BoolResult ArrayType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2015-08-04 09:06:57 +00:00
|
|
|
{
|
|
|
|
if (isImplicitlyConvertibleTo(_convertTo))
|
|
|
|
return true;
|
2021-03-04 07:52:17 +00:00
|
|
|
// allow conversion bytes <-> string and bytes -> bytesNN
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_convertTo.category() != category())
|
2021-03-04 07:52:17 +00:00
|
|
|
return isByteArray() && !isString() && _convertTo.category() == Type::Category::FixedBytes;
|
2015-08-04 09:06:57 +00:00
|
|
|
auto& convertTo = dynamic_cast<ArrayType const&>(_convertTo);
|
|
|
|
if (convertTo.location() != location())
|
|
|
|
return false;
|
|
|
|
if (!isByteArray() || !convertTo.isByteArray())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string ArrayType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
|
|
|
string id;
|
|
|
|
if (isString())
|
2017-01-19 12:18:56 +00:00
|
|
|
id = "t_string";
|
2017-01-17 09:47:44 +00:00
|
|
|
else if (isByteArray())
|
2017-01-19 12:18:56 +00:00
|
|
|
id = "t_bytes";
|
2017-01-17 09:47:44 +00:00
|
|
|
else
|
|
|
|
{
|
2017-01-19 12:18:56 +00:00
|
|
|
id = "t_array";
|
|
|
|
id += identifierList(baseType());
|
2017-01-17 09:47:44 +00:00
|
|
|
if (isDynamicallySized())
|
2017-01-19 12:18:56 +00:00
|
|
|
id += "dyn";
|
2017-01-17 09:47:44 +00:00
|
|
|
else
|
2017-01-19 12:18:56 +00:00
|
|
|
id += length().str();
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
id += identifierLocationSuffix();
|
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2015-02-20 14:52:30 +00:00
|
|
|
bool ArrayType::operator==(Type const& _other) const
|
2015-02-09 17:45:00 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2015-02-09 17:45:00 +00:00
|
|
|
return false;
|
2015-02-20 14:52:30 +00:00
|
|
|
ArrayType const& other = dynamic_cast<ArrayType const&>(_other);
|
2015-05-28 14:20:50 +00:00
|
|
|
if (
|
2015-06-09 12:26:08 +00:00
|
|
|
!ReferenceType::operator==(other) ||
|
2015-05-28 14:20:50 +00:00
|
|
|
other.isByteArray() != isByteArray() ||
|
|
|
|
other.isString() != isString() ||
|
|
|
|
other.isDynamicallySized() != isDynamicallySized()
|
|
|
|
)
|
2015-02-27 13:50:06 +00:00
|
|
|
return false;
|
2015-12-18 12:56:37 +00:00
|
|
|
if (*other.baseType() != *baseType())
|
|
|
|
return false;
|
2017-01-17 09:47:44 +00:00
|
|
|
return isDynamicallySized() || length() == other.length();
|
2015-02-09 17:45:00 +00:00
|
|
|
}
|
|
|
|
|
2020-04-14 17:03:46 +00:00
|
|
|
BoolResult ArrayType::validForLocation(DataLocation _loc) const
|
2017-07-11 20:56:09 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
if (auto arrayBaseType = dynamic_cast<ArrayType const*>(baseType()))
|
2020-04-14 17:03:46 +00:00
|
|
|
{
|
|
|
|
BoolResult result = arrayBaseType->validForLocation(_loc);
|
|
|
|
if (!result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
if (isDynamicallySized())
|
|
|
|
return true;
|
|
|
|
switch (_loc)
|
|
|
|
{
|
|
|
|
case DataLocation::Memory:
|
|
|
|
{
|
2020-04-16 15:51:18 +00:00
|
|
|
bigint size = bigint(length());
|
|
|
|
auto type = m_baseType;
|
|
|
|
while (auto arrayType = dynamic_cast<ArrayType const*>(type))
|
|
|
|
{
|
|
|
|
if (arrayType->isDynamicallySized())
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
size *= arrayType->length();
|
|
|
|
type = arrayType->baseType();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (type->isDynamicallySized())
|
|
|
|
size *= type->memoryHeadSize();
|
|
|
|
else
|
|
|
|
size *= type->memoryDataSize();
|
2020-04-14 17:03:46 +00:00
|
|
|
if (size >= numeric_limits<unsigned>::max())
|
|
|
|
return BoolResult::err("Type too large for memory.");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DataLocation::CallData:
|
|
|
|
{
|
|
|
|
if (unlimitedStaticCalldataSize(true) >= numeric_limits<unsigned>::max())
|
|
|
|
return BoolResult::err("Type too large for calldata.");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DataLocation::Storage:
|
2020-07-14 08:32:11 +00:00
|
|
|
if (storageSizeUpperBound() >= bigint(1) << 256)
|
2020-07-06 19:40:50 +00:00
|
|
|
return BoolResult::err("Type too large for storage.");
|
2020-04-14 17:03:46 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return true;
|
2017-07-11 20:56:09 +00:00
|
|
|
}
|
|
|
|
|
2019-07-09 14:10:38 +00:00
|
|
|
bigint ArrayType::unlimitedStaticCalldataSize(bool _padded) const
|
2015-03-03 10:28:56 +00:00
|
|
|
{
|
2019-07-09 14:10:38 +00:00
|
|
|
solAssert(!isDynamicallySized(), "");
|
|
|
|
bigint size = bigint(length()) * calldataStride();
|
2019-01-22 11:30:46 +00:00
|
|
|
if (_padded)
|
|
|
|
size = ((size + 31) / 32) * 32;
|
2017-07-11 20:56:09 +00:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ArrayType::calldataEncodedSize(bool _padded) const
|
|
|
|
{
|
2019-07-09 14:10:38 +00:00
|
|
|
solAssert(!isDynamicallyEncoded(), "");
|
|
|
|
bigint size = unlimitedStaticCalldataSize(_padded);
|
|
|
|
solAssert(size <= numeric_limits<unsigned>::max(), "Array size does not fit unsigned.");
|
|
|
|
return unsigned(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned ArrayType::calldataEncodedTailSize() const
|
|
|
|
{
|
|
|
|
solAssert(isDynamicallyEncoded(), "");
|
|
|
|
if (isDynamicallySized())
|
|
|
|
// We do not know the dynamic length itself, but at least the uint256 containing the
|
|
|
|
// length must still be present.
|
|
|
|
return 32;
|
|
|
|
bigint size = unlimitedStaticCalldataSize(false);
|
2015-03-03 10:28:56 +00:00
|
|
|
solAssert(size <= numeric_limits<unsigned>::max(), "Array size does not fit unsigned.");
|
|
|
|
return unsigned(size);
|
|
|
|
}
|
|
|
|
|
2017-08-07 10:41:45 +00:00
|
|
|
bool ArrayType::isDynamicallyEncoded() const
|
|
|
|
{
|
|
|
|
return isDynamicallySized() || baseType()->isDynamicallyEncoded();
|
|
|
|
}
|
|
|
|
|
2020-07-14 08:32:11 +00:00
|
|
|
bigint ArrayType::storageSizeUpperBound() const
|
|
|
|
{
|
|
|
|
if (isDynamicallySized())
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return length() * baseType()->storageSizeUpperBound();
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
u256 ArrayType::storageSize() const
|
2015-02-22 18:15:41 +00:00
|
|
|
{
|
|
|
|
if (isDynamicallySized())
|
|
|
|
return 1;
|
2015-03-16 16:52:19 +00:00
|
|
|
|
|
|
|
bigint size;
|
2015-08-31 16:44:29 +00:00
|
|
|
unsigned baseBytes = baseType()->storageBytes();
|
2015-03-16 16:52:19 +00:00
|
|
|
if (baseBytes == 0)
|
|
|
|
size = 1;
|
|
|
|
else if (baseBytes < 32)
|
2015-02-22 18:15:41 +00:00
|
|
|
{
|
2015-03-16 16:52:19 +00:00
|
|
|
unsigned itemsPerSlot = 32 / baseBytes;
|
2015-08-31 16:44:29 +00:00
|
|
|
size = (bigint(length()) + (itemsPerSlot - 1)) / itemsPerSlot;
|
2015-02-22 18:15:41 +00:00
|
|
|
}
|
2015-03-16 16:52:19 +00:00
|
|
|
else
|
2015-08-31 16:44:29 +00:00
|
|
|
size = bigint(length()) * baseType()->storageSize();
|
2020-05-28 02:32:46 +00:00
|
|
|
solAssert(size < bigint(1) << 256, "Array too large for storage.");
|
2015-03-16 16:52:19 +00:00
|
|
|
return max<u256>(1, u256(size));
|
2015-02-22 18:15:41 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> ArrayType::makeStackItems() const
|
2015-02-10 13:57:01 +00:00
|
|
|
{
|
2020-02-06 13:05:25 +00:00
|
|
|
switch (m_location)
|
|
|
|
{
|
|
|
|
case DataLocation::CallData:
|
|
|
|
if (isDynamicallySized())
|
|
|
|
return {std::make_tuple("offset", TypeProvider::uint256()), std::make_tuple("length", TypeProvider::uint256())};
|
|
|
|
else
|
|
|
|
return {std::make_tuple("offset", TypeProvider::uint256())};
|
|
|
|
case DataLocation::Memory:
|
|
|
|
return {std::make_tuple("mpos", TypeProvider::uint256())};
|
|
|
|
case DataLocation::Storage:
|
|
|
|
// byte offset inside storage value is omitted
|
|
|
|
return {std::make_tuple("slot", TypeProvider::uint256())};
|
|
|
|
}
|
|
|
|
solAssert(false, "");
|
2015-02-10 13:57:01 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string ArrayType::toString(bool _short) const
|
2015-02-16 16:33:13 +00:00
|
|
|
{
|
2015-06-09 12:26:08 +00:00
|
|
|
string ret;
|
2015-05-28 14:20:50 +00:00
|
|
|
if (isString())
|
2015-06-09 12:26:08 +00:00
|
|
|
ret = "string";
|
2015-05-28 14:20:50 +00:00
|
|
|
else if (isByteArray())
|
2015-06-09 12:26:08 +00:00
|
|
|
ret = "bytes";
|
|
|
|
else
|
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
ret = baseType()->toString(_short) + "[";
|
2015-06-09 12:26:08 +00:00
|
|
|
if (!isDynamicallySized())
|
2015-08-31 16:44:29 +00:00
|
|
|
ret += length().str();
|
2015-06-09 12:26:08 +00:00
|
|
|
ret += "]";
|
|
|
|
}
|
|
|
|
if (!_short)
|
|
|
|
ret += " " + stringForReferencePart();
|
|
|
|
return ret;
|
2015-02-20 14:52:30 +00:00
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
string ArrayType::canonicalName() const
|
2015-10-05 15:19:23 +00:00
|
|
|
{
|
|
|
|
string ret;
|
|
|
|
if (isString())
|
|
|
|
ret = "string";
|
|
|
|
else if (isByteArray())
|
|
|
|
ret = "bytes";
|
|
|
|
else
|
|
|
|
{
|
2017-06-08 09:14:58 +00:00
|
|
|
ret = baseType()->canonicalName() + "[";
|
2015-10-05 15:19:23 +00:00
|
|
|
if (!isDynamicallySized())
|
|
|
|
ret += length().str();
|
|
|
|
ret += "]";
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
string ArrayType::signatureInExternalFunction(bool _structsByName) const
|
|
|
|
{
|
|
|
|
if (isByteArray())
|
|
|
|
return canonicalName();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
solAssert(baseType(), "");
|
|
|
|
return
|
|
|
|
baseType()->signatureInExternalFunction(_structsByName) +
|
|
|
|
"[" +
|
|
|
|
(isDynamicallySized() ? "" : length().str()) +
|
|
|
|
"]";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap ArrayType::nativeMembers(ASTNode const*) const
|
2015-10-13 14:55:59 +00:00
|
|
|
{
|
2015-11-25 13:23:35 +00:00
|
|
|
MemberList::MemberMap members;
|
|
|
|
if (!isString())
|
2015-10-13 14:55:59 +00:00
|
|
|
{
|
2019-04-15 16:10:43 +00:00
|
|
|
members.emplace_back("length", TypeProvider::uint256());
|
2015-11-25 13:23:35 +00:00
|
|
|
if (isDynamicallySized() && location() == DataLocation::Storage)
|
2018-03-09 16:46:24 +00:00
|
|
|
{
|
2021-02-03 20:48:45 +00:00
|
|
|
Type const* thisAsPointer = TypeProvider::withLocation(this, location(), true);
|
2019-04-17 11:40:50 +00:00
|
|
|
members.emplace_back("push", TypeProvider::function(
|
2021-02-03 20:48:45 +00:00
|
|
|
TypePointers{thisAsPointer},
|
2015-11-25 13:23:35 +00:00
|
|
|
TypePointers{baseType()},
|
|
|
|
strings{string()},
|
2021-02-03 20:48:45 +00:00
|
|
|
strings{string()},
|
|
|
|
FunctionType::Kind::ArrayPush
|
|
|
|
)->asBoundFunction());
|
2019-09-13 22:54:51 +00:00
|
|
|
members.emplace_back("push", TypeProvider::function(
|
2021-02-03 20:48:45 +00:00
|
|
|
TypePointers{thisAsPointer, baseType()},
|
2019-09-13 22:54:51 +00:00
|
|
|
TypePointers{},
|
2021-02-03 20:48:45 +00:00
|
|
|
strings{string(),string()},
|
2019-09-13 22:54:51 +00:00
|
|
|
strings{},
|
2021-02-03 20:48:45 +00:00
|
|
|
FunctionType::Kind::ArrayPush
|
|
|
|
)->asBoundFunction());
|
2019-04-17 11:40:50 +00:00
|
|
|
members.emplace_back("pop", TypeProvider::function(
|
2021-02-03 20:48:45 +00:00
|
|
|
TypePointers{thisAsPointer},
|
2018-03-09 16:46:24 +00:00
|
|
|
TypePointers{},
|
2021-02-03 20:48:45 +00:00
|
|
|
strings{string()},
|
2019-02-07 14:53:11 +00:00
|
|
|
strings{},
|
2018-04-04 16:21:06 +00:00
|
|
|
FunctionType::Kind::ArrayPop
|
2021-02-03 20:48:45 +00:00
|
|
|
)->asBoundFunction());
|
2018-03-09 16:46:24 +00:00
|
|
|
}
|
2015-10-13 14:55:59 +00:00
|
|
|
}
|
2015-11-25 13:23:35 +00:00
|
|
|
return members;
|
2015-10-13 14:55:59 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* ArrayType::encodingType() const
|
2015-03-19 15:48:54 +00:00
|
|
|
{
|
2015-10-02 11:11:38 +00:00
|
|
|
if (location() == DataLocation::Storage)
|
2019-04-15 16:10:43 +00:00
|
|
|
return TypeProvider::uint256();
|
2015-10-02 11:11:38 +00:00
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return TypeProvider::withLocation(this, DataLocation::Memory, true);
|
2015-10-02 11:11:38 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* ArrayType::decodingType() const
|
2015-10-02 20:34:47 +00:00
|
|
|
{
|
|
|
|
if (location() == DataLocation::Storage)
|
2019-04-15 16:10:43 +00:00
|
|
|
return TypeProvider::uint256();
|
2015-10-02 20:34:47 +00:00
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2015-10-02 20:34:47 +00:00
|
|
|
}
|
|
|
|
|
2019-03-18 12:22:42 +00:00
|
|
|
TypeResult ArrayType::interfaceType(bool _inLibrary) const
|
2015-10-02 11:11:38 +00:00
|
|
|
{
|
2019-10-28 10:39:30 +00:00
|
|
|
if (_inLibrary && m_interfaceType_library.has_value())
|
2019-03-14 16:19:59 +00:00
|
|
|
return *m_interfaceType_library;
|
2015-10-02 11:11:38 +00:00
|
|
|
|
2019-10-28 10:39:30 +00:00
|
|
|
if (!_inLibrary && m_interfaceType.has_value())
|
2019-03-14 16:19:59 +00:00
|
|
|
return *m_interfaceType;
|
2015-03-19 15:48:54 +00:00
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
TypeResult result{nullptr};
|
2019-03-20 10:39:34 +00:00
|
|
|
TypeResult baseInterfaceType = m_baseType->interfaceType(_inLibrary);
|
2015-03-19 15:48:54 +00:00
|
|
|
|
2019-03-20 10:39:34 +00:00
|
|
|
if (!baseInterfaceType.get())
|
2019-03-07 16:12:10 +00:00
|
|
|
{
|
2019-03-20 10:39:34 +00:00
|
|
|
solAssert(!baseInterfaceType.message().empty(), "Expected detailed error message!");
|
|
|
|
result = baseInterfaceType;
|
2019-03-07 16:12:10 +00:00
|
|
|
}
|
|
|
|
else if (_inLibrary && location() == DataLocation::Storage)
|
2019-04-15 13:33:39 +00:00
|
|
|
result = this;
|
2016-11-11 11:07:30 +00:00
|
|
|
else if (m_arrayKind != ArrayKind::Ordinary)
|
2019-04-15 13:33:39 +00:00
|
|
|
result = TypeProvider::withLocation(this, DataLocation::Memory, true);
|
2019-03-07 16:12:10 +00:00
|
|
|
else if (isDynamicallySized())
|
2019-04-17 11:40:50 +00:00
|
|
|
result = TypeProvider::array(DataLocation::Memory, baseInterfaceType);
|
2016-11-11 11:07:30 +00:00
|
|
|
else
|
2019-04-17 11:40:50 +00:00
|
|
|
result = TypeProvider::array(DataLocation::Memory, baseInterfaceType, m_length);
|
2019-03-14 16:19:59 +00:00
|
|
|
|
|
|
|
if (_inLibrary)
|
|
|
|
m_interfaceType_library = result;
|
|
|
|
else
|
|
|
|
m_interfaceType = result;
|
|
|
|
|
|
|
|
return result;
|
2016-11-11 11:07:30 +00:00
|
|
|
}
|
|
|
|
|
2020-06-03 10:38:35 +00:00
|
|
|
Type const* ArrayType::finalBaseType(bool _breakIfDynamicArrayType) const
|
|
|
|
{
|
|
|
|
Type const* finalBaseType = this;
|
|
|
|
|
|
|
|
while (auto arrayType = dynamic_cast<ArrayType const*>(finalBaseType))
|
|
|
|
{
|
|
|
|
if (_breakIfDynamicArrayType && arrayType->isDynamicallySized())
|
|
|
|
break;
|
|
|
|
finalBaseType = arrayType->baseType();
|
|
|
|
}
|
|
|
|
|
|
|
|
return finalBaseType;
|
|
|
|
}
|
|
|
|
|
2019-07-09 14:10:38 +00:00
|
|
|
u256 ArrayType::memoryDataSize() const
|
2015-09-23 15:31:37 +00:00
|
|
|
{
|
|
|
|
solAssert(!isDynamicallySized(), "");
|
|
|
|
solAssert(m_location == DataLocation::Memory, "");
|
2019-07-09 14:10:38 +00:00
|
|
|
solAssert(!isByteArray(), "");
|
2015-09-24 08:51:06 +00:00
|
|
|
bigint size = bigint(m_length) * m_baseType->memoryHeadSize();
|
2019-10-21 13:14:20 +00:00
|
|
|
solAssert(size <= numeric_limits<u256>::max(), "Array size does not fit u256.");
|
2015-09-24 08:51:06 +00:00
|
|
|
return u256(size);
|
2015-09-23 15:31:37 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
std::unique_ptr<ReferenceType> ArrayType::copyForLocation(DataLocation _location, bool _isPointer) const
|
2015-02-20 14:52:30 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
auto copy = make_unique<ArrayType>(_location);
|
2020-03-13 11:50:14 +00:00
|
|
|
if (_location == DataLocation::Storage)
|
|
|
|
copy->m_isPointer = _isPointer;
|
2015-05-28 14:20:50 +00:00
|
|
|
copy->m_arrayKind = m_arrayKind;
|
2015-06-09 12:26:08 +00:00
|
|
|
copy->m_baseType = copy->copyForLocationIfReference(m_baseType);
|
2015-02-20 14:52:30 +00:00
|
|
|
copy->m_hasDynamicLength = m_hasDynamicLength;
|
|
|
|
copy->m_length = m_length;
|
|
|
|
return copy;
|
2015-02-16 16:33:13 +00:00
|
|
|
}
|
|
|
|
|
2019-09-03 16:30:00 +00:00
|
|
|
BoolResult ArraySliceType::isImplicitlyConvertibleTo(Type const& _other) const
|
|
|
|
{
|
2020-12-11 10:07:22 +00:00
|
|
|
return
|
|
|
|
(*this) == _other ||
|
|
|
|
(
|
|
|
|
m_arrayType.dataStoredIn(DataLocation::CallData) &&
|
|
|
|
m_arrayType.isDynamicallySized() &&
|
|
|
|
m_arrayType.isImplicitlyConvertibleTo(_other)
|
|
|
|
);
|
2019-09-03 16:30:00 +00:00
|
|
|
}
|
|
|
|
|
2021-03-04 07:52:17 +00:00
|
|
|
BoolResult ArraySliceType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
|
|
|
{
|
|
|
|
return
|
|
|
|
isImplicitlyConvertibleTo(_convertTo) ||
|
|
|
|
m_arrayType.isExplicitlyConvertibleTo(_convertTo);
|
|
|
|
}
|
|
|
|
|
2019-09-03 16:30:00 +00:00
|
|
|
string ArraySliceType::richIdentifier() const
|
|
|
|
{
|
|
|
|
return m_arrayType.richIdentifier() + "_slice";
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ArraySliceType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (auto const* other = dynamic_cast<ArraySliceType const*>(&_other))
|
|
|
|
return m_arrayType == other->m_arrayType;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
string ArraySliceType::toString(bool _short) const
|
|
|
|
{
|
|
|
|
return m_arrayType.toString(_short) + " slice";
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* ArraySliceType::mobileType() const
|
2020-05-13 08:25:46 +00:00
|
|
|
{
|
|
|
|
if (
|
|
|
|
m_arrayType.dataStoredIn(DataLocation::CallData) &&
|
|
|
|
m_arrayType.isDynamicallySized() &&
|
|
|
|
!m_arrayType.baseType()->isDynamicallyEncoded()
|
|
|
|
)
|
|
|
|
return &m_arrayType;
|
|
|
|
else
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
std::vector<std::tuple<std::string, Type const*>> ArraySliceType::makeStackItems() const
|
2020-02-04 16:08:55 +00:00
|
|
|
{
|
|
|
|
return {{"offset", TypeProvider::uint256()}, {"length", TypeProvider::uint256()}};
|
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string ContractType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-08-08 14:26:30 +00:00
|
|
|
return (m_super ? "t_super" : "t_contract") + parenthesizeUserIdentifier(m_contract.name()) + to_string(m_contract.id());
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool ContractType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-10-13 16:22:15 +00:00
|
|
|
return false;
|
2014-10-20 10:41:56 +00:00
|
|
|
ContractType const& other = dynamic_cast<ContractType const&>(_other);
|
2015-01-27 13:32:59 +00:00
|
|
|
return other.m_contract == m_contract && other.m_super == m_super;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string ContractType::toString(bool) const
|
2014-11-20 17:33:23 +00:00
|
|
|
{
|
2015-09-11 14:36:47 +00:00
|
|
|
return
|
|
|
|
string(m_contract.isLibrary() ? "library " : "contract ") +
|
|
|
|
string(m_super ? "super " : "") +
|
|
|
|
m_contract.name();
|
2014-11-20 17:33:23 +00:00
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
string ContractType::canonicalName() const
|
2015-10-05 15:19:23 +00:00
|
|
|
{
|
2020-09-10 10:01:23 +00:00
|
|
|
return *m_contract.annotation().canonicalName;
|
2015-10-05 15:19:23 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap ContractType::nativeMembers(ASTNode const*) const
|
2014-12-04 18:38:24 +00:00
|
|
|
{
|
2017-09-25 11:58:32 +00:00
|
|
|
MemberList::MemberMap members;
|
2020-10-14 09:17:53 +00:00
|
|
|
solAssert(!m_super, "");
|
|
|
|
if (!m_contract.isLibrary())
|
2015-11-25 13:23:35 +00:00
|
|
|
for (auto const& it: m_contract.interfaceFunctions())
|
2018-12-10 18:02:39 +00:00
|
|
|
members.emplace_back(
|
2021-02-08 12:33:39 +00:00
|
|
|
&it.second->declaration(),
|
|
|
|
it.second->asExternallyCallableFunction(m_contract.isLibrary())
|
2018-12-10 18:02:39 +00:00
|
|
|
);
|
2020-06-15 17:11:03 +00:00
|
|
|
|
2017-09-28 12:43:09 +00:00
|
|
|
return members;
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
FunctionType const* ContractType::newExpressionType() const
|
2014-12-12 15:49:26 +00:00
|
|
|
{
|
|
|
|
if (!m_constructorType)
|
2016-08-31 18:43:24 +00:00
|
|
|
m_constructorType = FunctionType::newExpressionType(m_contract);
|
2014-12-12 15:49:26 +00:00
|
|
|
return m_constructorType;
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
vector<tuple<VariableDeclaration const*, u256, unsigned>> ContractType::stateVariables() const
|
2015-03-16 15:15:13 +00:00
|
|
|
{
|
|
|
|
vector<VariableDeclaration const*> variables;
|
2021-03-31 18:03:04 +00:00
|
|
|
for (ContractDefinition const* contract: m_contract.annotation().linearizedBaseContracts | ranges::views::reverse)
|
2015-11-23 22:57:17 +00:00
|
|
|
for (VariableDeclaration const* variable: contract->stateVariables())
|
2020-02-27 15:13:55 +00:00
|
|
|
if (!(variable->isConstant() || variable->immutable()))
|
2015-11-23 22:57:17 +00:00
|
|
|
variables.push_back(variable);
|
2015-03-16 15:15:13 +00:00
|
|
|
TypePointers types;
|
|
|
|
for (auto variable: variables)
|
2015-09-16 14:56:30 +00:00
|
|
|
types.push_back(variable->annotation().type);
|
2015-03-16 15:15:13 +00:00
|
|
|
StorageOffsets offsets;
|
|
|
|
offsets.computeOffsets(types);
|
|
|
|
|
|
|
|
vector<tuple<VariableDeclaration const*, u256, unsigned>> variablesAndOffsets;
|
|
|
|
for (size_t index = 0; index < variables.size(); ++index)
|
2015-08-31 16:44:29 +00:00
|
|
|
if (auto const* offset = offsets.offset(index))
|
2018-12-10 18:02:39 +00:00
|
|
|
variablesAndOffsets.emplace_back(variables[index], offset->first, offset->second);
|
2015-03-16 15:15:13 +00:00
|
|
|
return variablesAndOffsets;
|
|
|
|
}
|
|
|
|
|
2020-03-10 13:30:04 +00:00
|
|
|
vector<VariableDeclaration const*> ContractType::immutableVariables() const
|
|
|
|
{
|
|
|
|
vector<VariableDeclaration const*> variables;
|
2021-03-31 18:03:04 +00:00
|
|
|
for (ContractDefinition const* contract: m_contract.annotation().linearizedBaseContracts | ranges::views::reverse)
|
2020-03-10 13:30:04 +00:00
|
|
|
for (VariableDeclaration const* variable: contract->stateVariables())
|
|
|
|
if (variable->immutable())
|
|
|
|
variables.push_back(variable);
|
|
|
|
return variables;
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> ContractType::makeStackItems() const
|
2020-02-04 16:08:55 +00:00
|
|
|
{
|
|
|
|
if (m_super)
|
|
|
|
return {};
|
|
|
|
else
|
2020-02-06 13:05:25 +00:00
|
|
|
return {make_tuple("address", isPayable() ? TypeProvider::payableAddress() : TypeProvider::address())};
|
2020-02-04 16:08:55 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
void StructType::clearCache() const
|
|
|
|
{
|
|
|
|
Type::clearCache();
|
|
|
|
|
|
|
|
m_interfaceType.reset();
|
|
|
|
m_interfaceType_library.reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
Type const* StructType::encodingType() const
|
|
|
|
{
|
|
|
|
if (location() != DataLocation::Storage)
|
|
|
|
return this;
|
|
|
|
|
2019-04-15 16:10:43 +00:00
|
|
|
return TypeProvider::uint256();
|
2019-04-15 13:33:39 +00:00
|
|
|
}
|
|
|
|
|
2019-02-13 15:22:42 +00:00
|
|
|
BoolResult StructType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2015-06-09 12:26:08 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_convertTo.category() != category())
|
2015-06-09 12:26:08 +00:00
|
|
|
return false;
|
|
|
|
auto& convertTo = dynamic_cast<StructType const&>(_convertTo);
|
|
|
|
// memory/calldata to storage can be converted, but only to a direct storage reference
|
2015-06-17 10:01:39 +00:00
|
|
|
if (convertTo.location() == DataLocation::Storage && location() != DataLocation::Storage && convertTo.isPointer())
|
2015-06-09 12:26:08 +00:00
|
|
|
return false;
|
2015-06-17 10:01:39 +00:00
|
|
|
if (convertTo.location() == DataLocation::CallData && location() != convertTo.location())
|
2015-06-09 12:26:08 +00:00
|
|
|
return false;
|
|
|
|
return this->m_struct == convertTo.m_struct;
|
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string StructType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-08-08 14:26:30 +00:00
|
|
|
return "t_struct" + parenthesizeUserIdentifier(m_struct.name()) + to_string(m_struct.id()) + identifierLocationSuffix();
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool StructType::operator==(Type const& _other) const
|
2014-10-13 16:22:15 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-10-13 16:22:15 +00:00
|
|
|
return false;
|
2014-10-20 10:41:56 +00:00
|
|
|
StructType const& other = dynamic_cast<StructType const&>(_other);
|
2015-06-09 12:26:08 +00:00
|
|
|
return ReferenceType::operator==(other) && other.m_struct == m_struct;
|
2014-10-13 16:22:15 +00:00
|
|
|
}
|
|
|
|
|
2019-07-09 14:10:38 +00:00
|
|
|
|
2019-01-22 11:30:46 +00:00
|
|
|
unsigned StructType::calldataEncodedSize(bool) const
|
2015-06-24 15:25:36 +00:00
|
|
|
{
|
2019-07-09 14:10:38 +00:00
|
|
|
solAssert(!isDynamicallyEncoded(), "");
|
|
|
|
|
2015-06-24 15:25:36 +00:00
|
|
|
unsigned size = 0;
|
2015-11-19 17:02:04 +00:00
|
|
|
for (auto const& member: members(nullptr))
|
2019-07-09 14:10:38 +00:00
|
|
|
{
|
2020-06-03 10:38:35 +00:00
|
|
|
solAssert(!member.type->containsNestedMapping(), "");
|
2019-07-09 14:10:38 +00:00
|
|
|
// Struct members are always padded.
|
|
|
|
size += member.type->calldataEncodedSize();
|
|
|
|
}
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
unsigned StructType::calldataEncodedTailSize() const
|
|
|
|
{
|
|
|
|
solAssert(isDynamicallyEncoded(), "");
|
|
|
|
|
|
|
|
unsigned size = 0;
|
|
|
|
for (auto const& member: members(nullptr))
|
|
|
|
{
|
2020-06-03 10:38:35 +00:00
|
|
|
solAssert(!member.type->containsNestedMapping(), "");
|
2019-07-09 14:10:38 +00:00
|
|
|
// Struct members are always padded.
|
|
|
|
size += member.type->calldataHeadSize();
|
|
|
|
}
|
2015-06-24 15:25:36 +00:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2019-02-05 19:29:57 +00:00
|
|
|
unsigned StructType::calldataOffsetOfMember(std::string const& _member) const
|
|
|
|
{
|
|
|
|
unsigned offset = 0;
|
|
|
|
for (auto const& member: members(nullptr))
|
|
|
|
{
|
2020-06-03 10:38:35 +00:00
|
|
|
solAssert(!member.type->containsNestedMapping(), "");
|
2019-02-05 19:29:57 +00:00
|
|
|
if (member.name == _member)
|
|
|
|
return offset;
|
2019-07-09 14:10:38 +00:00
|
|
|
// Struct members are always padded.
|
|
|
|
offset += member.type->calldataHeadSize();
|
2019-02-05 19:29:57 +00:00
|
|
|
}
|
|
|
|
solAssert(false, "Struct member not found.");
|
|
|
|
}
|
|
|
|
|
2017-08-07 10:41:45 +00:00
|
|
|
bool StructType::isDynamicallyEncoded() const
|
|
|
|
{
|
2019-10-01 14:40:39 +00:00
|
|
|
if (recursive())
|
|
|
|
return true;
|
2019-03-07 16:12:10 +00:00
|
|
|
solAssert(interfaceType(false).get(), "");
|
2017-08-24 13:20:49 +00:00
|
|
|
for (auto t: memoryMemberTypes())
|
|
|
|
{
|
|
|
|
solAssert(t, "Parameter should have external type.");
|
|
|
|
t = t->interfaceType(false);
|
|
|
|
if (t->isDynamicallyEncoded())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2017-08-07 10:41:45 +00:00
|
|
|
}
|
|
|
|
|
2019-07-09 14:10:38 +00:00
|
|
|
u256 StructType::memoryDataSize() const
|
2015-06-30 09:54:51 +00:00
|
|
|
{
|
|
|
|
u256 size;
|
2017-06-08 09:14:58 +00:00
|
|
|
for (auto const& t: memoryMemberTypes())
|
|
|
|
size += t->memoryHeadSize();
|
2015-06-30 09:54:51 +00:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2020-07-14 08:32:11 +00:00
|
|
|
bigint StructType::storageSizeUpperBound() const
|
|
|
|
{
|
|
|
|
bigint size = 1;
|
|
|
|
for (auto const& member: members(nullptr))
|
|
|
|
size += member.type->storageSizeUpperBound();
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
u256 StructType::storageSize() const
|
2014-11-07 01:06:37 +00:00
|
|
|
{
|
2015-11-19 17:02:04 +00:00
|
|
|
return max<u256>(1, members(nullptr).storageSize());
|
2014-11-07 01:06:37 +00:00
|
|
|
}
|
|
|
|
|
2020-06-03 10:38:35 +00:00
|
|
|
bool StructType::containsNestedMapping() const
|
|
|
|
{
|
|
|
|
if (!m_struct.annotation().containsNestedMapping.has_value())
|
|
|
|
{
|
|
|
|
bool hasNestedMapping = false;
|
|
|
|
|
|
|
|
util::BreadthFirstSearch<StructDefinition const*> breadthFirstSearch{{&m_struct}};
|
|
|
|
|
|
|
|
breadthFirstSearch.run(
|
|
|
|
[&](StructDefinition const* _struct, auto&& _addChild)
|
|
|
|
{
|
|
|
|
for (auto const& member: _struct->members())
|
|
|
|
{
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* memberType = member->annotation().type;
|
2020-06-03 10:38:35 +00:00
|
|
|
solAssert(memberType, "");
|
|
|
|
|
|
|
|
if (auto arrayType = dynamic_cast<ArrayType const*>(memberType))
|
|
|
|
memberType = arrayType->finalBaseType(false);
|
|
|
|
|
|
|
|
if (dynamic_cast<MappingType const*>(memberType))
|
|
|
|
{
|
|
|
|
hasNestedMapping = true;
|
|
|
|
breadthFirstSearch.abort();
|
|
|
|
}
|
|
|
|
else if (auto structType = dynamic_cast<StructType const*>(memberType))
|
|
|
|
_addChild(&structType->structDefinition());
|
|
|
|
}
|
|
|
|
|
|
|
|
});
|
|
|
|
|
|
|
|
m_struct.annotation().containsNestedMapping = hasNestedMapping;
|
|
|
|
}
|
|
|
|
|
|
|
|
return m_struct.annotation().containsNestedMapping.value();
|
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string StructType::toString(bool _short) const
|
2014-11-13 00:12:57 +00:00
|
|
|
{
|
2020-09-10 10:01:23 +00:00
|
|
|
string ret = "struct " + *m_struct.annotation().canonicalName;
|
2015-06-09 12:26:08 +00:00
|
|
|
if (!_short)
|
|
|
|
ret += " " + stringForReferencePart();
|
|
|
|
return ret;
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap StructType::nativeMembers(ASTNode const*) const
|
2014-11-13 00:12:57 +00:00
|
|
|
{
|
2015-11-25 13:23:35 +00:00
|
|
|
MemberList::MemberMap members;
|
|
|
|
for (ASTPointer<VariableDeclaration> const& variable: m_struct.members())
|
2014-11-20 09:19:43 +00:00
|
|
|
{
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* type = variable->annotation().type;
|
2017-02-16 11:36:43 +00:00
|
|
|
solAssert(type, "");
|
2020-06-03 10:38:35 +00:00
|
|
|
solAssert(!(location() != DataLocation::Storage && type->containsNestedMapping()), "");
|
2018-12-10 18:02:39 +00:00
|
|
|
members.emplace_back(
|
2021-02-08 12:33:39 +00:00
|
|
|
variable.get(),
|
|
|
|
copyForLocationIfReference(type)
|
2015-11-25 13:23:35 +00:00
|
|
|
);
|
2014-11-20 09:19:43 +00:00
|
|
|
}
|
2015-11-25 13:23:35 +00:00
|
|
|
return members;
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2019-03-18 12:22:42 +00:00
|
|
|
TypeResult StructType::interfaceType(bool _inLibrary) const
|
2015-10-02 11:11:38 +00:00
|
|
|
{
|
2020-04-14 14:36:37 +00:00
|
|
|
if (!_inLibrary)
|
2017-09-14 12:51:14 +00:00
|
|
|
{
|
2020-04-14 14:36:37 +00:00
|
|
|
if (!m_interfaceType.has_value())
|
2018-09-21 13:25:05 +00:00
|
|
|
{
|
2020-04-14 14:36:37 +00:00
|
|
|
if (recursive())
|
|
|
|
m_interfaceType = TypeResult::err("Recursive type not allowed for public or external contract functions.");
|
|
|
|
else
|
2019-03-14 16:19:59 +00:00
|
|
|
{
|
2021-03-22 16:12:05 +00:00
|
|
|
TypeResult result{nullptr};
|
2020-04-14 14:36:37 +00:00
|
|
|
for (ASTPointer<VariableDeclaration> const& member: m_struct.members())
|
2019-03-07 16:12:10 +00:00
|
|
|
{
|
2020-04-14 14:36:37 +00:00
|
|
|
if (!member->annotation().type)
|
2019-03-07 16:12:10 +00:00
|
|
|
{
|
2020-04-14 14:36:37 +00:00
|
|
|
result = TypeResult::err("Invalid type!");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
auto interfaceType = member->annotation().type->interfaceType(false);
|
|
|
|
if (!interfaceType.get())
|
|
|
|
{
|
|
|
|
solAssert(!interfaceType.message().empty(), "Expected detailed error message!");
|
|
|
|
result = interfaceType;
|
|
|
|
break;
|
2019-03-07 16:12:10 +00:00
|
|
|
}
|
|
|
|
}
|
2020-04-14 14:36:37 +00:00
|
|
|
if (result.message().empty())
|
|
|
|
m_interfaceType = TypeProvider::withLocation(this, DataLocation::Memory, true);
|
|
|
|
else
|
|
|
|
m_interfaceType = result;
|
2019-03-14 16:19:59 +00:00
|
|
|
}
|
2018-09-21 13:25:05 +00:00
|
|
|
}
|
2020-04-14 14:36:37 +00:00
|
|
|
return *m_interfaceType;
|
|
|
|
}
|
|
|
|
else if (m_interfaceType_library.has_value())
|
|
|
|
return *m_interfaceType_library;
|
2019-03-07 16:12:10 +00:00
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
TypeResult result{nullptr};
|
2019-03-07 16:12:10 +00:00
|
|
|
|
2020-08-27 08:00:08 +00:00
|
|
|
if (recursive() && !(_inLibrary && location() == DataLocation::Storage))
|
|
|
|
return TypeResult::err(
|
|
|
|
"Recursive structs can only be passed as storage pointers to libraries, "
|
|
|
|
"not as memory objects to contract functions."
|
|
|
|
);
|
|
|
|
|
2020-04-14 14:36:37 +00:00
|
|
|
util::BreadthFirstSearch<StructDefinition const*> breadthFirstSearch{{&m_struct}};
|
|
|
|
breadthFirstSearch.run(
|
2020-08-27 08:00:08 +00:00
|
|
|
[&](StructDefinition const* _struct, auto&& _addChild)
|
|
|
|
{
|
|
|
|
// Check that all members have interface types.
|
|
|
|
// Return an error if at least one struct member does not have a type.
|
|
|
|
// This might happen, for example, if the type of the member does not exist.
|
|
|
|
for (ASTPointer<VariableDeclaration> const& variable: _struct->members())
|
|
|
|
{
|
|
|
|
// If the struct member does not have a type return false.
|
|
|
|
// A TypeError is expected in this case.
|
|
|
|
if (!variable->annotation().type)
|
2020-04-14 14:36:37 +00:00
|
|
|
{
|
2020-08-27 08:00:08 +00:00
|
|
|
result = TypeResult::err("Invalid type!");
|
|
|
|
breadthFirstSearch.abort();
|
|
|
|
return;
|
|
|
|
}
|
2019-03-14 16:19:59 +00:00
|
|
|
|
2020-08-27 08:00:08 +00:00
|
|
|
Type const* memberType = variable->annotation().type;
|
2019-03-07 16:12:10 +00:00
|
|
|
|
2020-08-27 08:00:08 +00:00
|
|
|
while (
|
|
|
|
memberType->category() == Type::Category::Array ||
|
|
|
|
memberType->category() == Type::Category::Mapping
|
|
|
|
)
|
|
|
|
{
|
|
|
|
if (auto arrayType = dynamic_cast<ArrayType const*>(memberType))
|
|
|
|
memberType = arrayType->finalBaseType(false);
|
|
|
|
else if (auto mappingType = dynamic_cast<MappingType const*>(memberType))
|
|
|
|
memberType = mappingType->valueType();
|
|
|
|
}
|
2019-03-07 16:12:10 +00:00
|
|
|
|
2020-08-27 08:00:08 +00:00
|
|
|
if (StructType const* innerStruct = dynamic_cast<StructType const*>(memberType))
|
|
|
|
_addChild(&innerStruct->structDefinition());
|
|
|
|
else
|
|
|
|
{
|
|
|
|
auto iType = memberType->interfaceType(_inLibrary);
|
|
|
|
if (!iType.get())
|
2020-04-14 14:36:37 +00:00
|
|
|
{
|
2020-08-27 08:00:08 +00:00
|
|
|
solAssert(!iType.message().empty(), "Expected detailed error message!");
|
|
|
|
result = iType;
|
|
|
|
breadthFirstSearch.abort();
|
|
|
|
return;
|
2020-04-14 14:36:37 +00:00
|
|
|
}
|
2020-08-27 08:00:08 +00:00
|
|
|
}
|
2020-04-14 14:36:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2019-03-07 16:12:10 +00:00
|
|
|
|
2020-04-14 14:36:37 +00:00
|
|
|
if (!result.message().empty())
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (location() == DataLocation::Storage)
|
|
|
|
m_interfaceType_library = this;
|
2019-03-07 16:12:10 +00:00
|
|
|
else
|
2020-04-14 14:36:37 +00:00
|
|
|
m_interfaceType_library = TypeProvider::withLocation(this, DataLocation::Memory, true);
|
|
|
|
return *m_interfaceType_library;
|
|
|
|
}
|
2019-03-14 16:19:59 +00:00
|
|
|
|
2020-04-14 17:03:46 +00:00
|
|
|
BoolResult StructType::validForLocation(DataLocation _loc) const
|
|
|
|
{
|
|
|
|
for (auto const& member: m_struct.members())
|
|
|
|
if (auto referenceType = dynamic_cast<ReferenceType const*>(member->annotation().type))
|
|
|
|
{
|
|
|
|
BoolResult result = referenceType->validForLocation(_loc);
|
|
|
|
if (!result)
|
|
|
|
return result;
|
|
|
|
}
|
2020-07-06 19:40:50 +00:00
|
|
|
|
|
|
|
if (
|
|
|
|
_loc == DataLocation::Storage &&
|
2020-07-14 08:32:11 +00:00
|
|
|
storageSizeUpperBound() >= bigint(1) << 256
|
2020-07-06 19:40:50 +00:00
|
|
|
)
|
|
|
|
return BoolResult::err("Type too large for storage.");
|
|
|
|
|
2020-04-14 17:03:46 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-04-14 14:36:37 +00:00
|
|
|
bool StructType::recursive() const
|
|
|
|
{
|
|
|
|
solAssert(m_struct.annotation().recursive.has_value(), "Called StructType::recursive() before DeclarationTypeChecker.");
|
|
|
|
return *m_struct.annotation().recursive;
|
2015-10-02 11:11:38 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
std::unique_ptr<ReferenceType> StructType::copyForLocation(DataLocation _location, bool _isPointer) const
|
2015-06-05 09:07:50 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
auto copy = make_unique<StructType>(m_struct, _location);
|
2020-03-13 11:50:14 +00:00
|
|
|
if (_location == DataLocation::Storage)
|
|
|
|
copy->m_isPointer = _isPointer;
|
2015-06-05 09:07:50 +00:00
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
string StructType::signatureInExternalFunction(bool _structsByName) const
|
2015-10-05 15:19:23 +00:00
|
|
|
{
|
2017-06-08 09:14:58 +00:00
|
|
|
if (_structsByName)
|
|
|
|
return canonicalName();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
TypePointers memberTypes = memoryMemberTypes();
|
2021-04-08 12:08:14 +00:00
|
|
|
auto memberTypeStrings = memberTypes | ranges::views::transform([&](Type const* _t) -> string
|
2017-06-08 09:14:58 +00:00
|
|
|
{
|
|
|
|
solAssert(_t, "Parameter should have external type.");
|
2017-06-13 08:51:49 +00:00
|
|
|
auto t = _t->interfaceType(_structsByName);
|
2019-03-18 12:22:42 +00:00
|
|
|
solAssert(t.get(), "");
|
|
|
|
return t.get()->signatureInExternalFunction(_structsByName);
|
2017-06-08 09:14:58 +00:00
|
|
|
});
|
|
|
|
return "(" + boost::algorithm::join(memberTypeStrings, ",") + ")";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string StructType::canonicalName() const
|
|
|
|
{
|
2020-09-10 10:01:23 +00:00
|
|
|
return *m_struct.annotation().canonicalName;
|
2015-10-05 15:19:23 +00:00
|
|
|
}
|
|
|
|
|
2015-06-30 19:08:34 +00:00
|
|
|
FunctionTypePointer StructType::constructorType() const
|
|
|
|
{
|
|
|
|
TypePointers paramTypes;
|
|
|
|
strings paramNames;
|
2020-06-03 10:38:35 +00:00
|
|
|
solAssert(!containsNestedMapping(), "");
|
2015-11-19 17:02:04 +00:00
|
|
|
for (auto const& member: members(nullptr))
|
2015-06-30 19:08:34 +00:00
|
|
|
{
|
|
|
|
paramNames.push_back(member.name);
|
2019-04-17 11:25:03 +00:00
|
|
|
paramTypes.push_back(TypeProvider::withLocationIfReference(DataLocation::Memory, member.type));
|
2015-06-30 19:08:34 +00:00
|
|
|
}
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::function(
|
2015-06-30 19:08:34 +00:00
|
|
|
paramTypes,
|
2019-04-15 13:33:39 +00:00
|
|
|
TypePointers{TypeProvider::withLocation(this, DataLocation::Memory, false)},
|
2015-06-30 19:08:34 +00:00
|
|
|
paramNames,
|
2019-02-07 14:53:11 +00:00
|
|
|
strings(1, ""),
|
2017-03-16 11:58:17 +00:00
|
|
|
FunctionType::Kind::Internal
|
2015-06-30 19:08:34 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
pair<u256, unsigned> const& StructType::storageOffsetsOfMember(string const& _name) const
|
2014-11-13 00:12:57 +00:00
|
|
|
{
|
2015-11-19 17:02:04 +00:00
|
|
|
auto const* offsets = members(nullptr).memberStorageOffset(_name);
|
2015-03-13 18:48:24 +00:00
|
|
|
solAssert(offsets, "Storage offset of non-existing member requested.");
|
|
|
|
return *offsets;
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2015-06-30 09:54:51 +00:00
|
|
|
u256 StructType::memoryOffsetOfMember(string const& _name) const
|
|
|
|
{
|
|
|
|
u256 offset;
|
2015-11-19 17:02:04 +00:00
|
|
|
for (auto const& member: members(nullptr))
|
2015-06-30 09:54:51 +00:00
|
|
|
if (member.name == _name)
|
|
|
|
return offset;
|
|
|
|
else
|
|
|
|
offset += member.type->memoryHeadSize();
|
|
|
|
solAssert(false, "Member not found in struct.");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
TypePointers StructType::memoryMemberTypes() const
|
|
|
|
{
|
2020-06-03 10:38:35 +00:00
|
|
|
solAssert(!containsNestedMapping(), "");
|
2017-06-08 09:14:58 +00:00
|
|
|
TypePointers types;
|
|
|
|
for (ASTPointer<VariableDeclaration> const& variable: m_struct.members())
|
2020-06-03 10:38:35 +00:00
|
|
|
types.push_back(TypeProvider::withLocationIfReference(DataLocation::Memory, variable->annotation().type));
|
2017-06-08 09:14:58 +00:00
|
|
|
|
2020-06-03 10:38:35 +00:00
|
|
|
return types;
|
2015-07-15 23:06:19 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> StructType::makeStackItems() const
|
2020-06-10 15:27:59 +00:00
|
|
|
{
|
|
|
|
switch (m_location)
|
|
|
|
{
|
|
|
|
case DataLocation::CallData:
|
|
|
|
return {std::make_tuple("offset", TypeProvider::uint256())};
|
|
|
|
case DataLocation::Memory:
|
|
|
|
return {std::make_tuple("mpos", TypeProvider::uint256())};
|
|
|
|
case DataLocation::Storage:
|
|
|
|
return {std::make_tuple("slot", TypeProvider::uint256())};
|
|
|
|
}
|
|
|
|
solAssert(false, "");
|
|
|
|
}
|
|
|
|
|
2020-09-15 23:06:54 +00:00
|
|
|
vector<Type const*> StructType::decomposition() const
|
|
|
|
{
|
|
|
|
vector<Type const*> res;
|
|
|
|
for (MemberList::Member const& member: members(nullptr))
|
|
|
|
res.push_back(member.type);
|
|
|
|
return res;
|
|
|
|
}
|
2020-06-10 15:27:59 +00:00
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* EnumType::encodingType() const
|
2019-04-15 13:33:39 +00:00
|
|
|
{
|
2020-11-10 13:26:29 +00:00
|
|
|
solAssert(numberOfMembers() <= 256, "");
|
|
|
|
return TypeProvider::uint(8);
|
2019-04-15 13:33:39 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult EnumType::unaryOperatorResult(Token _operator) const
|
2015-02-11 15:37:46 +00:00
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
return _operator == Token::Delete ? TypeProvider::emptyTuple() : nullptr;
|
2015-02-11 15:37:46 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string EnumType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-08-08 14:26:30 +00:00
|
|
|
return "t_enum" + parenthesizeUserIdentifier(m_enum.name()) + to_string(m_enum.id());
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2015-02-11 15:37:46 +00:00
|
|
|
bool EnumType::operator==(Type const& _other) const
|
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2015-02-11 15:37:46 +00:00
|
|
|
return false;
|
|
|
|
EnumType const& other = dynamic_cast<EnumType const&>(_other);
|
|
|
|
return other.m_enum == m_enum;
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
unsigned EnumType::storageBytes() const
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2020-11-10 13:26:29 +00:00
|
|
|
solAssert(numberOfMembers() <= 256, "");
|
|
|
|
return 1;
|
2015-03-13 09:52:34 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string EnumType::toString(bool) const
|
2015-02-11 15:37:46 +00:00
|
|
|
{
|
2020-09-10 10:01:23 +00:00
|
|
|
return string("enum ") + *m_enum.annotation().canonicalName;
|
2015-02-11 15:37:46 +00:00
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
string EnumType::canonicalName() const
|
2015-10-05 15:19:23 +00:00
|
|
|
{
|
2020-09-10 10:01:23 +00:00
|
|
|
return *m_enum.annotation().canonicalName;
|
2015-10-05 15:19:23 +00:00
|
|
|
}
|
|
|
|
|
2016-11-07 17:15:59 +00:00
|
|
|
size_t EnumType::numberOfMembers() const
|
|
|
|
{
|
|
|
|
return m_enum.members().size();
|
2019-12-12 23:25:12 +00:00
|
|
|
}
|
2016-11-07 17:15:59 +00:00
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult EnumType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2015-02-12 16:59:52 +00:00
|
|
|
{
|
2020-11-09 09:10:30 +00:00
|
|
|
if (_convertTo == *this)
|
|
|
|
return true;
|
|
|
|
else if (auto integerType = dynamic_cast<IntegerType const*>(&_convertTo))
|
|
|
|
return !integerType->isSigned();
|
|
|
|
return false;
|
2015-02-12 16:59:52 +00:00
|
|
|
}
|
|
|
|
|
2016-05-10 09:15:41 +00:00
|
|
|
unsigned EnumType::memberValue(ASTString const& _member) const
|
2015-02-13 22:03:32 +00:00
|
|
|
{
|
2016-05-10 09:15:41 +00:00
|
|
|
unsigned index = 0;
|
2015-08-31 16:44:29 +00:00
|
|
|
for (ASTPointer<EnumValue> const& decl: m_enum.members())
|
2015-02-13 22:03:32 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (decl->name() == _member)
|
2015-02-13 22:03:32 +00:00
|
|
|
return index;
|
|
|
|
++index;
|
|
|
|
}
|
2017-10-05 19:18:46 +00:00
|
|
|
solAssert(false, "Requested unknown enum value " + _member);
|
2015-02-13 22:03:32 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult TupleType::isImplicitlyConvertibleTo(Type const& _other) const
|
2015-10-14 13:19:50 +00:00
|
|
|
{
|
|
|
|
if (auto tupleType = dynamic_cast<TupleType const*>(&_other))
|
|
|
|
{
|
|
|
|
TypePointers const& targets = tupleType->components();
|
|
|
|
if (targets.empty())
|
|
|
|
return components().empty();
|
2018-07-10 09:59:09 +00:00
|
|
|
if (components().size() != targets.size())
|
2015-10-14 13:19:50 +00:00
|
|
|
return false;
|
2018-07-10 09:59:09 +00:00
|
|
|
for (size_t i = 0; i < targets.size(); ++i)
|
|
|
|
if (!components()[i] && targets[i])
|
2015-10-14 13:19:50 +00:00
|
|
|
return false;
|
2018-07-10 09:59:09 +00:00
|
|
|
else if (components()[i] && targets[i] && !components()[i]->isImplicitlyConvertibleTo(*targets[i]))
|
2015-10-14 13:19:50 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string TupleType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2017-01-19 12:18:56 +00:00
|
|
|
return "t_tuple" + identifierList(components());
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2015-10-09 17:35:41 +00:00
|
|
|
bool TupleType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (auto tupleType = dynamic_cast<TupleType const*>(&_other))
|
|
|
|
return components() == tupleType->components();
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
string TupleType::toString(bool _short) const
|
|
|
|
{
|
2015-10-14 13:19:50 +00:00
|
|
|
if (components().empty())
|
2015-10-09 17:35:41 +00:00
|
|
|
return "tuple()";
|
|
|
|
string str = "tuple(";
|
2015-10-14 13:19:50 +00:00
|
|
|
for (auto const& t: components())
|
2015-10-12 21:02:35 +00:00
|
|
|
str += (t ? t->toString(_short) : "") + ",";
|
|
|
|
str.pop_back();
|
2015-10-09 17:35:41 +00:00
|
|
|
return str + ")";
|
|
|
|
}
|
|
|
|
|
|
|
|
u256 TupleType::storageSize() const
|
|
|
|
{
|
2017-07-19 01:19:00 +00:00
|
|
|
solAssert(false, "Storage size of non-storable tuple type requested.");
|
2015-10-09 17:35:41 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> TupleType::makeStackItems() const
|
2015-10-09 17:35:41 +00:00
|
|
|
{
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> slots;
|
2020-02-04 16:08:55 +00:00
|
|
|
unsigned i = 1;
|
2015-10-14 13:19:50 +00:00
|
|
|
for (auto const& t: components())
|
2020-02-04 16:08:55 +00:00
|
|
|
{
|
|
|
|
if (t)
|
|
|
|
slots.emplace_back("component_" + std::to_string(i), t);
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
return slots;
|
2015-10-09 17:35:41 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* TupleType::mobileType() const
|
2015-10-12 21:02:35 +00:00
|
|
|
{
|
2015-10-14 13:19:50 +00:00
|
|
|
TypePointers mobiles;
|
|
|
|
for (auto const& c: components())
|
2016-10-21 10:30:58 +00:00
|
|
|
{
|
|
|
|
if (c)
|
|
|
|
{
|
|
|
|
auto mt = c->mobileType();
|
|
|
|
if (!mt)
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-10-21 10:30:58 +00:00
|
|
|
mobiles.push_back(mt);
|
|
|
|
}
|
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
mobiles.push_back(nullptr);
|
2016-10-21 10:30:58 +00:00
|
|
|
}
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::tuple(move(mobiles));
|
2015-10-14 13:19:50 +00:00
|
|
|
}
|
|
|
|
|
2020-01-07 10:42:37 +00:00
|
|
|
FunctionType::FunctionType(FunctionDefinition const& _function, Kind _kind):
|
|
|
|
m_kind(_kind),
|
2017-07-01 09:09:24 +00:00
|
|
|
m_stateMutability(_function.stateMutability()),
|
2015-01-29 16:28:14 +00:00
|
|
|
m_declaration(&_function)
|
2014-11-25 13:43:23 +00:00
|
|
|
{
|
2020-01-07 10:42:37 +00:00
|
|
|
solAssert(
|
|
|
|
_kind == Kind::Internal || _kind == Kind::External || _kind == Kind::Declaration,
|
|
|
|
"Only internal or external function types or function declaration types can be created from function definitions."
|
|
|
|
);
|
|
|
|
if (_kind == Kind::Internal && m_stateMutability == StateMutability::Payable)
|
2017-07-01 09:09:24 +00:00
|
|
|
m_stateMutability = StateMutability::NonPayable;
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _function.parameters())
|
2015-01-23 15:37:06 +00:00
|
|
|
{
|
2021-02-06 14:36:43 +00:00
|
|
|
solAssert(var->annotation().type, "Parameter type is not yet available in the AST.");
|
2018-02-20 18:38:51 +00:00
|
|
|
m_parameterNames.push_back(var->name());
|
|
|
|
m_parameterTypes.push_back(var->annotation().type);
|
2015-01-23 15:37:06 +00:00
|
|
|
}
|
2015-08-31 16:44:29 +00:00
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _function.returnParameters())
|
2015-01-23 15:37:06 +00:00
|
|
|
{
|
2021-02-06 14:36:43 +00:00
|
|
|
solAssert(var->annotation().type, "Return parameter type is not yet available in the AST.");
|
2018-02-20 18:38:51 +00:00
|
|
|
m_returnParameterNames.push_back(var->name());
|
|
|
|
m_returnParameterTypes.push_back(var->annotation().type);
|
2015-01-23 15:37:06 +00:00
|
|
|
}
|
2019-02-07 14:53:11 +00:00
|
|
|
|
|
|
|
solAssert(
|
|
|
|
m_parameterNames.size() == m_parameterTypes.size(),
|
|
|
|
"Parameter names list must match parameter types list!"
|
|
|
|
);
|
|
|
|
|
|
|
|
solAssert(
|
|
|
|
m_returnParameterNames.size() == m_returnParameterTypes.size(),
|
|
|
|
"Return parameter names list must match return parameter types list!"
|
|
|
|
);
|
2014-11-25 13:43:23 +00:00
|
|
|
}
|
|
|
|
|
2015-01-22 16:40:22 +00:00
|
|
|
FunctionType::FunctionType(VariableDeclaration const& _varDecl):
|
2017-08-28 15:31:26 +00:00
|
|
|
m_kind(Kind::External),
|
|
|
|
m_stateMutability(StateMutability::View),
|
|
|
|
m_declaration(&_varDecl)
|
2015-01-22 16:40:22 +00:00
|
|
|
{
|
2015-09-16 14:56:30 +00:00
|
|
|
auto returnType = _varDecl.annotation().type;
|
2015-01-28 12:16:09 +00:00
|
|
|
|
2015-04-01 12:22:42 +00:00
|
|
|
while (true)
|
2015-01-30 15:06:56 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
if (auto mappingType = dynamic_cast<MappingType const*>(returnType))
|
2015-04-01 12:22:42 +00:00
|
|
|
{
|
2018-02-20 18:38:51 +00:00
|
|
|
m_parameterTypes.push_back(mappingType->keyType());
|
2018-12-10 18:02:39 +00:00
|
|
|
m_parameterNames.emplace_back("");
|
2015-08-31 16:44:29 +00:00
|
|
|
returnType = mappingType->valueType();
|
2015-04-01 12:22:42 +00:00
|
|
|
}
|
2019-04-15 13:33:39 +00:00
|
|
|
else if (auto arrayType = dynamic_cast<ArrayType const*>(returnType))
|
2015-04-01 12:22:42 +00:00
|
|
|
{
|
2015-06-17 10:01:39 +00:00
|
|
|
if (arrayType->isByteArray())
|
2018-09-20 14:54:57 +00:00
|
|
|
// Return byte arrays as whole.
|
2015-06-17 10:01:39 +00:00
|
|
|
break;
|
2015-08-31 16:44:29 +00:00
|
|
|
returnType = arrayType->baseType();
|
2018-12-10 18:02:39 +00:00
|
|
|
m_parameterNames.emplace_back("");
|
2019-04-15 16:10:43 +00:00
|
|
|
m_parameterTypes.push_back(TypeProvider::uint256());
|
2015-04-01 12:22:42 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
break;
|
2015-01-30 15:06:56 +00:00
|
|
|
}
|
2015-02-02 16:52:50 +00:00
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
if (auto structType = dynamic_cast<StructType const*>(returnType))
|
2015-02-06 18:57:08 +00:00
|
|
|
{
|
2015-11-19 17:02:04 +00:00
|
|
|
for (auto const& member: structType->members(nullptr))
|
2017-02-16 11:36:43 +00:00
|
|
|
{
|
|
|
|
solAssert(member.type, "");
|
2015-08-31 16:44:29 +00:00
|
|
|
if (member.type->category() != Category::Mapping)
|
2015-02-06 18:57:08 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
if (auto arrayType = dynamic_cast<ArrayType const*>(member.type))
|
2015-06-17 10:01:39 +00:00
|
|
|
if (!arrayType->isByteArray())
|
|
|
|
continue;
|
2019-04-15 13:33:39 +00:00
|
|
|
m_returnParameterTypes.push_back(TypeProvider::withLocationIfReference(
|
2018-02-21 10:07:40 +00:00
|
|
|
DataLocation::Memory,
|
|
|
|
member.type
|
|
|
|
));
|
2018-02-20 18:38:51 +00:00
|
|
|
m_returnParameterNames.push_back(member.name);
|
2015-02-06 18:57:08 +00:00
|
|
|
}
|
2017-02-16 11:36:43 +00:00
|
|
|
}
|
2015-02-06 18:57:08 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
m_returnParameterTypes.push_back(TypeProvider::withLocationIfReference(
|
2015-06-17 10:01:39 +00:00
|
|
|
DataLocation::Memory,
|
|
|
|
returnType
|
|
|
|
));
|
2018-12-10 18:02:39 +00:00
|
|
|
m_returnParameterNames.emplace_back("");
|
2015-02-06 18:57:08 +00:00
|
|
|
}
|
2019-02-07 14:53:11 +00:00
|
|
|
|
|
|
|
solAssert(
|
|
|
|
m_parameterNames.size() == m_parameterTypes.size(),
|
|
|
|
"Parameter names list must match parameter types list!"
|
|
|
|
);
|
|
|
|
solAssert(
|
|
|
|
m_returnParameterNames.size() == m_returnParameterTypes.size(),
|
|
|
|
"Return parameter names list must match return parameter types list!"
|
|
|
|
);
|
2015-01-22 16:40:22 +00:00
|
|
|
}
|
|
|
|
|
2016-08-31 18:43:24 +00:00
|
|
|
FunctionType::FunctionType(EventDefinition const& _event):
|
2017-08-28 15:31:26 +00:00
|
|
|
m_kind(Kind::Event),
|
|
|
|
m_stateMutability(StateMutability::NonPayable),
|
|
|
|
m_declaration(&_event)
|
2015-01-29 13:35:28 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _event.parameters())
|
2015-01-29 13:35:28 +00:00
|
|
|
{
|
2018-02-20 18:38:51 +00:00
|
|
|
m_parameterNames.push_back(var->name());
|
|
|
|
m_parameterTypes.push_back(var->annotation().type);
|
2015-01-29 13:35:28 +00:00
|
|
|
}
|
2019-02-07 14:53:11 +00:00
|
|
|
|
|
|
|
solAssert(
|
2021-01-28 11:56:22 +00:00
|
|
|
m_parameterNames.size() == m_parameterTypes.size(),
|
|
|
|
"Parameter names list must match parameter types list!"
|
|
|
|
);
|
2019-02-07 14:53:11 +00:00
|
|
|
solAssert(
|
2021-01-28 11:56:22 +00:00
|
|
|
m_returnParameterNames.size() == 0 &&
|
|
|
|
m_returnParameterTypes.size() == 0,
|
|
|
|
""
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
FunctionType::FunctionType(ErrorDefinition const& _error):
|
|
|
|
m_kind(Kind::Error),
|
|
|
|
m_stateMutability(StateMutability::Pure),
|
|
|
|
m_declaration(&_error)
|
|
|
|
{
|
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _error.parameters())
|
|
|
|
{
|
|
|
|
m_parameterNames.push_back(var->name());
|
|
|
|
m_parameterTypes.push_back(var->annotation().type);
|
|
|
|
}
|
|
|
|
|
|
|
|
solAssert(
|
|
|
|
m_parameterNames.size() == m_parameterTypes.size(),
|
|
|
|
"Parameter names list must match parameter types list!"
|
|
|
|
);
|
|
|
|
solAssert(
|
|
|
|
m_returnParameterNames.size() == 0 &&
|
|
|
|
m_returnParameterTypes.size() == 0,
|
|
|
|
""
|
|
|
|
);
|
2015-01-29 13:35:28 +00:00
|
|
|
}
|
|
|
|
|
2016-09-27 19:37:32 +00:00
|
|
|
FunctionType::FunctionType(FunctionTypeName const& _typeName):
|
2019-02-07 14:53:11 +00:00
|
|
|
m_parameterNames(_typeName.parameterTypes().size(), ""),
|
|
|
|
m_returnParameterNames(_typeName.returnParameterTypes().size(), ""),
|
2019-12-10 14:54:09 +00:00
|
|
|
m_kind(_typeName.visibility() == Visibility::External ? Kind::External : Kind::Internal),
|
2017-07-01 09:09:24 +00:00
|
|
|
m_stateMutability(_typeName.stateMutability())
|
2016-09-27 19:37:32 +00:00
|
|
|
{
|
2016-11-09 14:14:16 +00:00
|
|
|
if (_typeName.isPayable())
|
2017-02-11 03:13:36 +00:00
|
|
|
solAssert(m_kind == Kind::External, "Internal payable function type used.");
|
2016-09-27 19:37:32 +00:00
|
|
|
for (auto const& t: _typeName.parameterTypes())
|
|
|
|
{
|
|
|
|
solAssert(t->annotation().type, "Type not set for parameter.");
|
|
|
|
m_parameterTypes.push_back(t->annotation().type);
|
|
|
|
}
|
|
|
|
for (auto const& t: _typeName.returnParameterTypes())
|
|
|
|
{
|
|
|
|
solAssert(t->annotation().type, "Type not set for return parameter.");
|
|
|
|
m_returnParameterTypes.push_back(t->annotation().type);
|
|
|
|
}
|
2019-02-07 14:53:11 +00:00
|
|
|
|
|
|
|
solAssert(
|
|
|
|
m_parameterNames.size() == m_parameterTypes.size(),
|
|
|
|
"Parameter names list must match parameter types list!"
|
|
|
|
);
|
|
|
|
solAssert(
|
|
|
|
m_returnParameterNames.size() == m_returnParameterTypes.size(),
|
|
|
|
"Return parameter names list must match return parameter types list!"
|
|
|
|
);
|
2016-09-27 19:37:32 +00:00
|
|
|
}
|
|
|
|
|
2016-08-31 18:43:24 +00:00
|
|
|
FunctionTypePointer FunctionType::newExpressionType(ContractDefinition const& _contract)
|
|
|
|
{
|
|
|
|
FunctionDefinition const* constructor = _contract.constructor();
|
|
|
|
TypePointers parameters;
|
|
|
|
strings parameterNames;
|
2017-08-09 20:52:25 +00:00
|
|
|
StateMutability stateMutability = StateMutability::NonPayable;
|
2016-08-31 18:43:24 +00:00
|
|
|
|
2019-01-17 11:59:11 +00:00
|
|
|
solAssert(!_contract.isInterface(), "");
|
2017-08-11 23:45:37 +00:00
|
|
|
|
2016-08-31 18:43:24 +00:00
|
|
|
if (constructor)
|
|
|
|
{
|
|
|
|
for (ASTPointer<VariableDeclaration> const& var: constructor->parameters())
|
|
|
|
{
|
|
|
|
parameterNames.push_back(var->name());
|
|
|
|
parameters.push_back(var->annotation().type);
|
|
|
|
}
|
2017-08-09 20:52:25 +00:00
|
|
|
if (constructor->isPayable())
|
|
|
|
stateMutability = StateMutability::Payable;
|
2016-08-31 18:43:24 +00:00
|
|
|
}
|
2017-08-11 23:45:37 +00:00
|
|
|
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::function(
|
2016-08-31 18:43:24 +00:00
|
|
|
parameters,
|
2019-04-17 11:40:50 +00:00
|
|
|
TypePointers{TypeProvider::contract(_contract)},
|
2016-08-31 18:43:24 +00:00
|
|
|
parameterNames,
|
|
|
|
strings{""},
|
2017-02-11 03:13:36 +00:00
|
|
|
Kind::Creation,
|
2016-08-31 18:43:24 +00:00
|
|
|
false,
|
2017-08-09 20:52:25 +00:00
|
|
|
stateMutability
|
2016-08-31 18:43:24 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2016-02-18 12:29:02 +00:00
|
|
|
vector<string> FunctionType::parameterNames() const
|
2015-11-25 13:23:35 +00:00
|
|
|
{
|
|
|
|
if (!bound())
|
|
|
|
return m_parameterNames;
|
|
|
|
return vector<string>(m_parameterNames.cbegin() + 1, m_parameterNames.cend());
|
|
|
|
}
|
|
|
|
|
2018-02-20 23:40:38 +00:00
|
|
|
TypePointers FunctionType::returnParameterTypesWithoutDynamicTypes() const
|
|
|
|
{
|
|
|
|
TypePointers returnParameterTypes = m_returnParameterTypes;
|
|
|
|
|
2018-08-15 21:30:09 +00:00
|
|
|
if (
|
|
|
|
m_kind == Kind::External ||
|
|
|
|
m_kind == Kind::DelegateCall ||
|
|
|
|
m_kind == Kind::BareCall ||
|
|
|
|
m_kind == Kind::BareCallCode ||
|
|
|
|
m_kind == Kind::BareDelegateCall ||
|
|
|
|
m_kind == Kind::BareStaticCall
|
|
|
|
)
|
2018-02-20 23:40:38 +00:00
|
|
|
for (auto& param: returnParameterTypes)
|
2020-09-21 14:59:25 +00:00
|
|
|
{
|
|
|
|
solAssert(param->decodingType(), "");
|
|
|
|
if (param->decodingType()->isDynamicallyEncoded())
|
2019-04-17 11:40:50 +00:00
|
|
|
param = TypeProvider::inaccessibleDynamic();
|
2020-09-21 14:59:25 +00:00
|
|
|
}
|
2018-02-20 23:40:38 +00:00
|
|
|
|
|
|
|
return returnParameterTypes;
|
|
|
|
}
|
|
|
|
|
2015-11-25 13:23:35 +00:00
|
|
|
TypePointers FunctionType::parameterTypes() const
|
|
|
|
{
|
|
|
|
if (!bound())
|
|
|
|
return m_parameterTypes;
|
|
|
|
return TypePointers(m_parameterTypes.cbegin() + 1, m_parameterTypes.cend());
|
|
|
|
}
|
|
|
|
|
2020-11-19 09:53:07 +00:00
|
|
|
TypePointers const& FunctionType::parameterTypesIncludingSelf() const
|
|
|
|
{
|
|
|
|
return m_parameterTypes;
|
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string FunctionType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
|
|
|
string id = "t_function_";
|
2017-02-11 03:13:36 +00:00
|
|
|
switch (m_kind)
|
|
|
|
{
|
2020-01-07 10:42:37 +00:00
|
|
|
case Kind::Declaration: id += "declaration"; break;
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::Internal: id += "internal"; break;
|
|
|
|
case Kind::External: id += "external"; break;
|
|
|
|
case Kind::DelegateCall: id += "delegatecall"; break;
|
2017-08-01 09:32:23 +00:00
|
|
|
case Kind::BareCall: id += "barecall"; break;
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::BareCallCode: id += "barecallcode"; break;
|
|
|
|
case Kind::BareDelegateCall: id += "baredelegatecall"; break;
|
2018-08-15 12:40:20 +00:00
|
|
|
case Kind::BareStaticCall: id += "barestaticcall"; break;
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::Creation: id += "creation"; break;
|
|
|
|
case Kind::Send: id += "send"; break;
|
|
|
|
case Kind::Transfer: id += "transfer"; break;
|
2018-08-08 15:31:46 +00:00
|
|
|
case Kind::KECCAK256: id += "keccak256"; break;
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::Selfdestruct: id += "selfdestruct"; break;
|
|
|
|
case Kind::Revert: id += "revert"; break;
|
|
|
|
case Kind::ECRecover: id += "ecrecover"; break;
|
|
|
|
case Kind::SHA256: id += "sha256"; break;
|
|
|
|
case Kind::RIPEMD160: id += "ripemd160"; break;
|
2018-03-06 16:18:57 +00:00
|
|
|
case Kind::GasLeft: id += "gasleft"; break;
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::Event: id += "event"; break;
|
2021-01-28 11:56:22 +00:00
|
|
|
case Kind::Error: id += "error"; break;
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::SetGas: id += "setgas"; break;
|
|
|
|
case Kind::SetValue: id += "setvalue"; break;
|
|
|
|
case Kind::BlockHash: id += "blockhash"; break;
|
|
|
|
case Kind::AddMod: id += "addmod"; break;
|
|
|
|
case Kind::MulMod: id += "mulmod"; break;
|
|
|
|
case Kind::ArrayPush: id += "arraypush"; break;
|
2018-05-31 12:53:33 +00:00
|
|
|
case Kind::ArrayPop: id += "arraypop"; break;
|
2021-02-24 15:24:23 +00:00
|
|
|
case Kind::BytesConcat: id += "bytesconcat"; break;
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::ObjectCreation: id += "objectcreation"; break;
|
2017-03-20 18:06:17 +00:00
|
|
|
case Kind::Assert: id += "assert"; break;
|
2017-07-31 23:55:13 +00:00
|
|
|
case Kind::Require: id += "require"; break;
|
|
|
|
case Kind::ABIEncode: id += "abiencode"; break;
|
|
|
|
case Kind::ABIEncodePacked: id += "abiencodepacked"; break;
|
|
|
|
case Kind::ABIEncodeWithSelector: id += "abiencodewithselector"; break;
|
|
|
|
case Kind::ABIEncodeWithSignature: id += "abiencodewithsignature"; break;
|
2018-06-30 16:09:13 +00:00
|
|
|
case Kind::ABIDecode: id += "abidecode"; break;
|
2019-01-10 15:28:39 +00:00
|
|
|
case Kind::MetaType: id += "metatype"; break;
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
2017-08-15 21:47:26 +00:00
|
|
|
id += "_" + stateMutabilityToString(m_stateMutability);
|
2017-01-19 12:18:56 +00:00
|
|
|
id += identifierList(m_parameterTypes) + "returns" + identifierList(m_returnParameterTypes);
|
2017-01-17 09:47:44 +00:00
|
|
|
if (m_gasSet)
|
2017-01-20 10:47:20 +00:00
|
|
|
id += "gas";
|
2017-01-17 09:47:44 +00:00
|
|
|
if (m_valueSet)
|
2017-01-20 10:47:20 +00:00
|
|
|
id += "value";
|
2020-01-22 14:42:50 +00:00
|
|
|
if (m_saltSet)
|
|
|
|
id += "salt";
|
2017-01-17 09:47:44 +00:00
|
|
|
if (bound())
|
2017-01-19 12:18:56 +00:00
|
|
|
id += "bound_to" + identifierList(selfType());
|
2017-01-17 09:47:44 +00:00
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool FunctionType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-10-20 10:41:56 +00:00
|
|
|
return false;
|
2017-08-10 02:55:57 +00:00
|
|
|
FunctionType const& other = dynamic_cast<FunctionType const&>(_other);
|
2018-06-28 11:31:23 +00:00
|
|
|
if (!equalExcludingStateMutability(other))
|
2017-08-09 22:10:40 +00:00
|
|
|
return false;
|
2018-06-28 11:31:23 +00:00
|
|
|
if (m_stateMutability != other.stateMutability())
|
2015-11-27 13:08:09 +00:00
|
|
|
return false;
|
2014-11-25 13:43:23 +00:00
|
|
|
return true;
|
2014-10-20 10:41:56 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult FunctionType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
2016-12-01 12:12:10 +00:00
|
|
|
{
|
2020-01-07 10:42:37 +00:00
|
|
|
if (_convertTo.category() == category())
|
|
|
|
{
|
|
|
|
auto const& convertToType = dynamic_cast<FunctionType const&>(_convertTo);
|
|
|
|
return (m_kind == FunctionType::Kind::Declaration) == (convertToType.kind() == FunctionType::Kind::Declaration);
|
|
|
|
}
|
|
|
|
return false;
|
2016-12-01 12:12:10 +00:00
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
BoolResult FunctionType::isImplicitlyConvertibleTo(Type const& _convertTo) const
|
2018-06-28 11:31:23 +00:00
|
|
|
{
|
|
|
|
if (_convertTo.category() != category())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
FunctionType const& convertTo = dynamic_cast<FunctionType const&>(_convertTo);
|
|
|
|
|
2020-09-23 16:55:52 +00:00
|
|
|
// These two checks are duplicated in equalExcludingStateMutability, but are added here for error reporting.
|
|
|
|
if (convertTo.bound() != bound())
|
|
|
|
return BoolResult::err("Bound functions can not be converted to non-bound functions.");
|
|
|
|
|
|
|
|
if (convertTo.kind() != kind())
|
|
|
|
return BoolResult::err("Special functions can not be converted to function types.");
|
|
|
|
|
2018-06-28 11:31:23 +00:00
|
|
|
if (!equalExcludingStateMutability(convertTo))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// non-payable should not be convertible to payable
|
|
|
|
if (m_stateMutability != StateMutability::Payable && convertTo.stateMutability() == StateMutability::Payable)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// payable should be convertible to non-payable, because you are free to pay 0 ether
|
|
|
|
if (m_stateMutability == StateMutability::Payable && convertTo.stateMutability() == StateMutability::NonPayable)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// e.g. pure should be convertible to view, but not the other way around.
|
|
|
|
if (m_stateMutability > convertTo.stateMutability())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-05-07 22:31:34 +00:00
|
|
|
TypeResult FunctionType::unaryOperatorResult(Token _operator) const
|
2016-11-09 08:36:38 +00:00
|
|
|
{
|
2018-10-22 14:48:21 +00:00
|
|
|
if (_operator == Token::Delete)
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeResult(TypeProvider::emptyTuple());
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-11-09 08:36:38 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
TypeResult FunctionType::binaryOperatorResult(Token _operator, Type const* _other) const
|
2017-06-23 16:37:15 +00:00
|
|
|
{
|
2017-06-26 14:30:13 +00:00
|
|
|
if (_other->category() != category() || !(_operator == Token::Equal || _operator == Token::NotEqual))
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2017-06-23 16:37:15 +00:00
|
|
|
FunctionType const& other = dynamic_cast<FunctionType const&>(*_other);
|
|
|
|
if (kind() == Kind::Internal && other.kind() == Kind::Internal && sizeOnStack() == 1 && other.sizeOnStack() == 1)
|
2019-04-15 13:33:39 +00:00
|
|
|
return commonType(this, _other);
|
|
|
|
return nullptr;
|
2017-06-23 16:37:15 +00:00
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
string FunctionType::canonicalName() const
|
2016-11-14 12:13:37 +00:00
|
|
|
{
|
2017-02-11 03:13:36 +00:00
|
|
|
solAssert(m_kind == Kind::External, "");
|
2016-11-14 12:13:37 +00:00
|
|
|
return "function";
|
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string FunctionType::toString(bool _short) const
|
2014-11-13 00:12:57 +00:00
|
|
|
{
|
2020-01-07 10:42:37 +00:00
|
|
|
string name = "function ";
|
|
|
|
if (m_kind == Kind::Declaration)
|
|
|
|
{
|
|
|
|
auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(m_declaration);
|
|
|
|
solAssert(functionDefinition, "");
|
2020-05-04 16:38:00 +00:00
|
|
|
if (auto const* contract = dynamic_cast<ContractDefinition const*>(functionDefinition->scope()))
|
2020-09-10 10:01:23 +00:00
|
|
|
name += *contract->annotation().canonicalName + ".";
|
2020-01-07 10:42:37 +00:00
|
|
|
name += functionDefinition->name();
|
|
|
|
}
|
|
|
|
name += '(';
|
2014-11-25 13:43:23 +00:00
|
|
|
for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
|
2015-06-09 12:26:08 +00:00
|
|
|
name += (*it)->toString(_short) + (it + 1 == m_parameterTypes.end() ? "" : ",");
|
2016-11-16 14:09:01 +00:00
|
|
|
name += ")";
|
2017-08-15 21:47:26 +00:00
|
|
|
if (m_stateMutability != StateMutability::NonPayable)
|
|
|
|
name += " " + stateMutabilityToString(m_stateMutability);
|
2017-02-11 03:13:36 +00:00
|
|
|
if (m_kind == Kind::External)
|
2016-11-16 14:09:01 +00:00
|
|
|
name += " external";
|
|
|
|
if (!m_returnParameterTypes.empty())
|
|
|
|
{
|
|
|
|
name += " returns (";
|
|
|
|
for (auto it = m_returnParameterTypes.begin(); it != m_returnParameterTypes.end(); ++it)
|
|
|
|
name += (*it)->toString(_short) + (it + 1 == m_returnParameterTypes.end() ? "" : ",");
|
|
|
|
name += ")";
|
|
|
|
}
|
|
|
|
return name;
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2016-09-27 19:37:32 +00:00
|
|
|
unsigned FunctionType::calldataEncodedSize(bool _padded) const
|
|
|
|
{
|
|
|
|
unsigned size = storageBytes();
|
|
|
|
if (_padded)
|
|
|
|
size = ((size + 31) / 32) * 32;
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
u256 FunctionType::storageSize() const
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2017-02-11 03:13:36 +00:00
|
|
|
if (m_kind == Kind::External || m_kind == Kind::Internal)
|
2016-09-27 19:37:32 +00:00
|
|
|
return 1;
|
|
|
|
else
|
2017-07-19 01:19:00 +00:00
|
|
|
solAssert(false, "Storage size of non-storable function type requested.");
|
2016-09-27 19:37:32 +00:00
|
|
|
}
|
|
|
|
|
2019-03-19 15:13:16 +00:00
|
|
|
bool FunctionType::leftAligned() const
|
|
|
|
{
|
|
|
|
if (m_kind == Kind::External)
|
|
|
|
return true;
|
|
|
|
else
|
|
|
|
solAssert(false, "Alignment property of non-exportable function type requested.");
|
|
|
|
}
|
|
|
|
|
2016-09-27 19:37:32 +00:00
|
|
|
unsigned FunctionType::storageBytes() const
|
|
|
|
{
|
2017-02-11 03:13:36 +00:00
|
|
|
if (m_kind == Kind::External)
|
2016-09-27 19:37:32 +00:00
|
|
|
return 20 + 4;
|
2017-02-11 03:13:36 +00:00
|
|
|
else if (m_kind == Kind::Internal)
|
2016-09-27 19:37:32 +00:00
|
|
|
return 8; // it should really not be possible to create larger programs
|
|
|
|
else
|
2017-07-19 01:19:00 +00:00
|
|
|
solAssert(false, "Storage size of non-storable function type requested.");
|
2015-03-13 09:52:34 +00:00
|
|
|
}
|
|
|
|
|
2020-05-26 13:08:57 +00:00
|
|
|
bool FunctionType::nameable() const
|
|
|
|
{
|
|
|
|
return
|
|
|
|
(m_kind == Kind::Internal || m_kind == Kind::External) &&
|
|
|
|
!m_bound &&
|
|
|
|
!m_arbitraryParameters &&
|
|
|
|
!m_gasSet &&
|
|
|
|
!m_valueSet &&
|
|
|
|
!m_saltSet;
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> FunctionType::makeStackItems() const
|
2015-01-12 11:47:37 +00:00
|
|
|
{
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> slots;
|
2017-02-11 03:13:36 +00:00
|
|
|
Kind kind = m_kind;
|
|
|
|
if (m_kind == Kind::SetGas || m_kind == Kind::SetValue)
|
2015-02-22 17:38:32 +00:00
|
|
|
{
|
|
|
|
solAssert(m_returnParameterTypes.size() == 1, "");
|
2017-02-11 03:13:36 +00:00
|
|
|
kind = dynamic_cast<FunctionType const&>(*m_returnParameterTypes.front()).m_kind;
|
2015-02-22 17:38:32 +00:00
|
|
|
}
|
|
|
|
|
2019-11-11 16:09:59 +00:00
|
|
|
switch (kind)
|
2017-08-09 22:16:58 +00:00
|
|
|
{
|
|
|
|
case Kind::External:
|
|
|
|
case Kind::DelegateCall:
|
2020-03-05 18:26:30 +00:00
|
|
|
slots = {
|
|
|
|
make_tuple("address", TypeProvider::address()),
|
2020-07-23 12:19:15 +00:00
|
|
|
make_tuple("functionSelector", TypeProvider::uint(32))
|
2020-03-05 18:26:30 +00:00
|
|
|
};
|
2017-08-09 22:16:58 +00:00
|
|
|
break;
|
|
|
|
case Kind::BareCall:
|
|
|
|
case Kind::BareCallCode:
|
|
|
|
case Kind::BareDelegateCall:
|
2018-08-15 12:40:20 +00:00
|
|
|
case Kind::BareStaticCall:
|
2020-02-04 16:08:55 +00:00
|
|
|
case Kind::Transfer:
|
|
|
|
case Kind::Send:
|
|
|
|
slots = {make_tuple("address", TypeProvider::address())};
|
|
|
|
break;
|
2017-08-09 22:16:58 +00:00
|
|
|
case Kind::Internal:
|
2020-02-06 13:05:25 +00:00
|
|
|
slots = {make_tuple("functionIdentifier", TypeProvider::uint256())};
|
2020-02-04 16:08:55 +00:00
|
|
|
break;
|
2017-08-09 22:16:58 +00:00
|
|
|
case Kind::ArrayPush:
|
2018-05-31 12:53:33 +00:00
|
|
|
case Kind::ArrayPop:
|
2021-02-03 20:48:45 +00:00
|
|
|
solAssert(bound(), "");
|
|
|
|
slots = {};
|
2017-08-09 22:16:58 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-01-12 11:47:37 +00:00
|
|
|
if (m_gasSet)
|
2020-02-04 16:08:55 +00:00
|
|
|
slots.emplace_back("gas", TypeProvider::uint256());
|
2015-01-12 11:47:37 +00:00
|
|
|
if (m_valueSet)
|
2020-02-04 16:08:55 +00:00
|
|
|
slots.emplace_back("value", TypeProvider::uint256());
|
2020-01-22 14:42:50 +00:00
|
|
|
if (m_saltSet)
|
2020-02-25 16:57:28 +00:00
|
|
|
slots.emplace_back("salt", TypeProvider::fixedBytes(32));
|
2015-11-25 13:23:35 +00:00
|
|
|
if (bound())
|
2020-11-19 09:53:07 +00:00
|
|
|
slots.emplace_back("self", m_parameterTypes.front());
|
2020-02-04 16:08:55 +00:00
|
|
|
return slots;
|
2015-01-12 11:47:37 +00:00
|
|
|
}
|
|
|
|
|
2015-10-02 11:11:38 +00:00
|
|
|
FunctionTypePointer FunctionType::interfaceFunctionType() const
|
2015-03-27 12:28:32 +00:00
|
|
|
{
|
2015-10-02 11:11:38 +00:00
|
|
|
// Note that m_declaration might also be a state variable!
|
|
|
|
solAssert(m_declaration, "Declaration needed to determine interface function type.");
|
2020-05-04 16:38:00 +00:00
|
|
|
bool isLibraryFunction = false;
|
2021-01-28 11:56:22 +00:00
|
|
|
if (kind() != Kind::Event && kind() != Kind::Error)
|
2020-05-04 16:38:00 +00:00
|
|
|
if (auto const* contract = dynamic_cast<ContractDefinition const*>(m_declaration->scope()))
|
|
|
|
isLibraryFunction = contract->isLibrary();
|
2015-10-02 11:11:38 +00:00
|
|
|
|
2019-12-11 16:31:36 +00:00
|
|
|
util::Result<TypePointers> paramTypes =
|
2019-04-04 16:28:53 +00:00
|
|
|
transformParametersToExternal(m_parameterTypes, isLibraryFunction);
|
|
|
|
|
|
|
|
if (!paramTypes.message().empty())
|
|
|
|
return FunctionTypePointer();
|
|
|
|
|
2019-12-11 16:31:36 +00:00
|
|
|
util::Result<TypePointers> retParamTypes =
|
2019-04-04 16:28:53 +00:00
|
|
|
transformParametersToExternal(m_returnParameterTypes, isLibraryFunction);
|
|
|
|
|
|
|
|
if (!retParamTypes.message().empty())
|
|
|
|
return FunctionTypePointer();
|
2015-03-27 12:28:32 +00:00
|
|
|
|
2016-01-15 16:36:06 +00:00
|
|
|
auto variable = dynamic_cast<VariableDeclaration const*>(m_declaration);
|
2019-04-04 16:28:53 +00:00
|
|
|
if (variable && retParamTypes.get().empty())
|
2016-01-15 16:36:06 +00:00
|
|
|
return FunctionTypePointer();
|
|
|
|
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::function(
|
2017-08-09 22:10:40 +00:00
|
|
|
paramTypes,
|
|
|
|
retParamTypes,
|
|
|
|
m_parameterNames,
|
|
|
|
m_returnParameterNames,
|
|
|
|
m_kind,
|
|
|
|
m_arbitraryParameters,
|
2017-08-28 13:40:28 +00:00
|
|
|
m_stateMutability,
|
|
|
|
m_declaration
|
2016-08-31 18:43:24 +00:00
|
|
|
);
|
2015-03-27 12:28:32 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap FunctionType::nativeMembers(ASTNode const* _scope) const
|
2014-11-25 17:23:39 +00:00
|
|
|
{
|
2017-02-11 03:13:36 +00:00
|
|
|
switch (m_kind)
|
2014-11-25 17:23:39 +00:00
|
|
|
{
|
2020-01-07 10:42:37 +00:00
|
|
|
case Kind::Declaration:
|
2020-01-14 13:00:51 +00:00
|
|
|
if (declaration().isPartOfExternalInterface())
|
|
|
|
return {{"selector", TypeProvider::fixedBytes(4)}};
|
|
|
|
else
|
|
|
|
return MemberList::MemberMap();
|
|
|
|
case Kind::Internal:
|
|
|
|
if (
|
|
|
|
auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(m_declaration);
|
|
|
|
functionDefinition &&
|
|
|
|
_scope &&
|
|
|
|
functionDefinition->annotation().contract &&
|
|
|
|
_scope != functionDefinition->annotation().contract &&
|
|
|
|
functionDefinition->isPartOfExternalInterface()
|
|
|
|
)
|
|
|
|
{
|
2020-06-15 17:11:03 +00:00
|
|
|
auto const* contractScope = dynamic_cast<ContractDefinition const*>(_scope);
|
|
|
|
solAssert(contractScope && contractScope->derivesFrom(*functionDefinition->annotation().contract), "");
|
2020-01-14 13:00:51 +00:00
|
|
|
return {{"selector", TypeProvider::fixedBytes(4)}};
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return MemberList::MemberMap();
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::External:
|
|
|
|
case Kind::Creation:
|
2017-08-01 09:32:23 +00:00
|
|
|
case Kind::BareCall:
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::BareCallCode:
|
|
|
|
case Kind::BareDelegateCall:
|
2018-08-15 12:40:20 +00:00
|
|
|
case Kind::BareStaticCall:
|
2015-11-25 13:23:35 +00:00
|
|
|
{
|
2016-03-07 15:55:53 +00:00
|
|
|
MemberList::MemberMap members;
|
2017-06-27 09:25:36 +00:00
|
|
|
if (m_kind == Kind::External)
|
2019-08-13 14:43:25 +00:00
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
members.emplace_back("selector", TypeProvider::fixedBytes(4));
|
2019-08-13 14:43:25 +00:00
|
|
|
members.emplace_back("address", TypeProvider::address());
|
|
|
|
}
|
2017-11-13 00:54:29 +00:00
|
|
|
if (m_kind != Kind::BareDelegateCall)
|
2016-08-26 18:37:10 +00:00
|
|
|
{
|
2017-07-01 09:09:24 +00:00
|
|
|
if (isPayable())
|
2018-12-10 18:02:39 +00:00
|
|
|
members.emplace_back(
|
2016-08-26 18:37:10 +00:00
|
|
|
"value",
|
2019-04-17 11:40:50 +00:00
|
|
|
TypeProvider::function(
|
2016-08-26 18:37:10 +00:00
|
|
|
parseElementaryTypeVector({"uint"}),
|
2020-01-22 14:42:50 +00:00
|
|
|
TypePointers{copyAndSetCallOptions(false, true, false)},
|
2019-02-07 14:53:11 +00:00
|
|
|
strings(1, ""),
|
|
|
|
strings(1, ""),
|
2017-02-11 03:13:36 +00:00
|
|
|
Kind::SetValue,
|
2016-08-26 18:37:10 +00:00
|
|
|
false,
|
2019-06-13 13:51:15 +00:00
|
|
|
StateMutability::Pure,
|
2017-08-28 13:40:28 +00:00
|
|
|
nullptr,
|
2016-08-26 18:37:10 +00:00
|
|
|
m_gasSet,
|
2020-01-22 14:42:50 +00:00
|
|
|
m_valueSet,
|
|
|
|
m_saltSet
|
2016-08-26 18:37:10 +00:00
|
|
|
)
|
2018-12-10 18:02:39 +00:00
|
|
|
);
|
2016-08-26 18:37:10 +00:00
|
|
|
}
|
2017-02-11 03:13:36 +00:00
|
|
|
if (m_kind != Kind::Creation)
|
2018-12-10 18:02:39 +00:00
|
|
|
members.emplace_back(
|
2016-03-07 15:55:53 +00:00
|
|
|
"gas",
|
2019-04-17 11:40:50 +00:00
|
|
|
TypeProvider::function(
|
2016-03-07 15:55:53 +00:00
|
|
|
parseElementaryTypeVector({"uint"}),
|
2020-01-22 14:42:50 +00:00
|
|
|
TypePointers{copyAndSetCallOptions(true, false, false)},
|
2019-02-07 14:53:11 +00:00
|
|
|
strings(1, ""),
|
|
|
|
strings(1, ""),
|
2017-02-11 03:13:36 +00:00
|
|
|
Kind::SetGas,
|
2016-03-07 15:55:53 +00:00
|
|
|
false,
|
2019-06-13 13:51:15 +00:00
|
|
|
StateMutability::Pure,
|
2017-08-28 13:40:28 +00:00
|
|
|
nullptr,
|
2016-03-07 15:55:53 +00:00
|
|
|
m_gasSet,
|
2020-01-22 14:42:50 +00:00
|
|
|
m_valueSet,
|
|
|
|
m_saltSet
|
2015-11-25 13:23:35 +00:00
|
|
|
)
|
2018-12-10 18:02:39 +00:00
|
|
|
);
|
2015-11-25 13:23:35 +00:00
|
|
|
return members;
|
|
|
|
}
|
2019-11-14 14:43:02 +00:00
|
|
|
case Kind::DelegateCall:
|
|
|
|
{
|
|
|
|
auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(m_declaration);
|
|
|
|
solAssert(functionDefinition, "");
|
2019-12-10 14:54:09 +00:00
|
|
|
solAssert(functionDefinition->visibility() != Visibility::Private, "");
|
|
|
|
if (functionDefinition->visibility() != Visibility::Internal)
|
2019-11-14 14:43:02 +00:00
|
|
|
{
|
|
|
|
auto const* contract = dynamic_cast<ContractDefinition const*>(m_declaration->scope());
|
|
|
|
solAssert(contract, "");
|
|
|
|
solAssert(contract->isLibrary(), "");
|
|
|
|
return {{"selector", TypeProvider::fixedBytes(4)}};
|
|
|
|
}
|
|
|
|
return {};
|
|
|
|
}
|
2021-01-28 11:56:22 +00:00
|
|
|
case Kind::Error:
|
|
|
|
return {{"selector", TypeProvider::fixedBytes(4)}};
|
2014-11-25 17:23:39 +00:00
|
|
|
default:
|
2015-11-25 13:23:35 +00:00
|
|
|
return MemberList::MemberMap();
|
2014-11-25 17:23:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* FunctionType::encodingType() const
|
2016-09-28 17:22:23 +00:00
|
|
|
{
|
2020-04-07 15:41:03 +00:00
|
|
|
if (m_gasSet || m_valueSet)
|
|
|
|
return nullptr;
|
2016-09-28 17:22:23 +00:00
|
|
|
// Only external functions can be encoded, internal functions cannot leave code boundaries.
|
2017-02-11 03:13:36 +00:00
|
|
|
if (m_kind == Kind::External)
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2016-09-28 17:22:23 +00:00
|
|
|
else
|
2019-04-15 13:33:39 +00:00
|
|
|
return nullptr;
|
2016-09-28 17:22:23 +00:00
|
|
|
}
|
|
|
|
|
2019-03-18 12:22:42 +00:00
|
|
|
TypeResult FunctionType::interfaceType(bool /*_inLibrary*/) const
|
2016-09-27 19:37:32 +00:00
|
|
|
{
|
2017-02-11 03:13:36 +00:00
|
|
|
if (m_kind == Kind::External)
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2016-10-19 14:39:16 +00:00
|
|
|
else
|
2019-03-07 16:12:10 +00:00
|
|
|
return TypeResult::err("Internal type is not allowed for public or external functions.");
|
2016-09-27 19:37:32 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* FunctionType::mobileType() const
|
2020-07-15 14:27:38 +00:00
|
|
|
{
|
|
|
|
if (m_valueSet || m_gasSet || m_saltSet || m_bound)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// return function without parameter names
|
|
|
|
return TypeProvider::function(
|
|
|
|
m_parameterTypes,
|
|
|
|
m_returnParameterTypes,
|
|
|
|
strings(m_parameterTypes.size()),
|
|
|
|
strings(m_returnParameterNames.size()),
|
|
|
|
m_kind,
|
|
|
|
m_arbitraryParameters,
|
|
|
|
m_stateMutability,
|
|
|
|
m_declaration,
|
|
|
|
m_gasSet,
|
|
|
|
m_valueSet,
|
|
|
|
m_bound,
|
|
|
|
m_saltSet
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-03-19 16:12:21 +00:00
|
|
|
bool FunctionType::canTakeArguments(
|
|
|
|
FuncCallArguments const& _arguments,
|
2019-04-15 13:33:39 +00:00
|
|
|
Type const* _selfType
|
2019-03-19 16:12:21 +00:00
|
|
|
) const
|
2015-04-15 15:40:50 +00:00
|
|
|
{
|
2015-11-27 21:24:00 +00:00
|
|
|
solAssert(!bound() || _selfType, "");
|
|
|
|
if (bound() && !_selfType->isImplicitlyConvertibleTo(*selfType()))
|
|
|
|
return false;
|
2015-11-25 13:23:35 +00:00
|
|
|
TypePointers paramTypes = parameterTypes();
|
2019-03-19 16:12:21 +00:00
|
|
|
std::vector<std::string> const paramNames = parameterNames();
|
|
|
|
|
2015-04-15 15:40:50 +00:00
|
|
|
if (takesArbitraryParameters())
|
|
|
|
return true;
|
2019-03-19 16:12:21 +00:00
|
|
|
else if (_arguments.numArguments() != paramTypes.size())
|
2015-04-15 15:40:50 +00:00
|
|
|
return false;
|
2019-03-19 16:12:21 +00:00
|
|
|
else if (!_arguments.hasNamedArguments())
|
2016-02-18 12:29:02 +00:00
|
|
|
return equal(
|
2019-03-19 16:12:21 +00:00
|
|
|
_arguments.types.cbegin(),
|
|
|
|
_arguments.types.cend(),
|
2015-08-31 16:44:29 +00:00
|
|
|
paramTypes.cbegin(),
|
2019-04-15 13:33:39 +00:00
|
|
|
[](Type const* argumentType, Type const* parameterType)
|
2015-04-15 15:40:50 +00:00
|
|
|
{
|
|
|
|
return argumentType->isImplicitlyConvertibleTo(*parameterType);
|
|
|
|
}
|
|
|
|
);
|
2019-03-19 16:12:21 +00:00
|
|
|
else if (paramNames.size() != _arguments.numNames())
|
|
|
|
return false;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
solAssert(_arguments.numArguments() == _arguments.numNames(), "Expected equal sized type & name vectors");
|
|
|
|
|
|
|
|
size_t matchedNames = 0;
|
|
|
|
|
2020-09-09 06:52:29 +00:00
|
|
|
for (size_t a = 0; a < _arguments.names.size(); a++)
|
|
|
|
for (size_t p = 0; p < paramNames.size(); p++)
|
|
|
|
if (*_arguments.names[a] == paramNames[p])
|
2019-03-19 16:12:21 +00:00
|
|
|
{
|
|
|
|
matchedNames++;
|
2020-09-09 06:52:29 +00:00
|
|
|
if (!_arguments.types[a]->isImplicitlyConvertibleTo(*paramTypes[p]))
|
2019-03-19 16:12:21 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (matchedNames == _arguments.numNames())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2015-04-15 15:40:50 +00:00
|
|
|
}
|
|
|
|
|
2018-06-28 15:43:09 +00:00
|
|
|
bool FunctionType::hasEqualParameterTypes(FunctionType const& _other) const
|
2015-04-15 15:40:50 +00:00
|
|
|
{
|
|
|
|
if (m_parameterTypes.size() != _other.m_parameterTypes.size())
|
|
|
|
return false;
|
|
|
|
return equal(
|
|
|
|
m_parameterTypes.cbegin(),
|
|
|
|
m_parameterTypes.cend(),
|
|
|
|
_other.m_parameterTypes.cbegin(),
|
2019-04-15 13:33:39 +00:00
|
|
|
[](Type const* _a, Type const* _b) -> bool { return *_a == *_b; }
|
2015-04-15 15:40:50 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2018-06-28 11:31:23 +00:00
|
|
|
bool FunctionType::hasEqualReturnTypes(FunctionType const& _other) const
|
|
|
|
{
|
|
|
|
if (m_returnParameterTypes.size() != _other.m_returnParameterTypes.size())
|
|
|
|
return false;
|
|
|
|
return equal(
|
|
|
|
m_returnParameterTypes.cbegin(),
|
|
|
|
m_returnParameterTypes.cend(),
|
|
|
|
_other.m_returnParameterTypes.cbegin(),
|
2019-04-15 13:33:39 +00:00
|
|
|
[](Type const* _a, Type const* _b) -> bool { return *_a == *_b; }
|
2018-06-28 11:31:23 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FunctionType::equalExcludingStateMutability(FunctionType const& _other) const
|
|
|
|
{
|
|
|
|
if (m_kind != _other.m_kind)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!hasEqualParameterTypes(_other) || !hasEqualReturnTypes(_other))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
//@todo this is ugly, but cannot be prevented right now
|
2020-01-22 14:42:50 +00:00
|
|
|
if (m_gasSet != _other.m_gasSet || m_valueSet != _other.m_valueSet || m_saltSet != _other.m_saltSet)
|
2018-06-28 11:31:23 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (bound() != _other.bound())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
solAssert(!bound() || *selfType() == *_other.selfType(), "");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-05-15 16:02:09 +00:00
|
|
|
bool FunctionType::isBareCall() const
|
|
|
|
{
|
2017-02-11 03:13:36 +00:00
|
|
|
switch (m_kind)
|
2015-05-15 16:02:09 +00:00
|
|
|
{
|
2017-08-01 09:32:23 +00:00
|
|
|
case Kind::BareCall:
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::BareCallCode:
|
|
|
|
case Kind::BareDelegateCall:
|
2018-08-15 12:40:20 +00:00
|
|
|
case Kind::BareStaticCall:
|
2017-02-11 03:13:36 +00:00
|
|
|
case Kind::ECRecover:
|
|
|
|
case Kind::SHA256:
|
|
|
|
case Kind::RIPEMD160:
|
2015-05-15 16:02:09 +00:00
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-05 15:19:23 +00:00
|
|
|
string FunctionType::externalSignature() const
|
2015-01-07 01:27:05 +00:00
|
|
|
{
|
2015-10-05 15:19:23 +00:00
|
|
|
solAssert(m_declaration != nullptr, "External signature of function needs declaration");
|
2017-07-27 19:56:29 +00:00
|
|
|
solAssert(!m_declaration->name().empty(), "Fallback function has no signature.");
|
2018-08-15 15:11:43 +00:00
|
|
|
switch (kind())
|
|
|
|
{
|
|
|
|
case Kind::Internal:
|
|
|
|
case Kind::External:
|
|
|
|
case Kind::DelegateCall:
|
|
|
|
case Kind::Event:
|
2021-01-28 11:56:22 +00:00
|
|
|
case Kind::Error:
|
2020-01-07 10:42:37 +00:00
|
|
|
case Kind::Declaration:
|
2018-08-15 15:11:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
solAssert(false, "Invalid function type for requesting external signature.");
|
|
|
|
}
|
2015-10-05 15:19:23 +00:00
|
|
|
|
2021-01-28 11:56:22 +00:00
|
|
|
// "inLibrary" is only relevant if this is neither an event nor an error.
|
2020-05-04 16:38:00 +00:00
|
|
|
bool inLibrary = false;
|
2021-01-28 11:56:22 +00:00
|
|
|
if (kind() != Kind::Event && kind() != Kind::Error)
|
2020-05-04 16:38:00 +00:00
|
|
|
if (auto const* contract = dynamic_cast<ContractDefinition const*>(m_declaration->scope()))
|
|
|
|
inLibrary = contract->isLibrary();
|
2019-04-04 16:28:53 +00:00
|
|
|
|
|
|
|
auto extParams = transformParametersToExternal(m_parameterTypes, inLibrary);
|
|
|
|
|
|
|
|
solAssert(extParams.message().empty(), extParams.message());
|
|
|
|
|
2021-04-08 12:08:14 +00:00
|
|
|
auto typeStrings = extParams.get() | ranges::views::transform([&](Type const* _t) -> string
|
2015-03-23 17:08:45 +00:00
|
|
|
{
|
2017-06-08 09:14:58 +00:00
|
|
|
string typeName = _t->signatureInExternalFunction(inLibrary);
|
2019-04-04 16:28:53 +00:00
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
if (inLibrary && _t->dataStoredIn(DataLocation::Storage))
|
|
|
|
typeName += " storage";
|
|
|
|
return typeName;
|
|
|
|
});
|
|
|
|
return m_declaration->name() + "(" + boost::algorithm::join(typeStrings, ",") + ")";
|
2015-01-07 01:27:05 +00:00
|
|
|
}
|
|
|
|
|
2015-04-15 15:40:50 +00:00
|
|
|
u256 FunctionType::externalIdentifier() const
|
|
|
|
{
|
2020-10-12 14:36:48 +00:00
|
|
|
return util::selectorFromSignature32(externalSignature());
|
2015-04-15 15:40:50 +00:00
|
|
|
}
|
|
|
|
|
2019-12-09 00:26:23 +00:00
|
|
|
string FunctionType::externalIdentifierHex() const
|
|
|
|
{
|
2019-12-11 16:31:36 +00:00
|
|
|
return util::FixedHash<4>(util::keccak256(externalSignature())).hex();
|
2019-12-09 00:26:23 +00:00
|
|
|
}
|
|
|
|
|
2017-03-01 18:12:40 +00:00
|
|
|
bool FunctionType::isPure() const
|
|
|
|
{
|
2019-01-29 00:35:23 +00:00
|
|
|
// TODO: replace this with m_stateMutability == StateMutability::Pure once
|
|
|
|
// the callgraph analyzer is in place
|
2017-03-01 18:12:40 +00:00
|
|
|
return
|
2018-08-08 15:31:46 +00:00
|
|
|
m_kind == Kind::KECCAK256 ||
|
2017-02-11 03:13:36 +00:00
|
|
|
m_kind == Kind::ECRecover ||
|
|
|
|
m_kind == Kind::SHA256 ||
|
|
|
|
m_kind == Kind::RIPEMD160 ||
|
|
|
|
m_kind == Kind::AddMod ||
|
|
|
|
m_kind == Kind::MulMod ||
|
2018-05-15 11:04:49 +00:00
|
|
|
m_kind == Kind::ObjectCreation ||
|
|
|
|
m_kind == Kind::ABIEncode ||
|
|
|
|
m_kind == Kind::ABIEncodePacked ||
|
|
|
|
m_kind == Kind::ABIEncodeWithSelector ||
|
2018-06-30 16:09:13 +00:00
|
|
|
m_kind == Kind::ABIEncodeWithSignature ||
|
2019-01-10 15:28:39 +00:00
|
|
|
m_kind == Kind::ABIDecode ||
|
|
|
|
m_kind == Kind::MetaType;
|
2017-03-01 18:12:40 +00:00
|
|
|
}
|
|
|
|
|
2015-01-12 12:29:16 +00:00
|
|
|
TypePointers FunctionType::parseElementaryTypeVector(strings const& _types)
|
2015-01-12 11:46:52 +00:00
|
|
|
{
|
|
|
|
TypePointers pointers;
|
|
|
|
pointers.reserve(_types.size());
|
|
|
|
for (string const& type: _types)
|
2019-04-15 13:33:39 +00:00
|
|
|
pointers.push_back(TypeProvider::fromElementaryTypeName(type));
|
2015-01-12 11:46:52 +00:00
|
|
|
return pointers;
|
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* FunctionType::copyAndSetCallOptions(bool _setGas, bool _setValue, bool _setSalt) const
|
2015-01-12 11:47:37 +00:00
|
|
|
{
|
2020-01-07 10:42:37 +00:00
|
|
|
solAssert(m_kind != Kind::Declaration, "");
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::function(
|
2015-04-22 16:53:58 +00:00
|
|
|
m_parameterTypes,
|
|
|
|
m_returnParameterTypes,
|
2015-04-27 11:07:25 +00:00
|
|
|
m_parameterNames,
|
|
|
|
m_returnParameterNames,
|
2017-02-11 03:13:36 +00:00
|
|
|
m_kind,
|
2015-04-22 16:53:58 +00:00
|
|
|
m_arbitraryParameters,
|
2017-08-09 20:52:25 +00:00
|
|
|
m_stateMutability,
|
2017-08-28 13:40:28 +00:00
|
|
|
m_declaration,
|
2015-04-22 16:53:58 +00:00
|
|
|
m_gasSet || _setGas,
|
2015-11-25 13:23:35 +00:00
|
|
|
m_valueSet || _setValue,
|
2020-01-22 14:42:50 +00:00
|
|
|
m_saltSet || _setSalt,
|
2015-11-25 13:23:35 +00:00
|
|
|
m_bound
|
2015-04-22 16:53:58 +00:00
|
|
|
);
|
2015-01-12 11:47:37 +00:00
|
|
|
}
|
|
|
|
|
2020-06-10 14:46:02 +00:00
|
|
|
FunctionTypePointer FunctionType::asBoundFunction() const
|
2015-06-22 16:05:13 +00:00
|
|
|
{
|
2020-06-10 14:46:02 +00:00
|
|
|
solAssert(!m_parameterTypes.empty(), "");
|
|
|
|
solAssert(!m_gasSet, "");
|
|
|
|
solAssert(!m_valueSet, "");
|
|
|
|
solAssert(!m_saltSet, "");
|
|
|
|
return TypeProvider::function(
|
|
|
|
m_parameterTypes,
|
|
|
|
m_returnParameterTypes,
|
|
|
|
m_parameterNames,
|
|
|
|
m_returnParameterNames,
|
|
|
|
m_kind,
|
|
|
|
m_arbitraryParameters,
|
|
|
|
m_stateMutability,
|
|
|
|
m_declaration,
|
|
|
|
m_gasSet,
|
|
|
|
m_valueSet,
|
|
|
|
m_saltSet,
|
|
|
|
true
|
|
|
|
);
|
|
|
|
}
|
2016-10-14 18:30:04 +00:00
|
|
|
|
2020-06-10 14:46:02 +00:00
|
|
|
FunctionTypePointer FunctionType::asExternallyCallableFunction(bool _inLibrary) const
|
|
|
|
{
|
2015-06-22 18:50:29 +00:00
|
|
|
TypePointers parameterTypes;
|
|
|
|
for (auto const& t: m_parameterTypes)
|
2020-06-05 08:37:00 +00:00
|
|
|
if (TypeProvider::isReferenceWithLocation(t, DataLocation::CallData))
|
|
|
|
parameterTypes.push_back(
|
|
|
|
TypeProvider::withLocationIfReference(DataLocation::Memory, t, true)
|
|
|
|
);
|
2015-06-22 18:50:29 +00:00
|
|
|
else
|
|
|
|
parameterTypes.push_back(t);
|
2020-06-05 08:37:00 +00:00
|
|
|
|
|
|
|
TypePointers returnParameterTypes;
|
|
|
|
for (auto const& returnParamType: m_returnParameterTypes)
|
|
|
|
if (TypeProvider::isReferenceWithLocation(returnParamType, DataLocation::CallData))
|
|
|
|
returnParameterTypes.push_back(
|
|
|
|
TypeProvider::withLocationIfReference(DataLocation::Memory, returnParamType, true)
|
|
|
|
);
|
|
|
|
else
|
|
|
|
returnParameterTypes.push_back(returnParamType);
|
2015-06-22 18:50:29 +00:00
|
|
|
|
2017-02-11 03:13:36 +00:00
|
|
|
Kind kind = m_kind;
|
2016-04-26 23:02:10 +00:00
|
|
|
if (_inLibrary)
|
|
|
|
{
|
|
|
|
solAssert(!!m_declaration, "Declaration has to be available.");
|
2020-06-10 14:46:02 +00:00
|
|
|
solAssert(m_declaration->isPublic(), "");
|
|
|
|
kind = Kind::DelegateCall;
|
2016-04-26 23:02:10 +00:00
|
|
|
}
|
|
|
|
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::function(
|
2015-06-22 18:50:29 +00:00
|
|
|
parameterTypes,
|
2020-06-05 08:37:00 +00:00
|
|
|
returnParameterTypes,
|
2015-06-22 16:05:13 +00:00
|
|
|
m_parameterNames,
|
2016-06-01 21:39:19 +00:00
|
|
|
m_returnParameterNames,
|
2017-02-11 03:13:36 +00:00
|
|
|
kind,
|
2015-06-22 16:05:13 +00:00
|
|
|
m_arbitraryParameters,
|
2017-08-09 20:52:25 +00:00
|
|
|
m_stateMutability,
|
2017-08-28 13:40:28 +00:00
|
|
|
m_declaration,
|
2015-06-22 16:05:13 +00:00
|
|
|
m_gasSet,
|
2015-11-25 13:23:35 +00:00
|
|
|
m_valueSet,
|
2020-01-22 14:42:50 +00:00
|
|
|
m_saltSet,
|
2020-06-10 14:46:02 +00:00
|
|
|
m_bound
|
2015-06-22 16:05:13 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
Type const* FunctionType::selfType() const
|
2015-11-25 13:23:35 +00:00
|
|
|
{
|
2016-09-06 21:10:06 +00:00
|
|
|
solAssert(bound(), "Function is not bound.");
|
|
|
|
solAssert(m_parameterTypes.size() > 0, "Function has no self type.");
|
2015-11-25 13:23:35 +00:00
|
|
|
return m_parameterTypes.at(0);
|
|
|
|
}
|
|
|
|
|
2020-01-29 22:13:42 +00:00
|
|
|
ASTPointer<StructuredDocumentation> FunctionType::documentation() const
|
2015-01-29 15:39:30 +00:00
|
|
|
{
|
2020-01-29 22:13:42 +00:00
|
|
|
auto function = dynamic_cast<StructurallyDocumented const*>(m_declaration);
|
2015-01-29 15:39:30 +00:00
|
|
|
if (function)
|
2015-08-31 16:44:29 +00:00
|
|
|
return function->documentation();
|
2015-01-29 15:39:30 +00:00
|
|
|
|
2020-01-29 22:13:42 +00:00
|
|
|
return ASTPointer<StructuredDocumentation>();
|
2015-01-29 15:39:30 +00:00
|
|
|
}
|
|
|
|
|
2018-05-18 16:03:41 +00:00
|
|
|
bool FunctionType::padArguments() const
|
|
|
|
{
|
|
|
|
// No padding only for hash functions, low-level calls and the packed encoding function.
|
|
|
|
switch (m_kind)
|
|
|
|
{
|
|
|
|
case Kind::BareCall:
|
|
|
|
case Kind::BareCallCode:
|
|
|
|
case Kind::BareDelegateCall:
|
2018-08-15 12:40:20 +00:00
|
|
|
case Kind::BareStaticCall:
|
2018-05-18 16:03:41 +00:00
|
|
|
case Kind::SHA256:
|
|
|
|
case Kind::RIPEMD160:
|
2018-08-08 15:31:46 +00:00
|
|
|
case Kind::KECCAK256:
|
2018-05-18 16:03:41 +00:00
|
|
|
case Kind::ABIEncodePacked:
|
|
|
|
return false;
|
|
|
|
default:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
Type const* MappingType::encodingType() const
|
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::integer(256, IntegerType::Modifier::Unsigned);
|
2019-04-15 13:33:39 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string MappingType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2017-01-19 12:18:56 +00:00
|
|
|
return "t_mapping" + identifierList(m_keyType, m_valueType);
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool MappingType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-10-20 10:41:56 +00:00
|
|
|
return false;
|
|
|
|
MappingType const& other = dynamic_cast<MappingType const&>(_other);
|
|
|
|
return *other.m_keyType == *m_keyType && *other.m_valueType == *m_valueType;
|
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string MappingType::toString(bool _short) const
|
2014-11-13 00:12:57 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
return "mapping(" + keyType()->toString(_short) + " => " + valueType()->toString(_short) + ")";
|
2014-11-13 00:12:57 +00:00
|
|
|
}
|
|
|
|
|
2017-06-08 09:14:58 +00:00
|
|
|
string MappingType::canonicalName() const
|
2015-10-05 15:19:23 +00:00
|
|
|
{
|
2017-06-08 09:14:58 +00:00
|
|
|
return "mapping(" + keyType()->canonicalName() + " => " + valueType()->canonicalName() + ")";
|
2015-10-05 15:19:23 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 16:12:10 +00:00
|
|
|
TypeResult MappingType::interfaceType(bool _inLibrary) const
|
|
|
|
{
|
|
|
|
solAssert(keyType()->interfaceType(_inLibrary).get(), "Must be an elementary type!");
|
|
|
|
|
|
|
|
if (_inLibrary)
|
|
|
|
{
|
|
|
|
auto iType = valueType()->interfaceType(_inLibrary);
|
|
|
|
|
|
|
|
if (!iType.get())
|
|
|
|
{
|
|
|
|
solAssert(!iType.message().empty(), "Expected detailed error message!");
|
|
|
|
return iType;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2020-06-03 10:38:35 +00:00
|
|
|
return TypeResult::err(
|
|
|
|
"Types containing (nested) mappings can only be parameters or "
|
|
|
|
"return variables of internal or library functions."
|
|
|
|
);
|
2019-03-07 16:12:10 +00:00
|
|
|
|
2019-04-15 13:33:39 +00:00
|
|
|
return this;
|
2019-03-07 16:12:10 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string TypeType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2017-01-19 12:18:56 +00:00
|
|
|
return "t_type" + identifierList(actualType());
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2014-10-29 18:28:30 +00:00
|
|
|
bool TypeType::operator==(Type const& _other) const
|
2014-10-20 10:41:56 +00:00
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2014-10-20 10:41:56 +00:00
|
|
|
return false;
|
|
|
|
TypeType const& other = dynamic_cast<TypeType const&>(_other);
|
2015-08-31 16:44:29 +00:00
|
|
|
return *actualType() == *other.actualType();
|
2014-10-20 10:41:56 +00:00
|
|
|
}
|
2014-10-13 16:22:15 +00:00
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
u256 TypeType::storageSize() const
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2017-07-19 01:19:00 +00:00
|
|
|
solAssert(false, "Storage size of non-storable type type requested.");
|
2015-03-13 09:52:34 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
vector<tuple<string, Type const*>> TypeType::makeStackItems() const
|
2015-09-10 17:40:07 +00:00
|
|
|
{
|
2019-04-15 13:33:39 +00:00
|
|
|
if (auto contractType = dynamic_cast<ContractType const*>(m_actualType))
|
2015-09-10 17:40:07 +00:00
|
|
|
if (contractType->contractDefinition().isLibrary())
|
2020-10-14 09:17:53 +00:00
|
|
|
{
|
|
|
|
solAssert(!contractType->isSuper(), "");
|
2020-02-04 16:08:55 +00:00
|
|
|
return {make_tuple("address", TypeProvider::address())};
|
2020-10-14 09:17:53 +00:00
|
|
|
}
|
|
|
|
|
2020-02-04 16:08:55 +00:00
|
|
|
return {};
|
2015-09-10 17:40:07 +00:00
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap TypeType::nativeMembers(ASTNode const* _currentScope) const
|
2015-01-19 18:18:34 +00:00
|
|
|
{
|
2015-11-25 13:23:35 +00:00
|
|
|
MemberList::MemberMap members;
|
|
|
|
if (m_actualType->category() == Category::Contract)
|
2015-01-19 18:18:34 +00:00
|
|
|
{
|
2020-10-14 09:17:53 +00:00
|
|
|
auto contractType = dynamic_cast<ContractType const*>(m_actualType);
|
|
|
|
ContractDefinition const& contract = contractType->contractDefinition();
|
|
|
|
if (contractType->isSuper())
|
|
|
|
{
|
|
|
|
// add the most derived of all functions which are visible in derived contracts
|
|
|
|
auto bases = contract.annotation().linearizedBaseContracts;
|
|
|
|
solAssert(bases.size() >= 1, "linearizedBaseContracts should at least contain the most derived contract.");
|
|
|
|
// `sliced(1, ...)` ignores the most derived contract, which should not be searchable from `super`.
|
2021-08-24 08:37:26 +00:00
|
|
|
for (ContractDefinition const* base: bases | ranges::views::tail)
|
2020-10-14 09:17:53 +00:00
|
|
|
for (FunctionDefinition const* function: base->definedFunctions())
|
|
|
|
{
|
|
|
|
if (!function->isVisibleInDerivedContracts() || !function->isImplemented())
|
|
|
|
continue;
|
2020-01-14 13:00:51 +00:00
|
|
|
|
2020-10-14 09:17:53 +00:00
|
|
|
auto functionType = TypeProvider::function(*function, FunctionType::Kind::Internal);
|
|
|
|
bool functionWithEqualArgumentsFound = false;
|
|
|
|
for (auto const& member: members)
|
|
|
|
{
|
|
|
|
if (member.name != function->name())
|
|
|
|
continue;
|
|
|
|
auto memberType = dynamic_cast<FunctionType const*>(member.type);
|
|
|
|
solAssert(!!memberType, "Override changes type.");
|
|
|
|
if (!memberType->hasEqualParameterTypes(*functionType))
|
|
|
|
continue;
|
|
|
|
functionWithEqualArgumentsFound = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!functionWithEqualArgumentsFound)
|
2021-02-08 12:33:39 +00:00
|
|
|
members.emplace_back(function, functionType);
|
2020-10-14 09:17:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2015-12-18 14:56:26 +00:00
|
|
|
{
|
2020-10-14 09:17:53 +00:00
|
|
|
auto const* contractScope = dynamic_cast<ContractDefinition const*>(_currentScope);
|
|
|
|
bool inDerivingScope = contractScope && contractScope->derivesFrom(contract);
|
2020-01-14 13:00:51 +00:00
|
|
|
|
2020-10-14 09:17:53 +00:00
|
|
|
for (auto const* declaration: contract.declarations())
|
2020-03-06 09:44:51 +00:00
|
|
|
{
|
2020-10-14 09:17:53 +00:00
|
|
|
if (dynamic_cast<ModifierDefinition const*>(declaration))
|
|
|
|
continue;
|
|
|
|
if (declaration->name().empty())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!contract.isLibrary() && inDerivingScope && declaration->isVisibleInDerivedContracts())
|
|
|
|
{
|
|
|
|
if (
|
|
|
|
auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(declaration);
|
|
|
|
functionDefinition && !functionDefinition->isImplemented()
|
|
|
|
)
|
2021-02-08 12:33:39 +00:00
|
|
|
members.emplace_back(declaration, declaration->typeViaContractName());
|
2020-10-14 09:17:53 +00:00
|
|
|
else
|
2021-02-08 12:33:39 +00:00
|
|
|
members.emplace_back(declaration, declaration->type());
|
2020-10-14 09:17:53 +00:00
|
|
|
}
|
|
|
|
else if (
|
|
|
|
(contract.isLibrary() && declaration->isVisibleAsLibraryMember()) ||
|
|
|
|
declaration->isVisibleViaContractTypeAccess()
|
2020-03-06 09:44:51 +00:00
|
|
|
)
|
2021-02-08 12:33:39 +00:00
|
|
|
members.emplace_back(declaration, declaration->typeViaContractName());
|
2020-03-06 09:44:51 +00:00
|
|
|
}
|
2015-02-12 14:19:04 +00:00
|
|
|
}
|
2015-01-19 18:18:34 +00:00
|
|
|
}
|
2015-11-25 13:23:35 +00:00
|
|
|
else if (m_actualType->category() == Category::Enum)
|
|
|
|
{
|
|
|
|
EnumDefinition const& enumDef = dynamic_cast<EnumType const&>(*m_actualType).enumDefinition();
|
2019-04-15 13:33:39 +00:00
|
|
|
auto enumType = TypeProvider::enumType(enumDef);
|
2015-11-25 13:23:35 +00:00
|
|
|
for (ASTPointer<EnumValue> const& enumValue: enumDef.members())
|
2021-02-08 12:33:39 +00:00
|
|
|
members.emplace_back(enumValue.get(), enumType);
|
2015-11-25 13:23:35 +00:00
|
|
|
}
|
2021-02-24 15:24:23 +00:00
|
|
|
else if (
|
|
|
|
auto const* arrayType = dynamic_cast<ArrayType const*>(m_actualType);
|
|
|
|
arrayType && arrayType->isByteArray()
|
|
|
|
)
|
|
|
|
members.emplace_back("concat", TypeProvider::function(
|
|
|
|
TypePointers{},
|
|
|
|
TypePointers{TypeProvider::bytesMemory()},
|
|
|
|
strings{},
|
|
|
|
strings{string()},
|
|
|
|
FunctionType::Kind::BytesConcat,
|
|
|
|
/* _arbitraryParameters */ true,
|
|
|
|
StateMutability::Pure
|
|
|
|
));
|
|
|
|
|
2015-11-25 13:23:35 +00:00
|
|
|
return members;
|
2015-01-19 18:18:34 +00:00
|
|
|
}
|
|
|
|
|
2019-11-12 15:20:03 +00:00
|
|
|
BoolResult TypeType::isExplicitlyConvertibleTo(Type const& _convertTo) const
|
|
|
|
{
|
|
|
|
if (auto const* address = dynamic_cast<AddressType const*>(&_convertTo))
|
|
|
|
if (address->stateMutability() == StateMutability::NonPayable)
|
|
|
|
if (auto const* contractType = dynamic_cast<ContractType const*>(m_actualType))
|
|
|
|
return contractType->contractDefinition().isLibrary();
|
|
|
|
return isImplicitlyConvertibleTo(_convertTo);
|
|
|
|
}
|
|
|
|
|
2019-02-13 15:22:42 +00:00
|
|
|
ModifierType::ModifierType(ModifierDefinition const& _modifier)
|
2015-01-22 00:02:38 +00:00
|
|
|
{
|
|
|
|
TypePointers params;
|
2015-08-31 16:44:29 +00:00
|
|
|
params.reserve(_modifier.parameters().size());
|
|
|
|
for (ASTPointer<VariableDeclaration> const& var: _modifier.parameters())
|
2015-09-16 14:56:30 +00:00
|
|
|
params.push_back(var->annotation().type);
|
2015-01-22 00:02:38 +00:00
|
|
|
swap(params, m_parameterTypes);
|
|
|
|
}
|
|
|
|
|
2015-08-31 16:44:29 +00:00
|
|
|
u256 ModifierType::storageSize() const
|
2015-03-13 09:52:34 +00:00
|
|
|
{
|
2017-07-19 01:19:00 +00:00
|
|
|
solAssert(false, "Storage size of non-storable type type requested.");
|
2015-03-13 09:52:34 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string ModifierType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2017-01-19 12:18:56 +00:00
|
|
|
return "t_modifier" + identifierList(m_parameterTypes);
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2015-01-22 00:02:38 +00:00
|
|
|
bool ModifierType::operator==(Type const& _other) const
|
|
|
|
{
|
2015-08-31 16:44:29 +00:00
|
|
|
if (_other.category() != category())
|
2015-01-22 00:02:38 +00:00
|
|
|
return false;
|
|
|
|
ModifierType const& other = dynamic_cast<ModifierType const&>(_other);
|
|
|
|
|
|
|
|
if (m_parameterTypes.size() != other.m_parameterTypes.size())
|
|
|
|
return false;
|
2019-04-15 13:33:39 +00:00
|
|
|
auto typeCompare = [](Type const* _a, Type const* _b) -> bool { return *_a == *_b; };
|
2015-01-22 00:02:38 +00:00
|
|
|
|
2019-02-13 15:56:46 +00:00
|
|
|
if (!equal(
|
|
|
|
m_parameterTypes.cbegin(),
|
|
|
|
m_parameterTypes.cend(),
|
|
|
|
other.m_parameterTypes.cbegin(),
|
|
|
|
typeCompare
|
|
|
|
))
|
2015-01-22 00:02:38 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-06-09 12:26:08 +00:00
|
|
|
string ModifierType::toString(bool _short) const
|
2015-01-22 00:02:38 +00:00
|
|
|
{
|
|
|
|
string name = "modifier (";
|
|
|
|
for (auto it = m_parameterTypes.begin(); it != m_parameterTypes.end(); ++it)
|
2015-06-09 12:26:08 +00:00
|
|
|
name += (*it)->toString(_short) + (it + 1 == m_parameterTypes.end() ? "" : ",");
|
2015-01-22 00:02:38 +00:00
|
|
|
return name + ")";
|
|
|
|
}
|
2015-01-19 18:18:34 +00:00
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string ModuleType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
2018-08-08 14:26:30 +00:00
|
|
|
return "t_module_" + to_string(m_sourceUnit.id());
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
2015-12-15 14:46:03 +00:00
|
|
|
bool ModuleType::operator==(Type const& _other) const
|
2015-11-25 13:23:35 +00:00
|
|
|
{
|
2015-12-15 14:46:03 +00:00
|
|
|
if (_other.category() != category())
|
|
|
|
return false;
|
|
|
|
return &m_sourceUnit == &dynamic_cast<ModuleType const&>(_other).m_sourceUnit;
|
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap ModuleType::nativeMembers(ASTNode const*) const
|
2015-12-15 14:46:03 +00:00
|
|
|
{
|
|
|
|
MemberList::MemberMap symbols;
|
2021-02-08 12:33:39 +00:00
|
|
|
for (auto const& [name, declarations]: *m_sourceUnit.annotation().exportedSymbols)
|
|
|
|
for (Declaration const* symbol: declarations)
|
2021-02-23 10:30:34 +00:00
|
|
|
symbols.emplace_back(symbol, symbol->type(), name);
|
2015-12-15 14:46:03 +00:00
|
|
|
return symbols;
|
|
|
|
}
|
|
|
|
|
|
|
|
string ModuleType::toString(bool) const
|
|
|
|
{
|
2020-09-10 10:01:23 +00:00
|
|
|
return string("module \"") + *m_sourceUnit.annotation().path + string("\"");
|
2015-11-25 13:23:35 +00:00
|
|
|
}
|
|
|
|
|
2018-02-23 17:32:46 +00:00
|
|
|
string MagicType::richIdentifier() const
|
2017-01-17 09:47:44 +00:00
|
|
|
{
|
|
|
|
switch (m_kind)
|
|
|
|
{
|
|
|
|
case Kind::Block:
|
|
|
|
return "t_magic_block";
|
|
|
|
case Kind::Message:
|
|
|
|
return "t_magic_message";
|
|
|
|
case Kind::Transaction:
|
|
|
|
return "t_magic_transaction";
|
2017-07-31 23:55:13 +00:00
|
|
|
case Kind::ABI:
|
|
|
|
return "t_magic_abi";
|
2019-01-10 15:28:39 +00:00
|
|
|
case Kind::MetaType:
|
|
|
|
solAssert(m_typeArgument, "");
|
|
|
|
return "t_magic_meta_type_" + m_typeArgument->richIdentifier();
|
2017-01-17 09:47:44 +00:00
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2015-11-25 13:23:35 +00:00
|
|
|
bool MagicType::operator==(Type const& _other) const
|
|
|
|
{
|
|
|
|
if (_other.category() != category())
|
|
|
|
return false;
|
|
|
|
MagicType const& other = dynamic_cast<MagicType const&>(_other);
|
|
|
|
return other.m_kind == m_kind;
|
|
|
|
}
|
|
|
|
|
2020-06-15 17:11:03 +00:00
|
|
|
MemberList::MemberMap MagicType::nativeMembers(ASTNode const*) const
|
2014-11-24 12:23:58 +00:00
|
|
|
{
|
|
|
|
switch (m_kind)
|
|
|
|
{
|
2015-02-09 13:08:48 +00:00
|
|
|
case Kind::Block:
|
2015-11-25 13:23:35 +00:00
|
|
|
return MemberList::MemberMap({
|
2019-04-17 11:40:50 +00:00
|
|
|
{"coinbase", TypeProvider::payableAddress()},
|
2019-04-15 16:10:43 +00:00
|
|
|
{"timestamp", TypeProvider::uint256()},
|
2019-04-17 11:40:50 +00:00
|
|
|
{"blockhash", TypeProvider::function(strings{"uint"}, strings{"bytes32"}, FunctionType::Kind::BlockHash, false, StateMutability::View)},
|
2019-04-15 16:10:43 +00:00
|
|
|
{"difficulty", TypeProvider::uint256()},
|
|
|
|
{"number", TypeProvider::uint256()},
|
2020-09-22 17:12:01 +00:00
|
|
|
{"gaslimit", TypeProvider::uint256()},
|
2021-07-12 14:49:05 +00:00
|
|
|
{"chainid", TypeProvider::uint256()},
|
|
|
|
{"basefee", TypeProvider::uint256()}
|
2015-06-08 10:09:24 +00:00
|
|
|
});
|
2015-02-09 13:08:48 +00:00
|
|
|
case Kind::Message:
|
2015-11-25 13:23:35 +00:00
|
|
|
return MemberList::MemberMap({
|
2020-12-03 21:33:58 +00:00
|
|
|
{"sender", TypeProvider::address()},
|
2019-04-15 16:10:43 +00:00
|
|
|
{"gas", TypeProvider::uint256()},
|
|
|
|
{"value", TypeProvider::uint256()},
|
2019-04-17 11:40:50 +00:00
|
|
|
{"data", TypeProvider::array(DataLocation::CallData)},
|
|
|
|
{"sig", TypeProvider::fixedBytes(4)}
|
2015-06-08 10:09:24 +00:00
|
|
|
});
|
2015-02-09 13:08:48 +00:00
|
|
|
case Kind::Transaction:
|
2015-11-25 13:23:35 +00:00
|
|
|
return MemberList::MemberMap({
|
2020-12-03 21:33:58 +00:00
|
|
|
{"origin", TypeProvider::address()},
|
2019-04-15 16:10:43 +00:00
|
|
|
{"gasprice", TypeProvider::uint256()}
|
2015-06-08 10:09:24 +00:00
|
|
|
});
|
2017-07-31 23:55:13 +00:00
|
|
|
case Kind::ABI:
|
|
|
|
return MemberList::MemberMap({
|
2019-04-17 11:40:50 +00:00
|
|
|
{"encode", TypeProvider::function(
|
2019-04-15 13:33:39 +00:00
|
|
|
TypePointers{},
|
2019-04-17 11:40:50 +00:00
|
|
|
TypePointers{TypeProvider::array(DataLocation::Memory)},
|
2017-07-31 23:55:13 +00:00
|
|
|
strings{},
|
2019-02-07 14:53:11 +00:00
|
|
|
strings{1, ""},
|
2017-07-31 23:55:13 +00:00
|
|
|
FunctionType::Kind::ABIEncode,
|
|
|
|
true,
|
|
|
|
StateMutability::Pure
|
|
|
|
)},
|
2019-04-17 11:40:50 +00:00
|
|
|
{"encodePacked", TypeProvider::function(
|
2019-04-15 13:33:39 +00:00
|
|
|
TypePointers{},
|
2019-04-17 11:40:50 +00:00
|
|
|
TypePointers{TypeProvider::array(DataLocation::Memory)},
|
2017-07-31 23:55:13 +00:00
|
|
|
strings{},
|
2019-02-07 14:53:11 +00:00
|
|
|
strings{1, ""},
|
2017-07-31 23:55:13 +00:00
|
|
|
FunctionType::Kind::ABIEncodePacked,
|
|
|
|
true,
|
|
|
|
StateMutability::Pure
|
|
|
|
)},
|
2019-04-17 11:40:50 +00:00
|
|
|
{"encodeWithSelector", TypeProvider::function(
|
|
|
|
TypePointers{TypeProvider::fixedBytes(4)},
|
|
|
|
TypePointers{TypeProvider::array(DataLocation::Memory)},
|
2019-02-07 14:53:11 +00:00
|
|
|
strings{1, ""},
|
|
|
|
strings{1, ""},
|
2017-07-31 23:55:13 +00:00
|
|
|
FunctionType::Kind::ABIEncodeWithSelector,
|
|
|
|
true,
|
|
|
|
StateMutability::Pure
|
|
|
|
)},
|
2019-04-17 11:40:50 +00:00
|
|
|
{"encodeWithSignature", TypeProvider::function(
|
|
|
|
TypePointers{TypeProvider::array(DataLocation::Memory, true)},
|
|
|
|
TypePointers{TypeProvider::array(DataLocation::Memory)},
|
2019-02-07 14:53:11 +00:00
|
|
|
strings{1, ""},
|
|
|
|
strings{1, ""},
|
2017-07-31 23:55:13 +00:00
|
|
|
FunctionType::Kind::ABIEncodeWithSignature,
|
|
|
|
true,
|
|
|
|
StateMutability::Pure
|
2018-06-30 16:09:13 +00:00
|
|
|
)},
|
2019-04-17 11:40:50 +00:00
|
|
|
{"decode", TypeProvider::function(
|
2018-06-30 16:09:13 +00:00
|
|
|
TypePointers(),
|
|
|
|
TypePointers(),
|
|
|
|
strings{},
|
|
|
|
strings{},
|
|
|
|
FunctionType::Kind::ABIDecode,
|
|
|
|
true,
|
|
|
|
StateMutability::Pure
|
2017-07-31 23:55:13 +00:00
|
|
|
)}
|
|
|
|
});
|
2019-01-10 15:28:39 +00:00
|
|
|
case Kind::MetaType:
|
|
|
|
{
|
|
|
|
solAssert(
|
2020-05-07 16:24:37 +00:00
|
|
|
m_typeArgument && (
|
|
|
|
m_typeArgument->category() == Type::Category::Contract ||
|
|
|
|
m_typeArgument->category() == Type::Category::Integer
|
|
|
|
),
|
|
|
|
"Only contracts or integer types supported for now"
|
2019-01-10 15:28:39 +00:00
|
|
|
);
|
2020-05-07 16:24:37 +00:00
|
|
|
|
|
|
|
if (m_typeArgument->category() == Type::Category::Contract)
|
|
|
|
{
|
|
|
|
ContractDefinition const& contract = dynamic_cast<ContractType const&>(*m_typeArgument).contractDefinition();
|
|
|
|
if (contract.canBeDeployed())
|
|
|
|
return MemberList::MemberMap({
|
|
|
|
{"creationCode", TypeProvider::array(DataLocation::Memory)},
|
|
|
|
{"runtimeCode", TypeProvider::array(DataLocation::Memory)},
|
|
|
|
{"name", TypeProvider::stringMemory()},
|
|
|
|
});
|
|
|
|
else
|
|
|
|
return MemberList::MemberMap({
|
|
|
|
{"interfaceId", TypeProvider::fixedBytes(4)},
|
2020-08-26 18:32:27 +00:00
|
|
|
{"name", TypeProvider::stringMemory()},
|
2020-05-07 16:24:37 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
else if (m_typeArgument->category() == Type::Category::Integer)
|
|
|
|
{
|
|
|
|
IntegerType const* integerTypePointer = dynamic_cast<IntegerType const*>(m_typeArgument);
|
2020-04-08 22:08:49 +00:00
|
|
|
return MemberList::MemberMap({
|
2020-05-07 16:24:37 +00:00
|
|
|
{"min", integerTypePointer},
|
|
|
|
{"max", integerTypePointer},
|
2020-04-08 22:08:49 +00:00
|
|
|
});
|
2020-05-07 16:24:37 +00:00
|
|
|
}
|
2014-11-24 12:23:58 +00:00
|
|
|
}
|
2019-01-10 15:28:39 +00:00
|
|
|
}
|
|
|
|
solAssert(false, "Unknown kind of magic.");
|
|
|
|
return {};
|
2014-11-24 12:23:58 +00:00
|
|
|
}
|
|
|
|
|
2019-01-10 15:28:39 +00:00
|
|
|
string MagicType::toString(bool _short) const
|
2014-11-24 12:23:58 +00:00
|
|
|
{
|
|
|
|
switch (m_kind)
|
|
|
|
{
|
2015-02-09 13:08:48 +00:00
|
|
|
case Kind::Block:
|
2014-11-24 12:23:58 +00:00
|
|
|
return "block";
|
2015-02-09 13:08:48 +00:00
|
|
|
case Kind::Message:
|
2014-11-24 12:23:58 +00:00
|
|
|
return "msg";
|
2015-02-09 13:08:48 +00:00
|
|
|
case Kind::Transaction:
|
2014-11-24 12:23:58 +00:00
|
|
|
return "tx";
|
2017-07-31 23:55:13 +00:00
|
|
|
case Kind::ABI:
|
|
|
|
return "abi";
|
2019-01-10 15:28:39 +00:00
|
|
|
case Kind::MetaType:
|
|
|
|
solAssert(m_typeArgument, "");
|
|
|
|
return "type(" + m_typeArgument->toString(_short) + ")";
|
2014-11-24 12:23:58 +00:00
|
|
|
}
|
2019-01-10 15:28:39 +00:00
|
|
|
solAssert(false, "Unknown kind of magic.");
|
|
|
|
return {};
|
2014-11-24 12:23:58 +00:00
|
|
|
}
|
2019-01-10 15:44:31 +00:00
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* MagicType::typeArgument() const
|
2019-01-10 15:44:31 +00:00
|
|
|
{
|
|
|
|
solAssert(m_kind == Kind::MetaType, "");
|
|
|
|
solAssert(m_typeArgument, "");
|
|
|
|
return m_typeArgument;
|
|
|
|
}
|
2019-04-15 13:33:39 +00:00
|
|
|
|
2021-03-22 16:12:05 +00:00
|
|
|
Type const* InaccessibleDynamicType::decodingType() const
|
2019-04-15 13:33:39 +00:00
|
|
|
{
|
2019-04-17 11:40:50 +00:00
|
|
|
return TypeProvider::integer(256, IntegerType::Modifier::Unsigned);
|
2019-04-15 13:33:39 +00:00
|
|
|
}
|