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

3544 lines
120 KiB
C++
Raw Normal View History

Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
/*
Fix licensing headers Signed-off-by: VoR0220 <rj@erisindustries.com>
2016-11-18 23:13:20 +00:00
This file is part of solidity.
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Fix licensing headers Signed-off-by: VoR0220 <rj@erisindustries.com>
2016-11-18 23:13:20 +00:00
solidity is free software: you can redistribute it and/or modify
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
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.
Fix licensing headers Signed-off-by: VoR0220 <rj@erisindustries.com>
2016-11-18 23:13:20 +00:00
solidity is distributed in the hope that it will be useful,
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
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.
You should have received a copy of the GNU General Public License
Fix licensing headers Signed-off-by: VoR0220 <rj@erisindustries.com>
2016-11-18 23:13:20 +00:00
along with solidity. If not, see <http://www.gnu.org/licenses/>.
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
*/
Add SPDX license identifier if not present already in source file Fixes: #9220
2020-07-17 14:54:12 +00:00
// SPDX-License-Identifier: GPL-3.0
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
/**
* @author Christian <c@ethdev.com>
* @date 2015
* Type analyzer and checker.
*/
File reorganisation.
2015-10-20 22:21:52 +00:00
#include <libsolidity/analysis/TypeChecker.h>
#include <libsolidity/ast/AST.h>
Support referencing other constants in inline assembly
2019-12-03 00:02:33 +00:00
#include <libsolidity/ast/ASTUtils.h>
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
#include <libsolidity/ast/TypeProvider.h>
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
Rewrite header paths to adapt to recent `git mv` of libsolidity/inlineasm to libyul
2018-11-23 10:18:57 +00:00
#include <libyul/AsmAnalysis.h>
#include <libyul/AsmAnalysisInfo.h>
Rename AsmData -> AST Also attempt to only include ASTForward where appropriate.
2020-10-29 14:00:27 +00:00
#include <libyul/AST.h>
Codegen for object access.
2018-12-06 23:56:16 +00:00
Isolating files shared between Yul- and Solidity language frontend.
2018-11-14 13:59:30 +00:00
#include <liblangutil/ErrorReporter.h>
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
Library libdevcore renamed to libsolutil.
2020-01-06 10:52:23 +00:00
#include <libsolutil/Algorithms.h>
#include <libsolutil/StringUtils.h>
Dereference.
2021-01-12 11:08:43 +00:00
#include <libsolutil/Views.h>
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
#include <boost/algorithm/string/join.hpp>
Sort includes in libsolidity/analysis
2018-12-17 11:30:08 +00:00
#include <boost/algorithm/string/predicate.hpp>
Fix internal compiler error caused by oversized objects
2020-07-06 19:40:50 +00:00
#include <boost/range/adaptor/reversed.hpp>
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
Use zip.
2021-01-11 19:54:28 +00:00
#include <range/v3/view/zip.hpp>
Use drop_exactly.
2021-01-12 08:55:20 +00:00
#include <range/v3/view/drop_exactly.hpp>
Syntax for custom errors.
2021-01-28 11:56:22 +00:00
#include <range/v3/algorithm/count_if.hpp>
Use zip.
2021-01-11 19:54:28 +00:00
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
#include <memory>
#include <vector>
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
using namespace std;
C++ namespace cleanup (except tests).
2019-12-11 16:31:36 +00:00
using namespace solidity;
using namespace solidity::util;
using namespace solidity::langutil;
using namespace solidity::frontend;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Check base contracts for abi encoder compatibility
2019-03-04 13:33:46 +00:00
bool TypeChecker::typeSupportedByOldABIEncoder(Type const& _type, bool _isLibraryCall)
Fix multi-dimensional arrays in the ABI.
2018-02-19 17:21:02 +00:00
{
Packed Encoding: Disallow types in v2 that aren't allowed in v1
2019-02-04 17:13:41 +00:00
if (_isLibraryCall && _type.dataStoredIn(DataLocation::Storage))
Fix multi-dimensional arrays in the ABI.
2018-02-19 17:21:02 +00:00
return true;
Simplification of typeSupportedByOldABIEncoder
2018-06-14 18:19:36 +00:00
if (_type.category() == Type::Category::Struct)
Fix multi-dimensional arrays in the ABI.
2018-02-19 17:21:02 +00:00
return false;
Simplification of typeSupportedByOldABIEncoder
2018-06-14 18:19:36 +00:00
if (_type.category() == Type::Category::Array)
Fix multi-dimensional arrays in the ABI.
2018-02-19 17:21:02 +00:00
{
auto const& arrayType = dynamic_cast<ArrayType const&>(_type);
auto base = arrayType.baseType();
Packed Encoding: Disallow types in v2 that aren't allowed in v1
2019-02-04 17:13:41 +00:00
if (!typeSupportedByOldABIEncoder(*base, _isLibraryCall) || (base->category() == Type::Category::Array && base->isDynamicallySized()))
Fix multi-dimensional arrays in the ABI.
2018-02-19 17:21:02 +00:00
return false;
}
return true;
}
Refactor name and type resolution.
2020-06-11 15:17:07 +00:00
bool TypeChecker::checkTypeRequirements(SourceUnit const& _source)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
m_currentSourceUnit = &_source;
Refactor name and type resolution.
2020-06-11 15:17:07 +00:00
_source.accept(*this);
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
m_currentSourceUnit = nullptr;
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
return Error::containsOnlyWarnings(m_errorReporter.errors());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* TypeChecker::type(Expression const& _expression) const
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
solAssert(!!_expression.annotation().type, "Type requested but not present.");
return _expression.annotation().type;
}
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* TypeChecker::type(VariableDeclaration const& _variable) const
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
solAssert(!!_variable.annotation().type, "Type requested but not present.");
return _variable.annotation().type;
}
bool TypeChecker::visit(ContractDefinition const& _contract)
{
Rename scope to currentContract.
2020-06-09 16:17:58 +00:00
m_currentContract = &_contract;
Make members context-sensitive.
2015-11-19 17:02:04 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
ASTNode::listAccept(_contract.baseContracts(), *this);
Visit structs only once.
2017-03-21 14:05:59 +00:00
for (auto const& n: _contract.subNodes())
No need to visit structs early.
2018-11-29 17:18:17 +00:00
n->accept(*this);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Refactor storageSizeUpperBound.
2020-07-14 08:32:11 +00:00
m_currentContract = nullptr;
Fix internal compiler error caused by oversized objects
2020-07-06 19:40:50 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
Warn about copies in storage that might overwrite unexpectedly.
2017-06-21 17:32:56 +00:00
void TypeChecker::checkDoubleStorageAssignment(Assignment const& _assignment)
{
TupleType const& lhs = dynamic_cast<TupleType const&>(*type(_assignment.leftHandSide()));
TupleType const& rhs = dynamic_cast<TupleType const&>(*type(_assignment.rightHandSide()));
Remove remaining instances of ``fillRight`` left over from tuple wildcards assignments.
2018-08-07 16:44:51 +00:00
if (lhs.components().size() != rhs.components().size())
{
solAssert(m_errorReporter.hasErrors(), "");
return;
}
Warn about copies in storage that might overwrite unexpectedly.
2017-06-21 17:32:56 +00:00
size_t storageToStorageCopies = 0;
size_t toStorageCopies = 0;
for (size_t i = 0; i < lhs.components().size(); ++i)
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
ReferenceType const* ref = dynamic_cast<ReferenceType const*>(lhs.components()[i]);
Warn about copies in storage that might overwrite unexpectedly.
2017-06-21 17:32:56 +00:00
if (!ref || !ref->dataStoredIn(DataLocation::Storage) || ref->isPointer())
continue;
toStorageCopies++;
Remove remaining instances of ``fillRight`` left over from tuple wildcards assignments.
2018-08-07 16:44:51 +00:00
if (rhs.components()[i]->dataStoredIn(DataLocation::Storage))
Warn about copies in storage that might overwrite unexpectedly.
2017-06-21 17:32:56 +00:00
storageToStorageCopies++;
}
if (storageToStorageCopies >= 1 && toStorageCopies >= 2)
m_errorReporter.warning(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7238_error,
Warn about copies in storage that might overwrite unexpectedly.
2017-06-21 17:32:56 +00:00
_assignment.location(),
"This assignment performs two copies to storage. Since storage copies do not first "
"copy to a temporary location, one of them might be overwritten before the second "
"is executed and thus may have unexpected effects. It is safer to perform the copies "
"separately or assign to storage pointers first."
);
}
Fix abi.decode returning single value.
2018-09-04 14:24:21 +00:00
TypePointers TypeChecker::typeCheckABIDecodeAndRetrieveReturnType(FunctionCall const& _functionCall, bool _abiEncoderV2)
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
{
vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
if (arguments.size() != 2)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5782_error,
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
_functionCall.location(),
"This function takes two arguments, but " +
toString(arguments.size()) +
" were provided."
);
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
if (arguments.size() >= 1)
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
if (
!type(*arguments.front())->isImplicitlyConvertibleTo(*TypeProvider::bytesMemory()) &&
!type(*arguments.front())->isImplicitlyConvertibleTo(*TypeProvider::bytesCalldata())
)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1956_error,
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
arguments.front()->location(),
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
"The first argument to \"abi.decode\" must be implicitly convertible to "
"bytes memory or bytes calldata, but is of type " +
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
type(*arguments.front())->toString() +
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
"."
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
);
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
if (arguments.size() < 2)
Fix abi.decode returning single value.
2018-09-04 14:24:21 +00:00
return {};
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
// The following is a rather syntactic restriction, but we check it here anyway:
// The second argument has to be a tuple expression containing type names.
TupleExpression const* tupleExpression = dynamic_cast<TupleExpression const*>(arguments[1].get());
if (!tupleExpression)
{
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6444_error,
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
arguments[1]->location(),
"The second argument to \"abi.decode\" has to be a tuple of types."
);
Fix abi.decode returning single value.
2018-09-04 14:24:21 +00:00
return {};
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
}
Fix abi.decode returning single value.
2018-09-04 14:24:21 +00:00
TypePointers components;
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
for (auto const& typeArgument: tupleExpression->components())
{
solAssert(typeArgument, "");
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (TypeType const* argTypeType = dynamic_cast<TypeType const*>(type(*typeArgument)))
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
{
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* actualType = argTypeType->actualType();
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
solAssert(actualType, "");
// We force memory because the parser currently cannot handle
// data locations. Furthermore, storage can be a little dangerous and
// calldata is not really implemented anyway.
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
actualType = TypeProvider::withLocationIfReference(DataLocation::Memory, actualType);
Add payable and non-payable state mutability to AddressType.
2018-09-05 15:59:55 +00:00
// We force address payable for address types.
if (actualType->category() == Type::Category::Address)
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
actualType = TypeProvider::payableAddress();
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
solAssert(
!actualType->dataStoredIn(DataLocation::CallData) &&
!actualType->dataStoredIn(DataLocation::Storage),
""
);
if (!actualType->fullEncodingType(false, _abiEncoderV2, false))
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9611_error,
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
typeArgument->location(),
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
"Decoding type " + actualType->toString(false) + " not supported."
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
);
Fix ICE when trying to decode too large static arrays
2020-05-26 17:04:59 +00:00
if (auto referenceType = dynamic_cast<ReferenceType const*>(actualType))
{
auto result = referenceType->validForLocation(referenceType->location());
if (!result)
m_errorReporter.typeError(
6118_error,
typeArgument->location(),
result.message()
);
}
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
components.push_back(actualType);
}
else
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1039_error, typeArgument->location(), "Argument has to be a type name.");
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
components.push_back(TypeProvider::emptyTuple());
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
}
}
Fix abi.decode returning single value.
2018-09-04 14:24:21 +00:00
return components;
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
}
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
TypePointers TypeChecker::typeCheckMetaTypeFunctionAndRetrieveReturnType(FunctionCall const& _functionCall)
{
vector<ASTPointer<Expression const>> arguments = _functionCall.arguments();
if (arguments.size() != 1)
Disallow meta type on super.
2020-12-01 09:24:50 +00:00
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
8885_error,
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
_functionCall.location(),
"This function takes one argument, but " +
toString(arguments.size()) +
" were provided."
);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* firstArgType = type(*arguments.front());
implemented type(X).min and type(X).max for all integer types
2020-05-07 16:24:37 +00:00
bool wrongType = false;
if (firstArgType->category() == Type::Category::TypeType)
{
TypeType const* typeTypePtr = dynamic_cast<TypeType const*>(firstArgType);
Type::Category typeCategory = typeTypePtr->actualType()->category();
Disallow meta type on super.
2020-12-01 09:24:50 +00:00
if (auto const* contractType = dynamic_cast<ContractType const*>(typeTypePtr->actualType()))
wrongType = contractType->isSuper();
else if (typeCategory != Type::Category::Integer)
implemented type(X).min and type(X).max for all integer types
2020-05-07 16:24:37 +00:00
wrongType = true;
}
else
wrongType = true;
if (wrongType)
Disallow meta type on super.
2020-12-01 09:24:50 +00:00
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4259_error,
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
arguments.front()->location(),
implemented type(X).min and type(X).max for all integer types
2020-05-07 16:24:37 +00:00
"Invalid type for argument in the function call. "
"A contract type or an integer type is required, but " +
type(*arguments.front())->toString(true) + " provided."
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
);
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
return {TypeProvider::meta(dynamic_cast<TypeType const&>(*firstArgType).actualType())};
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
{
auto base = dynamic_cast<ContractDefinition const*>(&dereference(_inheritance.name()));
solAssert(base, "Base contract not available.");
Free functions.
2020-05-04 16:38:00 +00:00
solAssert(m_currentContract, "");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Rename scope to currentContract.
2020-06-09 16:17:58 +00:00
if (m_currentContract->isInterface() && !base->isInterface())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6536_error, _inheritance.location(), "Interfaces can only inherit from other interfaces.");
Prohibit interfaces inheriting from non-interfaces
2020-01-02 21:32:35 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
auto const& arguments = _inheritance.arguments();
Check inheritance specifier arguments for interfaces.
2017-08-21 14:43:15 +00:00
TypePointers parameterTypes;
Add ContractDefinition::isInterface.
2019-01-17 11:59:11 +00:00
if (!base->isInterface())
Check inheritance specifier arguments for interfaces.
2017-08-21 14:43:15 +00:00
// Interfaces do not have constructors, so there are zero parameters.
parameterTypes = ContractType(*base).newExpressionType()->parameterTypes();
Error when using empty parenthesis for base class constructors that require arguments.
2018-04-04 18:53:23 +00:00
if (arguments)
Fix: Type checker crash for wrong number of base constructor arguments.
2015-12-09 16:37:19 +00:00
{
Error when using empty parenthesis for base class constructors that require arguments.
2018-04-04 18:53:23 +00:00
if (parameterTypes.size() != arguments->size())
{
Turns wrong argument count in base constructor call into en error.
2018-07-06 20:53:55 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7927_error,
Turns wrong argument count in base constructor call into en error.
2018-07-06 20:53:55 +00:00
_inheritance.location(),
"Wrong argument count for constructor call: " +
toString(arguments->size()) +
" arguments given but expected " +
toString(parameterTypes.size()) +
Improves error with suggestion to remove parantheses.
2018-07-10 23:44:51 +00:00
". Remove parentheses if you do not want to provide arguments here."
Turns wrong argument count in base constructor call into en error.
2018-07-06 20:53:55 +00:00
);
Error when using empty parenthesis for base class constructors that require arguments.
2018-04-04 18:53:23 +00:00
}
Updates Changelog, syntax test and simplifies type checker.
2018-07-10 10:05:41 +00:00
for (size_t i = 0; i < std::min(arguments->size(), parameterTypes.size()); ++i)
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
{
BoolResult result = type(*(*arguments)[i])->isImplicitlyConvertibleTo(*parameterTypes[i]);
if (!result)
m_errorReporter.typeErrorConcatenateDescriptions(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9827_error,
Error when using empty parenthesis for base class constructors that require arguments.
2018-04-04 18:53:23 +00:00
(*arguments)[i]->location(),
"Invalid type for argument in constructor call. "
"Invalid implicit conversion from " +
type(*(*arguments)[i])->toString() +
" to " +
parameterTypes[i]->toString() +
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
" requested.",
result.message()
Error when using empty parenthesis for base class constructors that require arguments.
2018-04-04 18:53:23 +00:00
);
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
}
Error when using empty parenthesis for base class constructors that require arguments.
2018-04-04 18:53:23 +00:00
}
Added the `using x for y` directive.
2015-11-22 19:39:10 +00:00
}
virtual modifiers (in Abstract contracts) allow empty bodies
2020-04-15 10:42:15 +00:00
void TypeChecker::endVisit(ModifierDefinition const& _modifier)
{
Type Checker: Disallow ``virtual`` for modifiers in libraries.
2020-09-07 08:45:04 +00:00
if (_modifier.virtualSemantics())
if (auto const* contractDef = dynamic_cast<ContractDefinition const*>(_modifier.scope()))
if (contractDef->isLibrary())
m_errorReporter.typeError(
3275_error,
_modifier.location(),
"Modifiers in a library cannot be virtual."
);
virtual modifiers (in Abstract contracts) allow empty bodies
2020-04-15 10:42:15 +00:00
if (!_modifier.isImplemented() && !_modifier.virtualSemantics())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(8063_error, _modifier.location(), "Modifiers without implementation must be marked virtual.");
virtual modifiers (in Abstract contracts) allow empty bodies
2020-04-15 10:42:15 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
bool TypeChecker::visit(FunctionDefinition const& _function)
{
Disallow use of virtual and private together
2019-11-27 13:02:52 +00:00
if (_function.markedVirtual())
{
Free functions.
2020-05-04 16:38:00 +00:00
if (_function.isFree())
m_errorReporter.syntaxError(4493_error, _function.location(), "Free functions cannot be virtual.");
else if (_function.isConstructor())
Disallow visibility for constructors.
2020-06-10 16:19:42 +00:00
m_errorReporter.typeError(7001_error, _function.location(), "Constructors cannot be virtual.");
else if (_function.annotation().contract->isInterface())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.warning(5815_error, _function.location(), "Interface functions are implicitly \"virtual\"");
Disallow visibility for constructors.
2020-06-10 16:19:42 +00:00
else if (_function.visibility() == Visibility::Private)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3942_error, _function.location(), "\"virtual\" and \"private\" cannot be used together.");
Disallow visibility for constructors.
2020-06-10 16:19:42 +00:00
else if (_function.libraryFunction())
Fix error codes.
2020-06-10 16:25:19 +00:00
m_errorReporter.typeError(7801_error, _function.location(), "Library functions cannot be \"virtual\".");
Disallow use of virtual and private together
2019-11-27 13:02:52 +00:00
}
Free functions.
2020-05-04 16:38:00 +00:00
if (_function.overrides() && _function.isFree())
m_errorReporter.syntaxError(1750_error, _function.location(), "Free functions cannot override.");
Implement virtual keyword
2019-11-05 17:25:34 +00:00
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
if (!_function.modifiers().empty() && _function.isFree())
m_errorReporter.syntaxError(5811_error, _function.location(), "Free functions cannot have modifiers.");
Merged in changes from chriseth/payable
2016-08-26 18:37:10 +00:00
if (_function.isPayable())
{
Replace inContractKind by libraryFunction.
2020-06-09 15:56:58 +00:00
if (_function.libraryFunction())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7708_error, _function.location(), "Library functions cannot be payable.");
Free functions.
2020-05-04 16:38:00 +00:00
else if (_function.isFree())
m_errorReporter.typeError(9559_error, _function.location(), "Free functions cannot be payable.");
else if (_function.isOrdinary() && !_function.isPartOfExternalInterface())
Nicer error message for private payable functions
2020-07-14 13:25:17 +00:00
m_errorReporter.typeError(5587_error, _function.location(), "\"internal\" and \"private\" functions cannot be payable.");
Merged in changes from chriseth/payable
2016-08-26 18:37:10 +00:00
}
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
vector<VariableDeclaration const*> internalParametersInConstructor;
auto checkArgumentAndReturnParameter = [&](VariableDeclaration const& _var) {
if (type(_var)->containsNestedMapping())
if (_var.referenceLocation() == VariableDeclaration::Location::Storage)
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
solAssert(
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
_function.libraryFunction() || _function.isConstructor() || !_function.isPublic(),
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
"Mapping types for parameters or return variables "
"can only be used in internal or library functions."
);
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
bool functionIsExternallyVisible =
(!_function.isConstructor() && _function.isPublic()) ||
(_function.isConstructor() && !m_currentContract->abstract());
if (
_function.isConstructor() &&
_var.referenceLocation() == VariableDeclaration::Location::Storage &&
!m_currentContract->abstract()
)
m_errorReporter.typeError(
3644_error,
_var.location(),
"This parameter has a type that can only be used internally. "
"You can make the contract abstract to avoid this problem."
);
else if (functionIsExternallyVisible)
Allow mapping arguments for public and external library functions.
2018-11-08 10:22:57 +00:00
{
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
auto iType = type(_var)->interfaceType(_function.libraryFunction());
Disallow internal function types as parameters for public/external library function
2019-03-07 16:12:10 +00:00
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
if (!iType)
{
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
string message = iType.message();
solAssert(!message.empty(), "Expected detailed error message!");
if (_function.isConstructor())
message += " You can make the contract abstract to avoid this problem.";
m_errorReporter.typeError(4103_error, _var.location(), message);
}
else if (
Introduce abicoder pragma.
2020-10-22 17:19:14 +00:00
!useABICoderV2() &&
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
!typeSupportedByOldABIEncoder(*type(_var), _function.libraryFunction())
)
{
string message =
Wording in error messages.
2020-10-29 18:40:17 +00:00
"This type is only supported in ABI coder v2. "
"Use \"pragma abicoder v2;\" to enable the feature.";
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
if (_function.isConstructor())
message +=
" Alternatively, make the contract abstract and supply the "
"constructor arguments from a derived contract.";
m_errorReporter.typeError(
4957_error,
_var.location(),
message
);
Disallow internal function types as parameters for public/external library function
2019-03-07 16:12:10 +00:00
}
Allow mapping arguments for public and external library functions.
2018-11-08 10:22:57 +00:00
}
Refactor TypeChecker::visit(FunctionDefinition const&).
2019-01-17 15:37:36 +00:00
};
for (ASTPointer<VariableDeclaration> const& var: _function.parameters())
{
checkArgumentAndReturnParameter(*var);
var->accept(*this);
}
for (ASTPointer<VariableDeclaration> const& var: _function.returnParameters())
{
checkArgumentAndReturnParameter(*var);
Fix segmentation fault with constant function parameters
2017-06-15 15:36:14 +00:00
var->accept(*this);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Force contracts with constructors with internal parameters abstract.
2020-06-18 15:33:36 +00:00
Disallow invoking the same modifier multiple times.
2017-06-23 16:55:47 +00:00
set<Declaration const*> modifiers;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
for (ASTPointer<ModifierInvocation> const& modifier: _function.modifiers())
Disallow invoking the same modifier multiple times.
2017-06-23 16:55:47 +00:00
{
Free functions.
2020-05-04 16:38:00 +00:00
vector<ContractDefinition const*> baseContracts;
if (auto contract = dynamic_cast<ContractDefinition const*>(_function.scope()))
{
baseContracts = contract->annotation().linearizedBaseContracts;
// Delete first base which is just the main contract itself
baseContracts.erase(baseContracts.begin());
}
Disallow call of same-class-ctor as modifier
2019-10-22 10:26:26 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
visitManually(
*modifier,
Disallow call of same-class-ctor as modifier
2019-10-22 10:26:26 +00:00
_function.isConstructor() ? baseContracts : vector<ContractDefinition const*>()
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
Declaration const* decl = &dereference(modifier->name());
Disallow invoking the same modifier multiple times.
2017-06-23 16:55:47 +00:00
if (modifiers.count(decl))
{
if (dynamic_cast<ContractDefinition const*>(decl))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.declarationError(1697_error, modifier->location(), "Base constructor already provided.");
Disallow invoking the same modifier multiple times.
2017-06-23 16:55:47 +00:00
}
else
modifiers.insert(decl);
}
Free functions.
2020-05-04 16:38:00 +00:00
solAssert(_function.isFree() == !m_currentContract, "");
if (!m_currentContract)
{
solAssert(!_function.isConstructor(), "");
solAssert(!_function.isFallback(), "");
solAssert(!_function.isReceive(), "");
}
else if (m_currentContract->isInterface())
Reject invalid definitions for interface contracts
2017-02-07 22:13:03 +00:00
{
Simplify interface checks for FunctionDefinition
2017-03-17 17:01:13 +00:00
if (_function.isImplemented())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4726_error, _function.location(), "Functions in interfaces cannot have an implementation.");
enforce interface-functions to be external-declared - libsolidity: Enforce interface-functions must be external-declared. - Changelog adapted to reflect changes wrt. functions in interfaces. - test: Adjustments according to prior interface-function changes. - tests: Adapting SolidityEndToEndTest to interface-function change. - docs: Adapted documentation to interface-function change.
2018-07-12 12:57:42 +00:00
Simplify interface checks for FunctionDefinition
2017-03-17 17:01:13 +00:00
if (_function.isConstructor())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6482_error, _function.location(), "Constructor cannot be defined in interfaces.");
Disallow visibility for constructors.
2020-06-10 16:19:42 +00:00
else if (_function.visibility() != Visibility::External)
m_errorReporter.typeError(1560_error, _function.location(), "Functions in interfaces must be declared external.");
Simplify interface checks for FunctionDefinition
2017-03-17 17:01:13 +00:00
}
Rename scope to currentContract.
2020-06-09 16:17:58 +00:00
else if (m_currentContract->contractKind() == ContractKind::Library)
Library cannot have constructors
2017-08-16 21:19:08 +00:00
if (_function.isConstructor())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7634_error, _function.location(), "Constructor cannot be defined in libraries.");
Free functions.
2020-05-04 16:38:00 +00:00
Simplify interface checks for FunctionDefinition
2017-03-17 17:01:13 +00:00
if (_function.isImplemented())
_function.body().accept(*this);
Constructors must be implemented if declared.
2017-08-04 19:38:45 +00:00
else if (_function.isConstructor())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(5700_error, _function.location(), "Constructor must be implemented if declared.");
Replace inContractKind by libraryFunction.
2020-06-09 15:56:58 +00:00
else if (_function.libraryFunction())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9231_error, _function.location(), "Library functions must be implemented if declared.");
Require unimplemented functions to be virtual.
2019-12-02 20:39:53 +00:00
else if (!_function.virtualSemantics())
Free functions.
2020-05-04 16:38:00 +00:00
{
if (_function.isFree())
solAssert(m_errorReporter.hasErrors(), "");
else
m_errorReporter.typeError(5424_error, _function.location(), "Functions without implementation must be marked virtual.");
}
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (_function.isFallback())
typeCheckFallbackFunction(_function);
else if (_function.isConstructor())
typeCheckConstructor(_function);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
bool TypeChecker::visit(VariableDeclaration const& _variable)
{
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
_variable.typeName().accept(*this);
Fix SMT Checker crash due to missing type information
2019-02-27 10:55:59 +00:00
Refactoring to allow multi-variable declarations.
2015-10-08 16:01:12 +00:00
// type is filled either by ReferencesResolver directly from the type name or by
// TypeChecker at the VariableDeclarationStatement level.
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* varType = _variable.annotation().type;
Remove obsolete comment.
2018-11-28 10:48:51 +00:00
solAssert(!!varType, "Variable type not provided.");
Ensures an empty use of var keyword is caught with the proper error message.
2018-07-12 14:17:30 +00:00
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
if (_variable.value())
Error when Mapping type in (non-local) storage is assigned to
2020-05-19 08:05:15 +00:00
{
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
if (_variable.isStateVariable() && varType->containsNestedMapping())
Error when Mapping type in (non-local) storage is assigned to
2020-05-19 08:05:15 +00:00
{
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
m_errorReporter.typeError(
6280_error,
_variable.location(),
"Types in storage containing (nested) mappings cannot be assigned to."
);
Error when Mapping type in (non-local) storage is assigned to
2020-05-19 08:05:15 +00:00
_variable.value()->accept(*this);
}
else
expectType(*_variable.value(), *varType);
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (_variable.isConstant())
{
if (!_variable.value())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4266_error, _variable.location(), "Uninitialized \"constant\" variable.");
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
else if (!*_variable.value()->annotation().isPure)
Only allow compile-time constants for constant state variables.
2018-07-03 21:03:26 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
8349_error,
Only allow compile-time constants for constant state variables.
2018-07-03 21:03:26 +00:00
_variable.value()->location(),
"Initial value for constant variable has to be compile-time constant."
);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Parsing of immutable state variable.
2020-02-27 15:13:55 +00:00
else if (_variable.immutable())
Disallow external function pointers as immutables.
2020-04-03 09:56:51 +00:00
{
Parsing of immutable state variable.
2020-02-27 15:13:55 +00:00
if (!_variable.type()->isValueType())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6377_error, _variable.location(), "Immutable variables cannot have a non-value type.");
Disallow external function pointers as immutables.
2020-04-03 09:56:51 +00:00
if (
auto const* functionType = dynamic_cast<FunctionType const*>(_variable.type());
functionType && functionType->kind() == FunctionType::Kind::External
)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3366_error, _variable.location(), "Immutable variables of external function type are not yet supported.");
Disallow external function pointers as immutables.
2020-04-03 09:56:51 +00:00
solAssert(_variable.type()->sizeOnStack() == 1 || m_errorReporter.hasErrors(), "");
}
Parsing of immutable state variable.
2020-02-27 15:13:55 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!_variable.isStateVariable())
{
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
if (
_variable.referenceLocation() == VariableDeclaration::Location::CallData ||
_variable.referenceLocation() == VariableDeclaration::Location::Memory
)
if (varType->containsNestedMapping())
m_errorReporter.fatalTypeError(
4061_error,
_variable.location(),
"Type " + varType->toString(true) + " is only valid in storage because it contains a (nested) mapping."
);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Move Visibility out of Declaration.
2019-12-10 14:54:09 +00:00
else if (_variable.visibility() >= Visibility::Public)
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
{
FunctionType getter(_variable);
Introduce abicoder pragma.
2020-10-22 17:19:14 +00:00
if (!useABICoderV2())
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
{
vector<string> unsupportedTypes;
for (auto const& param: getter.parameterTypes() + getter.returnParameterTypes())
Packed Encoding: Disallow types in v2 that aren't allowed in v1
2019-02-04 17:13:41 +00:00
if (!typeSupportedByOldABIEncoder(*param, false /* isLibrary */))
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
unsupportedTypes.emplace_back(param->toString());
if (!unsupportedTypes.empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(
Fix error reporting source code format
2020-05-07 01:52:53 +00:00
2763_error,
_variable.location(),
Wording in error messages.
2020-10-29 18:40:17 +00:00
"The following types are only supported for getters in ABI coder v2: " +
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
joinHumanReadable(unsupportedTypes) +
Wording in error messages.
2020-10-29 18:40:17 +00:00
". Either remove \"public\" or use \"pragma abicoder v2;\" to enable the feature."
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
);
}
if (!getter.interfaceFunctionType())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6744_error, _variable.location(), "Internal or recursive type is not allowed for public state variables.");
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
}
Issue error properly for oversized arrays for calldata
2017-07-11 20:56:09 +00:00
Fix internal compiler error caused by oversized objects
2020-07-06 19:40:50 +00:00
bool isStructMemberDeclaration = dynamic_cast<StructDefinition const*>(_variable.scope()) != nullptr;
if (isStructMemberDeclaration)
return false;
Refactoring of errors and fixes for various ICEs.
2020-04-14 17:03:46 +00:00
if (auto referenceType = dynamic_cast<ReferenceType const*>(varType))
Dynamic type as mapping key returns error instead of assertion fail
2018-07-31 09:44:39 +00:00
{
Check that there is an interface type before querying validity of location.
2021-02-23 15:43:29 +00:00
BoolResult result = referenceType->validForLocation(referenceType->location());
Fix ICE caused by storage parameters with nested mappings in libraries
2020-10-06 18:58:46 +00:00
if (result)
{
bool isLibraryStorageParameter = (_variable.isLibraryFunctionParameter() && referenceType->location() == DataLocation::Storage);
Fix ICE related to mapping types in abstract contract constructor
2021-05-31 11:04:14 +00:00
// We skip the calldata check for abstract contract constructors.
bool isAbstractConstructorParam = _variable.isConstructorParameter() && m_currentContract && m_currentContract->abstract();
bool callDataCheckRequired =
!isAbstractConstructorParam &&
(_variable.isConstructorParameter() || _variable.isPublicCallableParameter()) &&
!isLibraryStorageParameter;
Fix ICE caused by storage parameters with nested mappings in libraries
2020-10-06 18:58:46 +00:00
if (callDataCheckRequired)
Check that there is an interface type before querying validity of location.
2021-02-23 15:43:29 +00:00
{
if (!referenceType->interfaceType(false))
solAssert(m_errorReporter.hasErrors(), "");
else
result = referenceType->validForLocation(DataLocation::CallData);
}
Fix ICE caused by storage parameters with nested mappings in libraries
2020-10-06 18:58:46 +00:00
}
Refactoring of errors and fixes for various ICEs.
2020-04-14 17:03:46 +00:00
if (!result)
{
solAssert(!result.message().empty(), "Expected detailed error message");
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1534_error, _variable.location(), result.message());
Fix internal compiler error caused by oversized objects
2020-07-06 19:40:50 +00:00
return false;
}
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
void TypeChecker::visitManually(
ModifierInvocation const& _modifier,
vector<ContractDefinition const*> const& _bases
)
{
Error when using no parentheses in modifier-style constructor calls.
2018-04-10 09:22:26 +00:00
std::vector<ASTPointer<Expression>> const& arguments =
_modifier.arguments() ? *_modifier.arguments() : std::vector<ASTPointer<Expression>>();
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
for (ASTPointer<Expression> const& argument: arguments)
argument->accept(*this);
Check for use of modifiers in invalid contexts
2019-10-21 11:18:19 +00:00
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
_modifier.name().accept(*this);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
auto const* declaration = &dereference(_modifier.name());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
vector<ASTPointer<VariableDeclaration>> emptyParameterList;
vector<ASTPointer<VariableDeclaration>> const* parameters = nullptr;
if (auto modifierDecl = dynamic_cast<ModifierDefinition const*>(declaration))
Disallow using modifiers not in the current contract or in base contracts.
2020-11-16 19:12:25 +00:00
{
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
parameters = &modifierDecl->parameters();
Disallow using modifiers not in the current contract or in base contracts.
2020-11-16 19:12:25 +00:00
if (auto const* modifierContract = dynamic_cast<ContractDefinition const*>(modifierDecl->scope()))
if (m_currentContract)
{
if (!contains(m_currentContract->annotation().linearizedBaseContracts, modifierContract))
m_errorReporter.typeError(
9428_error,
_modifier.location(),
"Can only use modifiers defined in the current contract or in base contracts."
);
}
Prevent calls to unimplemented modifiers.
2021-06-22 13:33:19 +00:00
if (
*_modifier.name().annotation().requiredLookup == VirtualLookup::Static &&
!modifierDecl->isImplemented()
)
m_errorReporter.typeError(
1835_error,
_modifier.location(),
"Cannot call unimplemented modifier. The modifier has no implementation in the referenced contract. Refer to it by its unqualified name if you want to call the implementation from the most derived contract."
);
Disallow using modifiers not in the current contract or in base contracts.
2020-11-16 19:12:25 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
// check parameters for Base constructors
for (ContractDefinition const* base: _bases)
if (declaration == base)
{
if (auto referencedConstructor = base->constructor())
parameters = &referencedConstructor->parameters();
else
parameters = &emptyParameterList;
break;
}
if (!parameters)
Fixed a crash during type checking.
2016-01-08 14:20:20 +00:00
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4659_error, _modifier.location(), "Referenced declaration is neither modifier nor base class.");
Fixed a crash during type checking.
2016-01-08 14:20:20 +00:00
return;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (parameters->size() != arguments.size())
Fix segfault when using wrong number of constructor arguments.
2016-02-11 16:10:35 +00:00
{
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2973_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_modifier.location(),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
"Wrong argument count for modifier invocation: " +
toString(arguments.size()) +
" arguments given but expected " +
toString(parameters->size()) +
"."
);
Fix segfault when using wrong number of constructor arguments.
2016-02-11 16:10:35 +00:00
return;
}
Error when using no parentheses in modifier-style constructor calls.
2018-04-10 09:22:26 +00:00
for (size_t i = 0; i < arguments.size(); ++i)
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
{
BoolResult result = type(*arguments[i])->isImplicitlyConvertibleTo(*type(*(*parameters)[i]));
if (!result)
m_errorReporter.typeErrorConcatenateDescriptions(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4649_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
arguments[i]->location(),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
"Invalid type for argument in modifier invocation. "
"Invalid implicit conversion from " +
type(*arguments[i])->toString() +
" to " +
type(*(*parameters)[i])->toString() +
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
" requested.",
result.message()
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
bool TypeChecker::visit(EventDefinition const& _eventDef)
{
Move Visibility out of Declaration.
2019-12-10 14:54:09 +00:00
solAssert(_eventDef.visibility() > Visibility::Internal, "");
Syntax for custom errors.
2021-01-28 11:56:22 +00:00
checkErrorAndEventParameters(_eventDef);
auto numIndexed = ranges::count_if(
_eventDef.parameters(),
[](ASTPointer<VariableDeclaration> const& var) { return var->isIndexed(); }
);
Do not show the same error multiple times for events
2017-08-28 20:05:47 +00:00
if (_eventDef.isAnonymous() && numIndexed > 4)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(8598_error, _eventDef.location(), "More than 4 indexed arguments for anonymous event.");
Do not show the same error multiple times for events
2017-08-28 20:05:47 +00:00
else if (!_eventDef.isAnonymous() && numIndexed > 3)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7249_error, _eventDef.location(), "More than 3 indexed arguments for event.");
Set type properly for event parameters
2020-07-17 08:49:36 +00:00
return true;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Syntax for custom errors.
2021-01-28 11:56:22 +00:00
bool TypeChecker::visit(ErrorDefinition const& _errorDef)
{
solAssert(_errorDef.visibility() > Visibility::Internal, "");
checkErrorAndEventParameters(_errorDef);
return true;
}
Check that no internals are used in any external function type.
2016-11-11 11:07:30 +00:00
void TypeChecker::endVisit(FunctionTypeName const& _funType)
{
FunctionType const& fun = dynamic_cast<FunctionType const&>(*_funType.annotation().type);
Change references to FunctionType::Location
2017-03-16 11:58:17 +00:00
if (fun.kind() == FunctionType::Kind::External)
Annotate struct definitions with a recursive flag.
2020-04-14 14:36:37 +00:00
{
for (auto const& t: _funType.parameterTypes() + _funType.returnParameterTypes())
{
solAssert(t->annotation().type, "Type not set for parameter.");
if (!t->annotation().type->interfaceType(false).get())
Treat invalid external function type as a fatal error to prevent the type from being used - `returnParameterTypesWithoutDynamicTypes()` assumes it won't encounter such types.
2021-06-02 19:38:57 +00:00
m_errorReporter.fatalTypeError(2582_error, t->location(), "Internal type cannot be used for external function type.");
Annotate struct definitions with a recursive flag.
2020-04-14 14:36:37 +00:00
}
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
solAssert(fun.interfaceType(false), "External function type uses internal types.");
Annotate struct definitions with a recursive flag.
2020-04-14 14:36:37 +00:00
}
Check that no internals are used in any external function type.
2016-11-11 11:07:30 +00:00
}
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
{
// External references have already been resolved in a prior stage and stored in the annotation.
Split external identifier access into resolving and code generation.
2017-03-14 14:41:23 +00:00
// We run the resolve step again regardless.
Renaming namespace dev::julia to dev::yul.
2018-10-15 09:58:51 +00:00
yul::ExternalIdentifierAccess::Resolver identifierAccess = [&](
Isolating libyul library API into its own namespace `yul`.
2018-11-21 11:42:34 +00:00
yul::Identifier const& _identifier,
Renaming namespace dev::julia to dev::yul.
2018-10-15 09:58:51 +00:00
yul::IdentifierContext _context,
Initial EVM1.5 assembly implementation.
2017-05-24 16:34:19 +00:00
bool
Fixed inline assembly external identifier access.
2021-08-04 16:11:00 +00:00
) -> bool
Move lambda.
2017-02-23 16:38:42 +00:00
{
Fixed inline assembly external identifier access.
2021-08-04 16:11:00 +00:00
if (_context == yul::IdentifierContext::NonExternal)
{
// Hack until we can disallow any shadowing: If we found an internal reference,
// clear the external references, so that codegen does not use it.
_inlineAssembly.annotation().externalReferences.erase(& _identifier);
return false;
}
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
auto ref = _inlineAssembly.annotation().externalReferences.find(&_identifier);
if (ref == _inlineAssembly.annotation().externalReferences.end())
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
InlineAssemblyAnnotation::ExternalIdentifierInfo& identifierInfo = ref->second;
Declaration const* declaration = identifierInfo.declaration;
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
solAssert(!!declaration, "");
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
if (auto var = dynamic_cast<VariableDeclaration const*>(declaration))
{
TypeChecker: Check if type exists before dereferencing it
2019-02-27 16:32:48 +00:00
solAssert(var->type(), "Expected variable type!");
Parsing of immutable state variable.
2020-02-27 15:13:55 +00:00
if (var->immutable())
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(3773_error, _identifier.debugData->location, "Assembly access to immutable variables is not supported.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Parsing of immutable state variable.
2020-02-27 15:13:55 +00:00
}
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
if (var->isConstant())
Properly warn about the use of constants in inline assembly in connection with ``_offset`` and ``_slot``.
2018-02-19 18:21:33 +00:00
{
Fix infinite loop when accessing circular constants from inline assembly.
2021-01-15 15:05:40 +00:00
if (isConstantVariableRecursive(*var))
{
m_errorReporter.typeError(
3558_error,
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
_identifier.debugData->location,
Fix infinite loop when accessing circular constants from inline assembly.
2021-01-15 15:05:40 +00:00
"Constant variable is circular."
);
return false;
}
Replaced "assert" with "if" (incorrect contract code is not supposed to trigger asserts).
2020-03-10 23:32:01 +00:00
var = rootConstVariableDeclaration(*var);
Support referencing other constants in inline assembly
2019-12-03 00:02:33 +00:00
Replaced "assert" with "if" (incorrect contract code is not supposed to trigger asserts).
2020-03-10 23:32:01 +00:00
if (var && !var->value())
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(3224_error, _identifier.debugData->location, "Constant has no value.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
}
else if (_context == yul::IdentifierContext::LValue)
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(6252_error, _identifier.debugData->location, "Constant variables cannot be assigned to.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
}
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
else if (!identifierInfo.suffix.empty())
Support constant numbers in inline assembly.
2019-07-01 13:34:34 +00:00
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(6617_error, _identifier.debugData->location, "The suffixes .offset and .slot can only be used on non-constant storage variables.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Support constant numbers in inline assembly.
2019-07-01 13:34:34 +00:00
}
Output error when forward referencing constants in inline assembly
2020-05-28 14:09:52 +00:00
else if (var && var->value() && !var->value()->annotation().type && !dynamic_cast<Literal const*>(var->value().get()))
{
m_errorReporter.typeError(
2249_error,
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
_identifier.debugData->location,
Output error when forward referencing constants in inline assembly
2020-05-28 14:09:52 +00:00
"Constant variables with non-literal values cannot be forward referenced from inline assembly."
);
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Output error when forward referencing constants in inline assembly
2020-05-28 14:09:52 +00:00
}
else if (!var || !type(*var)->isValueType() || (
!dynamic_cast<Literal const*>(var->value().get()) &&
type(*var->value())->category() != Type::Category::RationalNumber
))
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(7615_error, _identifier.debugData->location, "Only direct number constants and references to such constants are supported by inline assembly.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Output error when forward referencing constants in inline assembly
2020-05-28 14:09:52 +00:00
}
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
}
Added an assert for FixedPointType in InlineAssembly
2020-05-29 11:51:16 +00:00
solAssert(!dynamic_cast<FixedPointType const*>(var->type()), "FixedPointType not implemented.");
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
if (!identifierInfo.suffix.empty())
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
{
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
string const& suffix = identifierInfo.suffix;
solAssert((set<string>{"offset", "slot", "length"}).count(suffix), "");
if (var->isStateVariable() || var->type()->dataStoredIn(DataLocation::Storage))
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
{
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
if (suffix != "slot" && suffix != "offset")
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(4656_error, _identifier.debugData->location, "State variables only support \".slot\" and \".offset\".");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
}
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
else if (_context == yul::IdentifierContext::LValue)
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
{
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
if (var->isStateVariable())
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(4713_error, _identifier.debugData->location, "State variables cannot be assigned to - you have to use \"sstore()\".");
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
return false;
}
else if (suffix != "slot")
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(9739_error, _identifier.debugData->location, "Only .slot can be assigned to.");
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
return false;
}
}
}
else if (
auto const* arrayType = dynamic_cast<ArrayType const*>(var->type());
arrayType && arrayType->isDynamicallySized() && arrayType->dataStoredIn(DataLocation::CallData)
)
{
if (suffix != "offset" && suffix != "length")
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(1536_error, _identifier.debugData->location, "Calldata variables only support \".offset\" and \".length\".");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
}
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
}
else
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(3622_error, _identifier.debugData->location, "The suffix \"." + suffix + "\" is not supported by this variable or type.");
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
return false;
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
}
}
Support constant numbers in inline assembly.
2019-07-01 13:34:34 +00:00
else if (!var->isConstant() && var->isStateVariable())
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
{
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
m_errorReporter.typeError(
1408_error,
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
_identifier.debugData->location,
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
"Only local variables are supported. To access storage variables, use the \".slot\" and \".offset\" suffixes."
);
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
}
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
else if (var->type()->dataStoredIn(DataLocation::Storage))
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(9068_error, _identifier.debugData->location, "You have to use the \".slot\" or \".offset\" suffix to access storage reference variables.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
}
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
else if (var->type()->sizeOnStack() != 1)
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
{
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
if (
auto const* arrayType = dynamic_cast<ArrayType const*>(var->type());
arrayType && arrayType->isDynamicallySized() && arrayType->dataStoredIn(DataLocation::CallData)
)
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(1397_error, _identifier.debugData->location, "Call data elements cannot be accessed directly. Use \".offset\" and \".length\" to access the calldata offset and length of this array and then use \"calldatacopy\".");
Issue proper warning trying to access calldata variables in inline assembly
2017-07-11 11:37:34 +00:00
else
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
{
solAssert(!var->type()->dataStoredIn(DataLocation::CallData), "");
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(9857_error, _identifier.debugData->location, "Only types that use one stack slot are supported.");
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
}
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
}
}
Support .offset and .length for calldata bytes and string arrays.
2020-11-05 13:39:39 +00:00
else if (!identifierInfo.suffix.empty())
More precise error message if using non-variables with _slot/_offset
2018-08-07 12:17:56 +00:00
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(7944_error, _identifier.debugData->location, "The suffixes \".offset\", \".slot\" and \".length\" can only be used with variables.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
More precise error message if using non-variables with _slot/_offset
2018-08-07 12:17:56 +00:00
}
Renaming namespace dev::julia to dev::yul.
2018-10-15 09:58:51 +00:00
else if (_context == yul::IdentifierContext::LValue)
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
{
Treat magic variables as unknown identifiers in inline assembly This fixes #4575. For keywords such as 'super' and 'this', will be treated as unknown identifiers.
2019-10-25 02:14:00 +00:00
if (dynamic_cast<MagicVariableDeclaration const*>(declaration))
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Treat magic variables as unknown identifiers in inline assembly This fixes #4575. For keywords such as 'super' and 'this', will be treated as unknown identifiers.
2019-10-25 02:14:00 +00:00
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(1990_error, _identifier.debugData->location, "Only local variables can be assigned to in inline assembly.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
}
Renaming namespace dev::julia to dev::yul.
2018-10-15 09:58:51 +00:00
if (_context == yul::IdentifierContext::RValue)
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
{
solAssert(!!declaration->type(), "Type of declaration required but not yet determined.");
if (dynamic_cast<FunctionDefinition const*>(declaration))
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.declarationError(2025_error, _identifier.debugData->location, "Access to functions is not allowed in inline assembly.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
}
else if (dynamic_cast<VariableDeclaration const*>(declaration))
{
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
}
else if (auto contract = dynamic_cast<ContractDefinition const*>(declaration))
{
if (!contract->isLibrary())
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
{
Refactoring yul source locations.
2021-04-27 14:53:04 +00:00
m_errorReporter.typeError(4977_error, _identifier.debugData->location, "Expected a library.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
}
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
}
else
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
}
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
identifierInfo.valueSize = 1;
return true;
Move lambda.
2017-02-23 16:38:42 +00:00
};
Refactor to combined scope and stack height info.
2017-04-26 13:41:08 +00:00
solAssert(!_inlineAssembly.annotation().analysisInfo, "");
Isolating libyul library API into its own namespace `yul`.
2018-11-21 11:42:34 +00:00
_inlineAssembly.annotation().analysisInfo = make_shared<yul::AsmAnalysisInfo>();
yul::AsmAnalyzer analyzer(
Refactor to combined scope and stack height info.
2017-04-26 13:41:08 +00:00
*_inlineAssembly.annotation().analysisInfo,
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter,
Provide dialect to Parser and InlineAssembly AST nodes.
2019-05-22 11:57:48 +00:00
_inlineAssembly.dialect(),
Refactor to combined scope and stack height info.
2017-04-26 13:41:08 +00:00
identifierAccess
);
Use actual type checking phase of assembler.
2017-03-21 18:38:37 +00:00
if (!analyzer.analyze(_inlineAssembly.operations()))
Refactor CodeGen to recurse on blocks.
2017-02-15 15:47:54 +00:00
return false;
return true;
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
bool TypeChecker::visit(IfStatement const& _ifStatement)
{
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
expectType(_ifStatement.condition(), *TypeProvider::boolean());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
_ifStatement.trueStatement().accept(*this);
if (_ifStatement.falseStatement())
_ifStatement.falseStatement()->accept(*this);
return false;
}
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
void TypeChecker::endVisit(TryStatement const& _tryStatement)
{
FunctionCall const* externalCall = dynamic_cast<FunctionCall const*>(&_tryStatement.externalCall());
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
if (!externalCall || *externalCall->annotation().kind != FunctionCallKind::FunctionCall)
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
{
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5347_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
_tryStatement.externalCall().location(),
"Try can only be used with external function calls and contract creation calls."
);
return;
}
FunctionType const& functionType = dynamic_cast<FunctionType const&>(*externalCall->expression().annotation().type);
if (
functionType.kind() != FunctionType::Kind::External &&
functionType.kind() != FunctionType::Kind::Creation &&
functionType.kind() != FunctionType::Kind::DelegateCall
)
{
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2536_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
_tryStatement.externalCall().location(),
"Try can only be used with external function calls and contract creation calls."
);
return;
}
externalCall->annotation().tryCall = true;
solAssert(_tryStatement.clauses().size() >= 2, "");
solAssert(_tryStatement.clauses().front(), "");
TryCatchClause const& successClause = *_tryStatement.clauses().front();
if (successClause.parameters())
{
TypePointers returnTypes =
m_evmVersion.supportsReturndata() ?
functionType.returnParameterTypes() :
functionType.returnParameterTypesWithoutDynamicTypes();
std::vector<ASTPointer<VariableDeclaration>> const& parameters =
successClause.parameters()->parameters();
if (returnTypes.size() != parameters.size())
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2800_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
successClause.location(),
"Function returns " +
to_string(functionType.returnParameterTypes().size()) +
" values, but returns clause has " +
to_string(parameters.size()) +
" variables."
);
Use zip.
2021-01-11 19:54:28 +00:00
for (auto&& [parameter, returnType]: ranges::views::zip(parameters, returnTypes))
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
{
Use zip.
2021-01-11 19:54:28 +00:00
solAssert(returnType, "");
if (parameter && *parameter->annotation().type != *returnType)
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6509_error,
Use zip.
2021-01-11 19:54:28 +00:00
parameter->location(),
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
"Invalid type, expected " +
Use zip.
2021-01-11 19:54:28 +00:00
returnType->toString(false) +
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
" but got " +
Use zip.
2021-01-11 19:54:28 +00:00
parameter->annotation().type->toString() +
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
"."
);
}
}
Catch panic.
2020-10-20 13:30:46 +00:00
TryCatchClause const* panicClause = nullptr;
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
TryCatchClause const* errorClause = nullptr;
TryCatchClause const* lowLevelClause = nullptr;
Dereference.
2021-01-12 11:08:43 +00:00
for (auto const& clause: _tryStatement.clauses() | ranges::views::drop_exactly(1) | views::dereferenceChecked)
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
{
if (clause.errorName() == "")
{
if (lowLevelClause)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5320_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
clause.location(),
SecondarySourceLocation{}.append("The first clause is here:", lowLevelClause->location()),
"This try statement already has a low-level catch clause."
);
lowLevelClause = &clause;
if (clause.parameters() && !clause.parameters()->parameters().empty())
{
if (
clause.parameters()->parameters().size() != 1 ||
*clause.parameters()->parameters().front()->type() != *TypeProvider::bytesMemory()
)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6231_error, clause.location(), "Expected `catch (bytes memory ...) { ... }` or `catch { ... }`.");
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
if (!m_evmVersion.supportsReturndata())
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9908_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
clause.location(),
"This catch clause type cannot be used on the selected EVM version (" +
m_evmVersion.name() +
"). You need at least a Byzantium-compatible EVM or use `catch { ... }`."
);
}
}
Catch panic.
2020-10-20 13:30:46 +00:00
else if (clause.errorName() == "Error" || clause.errorName() == "Panic")
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
{
if (!m_evmVersion.supportsReturndata())
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1812_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
clause.location(),
"This catch clause type cannot be used on the selected EVM version (" +
m_evmVersion.name() +
"). You need at least a Byzantium-compatible EVM or use `catch { ... }`."
);
Catch panic.
2020-10-20 13:30:46 +00:00
if (clause.errorName() == "Error")
{
if (errorClause)
m_errorReporter.typeError(
1036_error,
clause.location(),
SecondarySourceLocation{}.append("The first clause is here:", errorClause->location()),
"This try statement already has an \"Error\" catch clause."
);
errorClause = &clause;
if (
!clause.parameters() ||
clause.parameters()->parameters().size() != 1 ||
*clause.parameters()->parameters().front()->type() != *TypeProvider::stringMemory()
)
m_errorReporter.typeError(2943_error, clause.location(), "Expected `catch Error(string memory ...) { ... }`.");
}
else
{
if (panicClause)
m_errorReporter.typeError(
6732_error,
clause.location(),
SecondarySourceLocation{}.append("The first clause is here:", panicClause->location()),
"This try statement already has a \"Panic\" catch clause."
);
panicClause = &clause;
if (
!clause.parameters() ||
clause.parameters()->parameters().size() != 1 ||
*clause.parameters()->parameters().front()->type() != *TypeProvider::uint256()
)
m_errorReporter.typeError(1271_error, clause.location(), "Expected `catch Panic(uint ...) { ... }`.");
}
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
}
else
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
3542_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
clause.location(),
Catch panic.
2020-10-20 13:30:46 +00:00
"Invalid catch clause name. Expected either `catch (...)`, `catch Error(...)`, or `catch Panic(...)`."
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
);
}
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
bool TypeChecker::visit(WhileStatement const& _whileStatement)
{
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
expectType(_whileStatement.condition(), *TypeProvider::boolean());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
_whileStatement.body().accept(*this);
return false;
}
bool TypeChecker::visit(ForStatement const& _forStatement)
{
if (_forStatement.initializationExpression())
_forStatement.initializationExpression()->accept(*this);
if (_forStatement.condition())
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
expectType(*_forStatement.condition(), *TypeProvider::boolean());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (_forStatement.loopExpression())
_forStatement.loopExpression()->accept(*this);
_forStatement.body().accept(*this);
return false;
}
void TypeChecker::endVisit(Return const& _return)
{
Disallow empty return expressions in functions with non-empty return parameters.
2018-08-07 18:47:23 +00:00
ParameterList const* params = _return.annotation().functionReturnParameters;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!_return.expression())
Disallow empty return expressions in functions with non-empty return parameters.
2018-08-07 18:47:23 +00:00
{
if (params && !params->parameters().empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6777_error, _return.location(), "Return arguments required.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return;
Disallow empty return expressions in functions with non-empty return parameters.
2018-08-07 18:47:23 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!params)
Tuple expressions.
2015-10-12 21:02:35 +00:00
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7552_error, _return.location(), "Return arguments not allowed.");
Tuple expressions.
2015-10-12 21:02:35 +00:00
return;
}
TypePointers returnTypes;
for (auto const& var: params->parameters())
returnTypes.push_back(type(*var));
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto tupleType = dynamic_cast<TupleType const*>(type(*_return.expression())))
Tuple expressions.
2015-10-12 21:02:35 +00:00
{
if (tupleType->components().size() != params->parameters().size())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(5132_error, _return.location(), "Different number of arguments in return statement than in returns declaration.");
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
else
{
BoolResult result = tupleType->isImplicitlyConvertibleTo(TupleType(returnTypes));
if (!result)
m_errorReporter.typeErrorConcatenateDescriptions(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5992_error,
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
_return.expression()->location(),
"Return argument type " +
type(*_return.expression())->toString() +
" is not implicitly convertible to expected type " +
TupleType(returnTypes).toString(false) + ".",
result.message()
);
}
Tuple expressions.
2015-10-12 21:02:35 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else if (params->parameters().size() != 1)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(8863_error, _return.location(), "Different number of arguments in return statement than in returns declaration.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
{
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* expected = type(*params->parameters().front());
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
BoolResult result = type(*_return.expression())->isImplicitlyConvertibleTo(*expected);
if (!result)
m_errorReporter.typeErrorConcatenateDescriptions(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6359_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_return.expression()->location(),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
"Return argument type " +
type(*_return.expression())->toString() +
" is not implicitly convertible to expected type (type of first return variable) " +
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
expected->toString() + ".",
result.message()
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
}
}
Introduce emit statement.
2018-02-16 15:55:21 +00:00
void TypeChecker::endVisit(EmitStatement const& _emit)
{
if (
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
*_emit.eventCall().annotation().kind != FunctionCallKind::FunctionCall ||
Show proper error when trying to emit a non-event
2018-05-04 04:21:28 +00:00
type(_emit.eventCall().expression())->category() != Type::Category::Function ||
Introduce emit statement.
2018-02-16 15:55:21 +00:00
dynamic_cast<FunctionType const&>(*type(_emit.eventCall().expression())).kind() != FunctionType::Kind::Event
)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9292_error, _emit.eventCall().expression().location(), "Expression has to be an event invocation.");
Introduce emit statement.
2018-02-16 15:55:21 +00:00
}
Revert statement.
2021-02-24 09:55:49 +00:00
void TypeChecker::endVisit(RevertStatement const& _revert)
{
FunctionCall const& errorCall = _revert.errorCall();
if (
*errorCall.annotation().kind != FunctionCallKind::FunctionCall ||
type(errorCall.expression())->category() != Type::Category::Function ||
dynamic_cast<FunctionType const&>(*type(errorCall.expression())).kind() != FunctionType::Kind::Error
)
m_errorReporter.typeError(1885_error, errorCall.expression().location(), "Expression has to be an error.");
}
Refactoring to allow multi-variable declarations.
2015-10-08 16:01:12 +00:00
bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
{
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
if (!_statement.initialValue())
Refactoring to allow multi-variable declarations.
2015-10-08 16:01:12 +00:00
{
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
// No initial value is only permitted for single variables with specified type.
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
// This usually already results in a parser error.
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
if (_statement.declarations().size() != 1 || !_statement.declarations().front())
Ensures an empty use of var keyword is caught with the proper error message.
2018-07-12 14:17:30 +00:00
{
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
solAssert(m_errorReporter.hasErrors(), "");
Ensures an empty use of var keyword is caught with the proper error message.
2018-07-12 14:17:30 +00:00
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
// It is okay to return here, as there are no named components on the
// left-hand-side that could cause any damage later.
return false;
Ensures an empty use of var keyword is caught with the proper error message.
2018-07-12 14:17:30 +00:00
}
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
VariableDeclaration const& varDecl = *_statement.declarations().front();
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
solAssert(varDecl.annotation().type, "");
Ensures an empty use of var keyword is caught with the proper error message.
2018-07-12 14:17:30 +00:00
Removed redundant declaration check; changed relevant test cases
2020-04-02 06:57:38 +00:00
if (dynamic_cast<MappingType const*>(type(varDecl)))
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4182_error,
Disallow uninitialized mapping variables.
2017-03-03 17:44:35 +00:00
varDecl.location(),
"Uninitialized mapping. Mappings cannot be created dynamically, you have to assign them from a state variable."
);
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
varDecl.accept(*this);
Refactoring to allow multi-variable declarations.
2015-10-08 16:01:12 +00:00
return false;
}
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
// Here we have an initial value and might have to derive some types before we can visit
// the variable declaration(s).
_statement.initialValue()->accept(*this);
Multi-variable declarations.
2015-10-09 18:44:56 +00:00
TypePointers valueTypes;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto tupleType = dynamic_cast<TupleType const*>(type(*_statement.initialValue())))
Multi-variable declarations.
2015-10-09 18:44:56 +00:00
valueTypes = tupleType->components();
else
Tuple expressions.
2015-10-12 21:02:35 +00:00
valueTypes = TypePointers{type(*_statement.initialValue())};
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
Multi-variable declarations.
2015-10-09 18:44:56 +00:00
vector<ASTPointer<VariableDeclaration>> const& variables = _statement.declarations();
Some further test fixes.
2015-10-13 12:31:24 +00:00
if (variables.empty())
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
// We already have an error for this in the SyntaxChecker.
solAssert(m_errorReporter.hasErrors(), "");
Deprecate wildcard assignments.
2018-05-03 17:21:42 +00:00
else if (valueTypes.size() != variables.size())
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7364_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_statement.location(),
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
"Different number of components on the left hand side (" +
toString(variables.size()) +
") than on the right hand side (" +
Multi-variable declarations.
2015-10-09 18:44:56 +00:00
toString(valueTypes.size()) +
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
")."
Multi-variable declarations.
2015-10-09 18:44:56 +00:00
);
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
for (size_t i = 0; i < min(variables.size(), valueTypes.size()); ++i)
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
{
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
if (!variables[i])
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
continue;
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
VariableDeclaration const& var = *variables[i];
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
solAssert(!var.value(), "Value has to be tied to statement.");
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* valueComponentType = valueTypes[i];
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
solAssert(!!valueComponentType, "");
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
solAssert(var.annotation().type, "");
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
var.accept(*this);
BoolResult result = valueComponentType->isImplicitlyConvertibleTo(*var.annotation().type);
if (!result)
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
{
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
auto errorMsg = "Type " +
valueComponentType->toString() +
" is not implicitly convertible to expected type " +
var.annotation().type->toString();
if (
valueComponentType->category() == Type::Category::RationalNumber &&
dynamic_cast<RationalNumberType const&>(*valueComponentType).isFractional() &&
valueComponentType->mobileType()
)
reorganized tests and fixed mobile types and implicit conversions of rationals and fixed point types one final tweak check for null types
2016-05-05 22:47:08 +00:00
{
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
if (var.annotation().type->operator==(*valueComponentType->mobileType()))
m_errorReporter.typeError(
5107_error,
_statement.location(),
errorMsg + ", but it can be explicitly converted."
);
reorganized tests and fixed mobile types and implicit conversions of rationals and fixed point types one final tweak check for null types
2016-05-05 22:47:08 +00:00
else
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
m_errorReporter.typeError(
4486_error,
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
_statement.location(),
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
errorMsg +
". Try converting to type " +
valueComponentType->mobileType()->toString() +
" or use an explicit conversion."
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
);
reorganized tests and fixed mobile types and implicit conversions of rationals and fixed point types one final tweak check for null types
2016-05-05 22:47:08 +00:00
}
Remove special treatment of ``var``.
2020-07-15 17:50:59 +00:00
else
m_errorReporter.typeErrorConcatenateDescriptions(
9574_error,
_statement.location(),
errorMsg + ".",
result.message()
);
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
}
Refactoring to allow multi-variable declarations.
2015-10-08 16:01:12 +00:00
}
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
TypeChecker: Check if type exists before dereferencing it
2019-02-27 16:32:48 +00:00
if (valueTypes.size() != variables.size())
{
solAssert(m_errorReporter.hasErrors(), "Should have errors!");
for (auto const& var: variables)
if (var && !var->annotation().type)
BOOST_THROW_EXCEPTION(FatalError());
}
Refactoring to allow multi-variable declarations.
2015-10-08 16:01:12 +00:00
return false;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
void TypeChecker::endVisit(ExpressionStatement const& _statement)
{
changed names for Rational Constants and categories
2016-03-29 20:08:51 +00:00
if (type(_statement.expression())->category() == Type::Category::RationalNumber)
Prefer mobileType() to check rational range.
2016-05-10 08:26:53 +00:00
if (!dynamic_cast<RationalNumberType const&>(*type(_statement.expression())).mobileType())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3757_error, _statement.expression().location(), "Invalid rational number.");
Warn about unused return values.
2016-06-21 12:36:23 +00:00
Only warn about unused return in low-level functions.
2016-06-24 14:41:17 +00:00
if (auto call = dynamic_cast<FunctionCall const*>(&_statement.expression()))
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto callType = dynamic_cast<FunctionType const*>(type(call->expression())))
Only warn about unused return in low-level functions.
2016-06-24 14:41:17 +00:00
{
Change references to FunctionType::Location
2017-03-16 11:58:17 +00:00
auto kind = callType->kind();
Only warn about unused return in low-level functions.
2016-06-24 14:41:17 +00:00
if (
Rename Bare to Barecall
2017-08-01 09:32:23 +00:00
kind == FunctionType::Kind::BareCall ||
Change references to FunctionType::Location
2017-03-16 11:58:17 +00:00
kind == FunctionType::Kind::BareCallCode ||
Add ``staticcall`` to ``address``.
2018-08-15 12:40:20 +00:00
kind == FunctionType::Kind::BareDelegateCall ||
kind == FunctionType::Kind::BareStaticCall
Only warn about unused return in low-level functions.
2016-06-24 14:41:17 +00:00
)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.warning(9302_error, _statement.location(), "Return value of low-level calls not used.");
Change references to FunctionType::Location
2017-03-16 11:58:17 +00:00
else if (kind == FunctionType::Kind::Send)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.warning(5878_error, _statement.location(), "Failure condition of 'send' ignored. Consider using 'transfer' instead.");
Only warn about unused return in low-level functions.
2016-06-24 14:41:17 +00:00
}
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
[cond-expr] change endVisit() to visit()
2016-01-07 09:01:46 +00:00
bool TypeChecker::visit(Conditional const& _conditional)
[cond-expr] add type checker
2015-12-22 16:50:06 +00:00
{
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
expectType(_conditional.condition(), *TypeProvider::boolean());
[cond-expr] support conditional expression as lvalue
2015-12-23 16:12:41 +00:00
[cond-expr] don't allow conditional as left value for the first stage
2016-01-11 07:08:28 +00:00
_conditional.trueExpression().accept(*this);
_conditional.falseExpression().accept(*this);
[cond-expr] change endVisit() to visit()
2016-01-07 09:01:46 +00:00
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* trueType = type(_conditional.trueExpression())->mobileType();
Type const* falseType = type(_conditional.falseExpression())->mobileType();
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* commonType = nullptr;
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
More checks for missing mobile type.
2016-10-21 10:30:58 +00:00
if (!trueType)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9717_error, _conditional.trueExpression().location(), "Invalid mobile type in true expression.");
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
else
commonType = trueType;
More checks for missing mobile type.
2016-10-21 10:30:58 +00:00
if (!falseType)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3703_error, _conditional.falseExpression().location(), "Invalid mobile type in false expression.");
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
else
commonType = falseType;
[cond-expr] change endVisit() to visit()
2016-01-07 09:01:46 +00:00
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
if (!trueType && !falseType)
BOOST_THROW_EXCEPTION(FatalError());
else if (trueType && falseType)
[cond-expr] change endVisit() to visit()
2016-01-07 09:01:46 +00:00
{
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
commonType = Type::commonType(trueType, falseType);
if (!commonType)
{
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1080_error,
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
_conditional.location(),
"True expression's type " +
trueType->toString() +
Replace "doesn't" with "does not" in error message
2020-07-06 11:44:33 +00:00
" does not match false expression's type " +
Conditional Expression: Delay invalid type fatal error Check the whole conditional first and then output errors for both, the true and false expressions.
2019-02-06 19:42:38 +00:00
falseType->toString() +
"."
);
// even we can't find a common type, we have to set a type here,
// otherwise the upper statement will not be able to check the type.
commonType = trueType;
}
[cond-expr] don't allow conditional as left value for the first stage
2016-01-11 07:08:28 +00:00
}
[cond-expr] change endVisit() to visit()
2016-01-07 09:01:46 +00:00
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_conditional.annotation().isConstant = false;
[cond-expr] don't allow conditional as left value for the first stage
2016-01-11 07:08:28 +00:00
_conditional.annotation().type = commonType;
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
_conditional.annotation().isPure =
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
*_conditional.condition().annotation().isPure &&
*_conditional.trueExpression().annotation().isPure &&
*_conditional.falseExpression().annotation().isPure;
_conditional.annotation().isLValue = false;
[cond-expr] change endVisit() to visit()
2016-01-07 09:01:46 +00:00
Replaced all instances of lValueRequested to willBeWrittenTo
2020-04-09 10:48:57 +00:00
if (_conditional.annotation().willBeWrittenTo)
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.typeError(
[TypeChecker] Remove function input and return parameter names from mobileType
2020-07-15 14:27:38 +00:00
2212_error,
_conditional.location(),
"Conditional expression as left value is not supported yet."
[cond-expr] don't allow conditional as left value for the first stage
2016-01-11 07:08:28 +00:00
);
[cond-expr] change endVisit() to visit()
2016-01-07 09:01:46 +00:00
return false;
[cond-expr] add type checker
2015-12-22 16:50:06 +00:00
}
Disallow assignments to mappings within tuple assignments.
2018-08-03 12:32:37 +00:00
void TypeChecker::checkExpressionAssignment(Type const& _type, Expression const& _expression)
{
if (auto const* tupleExpression = dynamic_cast<TupleExpression const*>(&_expression))
{
Disallow empty tuples on the left hand side
2020-04-23 05:02:04 +00:00
if (tupleExpression->components().empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(5547_error, _expression.location(), "Empty tuple on the left hand side.");
Disallow empty tuples on the left hand side
2020-04-23 05:02:04 +00:00
Review suggestions; to be squashed.
2018-08-03 15:38:06 +00:00
auto const* tupleType = dynamic_cast<TupleType const*>(&_type);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
auto const& types = tupleType && tupleExpression->components().size() != 1 ? tupleType->components() : vector<Type const*> { &_type };
Review suggestions; to be squashed.
2018-08-03 15:38:06 +00:00
Fixes invalid function calls to literals inside tuple assignment's LHS.
2018-10-05 13:38:14 +00:00
solAssert(
tupleExpression->components().size() == types.size() || m_errorReporter.hasErrors(),
Fix #8450. Prevented internal compiler errors when assigning nested tuples.
2020-03-30 13:18:51 +00:00
"Array sizes don't match and no errors generated."
Fixes invalid function calls to literals inside tuple assignment's LHS.
2018-10-05 13:38:14 +00:00
);
for (size_t i = 0; i < min(tupleExpression->components().size(), types.size()); i++)
Review suggestions; to be squashed.
2018-08-03 15:38:06 +00:00
if (types[i])
{
solAssert(!!tupleExpression->components()[i], "");
checkExpressionAssignment(*types[i], *tupleExpression->components()[i]);
}
Disallow assignments to mappings within tuple assignments.
2018-08-03 12:32:37 +00:00
}
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
else if (_type.nameable() && _type.containsNestedMapping())
Allow assignments to local variables of mapping types.
2018-08-03 14:22:03 +00:00
{
bool isLocalOrReturn = false;
if (auto const* identifier = dynamic_cast<Identifier const*>(&_expression))
if (auto const *variableDeclaration = dynamic_cast<VariableDeclaration const*>(identifier->annotation().referencedDeclaration))
if (variableDeclaration->isLocalOrReturn())
isLocalOrReturn = true;
if (!isLocalOrReturn)
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
m_errorReporter.typeError(9214_error, _expression.location(), "Types in storage containing (nested) mappings cannot be assigned to.");
Allow assignments to local variables of mapping types.
2018-08-03 14:22:03 +00:00
}
Disallow assignments to mappings within tuple assignments.
2018-08-03 12:32:37 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
bool TypeChecker::visit(Assignment const& _assignment)
{
Validate immutable variables
2020-03-10 17:15:50 +00:00
requireLValue(
_assignment.leftHandSide(),
_assignment.assignmentOperator() == Token::Assign
);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* t = type(_assignment.leftHandSide());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
_assignment.annotation().type = t;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_assignment.annotation().isPure = false;
_assignment.annotation().isLValue = false;
_assignment.annotation().isConstant = false;
Disallow assignments to mappings within tuple assignments.
2018-08-03 12:32:37 +00:00
checkExpressionAssignment(*t, _assignment.leftHandSide());
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (TupleType const* tupleType = dynamic_cast<TupleType const*>(t))
Destructuring assignments.
2015-10-14 13:19:50 +00:00
{
Disallow compound assignment for tuples.
2017-03-06 13:50:00 +00:00
if (_assignment.assignmentOperator() != Token::Assign)
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4289_error,
Disallow compound assignment for tuples.
2017-03-06 13:50:00 +00:00
_assignment.location(),
"Compound assignment is not allowed for tuple types."
);
MacOS fix.
2015-10-15 14:02:00 +00:00
// Sequenced assignments of tuples is not valid, make the result a "void" type.
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
_assignment.annotation().type = TypeProvider::emptyTuple();
Deprecate wildcard assignments.
2018-05-03 17:21:42 +00:00
Destructuring assignments.
2015-10-14 13:19:50 +00:00
expectType(_assignment.rightHandSide(), *tupleType);
Warn about copies in storage that might overwrite unexpectedly.
2017-06-21 17:32:56 +00:00
Fix crash on assignment to non-lvalue.
2017-07-26 12:19:46 +00:00
// expectType does not cause fatal errors, so we have to check again here.
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (dynamic_cast<TupleType const*>(type(_assignment.rightHandSide())))
Fix crash on assignment to non-lvalue.
2017-07-26 12:19:46 +00:00
checkDoubleStorageAssignment(_assignment);
Destructuring assignments.
2015-10-14 13:19:50 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else if (_assignment.assignmentOperator() == Token::Assign)
expectType(_assignment.rightHandSide(), *t);
else
{
// compound assignment
_assignment.rightHandSide().accept(*this);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* resultType = t->binaryOperatorResult(
Refactor `solidity::Token` into an `enum class` with `TokenTraits` helper namespace
2018-10-22 14:48:21 +00:00
TokenTraits::AssignmentToBinaryOp(_assignment.assignmentOperator()),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
type(_assignment.rightHandSide())
);
if (!resultType || *resultType != *t)
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7366_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_assignment.location(),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
"Operator " +
Refactor `solidity::Token` into an `enum class` with `TokenTraits` helper namespace
2018-10-22 14:48:21 +00:00
string(TokenTraits::toString(_assignment.assignmentOperator())) +
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
" not compatible with types " +
t->toString() +
" and " +
type(_assignment.rightHandSide())->toString()
);
}
return false;
}
Tuple expressions.
2015-10-12 21:02:35 +00:00
bool TypeChecker::visit(TupleExpression const& _tuple)
{
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_tuple.annotation().isConstant = false;
Tuple expressions.
2015-10-12 21:02:35 +00:00
vector<ASTPointer<Expression>> const& components = _tuple.components();
TypePointers types;
final changes to typechecker, the expression compiler, and a couple more tests for good measure
2016-01-11 20:25:59 +00:00
Replaced all instances of lValueRequested to willBeWrittenTo
2020-04-09 10:48:57 +00:00
if (_tuple.annotation().willBeWrittenTo)
Tuple expressions.
2015-10-12 21:02:35 +00:00
{
final changes to typechecker, the expression compiler, and a couple more tests for good measure
2016-01-11 20:25:59 +00:00
if (_tuple.isInlineArray())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(3025_error, _tuple.location(), "Inline array type cannot be declared as LValue.");
Tuple expressions.
2015-10-12 21:02:35 +00:00
for (auto const& component: components)
if (component)
{
Validate immutable variables
2020-03-10 17:15:50 +00:00
requireLValue(
*component,
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
_tuple.annotation().lValueOfOrdinaryAssignment
Validate immutable variables
2020-03-10 17:15:50 +00:00
);
Tuple expressions.
2015-10-12 21:02:35 +00:00
types.push_back(type(*component));
}
else
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
types.push_back(nullptr);
support decayed tuple expression as left value
2016-01-04 08:11:04 +00:00
if (components.size() == 1)
_tuple.annotation().type = type(*components[0]);
else
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
_tuple.annotation().type = TypeProvider::tuple(move(types));
Tuple expressions.
2015-10-12 21:02:35 +00:00
// If some of the components are not LValues, the error is reported above.
_tuple.annotation().isLValue = true;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_tuple.annotation().isPure = false;
Tuple expressions.
2015-10-12 21:02:35 +00:00
}
else
{
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
bool isPure = true;
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* inlineArrayType = nullptr;
Turns it into warning (error for 0.5.0) and adds Changelog entry.
2018-04-23 14:20:37 +00:00
Tuple expressions.
2015-10-12 21:02:35 +00:00
for (size_t i = 0; i < components.size(); ++i)
{
Disallow empty tuple components.
2018-07-10 10:37:09 +00:00
if (!components[i])
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(8381_error, _tuple.location(), "Tuple component cannot be empty.");
Prevents null type from being used in tuple.
2018-04-22 14:54:33 +00:00
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
components[i]->accept(*this);
types.push_back(type(*components[i]));
Validate each tuple literal
2017-09-18 10:39:17 +00:00
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
if (types[i]->category() == Type::Category::Tuple)
if (dynamic_cast<TupleType const&>(*types[i]).components().empty())
More checks for missing mobile type.
2016-10-21 10:30:58 +00:00
{
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
if (_tuple.isInlineArray())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(5604_error, components[i]->location(), "Array component cannot be empty.");
m_errorReporter.typeError(6473_error, components[i]->location(), "Tuple component cannot be empty.");
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
}
Remove duplicate if-check
2019-02-07 14:53:49 +00:00
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
// Note: code generation will visit each of the expression even if they are not assigned from.
if (types[i]->category() == Type::Category::RationalNumber && components.size() > 1)
if (!dynamic_cast<RationalNumberType const&>(*types[i]).mobileType())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(3390_error, components[i]->location(), "Invalid rational number.");
More checks for missing mobile type.
2016-10-21 10:30:58 +00:00
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
if (_tuple.isInlineArray())
{
solAssert(!!types[i], "Inline array cannot have empty components");
if ((i == 0 || inlineArrayType) && !types[i]->mobileType())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(9563_error, components[i]->location(), "Invalid mobile type.");
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
if (i == 0)
inlineArrayType = types[i]->mobileType();
else if (inlineArrayType)
inlineArrayType = Type::commonType(inlineArrayType, types[i]);
Tuple expressions.
2015-10-12 21:02:35 +00:00
}
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (!*components[i]->annotation().isPure)
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
isPure = false;
Tuple expressions.
2015-10-12 21:02:35 +00:00
}
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
_tuple.annotation().isPure = isPure;
final changes to typechecker, the expression compiler, and a couple more tests for good measure
2016-01-11 20:25:59 +00:00
if (_tuple.isInlineArray())
{
Improves address literal checksum error message
2017-10-05 13:28:25 +00:00
if (!inlineArrayType)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(6378_error, _tuple.location(), "Unable to deduce common type for array elements.");
Disallow non-namable types for inline arrays.
2020-05-26 13:20:54 +00:00
else if (!inlineArrayType->nameable())
m_errorReporter.fatalTypeError(
9656_error,
_tuple.location(),
"Unable to deduce nameable type for array elements. Try adding explicit type conversion for the first element."
);
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
else if (inlineArrayType->containsNestedMapping())
m_errorReporter.fatalTypeError(
1545_error,
_tuple.location(),
"Type " + inlineArrayType->toString(true) + " is only valid in storage."
);
Disallow inline arrays of mapping type.
2018-11-29 18:44:33 +00:00
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
_tuple.annotation().type = TypeProvider::array(DataLocation::Memory, inlineArrayType, types.size());
final changes to typechecker, the expression compiler, and a couple more tests for good measure
2016-01-11 20:25:59 +00:00
}
Tuple expressions.
2015-10-12 21:02:35 +00:00
else
{
final changes to typechecker, the expression compiler, and a couple more tests for good measure
2016-01-11 20:25:59 +00:00
if (components.size() == 1)
_tuple.annotation().type = type(*components[0]);
else
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
_tuple.annotation().type = TypeProvider::tuple(move(types));
Tuple expressions.
2015-10-12 21:02:35 +00:00
}
final changes to typechecker, the expression compiler, and a couple more tests for good measure
2016-01-11 20:25:59 +00:00
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_tuple.annotation().isLValue = false;
Tuple expressions.
2015-10-12 21:02:35 +00:00
}
return false;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
bool TypeChecker::visit(UnaryOperation const& _operation)
{
// Inc, Dec, Add, Sub, Not, BitNot, Delete
Refactor `solidity::Token` into an `enum class` with `TokenTraits` helper namespace
2018-10-22 14:48:21 +00:00
Token op = _operation.getOperator();
bool const modifying = (op == Token::Inc || op == Token::Dec || op == Token::Delete);
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
if (modifying)
Validate immutable variables
2020-03-10 17:15:50 +00:00
requireLValue(_operation.subExpression(), false);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
_operation.subExpression().accept(*this);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* subExprType = type(_operation.subExpression());
Type const* t = type(_operation.subExpression())->unaryOperatorResult(op);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!t)
{
Type Checker: Fix internal error when applying unary operators to tuples with empty components
2020-04-28 15:15:55 +00:00
string description = "Unary operator " + string(TokenTraits::toString(op)) + " cannot be applied to type " + subExprType->toString();
if (modifying)
// Cannot just report the error, ignore the unary operator, and continue,
// because the sub-expression was already processed with requireLValue()
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(9767_error, _operation.location(), description);
Type Checker: Fix internal error when applying unary operators to tuples with empty components
2020-04-28 15:15:55 +00:00
else
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4907_error, _operation.location(), description);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
t = subExprType;
}
_operation.annotation().type = t;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_operation.annotation().isConstant = false;
_operation.annotation().isPure = !modifying && *_operation.subExpression().annotation().isPure;
_operation.annotation().isLValue = false;
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
void TypeChecker::endVisit(BinaryOperation const& _operation)
{
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* leftType = type(_operation.leftExpression());
Type const* rightType = type(_operation.rightExpression());
Adds an additional message to failing type conversions.
2018-12-05 13:34:27 +00:00
TypeResult result = leftType->binaryOperatorResult(_operation.getOperator(), rightType);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* commonType = result.get();
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!commonType)
{
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2271_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_operation.location(),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
"Operator " +
Refactor `solidity::Token` into an `enum class` with `TokenTraits` helper namespace
2018-10-22 14:48:21 +00:00
string(TokenTraits::toString(_operation.getOperator())) +
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
" not compatible with types " +
leftType->toString() +
" and " +
Adds an additional message to failing type conversions.
2018-12-05 13:34:27 +00:00
rightType->toString() +
(!result.message().empty() ? ". " + result.message() : "")
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
commonType = leftType;
}
_operation.annotation().commonType = commonType;
_operation.annotation().type =
Refactor `solidity::Token` into an `enum class` with `TokenTraits` helper namespace
2018-10-22 14:48:21 +00:00
TokenTraits::isCompareOp(_operation.getOperator()) ?
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
TypeProvider::boolean() :
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
commonType;
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
_operation.annotation().isPure =
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
*_operation.leftExpression().annotation().isPure &&
*_operation.rightExpression().annotation().isPure;
_operation.annotation().isLValue = false;
_operation.annotation().isConstant = false;
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
Warn about shift of literals.
2017-08-16 11:52:06 +00:00
if (_operation.getOperator() == Token::Exp || _operation.getOperator() == Token::SHL)
Warn about literal constant base in exponentiation.
2017-03-07 12:44:11 +00:00
{
Warn about shift of literals.
2017-08-16 11:52:06 +00:00
string operation = _operation.getOperator() == Token::Exp ? "exponentiation" : "shift";
Warn about literal constant base in exponentiation.
2017-03-07 12:44:11 +00:00
if (
leftType->category() == Type::Category::RationalNumber &&
rightType->category() != Type::Category::RationalNumber
)
Remove unreachable warning for shift/exp operator
2021-02-15 23:09:29 +00:00
{
// These rules are enforced by the binary operator, but assert them here too.
if (auto type = dynamic_cast<IntegerType const*>(commonType))
solAssert(type->numBits() == 256, "");
if (auto type = dynamic_cast<FixedPointType const*>(commonType))
solAssert(type->numBits() == 256, "");
}
Allow exponentials with signed base and unsigned power.
2019-07-07 15:53:03 +00:00
if (
commonType->category() == Type::Category::Integer &&
rightType->category() == Type::Category::Integer &&
dynamic_cast<IntegerType const&>(*commonType).numBits() <
dynamic_cast<IntegerType const&>(*rightType).numBits()
)
m_errorReporter.warning(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
3149_error,
Allow exponentials with signed base and unsigned power.
2019-07-07 15:53:03 +00:00
_operation.location(),
"The result type of the " +
operation +
" operation is equal to the type of the first operand (" +
commonType->toString() +
") ignoring the (larger) type of the second operand (" +
rightType->toString() +
") which might be unexpected. Silence this warning by either converting "
"the first or the second operand to the type of the other."
);
Warn about literal constant base in exponentiation.
2017-03-07 12:44:11 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* TypeChecker::typeCheckTypeConversionAndRetrieveReturnType(
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
FunctionCall const& _functionCall
)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
solAssert(*_functionCall.annotation().kind == FunctionCallKind::TypeConversion, "");
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* expressionType = type(_functionCall.expression());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
bool const isPositionalCall = _functionCall.names().empty();
refactoring functionCallAnnotation
2017-05-19 13:45:01 +00:00
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* resultType = dynamic_cast<TypeType const&>(*expressionType).actualType();
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
if (arguments.size() != 1)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2558_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
_functionCall.location(),
"Exactly one argument expected for explicit type conversion."
);
else if (!isPositionalCall)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5153_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
_functionCall.location(),
"Type conversion cannot allow named arguments."
);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
Type const* argType = type(*arguments.front());
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Resulting data location is memory unless we are converting from a reference
// type with a different data location.
// (data location cannot yet be specified for type conversions)
DataLocation dataLoc = DataLocation::Memory;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto argRefType = dynamic_cast<ReferenceType const*>(argType))
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
dataLoc = argRefType->location();
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto type = dynamic_cast<ReferenceType const*>(resultType))
resultType = TypeProvider::withLocation(type, dataLoc, type->isPointer());
Display BoolResult from implicit/explicit conversions for more clarity in error messages
2020-09-23 14:08:55 +00:00
BoolResult result = argType->isExplicitlyConvertibleTo(*resultType);
if (result)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto argArrayType = dynamic_cast<ArrayType const*>(argType))
Do not set to ref for explicit conversion and add assertion for array type conversion. Also, add some test cases for #4901 and #4948.
2018-09-12 10:01:34 +00:00
{
Allowing conversion from bytes to bytesNN in type checker.
2021-03-04 07:52:17 +00:00
if (auto resultArrayType = dynamic_cast<ArrayType const*>(resultType))
solAssert(
argArrayType->location() != DataLocation::Storage ||
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
(
Allowing conversion from bytes to bytesNN in type checker.
2021-03-04 07:52:17 +00:00
(
resultArrayType->isPointer() ||
(argArrayType->isByteArray() && resultArrayType->isByteArray())
) &&
resultArrayType->location() == DataLocation::Storage
),
"Invalid explicit conversion to storage type."
);
else
solAssert(
argArrayType->isByteArray() && !argArrayType->isString() && resultType->category() == Type::Category::FixedBytes,
""
);
Add payable and non-payable state mutability to AddressType.
2018-09-05 15:59:55 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
}
else
{
if (
resultType->category() == Type::Category::Contract &&
argType->category() == Type::Category::Address
)
Add payable and non-payable state mutability to AddressType.
2018-09-05 15:59:55 +00:00
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
solAssert(dynamic_cast<ContractType const*>(resultType)->isPayable(), "");
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
solAssert(
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
dynamic_cast<AddressType const*>(argType)->stateMutability() <
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
StateMutability::Payable,
""
);
SecondarySourceLocation ssl;
if (
auto const* identifier = dynamic_cast<Identifier const*>(arguments.front().get())
)
if (
auto const* variableDeclaration = dynamic_cast<VariableDeclaration const*>(
identifier->annotation().referencedDeclaration
)
)
ssl.append(
"Did you mean to declare this variable as \"address payable\"?",
variableDeclaration->location()
);
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7398_error,
Add update suggestion.
2019-08-15 16:46:44 +00:00
_functionCall.location(),
ssl,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
"Explicit type conversion not allowed from non-payable \"address\" to \"" +
resultType->toString() +
"\", which has a payable fallback function."
);
Add payable and non-payable state mutability to AddressType.
2018-09-05 15:59:55 +00:00
}
Add update suggestion.
2019-08-15 16:46:44 +00:00
else if (
auto const* functionType = dynamic_cast<FunctionType const*>(argType);
functionType &&
functionType->kind() == FunctionType::Kind::External &&
resultType->category() == Type::Category::Address
)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5030_error,
Add update suggestion.
2019-08-15 16:46:44 +00:00
_functionCall.location(),
"Explicit type conversion not allowed from \"" +
argType->toString() +
"\" to \"" +
resultType->toString() +
"\". To obtain the address of the contract of the function, " +
"you can use the .address member of the function."
);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
else
Display BoolResult from implicit/explicit conversions for more clarity in error messages
2020-09-23 14:08:55 +00:00
m_errorReporter.typeErrorConcatenateDescriptions(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9640_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
_functionCall.location(),
"Explicit type conversion not allowed from \"" +
argType->toString() +
"\" to \"" +
resultType->toString() +
Display BoolResult from implicit/explicit conversions for more clarity in error messages
2020-09-23 14:08:55 +00:00
"\".",
result.message()
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
);
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
return resultType;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
void TypeChecker::typeCheckFunctionCall(
FunctionCall const& _functionCall,
FunctionTypePointer _functionType
)
{
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
// Actual function call or struct constructor call.
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
solAssert(!!_functionType, "");
solAssert(_functionType->kind() != FunctionType::Kind::ABIDecode, "");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Introduce FunctionKind::Declaration and allow accessing function signatures via contract name.
2020-01-07 10:42:37 +00:00
if (_functionType->kind() == FunctionType::Kind::Declaration)
{
Free functions.
2020-05-04 16:38:00 +00:00
solAssert(_functionType->declaration().annotation().contract, "");
Fix calling unimplemented base function.
2020-03-06 09:44:51 +00:00
if (
Free functions.
2020-05-04 16:38:00 +00:00
m_currentContract &&
Rename scope to currentContract.
2020-06-09 16:17:58 +00:00
m_currentContract->derivesFrom(*_functionType->declaration().annotation().contract) &&
Fix calling unimplemented base function.
2020-03-06 09:44:51 +00:00
!dynamic_cast<FunctionDefinition const&>(_functionType->declaration()).isImplemented()
)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7501_error,
Fix calling unimplemented base function.
2020-03-06 09:44:51 +00:00
_functionCall.location(),
"Cannot call unimplemented base function."
);
else
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
3419_error,
Fix calling unimplemented base function.
2020-03-06 09:44:51 +00:00
_functionCall.location(),
"Cannot call function via contract type name."
);
Introduce FunctionKind::Declaration and allow accessing function signatures via contract name.
2020-01-07 10:42:37 +00:00
return;
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Check for unsupported use of bare static call
if (
_functionType->kind() == FunctionType::Kind::BareStaticCall &&
!m_evmVersion.hasStaticCall()
)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5052_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
_functionCall.location(),
"\"staticcall\" is not supported by the VM version."
);
// Perform standard function call type checking
typeCheckFunctionGeneralChecks(_functionCall, _functionType);
}
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
void TypeChecker::typeCheckFallbackFunction(FunctionDefinition const& _function)
{
solAssert(_function.isFallback(), "");
Replace inContractKind by libraryFunction.
2020-06-09 15:56:58 +00:00
if (_function.libraryFunction())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(5982_error, _function.location(), "Libraries cannot have fallback functions.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (_function.stateMutability() != StateMutability::NonPayable && _function.stateMutability() != StateMutability::Payable)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4575_error,
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
_function.location(),
"Fallback function must be payable or non-payable, but is \"" +
stateMutabilityToString(_function.stateMutability()) +
"\"."
);
Move Visibility out of Declaration.
2019-12-10 14:54:09 +00:00
if (_function.visibility() != Visibility::External)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1159_error, _function.location(), "Fallback function must be defined as \"external\".");
Allow fallback function to return data.
2020-11-05 17:03:32 +00:00
if (!_function.returnParameters().empty() || !_function.parameters().empty())
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
{
Allow fallback function to return data.
2020-11-05 17:03:32 +00:00
if (
_function.returnParameters().size() != 1 ||
*type(*_function.returnParameters().front()) != *TypeProvider::bytesMemory() ||
_function.parameters().size() != 1 ||
*type(*_function.parameters().front()) != *TypeProvider::bytesCalldata()
)
m_errorReporter.typeError(
5570_error,
_function.returnParameterList()->location(),
"Fallback function either has to have the signature \"fallback()\" or \"fallback(bytes calldata) returns (bytes memory)\"."
);
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
}
}
void TypeChecker::typeCheckConstructor(FunctionDefinition const& _function)
{
solAssert(_function.isConstructor(), "");
Disallow virtual and override for constructors.
2020-04-15 11:58:37 +00:00
if (_function.overrides())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1209_error, _function.location(), "Constructors cannot override.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (!_function.returnParameters().empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9712_error, _function.returnParameterList()->location(), "Non-empty \"returns\" directive for constructor.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (_function.stateMutability() != StateMutability::NonPayable && _function.stateMutability() != StateMutability::Payable)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1558_error,
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
_function.location(),
"Constructor must be payable or non-payable, but is \"" +
stateMutabilityToString(_function.stateMutability()) +
"\"."
);
Make visibility optional, but it has to be consistent.
2020-06-30 10:04:58 +00:00
if (!_function.noVisibilitySpecified())
{
auto const& contract = dynamic_cast<ContractDefinition const&>(*_function.scope());
if (_function.visibility() != Visibility::Public && _function.visibility() != Visibility::Internal)
m_errorReporter.typeError(9239_error, _function.location(), "Constructor cannot have visibility.");
else if (_function.isPublic() && contract.abstract())
m_errorReporter.declarationError(
8295_error,
_function.location(),
"Abstract contracts cannot have public constructors. Remove the \"public\" keyword to fix this."
);
else if (!_function.isPublic() && !contract.abstract())
m_errorReporter.declarationError(
1845_error,
_function.location(),
"Non-abstract contracts cannot have internal constructors. Remove the \"internal\" keyword and make the contract abstract to fix this."
);
else
m_errorReporter.warning(
2462_error,
_function.location(),
"Visibility for constructor is ignored. If you want the contract to be non-deployable, making it \"abstract\" is sufficient."
);
}
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
void TypeChecker::typeCheckABIEncodeFunctions(
FunctionCall const& _functionCall,
FunctionTypePointer _functionType
)
{
solAssert(!!_functionType, "");
solAssert(
_functionType->kind() == FunctionType::Kind::ABIEncode ||
_functionType->kind() == FunctionType::Kind::ABIEncodePacked ||
_functionType->kind() == FunctionType::Kind::ABIEncodeWithSelector ||
_functionType->kind() == FunctionType::Kind::ABIEncodeWithSignature,
"ABI function has unexpected FunctionType::Kind."
);
solAssert(_functionType->takesArbitraryParameters(), "ABI functions should be variadic.");
bool const isPacked = _functionType->kind() == FunctionType::Kind::ABIEncodePacked;
solAssert(_functionType->padArguments() != isPacked, "ABI function with unexpected padding");
Add ``staticcall`` to ``address``.
2018-08-15 12:40:20 +00:00
Introduce abicoder pragma.
2020-10-22 17:19:14 +00:00
bool const abiEncoderV2 = useABICoderV2();
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Check for named arguments
if (!_functionCall.names().empty())
Warn about obsolete sha3/suicide calls
2017-07-31 19:31:12 +00:00
{
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2627_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
_functionCall.location(),
"Named arguments cannot be used for functions that take arbitrary parameters."
);
return;
Warn about obsolete sha3/suicide calls
2017-07-31 19:31:12 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Perform standard function call type checking
typeCheckFunctionGeneralChecks(_functionCall, _functionType);
Warn on using literals in tight packing
2017-08-25 11:17:44 +00:00
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Check additional arguments for variadic functions
vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
for (size_t i = 0; i < arguments.size(); ++i)
Warn on using literals in tight packing
2017-08-25 11:17:44 +00:00
{
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
auto const& argType = type(*arguments[i]);
if (argType->category() == Type::Category::RationalNumber)
Warn on using literals in tight packing
2017-08-25 11:17:44 +00:00
{
Return TypeError is fixed point encoding is attempted.
2019-01-17 12:36:06 +00:00
auto const& rationalType = dynamic_cast<RationalNumberType const&>(*argType);
if (rationalType.isFractional())
{
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6090_error,
Return TypeError is fixed point encoding is attempted.
2019-01-17 12:36:06 +00:00
arguments[i]->location(),
Change error message and add tests
2019-01-17 12:54:31 +00:00
"Fractional numbers cannot yet be encoded."
Return TypeError is fixed point encoding is attempted.
2019-01-17 12:36:06 +00:00
);
continue;
}
else if (!argType->mobileType())
Warn on using literals in tight packing
2017-08-25 11:17:44 +00:00
{
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
8009_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
arguments[i]->location(),
"Invalid rational number (too large or division by zero)."
);
continue;
}
else if (isPacked)
{
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7279_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
arguments[i]->location(),
"Cannot perform packed encoding for a literal."
" Please convert it to an explicit type first."
);
continue;
Warn on using literals in tight packing
2017-08-25 11:17:44 +00:00
}
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
Packed Encoding: Disallow types in v2 that aren't allowed in v1
2019-02-04 17:13:41 +00:00
if (isPacked && !typeSupportedByOldABIEncoder(*argType, false /* isLibrary */))
{
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9578_error,
Packed Encoding: Disallow types in v2 that aren't allowed in v1
2019-02-04 17:13:41 +00:00
arguments[i]->location(),
"Type not supported in packed mode."
);
continue;
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
if (!argType->fullEncodingType(false, abiEncoderV2, !_functionType->padArguments()))
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2056_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
arguments[i]->location(),
"This type cannot be encoded."
);
Warn on using literals in tight packing
2017-08-25 11:17:44 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
}
Warn on using literals in tight packing
2017-08-25 11:17:44 +00:00
Check if all types in bytes.concat are fixed bytes or byte array.
2021-02-23 10:05:07 +00:00
void TypeChecker::typeCheckBytesConcatFunction(
FunctionCall const& _functionCall,
FunctionType const* _functionType
)
{
solAssert(_functionType, "");
solAssert(_functionType->kind() == FunctionType::Kind::BytesConcat, "");
solAssert(_functionCall.names().empty(), "");
typeCheckFunctionGeneralChecks(_functionCall, _functionType);
for (shared_ptr<Expression const> const& argument: _functionCall.arguments())
Fix ICE for 32-byte hex literals and zero literals in bytes.concat() by disallowing them
2021-06-28 14:53:54 +00:00
{
Type const* argumentType = type(*argument);
bool notConvertibleToBytes =
Check if all types in bytes.concat are fixed bytes or byte array.
2021-02-23 10:05:07 +00:00
!argumentType->isImplicitlyConvertibleTo(*TypeProvider::fixedBytes(32)) &&
Fix ICE for 32-byte hex literals and zero literals in bytes.concat() by disallowing them
2021-06-28 14:53:54 +00:00
!argumentType->isImplicitlyConvertibleTo(*TypeProvider::bytesMemory());
bool numberLiteral = (dynamic_cast<RationalNumberType const*>(argumentType) != nullptr);
if (notConvertibleToBytes || numberLiteral)
Check if all types in bytes.concat are fixed bytes or byte array.
2021-02-23 10:05:07 +00:00
m_errorReporter.typeError(
8015_error,
argument->location(),
"Invalid type for argument in the bytes.concat function call. "
"bytes or fixed bytes type is required, but " +
argumentType->toString(true) + " provided."
);
Fix ICE for 32-byte hex literals and zero literals in bytes.concat() by disallowing them
2021-06-28 14:53:54 +00:00
}
Check if all types in bytes.concat are fixed bytes or byte array.
2021-02-23 10:05:07 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
void TypeChecker::typeCheckFunctionGeneralChecks(
FunctionCall const& _functionCall,
FunctionTypePointer _functionType
)
{
// Actual function call or struct constructor call.
Add abi.decode(bytes data, (...))
2018-06-30 16:09:13 +00:00
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
solAssert(!!_functionType, "");
solAssert(_functionType->kind() != FunctionType::Kind::ABIDecode, "");
Fix abi.decode returning single value.
2018-09-04 14:24:21 +00:00
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
bool const isPositionalCall = _functionCall.names().empty();
bool const isVariadic = _functionType->takesArbitraryParameters();
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
auto functionCallKind = *_functionCall.annotation().kind;
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
solAssert(
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
!isVariadic || functionCallKind == FunctionCallKind::FunctionCall,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
"Struct constructor calls cannot be variadic."
);
TypePointers const& parameterTypes = _functionType->parameterTypes();
vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
vector<ASTPointer<ASTString>> const& argumentNames = _functionCall.names();
// Check number of passed in arguments
if (
arguments.size() < parameterTypes.size() ||
(!isVariadic && arguments.size() > parameterTypes.size())
)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
bool const isStructConstructorCall =
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
functionCallKind == FunctionCallKind::StructConstructorCall;
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
string msg = isVariadic ?
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
"Need at least " +
toString(parameterTypes.size()) +
" arguments for " +
string(isStructConstructorCall ? "struct constructor" : "function call") +
", but provided only " +
toString(arguments.size()) +
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
"."
:
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
"Wrong argument count for " +
string(isStructConstructorCall ? "struct constructor" : "function call") +
": " +
toString(arguments.size()) +
" arguments given but " +
string(isVariadic ? "need at least " : "expected ") +
toString(parameterTypes.size()) +
".";
Improve error message for wrong struct initialization (#3359)
2018-01-04 10:24:39 +00:00
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
if (isStructConstructorCall)
Remove untriggerable errors on variadic calls (which have been removed)
2021-02-15 19:52:10 +00:00
{
solAssert(!isVariadic, "");
return { 9755_error, msg };
}
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
else if (
_functionType->kind() == FunctionType::Kind::BareCall ||
_functionType->kind() == FunctionType::Kind::BareCallCode ||
_functionType->kind() == FunctionType::Kind::BareDelegateCall ||
_functionType->kind() == FunctionType::Kind::BareStaticCall
)
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
{
Remove untriggerable errors on variadic calls (which have been removed)
2021-02-15 19:52:10 +00:00
solAssert(!isVariadic, "");
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
if (arguments.empty())
return {
Remove untriggerable errors on variadic calls (which have been removed)
2021-02-15 19:52:10 +00:00
6138_error,
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
msg +
" This function requires a single bytes argument."
" Use \"\" as argument to provide empty calldata."
};
else
return {
Remove untriggerable errors on variadic calls (which have been removed)
2021-02-15 19:52:10 +00:00
8922_error,
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
msg +
" This function requires a single bytes argument."
" If all your arguments are value types, you can use"
" abi.encode(...) to properly generate it."
};
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
}
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
else if (
_functionType->kind() == FunctionType::Kind::KECCAK256 ||
_functionType->kind() == FunctionType::Kind::SHA256 ||
_functionType->kind() == FunctionType::Kind::RIPEMD160
)
Remove untriggerable errors on variadic calls (which have been removed)
2021-02-15 19:52:10 +00:00
{
solAssert(!isVariadic, "");
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
return {
Remove untriggerable errors on variadic calls (which have been removed)
2021-02-15 19:52:10 +00:00
4323_error,
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
msg +
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
" This function requires a single bytes argument."
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
" Use abi.encodePacked(...) to obtain the pre-0.5.0"
" behaviour or abi.encode(...) to use ABI encoding."
};
Remove untriggerable errors on variadic calls (which have been removed)
2021-02-15 19:52:10 +00:00
}
Provide better suggestions in error messages with respect to call and hash functions.
2018-06-14 14:08:59 +00:00
else
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
return { isVariadic ? 9308_error : 6160_error, msg };
}();
m_errorReporter.typeError(errorId, _functionCall.location(), description);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
return;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Parameter to argument map
std::vector<Expression const*> paramArgMap(parameterTypes.size());
// Map parameters to arguments - trivially for positional calls, less so for named calls
if (isPositionalCall)
for (size_t i = 0; i < paramArgMap.size(); ++i)
paramArgMap[i] = arguments[i].get();
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
{
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
auto const& parameterNames = _functionType->parameterNames();
Ensure function parameter names always matches parameter types length
2019-02-07 14:53:11 +00:00
solAssert(
parameterNames.size() == argumentNames.size(),
"Unexpected parameter length mismatch!"
);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Check for duplicate argument names
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
bool duplication = false;
for (size_t i = 0; i < argumentNames.size(); i++)
for (size_t j = i + 1; j < argumentNames.size(); j++)
if (*argumentNames[i] == *argumentNames[j])
{
duplication = true;
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6995_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
arguments[i]->location(),
"Duplicate named argument \"" + *argumentNames[i] + "\"."
);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
if (duplication)
return;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// map parameter names to argument names
{
bool not_all_mapped = false;
Fix wrong name used in error message when reporting invalid named argument
2020-09-17 15:21:47 +00:00
for (size_t i = 0; i < argumentNames.size(); i++)
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
{
size_t j;
Fix wrong name used in error message when reporting invalid named argument
2020-09-17 15:21:47 +00:00
for (j = 0; j < parameterNames.size(); j++)
if (parameterNames[j] == *argumentNames[i])
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
break;
Fix wrong name used in error message when reporting invalid named argument
2020-09-17 15:21:47 +00:00
if (j < parameterNames.size())
paramArgMap[j] = arguments[i].get();
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
else
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
not_all_mapped = true;
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4974_error,
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
_functionCall.location(),
"Named argument \"" +
*argumentNames[i] +
"\" does not match function declaration."
);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
}
if (not_all_mapped)
return;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Check for compatible types between arguments and parameters
for (size_t i = 0; i < paramArgMap.size(); ++i)
{
solAssert(!!paramArgMap[i], "unmapped parameter");
Improved error messages when converting to/from builtin functions
2020-09-23 16:55:52 +00:00
BoolResult result = type(*paramArgMap[i])->isImplicitlyConvertibleTo(*parameterTypes[i]);
if (!result)
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
{
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
string msg =
"Invalid type for argument in function call. "
"Invalid implicit conversion from " +
type(*paramArgMap[i])->toString() +
" to " +
parameterTypes[i]->toString() +
" requested.";
Improved error messages when converting to/from builtin functions
2020-09-23 16:55:52 +00:00
if (!result.message().empty())
msg += " " + result.message();
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
if (
_functionType->kind() == FunctionType::Kind::BareCall ||
_functionType->kind() == FunctionType::Kind::BareCallCode ||
_functionType->kind() == FunctionType::Kind::BareDelegateCall ||
_functionType->kind() == FunctionType::Kind::BareStaticCall
)
return {
8051_error,
msg +
" This function requires a single bytes argument."
" If all your arguments are value types, you can"
" use abi.encode(...) to properly generate it."
};
else if (
_functionType->kind() == FunctionType::Kind::KECCAK256 ||
_functionType->kind() == FunctionType::Kind::SHA256 ||
_functionType->kind() == FunctionType::Kind::RIPEMD160
)
return {
7556_error,
msg +
" This function requires a single bytes argument."
" Use abi.encodePacked(...) to obtain the pre-0.5.0"
" behaviour or abi.encode(...) to use ABI encoding."
};
else
return { 9553_error, msg };
}();
m_errorReporter.typeError(errorId, paramArgMap[i]->location(), description);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
}
}
Add missing checks for parameter compatibilty with ABIEncoderV1 in calls
2020-09-17 13:03:49 +00:00
TypePointers const& returnParameterTypes = _functionType->returnParameterTypes();
bool isLibraryCall = (_functionType->kind() == FunctionType::Kind::DelegateCall);
bool callRequiresABIEncoding =
// ABIEncode/ABIDecode calls not included because they should have been already validated
// at this point and they have variadic arguments so they need special handling.
_functionType->kind() == FunctionType::Kind::DelegateCall ||
_functionType->kind() == FunctionType::Kind::External ||
_functionType->kind() == FunctionType::Kind::Creation ||
Syntax for custom errors.
2021-01-28 11:56:22 +00:00
_functionType->kind() == FunctionType::Kind::Event ||
_functionType->kind() == FunctionType::Kind::Error;
Add missing checks for parameter compatibilty with ABIEncoderV1 in calls
2020-09-17 13:03:49 +00:00
Introduce abicoder pragma.
2020-10-22 17:19:14 +00:00
if (callRequiresABIEncoding && !useABICoderV2())
Add missing checks for parameter compatibilty with ABIEncoderV1 in calls
2020-09-17 13:03:49 +00:00
{
solAssert(!isVariadic, "");
solAssert(parameterTypes.size() == arguments.size(), "");
solAssert(!_functionType->isBareCall(), "");
solAssert(*_functionCall.annotation().kind == FunctionCallKind::FunctionCall, "");
for (size_t i = 0; i < parameterTypes.size(); ++i)
{
solAssert(parameterTypes[i], "");
if (!typeSupportedByOldABIEncoder(*parameterTypes[i], isLibraryCall))
m_errorReporter.typeError(
2443_error,
paramArgMap[i]->location(),
"The type of this parameter, " + parameterTypes[i]->toString(true) + ", "
Wording in error messages.
2020-10-29 18:40:17 +00:00
"is only supported in ABI coder v2. "
"Use \"pragma abicoder v2;\" to enable the feature."
Add missing checks for parameter compatibilty with ABIEncoderV1 in calls
2020-09-17 13:03:49 +00:00
);
}
for (size_t i = 0; i < returnParameterTypes.size(); ++i)
{
solAssert(returnParameterTypes[i], "");
if (!typeSupportedByOldABIEncoder(*returnParameterTypes[i], isLibraryCall))
m_errorReporter.typeError(
2428_error,
_functionCall.location(),
"The type of return parameter " + toString(i + 1) + ", " + returnParameterTypes[i]->toString(true) + ", "
Wording in error messages.
2020-10-29 18:40:17 +00:00
"is only supported in ABI coder v2. "
"Use \"pragma abicoder v2;\" to enable the feature."
Add missing checks for parameter compatibilty with ABIEncoderV1 in calls
2020-09-17 13:03:49 +00:00
);
}
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
}
bool TypeChecker::visit(FunctionCall const& _functionCall)
{
vector<ASTPointer<Expression const>> const& arguments = _functionCall.arguments();
bool argumentsArePure = true;
// We need to check arguments' type first as they will be needed for overload resolution.
for (ASTPointer<Expression const> const& argument: arguments)
{
argument->accept(*this);
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (!*argument->annotation().isPure)
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
argumentsArePure = false;
}
Fix function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
// Store argument types - and names if given - for overload resolution
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
{
Fix function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
FuncCallArguments funcCallArgs;
funcCallArgs.names = _functionCall.names();
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
for (ASTPointer<Expression const> const& argument: arguments)
Fix function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
funcCallArgs.types.push_back(type(*argument));
_functionCall.expression().annotation().arguments = std::move(funcCallArgs);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
}
_functionCall.expression().accept(*this);
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
Type const* expressionType = type(_functionCall.expression());
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Determine function call kind and function type for this FunctionCall node
FunctionCallAnnotation& funcCallAnno = _functionCall.annotation();
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
FunctionTypePointer functionType = nullptr;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
funcCallAnno.isConstant = false;
bool isLValue = false;
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
Add push() for dynamic storage arrays
2019-09-13 22:54:51 +00:00
// Determine and assign function call kind, lvalue, purity and function type for this FunctionCall node
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
switch (expressionType->category())
{
case Type::Category::Function:
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
functionType = dynamic_cast<FunctionType const*>(expressionType);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
funcCallAnno.kind = FunctionCallKind::FunctionCall;
Mark expressions that are called directly in the annotations
2020-11-24 11:27:55 +00:00
if (auto memberAccess = dynamic_cast<MemberAccess const*>(&_functionCall.expression()))
{
if (dynamic_cast<FunctionDefinition const*>(memberAccess->annotation().referencedDeclaration))
_functionCall.expression().annotation().calledDirectly = true;
}
else if (auto identifier = dynamic_cast<Identifier const*>(&_functionCall.expression()))
if (dynamic_cast<FunctionDefinition const*>(identifier->annotation().referencedDeclaration))
_functionCall.expression().annotation().calledDirectly = true;
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Purity for function calls also depends upon the callee and its FunctionType
funcCallAnno.isPure =
argumentsArePure &&
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
*_functionCall.expression().annotation().isPure &&
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
functionType->isPure();
Fix issue with pop on storage array.
2021-02-03 20:48:45 +00:00
if (functionType->kind() == FunctionType::Kind::ArrayPush)
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
isLValue = functionType->parameterTypes().empty();
Add push() for dynamic storage arrays
2019-09-13 22:54:51 +00:00
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
break;
case Type::Category::TypeType:
{
// Determine type for type conversion or struct construction expressions
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* actualType = dynamic_cast<TypeType const&>(*expressionType).actualType();
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
solAssert(!!actualType, "");
if (actualType->category() == Type::Category::Struct)
{
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
if (actualType->containsNestedMapping())
m_errorReporter.fatalTypeError(
9515_error,
_functionCall.location(),
"Struct containing a (nested) mapping cannot be constructed."
);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
functionType = dynamic_cast<StructType const&>(*actualType).constructorType();
funcCallAnno.kind = FunctionCallKind::StructConstructorCall;
}
else
Disallow conversion to super.
2020-12-01 09:34:45 +00:00
{
if (auto const* contractType = dynamic_cast<ContractType const*>(actualType))
if (contractType->isSuper())
m_errorReporter.fatalTypeError(
1744_error,
_functionCall.location(),
"Cannot convert to the super type."
);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
funcCallAnno.kind = FunctionCallKind::TypeConversion;
Disallow conversion to super.
2020-12-01 09:34:45 +00:00
}
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
funcCallAnno.isPure = argumentsArePure;
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
break;
}
default:
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(5704_error, _functionCall.location(), "Type is not callable");
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
// Unreachable, because fatalTypeError throws. We don't set kind, but that's okay because the switch below
// is never reached. And, even if it was, SetOnce would trigger an assertion violation and not UB.
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
funcCallAnno.isPure = argumentsArePure;
break;
}
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
funcCallAnno.isLValue = isLValue;
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
// Determine return types
Make FunctionCallAnnotation::kind a SetOnce
2020-04-08 17:38:30 +00:00
switch (*funcCallAnno.kind)
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
{
case FunctionCallKind::TypeConversion:
funcCallAnno.type = typeCheckTypeConversionAndRetrieveReturnType(_functionCall);
break;
case FunctionCallKind::StructConstructorCall: // fall-through
case FunctionCallKind::FunctionCall:
{
TypePointers returnTypes;
switch (functionType->kind())
{
case FunctionType::Kind::ABIDecode:
{
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
returnTypes = typeCheckABIDecodeAndRetrieveReturnType(
_functionCall,
Introduce abicoder pragma.
2020-10-22 17:19:14 +00:00
useABICoderV2()
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
);
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
break;
}
case FunctionType::Kind::ABIEncode:
case FunctionType::Kind::ABIEncodePacked:
case FunctionType::Kind::ABIEncodeWithSelector:
case FunctionType::Kind::ABIEncodeWithSignature:
{
typeCheckABIEncodeFunctions(_functionCall, functionType);
returnTypes = functionType->returnParameterTypes();
break;
}
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
case FunctionType::Kind::MetaType:
returnTypes = typeCheckMetaTypeFunctionAndRetrieveReturnType(_functionCall);
break;
Check if all types in bytes.concat are fixed bytes or byte array.
2021-02-23 10:05:07 +00:00
case FunctionType::Kind::BytesConcat:
{
typeCheckBytesConcatFunction(_functionCall, functionType);
returnTypes = functionType->returnParameterTypes();
break;
}
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
default:
{
typeCheckFunctionCall(_functionCall, functionType);
returnTypes = m_evmVersion.supportsReturndata() ?
functionType->returnParameterTypes() :
functionType->returnParameterTypesWithoutDynamicTypes();
break;
}
}
funcCallAnno.type = returnTypes.size() == 1 ?
move(returnTypes.front()) :
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
TypeProvider::tuple(move(returnTypes));
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
break;
}
default:
// for non-callables, ensure error reported and annotate node to void function
solAssert(m_errorReporter.hasErrors(), "");
funcCallAnno.kind = FunctionCallKind::FunctionCall;
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
funcCallAnno.type = TypeProvider::emptyTuple();
Refactor of bool TypeChecker::visit(FunctionCall const& _functionCall). Visit method now cleanly determines if node represents a function call, struct construction or type conversion. Type checking, validation and error message logic is moved to separate methods.
2018-10-18 21:53:59 +00:00
break;
}
Fix abi.decode returning single value.
2018-09-04 14:24:21 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
bool TypeChecker::visit(FunctionCallOptions const& _functionCallOptions)
{
solAssert(_functionCallOptions.options().size() == _functionCallOptions.names().size(), "Lengths of name & value arrays differ!");
Propagate function call argument types across function call options.
2020-07-07 09:30:15 +00:00
_functionCallOptions.expression().annotation().arguments = _functionCallOptions.annotation().arguments;
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.expression().accept(*this);
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_functionCallOptions.annotation().isPure = false;
_functionCallOptions.annotation().isConstant = false;
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
_functionCallOptions.annotation().isLValue = false;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
auto expressionFunctionType = dynamic_cast<FunctionType const*>(type(_functionCallOptions.expression()));
if (!expressionFunctionType)
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(2622_error, _functionCallOptions.location(), "Expected callable expression before call options.");
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
return false;
}
bool setSalt = false;
bool setValue = false;
bool setGas = false;
FunctionType::Kind kind = expressionFunctionType->kind();
if (
kind != FunctionType::Kind::Creation &&
kind != FunctionType::Kind::External &&
kind != FunctionType::Kind::BareCall &&
kind != FunctionType::Kind::BareCallCode &&
kind != FunctionType::Kind::BareDelegateCall &&
kind != FunctionType::Kind::BareStaticCall
)
{
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2193_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Function call options can only be set on external function calls or contract creations."
);
return false;
}
Disallow specifying call options multiple times.
2020-11-02 13:10:37 +00:00
if (
expressionFunctionType->valueSet() ||
expressionFunctionType->gasSet() ||
expressionFunctionType->saltSet()
)
m_errorReporter.typeError(
1645_error,
_functionCallOptions.location(),
"Function call options have already been set, you have to combine them into a single "
"{...}-option."
);
auto setCheckOption = [&](bool& _option, string const& _name)
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
{
Disallow specifying call options multiple times.
2020-11-02 13:10:37 +00:00
if (_option)
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9886_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Duplicate option \"" + std::move(_name) + "\"."
);
_option = true;
};
for (size_t i = 0; i < _functionCallOptions.names().size(); ++i)
{
string const& name = *(_functionCallOptions.names()[i]);
if (name == "salt")
{
if (kind == FunctionType::Kind::Creation)
{
Disallow specifying call options multiple times.
2020-11-02 13:10:37 +00:00
setCheckOption(setSalt, "salt");
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
expectType(*_functionCallOptions.options()[i], *TypeProvider::fixedBytes(32));
}
else
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2721_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Function call option \"salt\" can only be used with \"new\"."
);
}
else if (name == "value")
{
if (kind == FunctionType::Kind::BareDelegateCall)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6189_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Cannot set option \"value\" for delegatecall."
);
else if (kind == FunctionType::Kind::BareStaticCall)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2842_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Cannot set option \"value\" for staticcall."
);
else if (!expressionFunctionType->isPayable())
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7006_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
Deprecated warning for .value() and .gas() on function and constructror calls
2020-03-03 11:15:59 +00:00
kind == FunctionType::Kind::Creation ?
"Cannot set option \"value\", since the constructor of " +
expressionFunctionType->returnParameterTypes().front()->toString() +
" is not payable." :
"Cannot set option \"value\" on a non-payable function type."
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
);
else
{
expectType(*_functionCallOptions.options()[i], *TypeProvider::uint256());
Disallow specifying call options multiple times.
2020-11-02 13:10:37 +00:00
setCheckOption(setValue, "value");
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
}
}
else if (name == "gas")
{
if (kind == FunctionType::Kind::Creation)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9903_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Function call option \"gas\" cannot be used with \"new\"."
);
else
{
expectType(*_functionCallOptions.options()[i], *TypeProvider::uint256());
Disallow specifying call options multiple times.
2020-11-02 13:10:37 +00:00
setCheckOption(setGas, "gas");
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
}
}
else
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9318_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Unknown call option \"" + name + "\". Valid options are \"salt\", \"value\" and \"gas\"."
);
}
if (setSalt && !m_evmVersion.hasCreate2())
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5189_error,
Implement new with CREATE2 and function call options.
2020-01-22 14:42:50 +00:00
_functionCallOptions.location(),
"Unsupported call option \"salt\" (requires Constantinople-compatible VMs)."
);
_functionCallOptions.annotation().type = expressionFunctionType->copyAndSetCallOptions(setGas, setValue, setSalt);
return false;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
void TypeChecker::endVisit(NewExpression const& _newExpression)
{
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* type = _newExpression.typeName().annotation().type;
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
solAssert(!!type, "Type name not resolved.");
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_newExpression.annotation().isConstant = false;
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
_newExpression.annotation().isLValue = false;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
if (auto contractName = dynamic_cast<UserDefinedTypeName const*>(&_newExpression.typeName()))
{
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
auto contract = dynamic_cast<ContractDefinition const*>(&dereference(contractName->pathNode()));
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
if (!contract)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(5540_error, _newExpression.location(), "Identifier is not a contract.");
Add ContractDefinition::isInterface.
2019-01-17 11:59:11 +00:00
if (contract->isInterface())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(2971_error, _newExpression.location(), "Cannot instantiate an interface.");
Some changes to "abstract".
2019-11-04 13:12:58 +00:00
if (contract->abstract())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4614_error, _newExpression.location(), "Cannot instantiate an abstract contract.");
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
Change function type to include and propagate payable and constant modifier.
2016-08-31 18:43:24 +00:00
_newExpression.annotation().type = FunctionType::newExpressionType(*contract);
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_newExpression.annotation().isPure = false;
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
}
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
else if (type->category() == Type::Category::Array)
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
{
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
if (type->containsNestedMapping())
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1164_error,
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
_newExpression.typeName().location(),
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
"Array containing a (nested) mapping cannot be constructed in memory."
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
);
if (!type->isDynamicallySized())
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
3904_error,
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
_newExpression.typeName().location(),
"Length has to be placed in parentheses after the array type for new expression."
);
[libsolidity] remove ReferenceType::copyForLocationIfReference (use TypeProvider instead)
2019-04-17 11:25:03 +00:00
type = TypeProvider::withLocationIfReference(DataLocation::Memory, type);
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
_newExpression.annotation().type = TypeProvider::function(
[libsolidity] TypeProvider: adds explicit uint256() accessor and removes default params in integerType(...).
2019-04-15 16:10:43 +00:00
TypePointers{TypeProvider::uint256()},
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
TypePointers{type},
Ensure function parameter names always matches parameter types length
2019-02-07 14:53:11 +00:00
strings(1, ""),
strings(1, ""),
Mark all built in functions with appropriate statemutability
2017-08-28 12:35:28 +00:00
FunctionType::Kind::ObjectCreation,
false,
StateMutability::Pure
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
);
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
_newExpression.annotation().isPure = true;
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
}
else
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
{
_newExpression.annotation().isPure = false;
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(8807_error, _newExpression.location(), "Contract or array type expected.");
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
bool TypeChecker::visit(MemberAccess const& _memberAccess)
{
_memberAccess.expression().accept(*this);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* exprType = type(_memberAccess.expression());
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
ASTString const& memberName = _memberAccess.memberName();
Add annotation field ``requiresVirtualLookup``
2020-09-16 09:00:07 +00:00
auto& annotation = _memberAccess.annotation();
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
// Retrieve the types of the arguments if this is used to call a function.
Add annotation field ``requiresVirtualLookup``
2020-09-16 09:00:07 +00:00
auto const& arguments = annotation.arguments;
Free functions.
2020-05-04 16:38:00 +00:00
MemberList::MemberMap possibleMembers = exprType->members(currentDefinitionScope()).membersByName(memberName);
Improve error message for failed member lookup.
2018-04-18 18:40:46 +00:00
size_t const initialMemberCount = possibleMembers.size();
Fix function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
if (initialMemberCount > 1 && arguments)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
// do overload resolution
for (auto it = possibleMembers.begin(); it != possibleMembers.end();)
if (
it->type->category() == Type::Category::Function &&
Fix function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
!dynamic_cast<FunctionType const&>(*it->type).canTakeArguments(*arguments, exprType)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
)
it = possibleMembers.erase(it);
else
++it;
}
Add suggestion to error message
2018-07-17 12:31:21 +00:00
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
annotation.isConstant = false;
Use empty() instead of size() == 0
2018-10-09 03:29:37 +00:00
if (possibleMembers.empty())
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
Fix ICE by avoiding copyForLocation() on ArraySliceType
2020-05-26 15:23:49 +00:00
if (initialMemberCount == 0 && !dynamic_cast<ArraySliceType const*>(exprType))
Improve error message for failed member lookup.
2018-04-18 18:40:46 +00:00
{
// Try to see if the member was removed because it is only available for storage types.
[libsolidity] remove ReferenceType::copyForLocationIfReference (use TypeProvider instead)
2019-04-17 11:25:03 +00:00
auto storageType = TypeProvider::withLocationIfReference(
Improve error message for failed member lookup.
2018-04-18 18:40:46 +00:00
DataLocation::Storage,
exprType
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
Free functions.
2020-05-04 16:38:00 +00:00
if (!storageType->members(currentDefinitionScope()).membersByName(memberName).empty())
Improve error message for failed member lookup.
2018-04-18 18:40:46 +00:00
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4994_error,
Improve error message for failed member lookup.
2018-04-18 18:40:46 +00:00
_memberAccess.location(),
"Member \"" + memberName + "\" is not available in " +
exprType->toString() +
" outside of storage."
);
}
Make sure "value" error hint is only displayed in the right context Before, the hint would be shown for any "value" member, even a user-specified one.
2019-02-12 15:09:16 +00:00
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
string errorMsg = "Member \"" + memberName + "\" not found or not visible "
"after argument-dependent lookup in " + exprType->toString() + ".";
Make sure "value" error hint is only displayed in the right context Before, the hint would be shown for any "value" member, even a user-specified one.
2019-02-12 15:09:16 +00:00
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
if (auto const* funType = dynamic_cast<FunctionType const*>(exprType))
Make sure "value" error hint is only displayed in the right context Before, the hint would be shown for any "value" member, even a user-specified one.
2019-02-12 15:09:16 +00:00
{
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
TypePointers const& t = funType->returnParameterTypes();
if (memberName == "value")
{
if (funType->kind() == FunctionType::Kind::Creation)
return {
8827_error,
"Constructor for " + t.front()->toString() + " must be payable for member \"value\" to be available."
};
else if (
funType->kind() == FunctionType::Kind::DelegateCall ||
funType->kind() == FunctionType::Kind::BareDelegateCall
)
return { 8477_error, "Member \"value\" is not allowed in delegated calls due to \"msg.value\" persisting." };
else
return { 8820_error, "Member \"value\" is only available for payable functions." };
}
Improve error message for delegatecall.value
2019-06-06 08:36:41 +00:00
else if (
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
t.size() == 1 && (
t.front()->category() == Type::Category::Struct ||
t.front()->category() == Type::Category::Contract
)
Improve error message for delegatecall.value
2019-06-06 08:36:41 +00:00
)
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
return { 6005_error, errorMsg + " Did you intend to call the function?" };
Make sure "value" error hint is only displayed in the right context Before, the hint would be shown for any "value" member, even a user-specified one.
2019-02-12 15:09:16 +00:00
}
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
else if (exprType->category() == Type::Category::Contract)
Fix error msg hint for non-payable contracts
2019-02-12 15:56:22 +00:00
{
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
for (MemberList::Member const& addressMember: TypeProvider::payableAddress()->nativeMembers(nullptr))
if (addressMember.name == memberName)
{
auto const* var = dynamic_cast<Identifier const*>(&_memberAccess.expression());
string varName = var ? var->name() : "...";
errorMsg += " Use \"address(" + varName + ")." + memberName + "\" to access this address member.";
Fixed seed for randomness, fixed conflicts in errorids
2020-05-26 12:37:31 +00:00
return { 3125_error, errorMsg };
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
}
}
else if (auto const* addressType = dynamic_cast<AddressType const*>(exprType))
{
// Trigger error when using send or transfer with a non-payable fallback function.
if (memberName == "send" || memberName == "transfer")
{
solAssert(
addressType->stateMutability() != StateMutability::Payable,
"Expected address not-payable as members were not found"
);
Fix error msg hint for non-payable contracts
2019-02-12 15:56:22 +00:00
Fixed seed for randomness, fixed conflicts in errorids
2020-05-26 12:37:31 +00:00
return { 9862_error, "\"send\" and \"transfer\" are only available for objects of type \"address payable\", not \"" + exprType->toString() + "\"." };
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
}
Fix error msg hint for non-payable contracts
2019-02-12 15:56:22 +00:00
}
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
Fixed seed for randomness, fixed conflicts in errorids
2020-05-26 12:37:31 +00:00
return { 9582_error, errorMsg };
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
}();
Fix error msg hint for non-payable contracts
2019-02-12 15:56:22 +00:00
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.fatalTypeError(
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
errorId,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_memberAccess.location(),
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
description
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
}
else if (possibleMembers.size() > 1)
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6675_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_memberAccess.location(),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
"Member \"" + memberName + "\" not unique "
Merged in changes from chriseth/payable
2016-08-26 18:37:10 +00:00
"after argument-dependent lookup in " + exprType->toString() +
Add missing period in the end of error messages
2018-07-16 15:11:39 +00:00
(memberName == "value" ? " - did you forget the \"payable\" modifier?" : ".")
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
annotation.referencedDeclaration = possibleMembers.front().declaration;
annotation.type = possibleMembers.front().type;
Also check the object type for bound functions.
2015-11-27 21:24:00 +00:00
Add annotation field ``requiresVirtualLookup``
2020-09-16 09:00:07 +00:00
VirtualLookup requiredLookup = VirtualLookup::Static;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto funType = dynamic_cast<FunctionType const*>(annotation.type))
Deprecated warning for .value() and .gas() on function and constructror calls
2020-03-03 11:15:59 +00:00
{
Turn unreachable error into assert The exact conditions are already checked when iterating over the possibleMembers where the function `canTakeArguments()` is called for each member. The function does the identical check.
2019-02-12 10:41:05 +00:00
solAssert(
!funType->bound() || exprType->isImplicitlyConvertibleTo(*funType->selfType()),
"Function \"" + memberName + "\" cannot be called on an object of type " +
exprType->toString() + " (expected " + funType->selfType()->toString() + ")."
);
Also check the object type for bound functions.
2015-11-27 21:24:00 +00:00
Deprecated warning for .value() and .gas() on function and constructror calls
2020-03-03 11:15:59 +00:00
if (
dynamic_cast<FunctionType const*>(exprType) &&
!annotation.referencedDeclaration &&
(memberName == "value" || memberName == "gas")
)
Converted warnings for .gas and .value into an error
2020-04-03 11:43:33 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1621_error,
Deprecated warning for .value() and .gas() on function and constructror calls
2020-03-03 11:15:59 +00:00
_memberAccess.location(),
"Using \"." + memberName + "(...)\" is deprecated. Use \"{" + memberName + ": ...}\" instead."
);
Add annotation field ``requiresVirtualLookup``
2020-09-16 09:00:07 +00:00
Fix ICE caused by an array of mappings
2020-09-27 19:35:41 +00:00
if (
funType->kind() == FunctionType::Kind::ArrayPush &&
arguments.value().numArguments() != 0 &&
exprType->containsNestedMapping()
)
m_errorReporter.typeError(
8871_error,
_memberAccess.location(),
"Storage arrays with nested mappings do not support .push(<arg>)."
);
Add annotation field ``requiresVirtualLookup``
2020-09-16 09:00:07 +00:00
if (!funType->bound())
Change type of super to TypeType
2020-10-14 09:17:53 +00:00
if (auto typeType = dynamic_cast<TypeType const*>(exprType))
{
auto contractType = dynamic_cast<ContractType const*>(typeType->actualType());
if (contractType && contractType->isSuper())
Fix incorrectly set annotation.requiredLookup
2020-10-30 14:40:06 +00:00
requiredLookup = VirtualLookup::Super;
Change type of super to TypeType
2020-10-14 09:17:53 +00:00
}
Deprecated warning for .value() and .gas() on function and constructror calls
2020-03-03 11:15:59 +00:00
}
Add annotation field ``requiresVirtualLookup``
2020-09-16 09:00:07 +00:00
annotation.requiredLookup = requiredLookup;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto const* structType = dynamic_cast<StructType const*>(exprType))
ABIEncoderV2: Implement calldata structs without dynamically encoded members.
2019-02-05 19:29:57 +00:00
annotation.isLValue = !structType->dataStoredIn(DataLocation::CallData);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else if (exprType->category() == Type::Category::Array)
Makes array length access read-only.
2019-09-18 12:58:20 +00:00
annotation.isLValue = false;
Index access for bytesXX.
2016-02-03 20:34:24 +00:00
else if (exprType->category() == Type::Category::FixedBytes)
annotation.isLValue = false;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
else if (TypeType const* typeType = dynamic_cast<decltype(typeType)>(exprType))
analysis: determine if a member access on a contract is an l-value
2016-10-24 17:22:09 +00:00
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (ContractType const* contractType = dynamic_cast<decltype(contractType)>(typeType->actualType()))
Mark function selector accesses as pure for pure expressions and mark function accesses via contract name as pure.
2020-02-07 11:44:52 +00:00
{
analysis: determine if a member access on a contract is an l-value
2016-10-24 17:22:09 +00:00
annotation.isLValue = annotation.referencedDeclaration->isLValue();
Mark function selector accesses as pure for pure expressions and mark function accesses via contract name as pure.
2020-02-07 11:44:52 +00:00
if (
auto const* functionType = dynamic_cast<FunctionType const*>(annotation.type);
functionType &&
functionType->kind() == FunctionType::Kind::Declaration
)
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
annotation.isPure = *_memberAccess.expression().annotation().isPure;
Mark function selector accesses as pure for pure expressions and mark function accesses via contract name as pure.
2020-02-07 11:44:52 +00:00
}
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
else
annotation.isLValue = false;
analysis: determine if a member access on a contract is an l-value
2016-10-24 17:22:09 +00:00
}
Modules are pure.
2020-06-16 14:49:31 +00:00
else if (exprType->category() == Type::Category::Module)
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
{
annotation.isPure = *_memberAccess.expression().annotation().isPure;
annotation.isLValue = false;
}
else
annotation.isLValue = false;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
// TODO some members might be pure, but for example `address(0x123).balance` is not pure
Allow enum values for constants.
2017-03-01 18:49:15 +00:00
// although every subexpression is, so leaving this limited for now.
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto tt = dynamic_cast<TypeType const*>(exprType))
Allow enum values for constants.
2017-03-01 18:49:15 +00:00
if (tt->actualType()->category() == Type::Category::Enum)
annotation.isPure = true;
Mark function selector accesses as pure for pure expressions and mark function accesses via contract name as pure.
2020-02-07 11:44:52 +00:00
if (
auto const* functionType = dynamic_cast<FunctionType const*>(exprType);
functionType &&
functionType->hasDeclaration() &&
dynamic_cast<FunctionDefinition const*>(&functionType->declaration()) &&
memberName == "selector"
)
if (auto const* parentAccess = dynamic_cast<MemberAccess const*>(&_memberAccess.expression()))
{
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
bool isPure = *parentAccess->expression().annotation().isPure;
Mark function selector accesses as pure for pure expressions and mark function accesses via contract name as pure.
2020-02-07 11:44:52 +00:00
if (auto const* exprInt = dynamic_cast<Identifier const*>(&parentAccess->expression()))
if (exprInt->name() == "this" || exprInt->name() == "super")
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
isPure = true;
annotation.isPure = isPure;
Mark function selector accesses as pure for pure expressions and mark function accesses via contract name as pure.
2020-02-07 11:44:52 +00:00
}
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto magicType = dynamic_cast<MagicType const*>(exprType))
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
{
ABI encoding functions are pure and should be usable in constants.
2018-05-15 11:04:49 +00:00
if (magicType->kind() == MagicType::Kind::ABI)
annotation.isPure = true;
Add code access dependency.
2019-01-14 23:14:10 +00:00
else if (magicType->kind() == MagicType::Kind::MetaType && (
memberName == "creationCode" || memberName == "runtimeCode"
))
{
annotation.isPure = true;
trigger error when runtimeCode is called on contracts with immutables
2020-05-06 16:26:54 +00:00
ContractType const& accessedContractType = dynamic_cast<ContractType const&>(*magicType->typeArgument());
Disallow meta type on super.
2020-12-01 09:24:50 +00:00
solAssert(!accessedContractType.isSuper(), "");
trigger error when runtimeCode is called on contracts with immutables
2020-05-06 16:26:54 +00:00
if (
memberName == "runtimeCode" &&
!accessedContractType.immutableVariables().empty()
)
m_errorReporter.typeError(
9274_error,
_memberAccess.location(),
"\"runtimeCode\" is not available for contracts containing immutable variables."
);
Add code access dependency.
2019-01-14 23:14:10 +00:00
}
Provide access to the name of contracts.
2019-01-22 16:15:55 +00:00
else if (magicType->kind() == MagicType::Kind::MetaType && memberName == "name")
annotation.isPure = true;
Add support for interfaceID.
2020-04-08 22:08:49 +00:00
else if (magicType->kind() == MagicType::Kind::MetaType && memberName == "interfaceId")
annotation.isPure = true;
implemented type(X).min and type(X).max for all integer types
2020-05-07 16:24:37 +00:00
else if (
magicType->kind() == MagicType::Kind::MetaType &&
(memberName == "min" || memberName == "max")
)
annotation.isPure = true;
Introduce block.chainid
2020-09-22 17:12:01 +00:00
else if (magicType->kind() == MagicType::Kind::Block && memberName == "chainid" && !m_evmVersion.hasChainID())
m_errorReporter.typeError(
3081_error,
_memberAccess.location(),
"\"chainid\" is not supported by the VM version."
);
Implemented `block.basefee` in Solidilty and `basefee()` in Yul. Also added basefee to Yul grammar.
2021-07-12 14:49:05 +00:00
else if (magicType->kind() == MagicType::Kind::Block && memberName == "basefee" && !m_evmVersion.hasBaseFee())
m_errorReporter.typeError(
5921_error,
_memberAccess.location(),
"\"basefee\" is not supported by the VM version."
);
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
}
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
Support address().codehash
2020-09-24 17:45:40 +00:00
if (
_memberAccess.expression().annotation().type->category() == Type::Category::Address &&
memberName == "codehash" &&
!m_evmVersion.hasExtCodeHash()
)
m_errorReporter.typeError(
7598_error,
_memberAccess.location(),
"\"codehash\" is not supported by the VM version."
);
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (!annotation.isPure.set())
annotation.isPure = false;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
bool TypeChecker::visit(IndexAccess const& _access)
{
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_access.annotation().isConstant = false;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
_access.baseExpression().accept(*this);
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* baseType = type(_access.baseExpression());
Type const* resultType = nullptr;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
bool isLValue = false;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
bool isPure = *_access.baseExpression().annotation().isPure;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
Expression const* index = _access.indexExpression();
switch (baseType->category())
{
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
case Type::Category::ArraySlice:
{
auto const& arrayType = dynamic_cast<ArraySliceType const&>(*baseType).arrayType();
if (arrayType.location() != DataLocation::CallData || !arrayType.isDynamicallySized())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4802_error, _access.location(), "Index access is only implemented for slices of dynamic calldata arrays.");
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
baseType = &arrayType;
[[fallthrough]];
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
case Type::Category::Array:
{
ArrayType const& actualType = dynamic_cast<ArrayType const&>(*baseType);
if (!index)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9689_error, _access.location(), "Index expression cannot be omitted.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else if (actualType.isString())
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9961_error, _access.location(), "Index access for string is not possible.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
index->accept(*this);
}
else
{
[libsolidity] TypeProvider: adds explicit uint256() accessor and removes default params in integerType(...).
2019-04-15 16:10:43 +00:00
expectType(*index, *TypeProvider::uint256());
Fix #4716: Crash when array index value is too large
2018-08-30 03:08:49 +00:00
if (!m_errorReporter.hasErrors())
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto numberType = dynamic_cast<RationalNumberType const*>(type(*index)))
Fix #4716: Crash when array index value is too large
2018-08-30 03:08:49 +00:00
{
solAssert(!numberType->isFractional(), "");
Simplify interface of RationalNumber.
2016-05-10 12:30:24 +00:00
if (!actualType.isDynamicallySized() && actualType.length() <= numberType->literalValue(nullptr))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3383_error, _access.location(), "Out of bounds array access.");
Fix #4716: Crash when array index value is too large
2018-08-30 03:08:49 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
resultType = actualType.baseType();
isLValue = actualType.location() != DataLocation::CallData;
break;
}
case Type::Category::Mapping:
{
MappingType const& actualType = dynamic_cast<MappingType const&>(*baseType);
if (!index)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1267_error, _access.location(), "Index expression cannot be omitted.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
expectType(*index, *actualType.keyType());
resultType = actualType.valueType();
isLValue = true;
break;
}
case Type::Category::TypeType:
{
TypeType const& typeType = dynamic_cast<TypeType const&>(*baseType);
Allow arrays of contract types as type expressions e.g. for abi.decode.
2020-10-15 18:00:22 +00:00
if (auto const* contractType = dynamic_cast<ContractType const*>(typeType.actualType()))
if (contractType->contractDefinition().isLibrary())
m_errorReporter.typeError(2876_error, _access.location(), "Index access for library types and arrays of libraries are not possible.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!index)
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
resultType = TypeProvider::typeType(TypeProvider::array(DataLocation::Memory, typeType.actualType()));
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
{
Fix crash for too large struct array indicies
2019-02-05 12:32:01 +00:00
u256 length = 1;
[libsolidity] TypeProvider: adds explicit uint256() accessor and removes default params in integerType(...).
2019-04-15 16:10:43 +00:00
if (expectType(*index, *TypeProvider::uint256()))
Fix crash for too large struct array indicies
2019-02-05 12:32:01 +00:00
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto indexValue = dynamic_cast<RationalNumberType const*>(type(*index)))
Fix crash for too large struct array indicies
2019-02-05 12:32:01 +00:00
length = indexValue->literalValue(nullptr);
else
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(3940_error, index->location(), "Integer constant expected.");
Fix crash for too large struct array indicies
2019-02-05 12:32:01 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
Fix crash for too large struct array indicies
2019-02-05 12:32:01 +00:00
solAssert(m_errorReporter.hasErrors(), "Expected errors as expectType returned false");
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
resultType = TypeProvider::typeType(TypeProvider::array(
Fix crash for too large struct array indicies
2019-02-05 12:32:01 +00:00
DataLocation::Memory,
typeType.actualType(),
length
));
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
break;
}
Index access for bytesXX.
2016-02-03 20:34:24 +00:00
case Type::Category::FixedBytes:
{
FixedBytesType const& bytesType = dynamic_cast<FixedBytesType const&>(*baseType);
if (!index)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(8830_error, _access.location(), "Index expression cannot be omitted.");
Index access for bytesXX.
2016-02-03 20:34:24 +00:00
else
{
[libsolidity] TypeProvider: adds explicit uint256() accessor and removes default params in integerType(...).
2019-04-15 16:10:43 +00:00
if (!expectType(*index, *TypeProvider::uint256()))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(6318_error, _access.location(), "Index expression cannot be represented as an unsigned integer.");
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto integerType = dynamic_cast<RationalNumberType const*>(type(*index)))
Index access for bytesXX.
2016-02-03 20:34:24 +00:00
if (bytesType.numBytes() <= integerType->literalValue(nullptr))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1859_error, _access.location(), "Out of bounds array access.");
Index access for bytesXX.
2016-02-03 20:34:24 +00:00
}
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
resultType = TypeProvider::fixedBytes(1);
Index access for bytesXX.
2016-02-03 20:34:24 +00:00
isLValue = false; // @todo this heavily depends on how it is embedded
break;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
default:
Refactor error reporting This commit introduces ErrorReporter, a utility class which consolidates all of the error logging functionality into a common set of functions. It also replaces all direct interactions with an ErrorList with calls to an ErrorReporter. This commit resolves issue #2209
2017-05-11 13:26:35 +00:00
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2614_error,
passed SourceLocations instead of nodes to the error reporting function
2015-11-04 10:49:26 +00:00
_access.baseExpression().location(),
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
"Indexed expression has to be a type, mapping or array (is " + baseType->toString() + ")"
);
}
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
_access.annotation().type = resultType;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
_access.annotation().isLValue = isLValue;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (index && !*index->annotation().isPure)
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
isPure = false;
_access.annotation().isPure = isPure;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
bool TypeChecker::visit(IndexRangeAccess const& _access)
{
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_access.annotation().isConstant = false;
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
_access.baseExpression().accept(*this);
bool isLValue = false; // TODO: set this correctly when implementing slices for memory and storage arrays
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
bool isPure = *_access.baseExpression().annotation().isPure;
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
if (Expression const* start = _access.startExpression())
{
expectType(*start, *TypeProvider::uint256());
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (!*start->annotation().isPure)
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
isPure = false;
}
if (Expression const* end = _access.endExpression())
{
expectType(*end, *TypeProvider::uint256());
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (!*end->annotation().isPure)
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
isPure = false;
}
Fix missing annotation settings because of early return
2020-09-28 10:12:00 +00:00
_access.annotation().isLValue = isLValue;
_access.annotation().isPure = isPure;
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
Type const* exprType = type(_access.baseExpression());
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
if (exprType->category() == Type::Category::TypeType)
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1760_error, _access.location(), "Types cannot be sliced.");
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
_access.annotation().type = exprType;
return false;
}
ArrayType const* arrayType = nullptr;
if (auto const* arraySlice = dynamic_cast<ArraySliceType const*>(exprType))
arrayType = &arraySlice->arrayType();
else if (!(arrayType = dynamic_cast<ArrayType const*>(exprType)))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(4781_error, _access.location(), "Index range access is only possible for arrays and array slices.");
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
if (arrayType->location() != DataLocation::CallData || !arrayType->isDynamicallySized())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1227_error, _access.location(), "Index range access is only supported for dynamic calldata arrays.");
Disallow array slicing for arrays with dyanmically encoded base types.
2020-05-13 09:00:47 +00:00
else if (arrayType->baseType()->isDynamicallyEncoded())
Fixed seed for randomness, fixed conflicts in errorids
2020-05-26 12:37:31 +00:00
m_errorReporter.typeError(2148_error, _access.location(), "Index range access is not supported for arrays with dynamically encoded base types.");
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
_access.annotation().type = TypeProvider::arraySlice(*arrayType);
return false;
}
Extract typing.
2020-04-07 17:31:48 +00:00
vector<Declaration const*> TypeChecker::cleanOverloadedDeclarations(
Identifier const& _identifier,
vector<Declaration const*> const& _candidates
)
{
solAssert(_candidates.size() > 1, "");
vector<Declaration const*> uniqueDeclarations;
for (Declaration const* declaration: _candidates)
{
solAssert(declaration, "");
// the declaration is functionDefinition, eventDefinition or a VariableDeclaration while declarations > 1
solAssert(
dynamic_cast<FunctionDefinition const*>(declaration) ||
dynamic_cast<EventDefinition const*>(declaration) ||
dynamic_cast<VariableDeclaration const*>(declaration) ||
dynamic_cast<MagicVariableDeclaration const*>(declaration),
"Found overloading involving something not a function, event or a (magic) variable."
);
FunctionTypePointer functionType {declaration->functionType(false)};
if (!functionType)
functionType = declaration->functionType(true);
solAssert(functionType, "Failed to determine the function type of the overloaded.");
Replace `TypePointer` with `Type const*`
2021-03-22 16:12:05 +00:00
for (Type const* parameter: functionType->parameterTypes() + functionType->returnParameterTypes())
Extract typing.
2020-04-07 17:31:48 +00:00
if (!parameter)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalDeclarationError(3893_error, _identifier.location(), "Function type can not be used in this context.");
Extract typing.
2020-04-07 17:31:48 +00:00
if (uniqueDeclarations.end() == find_if(
uniqueDeclarations.begin(),
uniqueDeclarations.end(),
[&](Declaration const* d)
{
FunctionType const* newFunctionType = d->functionType(false);
if (!newFunctionType)
newFunctionType = d->functionType(true);
return newFunctionType && functionType->hasEqualParameterTypes(*newFunctionType);
}
))
uniqueDeclarations.push_back(declaration);
}
return uniqueDeclarations;
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
bool TypeChecker::visit(Identifier const& _identifier)
{
Refactored annotations.
2015-09-21 16:55:58 +00:00
IdentifierAnnotation& annotation = _identifier.annotation();
Add missing annotation assignments
2020-10-05 10:21:30 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!annotation.referencedDeclaration)
{
Extract typing.
2020-04-07 17:31:48 +00:00
annotation.overloadedDeclarations = cleanOverloadedDeclarations(_identifier, annotation.candidateDeclarations);
Fix failure to find overload resolution when overrides are involved
2020-05-27 16:22:04 +00:00
if (annotation.overloadedDeclarations.empty())
m_errorReporter.fatalTypeError(7593_error, _identifier.location(), "No candidates for overload resolution found.");
else if (annotation.overloadedDeclarations.size() == 1)
annotation.referencedDeclaration = *annotation.overloadedDeclarations.begin();
else if (!annotation.arguments)
analysis: changes necessary to compile std/StandardToken.sol
2016-12-02 15:24:53 +00:00
{
// The identifier should be a public state variable shadowing other functions
vector<Declaration const*> candidates;
for (Declaration const* declaration: annotation.overloadedDeclarations)
{
if (VariableDeclaration const* variableDeclaration = dynamic_cast<decltype(variableDeclaration)>(declaration))
candidates.push_back(declaration);
}
if (candidates.empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(2144_error, _identifier.location(), "No matching declaration found after variable lookup.");
analysis: changes necessary to compile std/StandardToken.sol
2016-12-02 15:24:53 +00:00
else if (candidates.size() == 1)
annotation.referencedDeclaration = candidates.front();
else
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(7589_error, _identifier.location(), "No unique declaration found after variable lookup.");
analysis: changes necessary to compile std/StandardToken.sol
2016-12-02 15:24:53 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else
{
vector<Declaration const*> candidates;
for (Declaration const* declaration: annotation.overloadedDeclarations)
{
Allow function overloads involving MagicVariableDeclarations.
2017-12-30 12:46:53 +00:00
FunctionTypePointer functionType = declaration->functionType(true);
solAssert(!!functionType, "Requested type not present.");
Fix function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
if (functionType->canTakeArguments(*annotation.arguments))
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
candidates.push_back(declaration);
}
List candidates when overload failed fixes #7146
2019-11-13 13:24:48 +00:00
if (candidates.size() == 1)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
annotation.referencedDeclaration = candidates.front();
else
List candidates when overload failed fixes #7146
2019-11-13 13:24:48 +00:00
{
SecondarySourceLocation ssl;
for (Declaration const* declaration: annotation.overloadedDeclarations)
Replaced SourceLocation::isEmpty() with isValid() and hasText(). The function SourceLocation::isEmpty() had somewhat dual role. Sometimes it indicates that the SourceLocation is invalid. Sometimes it means that there is no corresponding source text. Hence the proposal is to replace it with two functions, isValid() and hasText(). I also removed Scanner::sourceAt(). (Do we have a rule of thumb to remove unused code?) Since hasText() checks that start and end are valid indices for source, I adjusted a couple of tests to avoid empty source strings.
2020-02-03 07:04:21 +00:00
if (!declaration->location().isValid())
Reconstruct function definition for magic variables in overload error message.
2019-11-13 17:06:50 +00:00
{
// Try to re-construct function definition
string description;
for (auto const& param: declaration->functionType(true)->parameterTypes())
description += (description.empty() ? "" : ", ") + param->toString(false);
description = "function " + _identifier.name() + "(" + description + ")";
ssl.append("Candidate: " + description, declaration->location());
}
else
ssl.append("Candidate:", declaration->location());
List candidates when overload failed fixes #7146
2019-11-13 13:24:48 +00:00
if (candidates.empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(9322_error, _identifier.location(), ssl, "No matching declaration found after argument-dependent lookup.");
List candidates when overload failed fixes #7146
2019-11-13 13:24:48 +00:00
else
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(4487_error, _identifier.location(), ssl, "No unique declaration found after argument-dependent lookup.");
List candidates when overload failed fixes #7146
2019-11-13 13:24:48 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
}
solAssert(
!!annotation.referencedDeclaration,
"Referenced declaration is null after overload resolution."
);
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
bool isConstant = false;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
annotation.isLValue = annotation.referencedDeclaration->isLValue();
Make members context-sensitive.
2015-11-19 17:02:04 +00:00
annotation.type = annotation.referencedDeclaration->type();
Clean up visibility via contract name and fix ICE on calling unimplemented base function.
2020-01-14 13:00:51 +00:00
solAssert(annotation.type, "Declaration referenced before type could be determined.");
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
if (auto variableDeclaration = dynamic_cast<VariableDeclaration const*>(annotation.referencedDeclaration))
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
annotation.isPure = isConstant = variableDeclaration->isConstant();
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
else if (dynamic_cast<MagicVariableDeclaration const*>(annotation.referencedDeclaration))
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
annotation.isPure = dynamic_cast<FunctionType const*>(annotation.type);
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
else if (dynamic_cast<TypeType const*>(annotation.type))
Detect custom type expressions that have no effect
2019-02-18 17:19:55 +00:00
annotation.isPure = true;
Modules are pure.
2020-06-16 14:49:31 +00:00
else if (dynamic_cast<ModuleType const*>(annotation.type))
annotation.isPure = true;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
else
annotation.isPure = false;
annotation.isConstant = isConstant;
Report deprecation error on functions sha3 and suicide also without call.
2018-11-29 09:05:52 +00:00
Add annotation field ``requiresVirtualLookup``
2020-09-16 09:00:07 +00:00
annotation.requiredLookup =
dynamic_cast<CallableDeclaration const*>(annotation.referencedDeclaration) ?
VirtualLookup::Virtual : VirtualLookup::Static;
Report deprecation error on functions sha3 and suicide also without call.
2018-11-29 09:05:52 +00:00
// Check for deprecated function names.
// The check is done here for the case without an actual function call.
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (FunctionType const* fType = dynamic_cast<FunctionType const*>(_identifier.annotation().type))
Report deprecation error on functions sha3 and suicide also without call.
2018-11-29 09:05:52 +00:00
{
if (_identifier.name() == "sha3" && fType->kind() == FunctionType::Kind::KECCAK256)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
3557_error,
Report deprecation error on functions sha3 and suicide also without call.
2018-11-29 09:05:52 +00:00
_identifier.location(),
Add missing dots in deprecation warning
2019-10-21 11:17:12 +00:00
"\"sha3\" has been deprecated in favour of \"keccak256\"."
Report deprecation error on functions sha3 and suicide also without call.
2018-11-29 09:05:52 +00:00
);
else if (_identifier.name() == "suicide" && fType->kind() == FunctionType::Kind::Selfdestruct)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
8050_error,
Report deprecation error on functions sha3 and suicide also without call.
2018-11-29 09:05:52 +00:00
_identifier.location(),
Add missing dots in deprecation warning
2019-10-21 11:17:12 +00:00
"\"suicide\" has been deprecated in favour of \"selfdestruct\"."
Report deprecation error on functions sha3 and suicide also without call.
2018-11-29 09:05:52 +00:00
);
}
Deprecated identifier now
2020-05-05 08:56:18 +00:00
if (
MagicVariableDeclaration const* magicVar =
dynamic_cast<MagicVariableDeclaration const*>(annotation.referencedDeclaration)
)
if (magicVar->type()->category() == Type::Category::Integer)
{
solAssert(_identifier.name() == "now", "");
Fixing tests on breaking branch.
2020-05-19 13:12:56 +00:00
m_errorReporter.typeError(
7359_error,
_identifier.location(),
"\"now\" has been deprecated. Use \"block.timestamp\" instead."
);
Deprecated identifier now
2020-05-05 08:56:18 +00:00
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
void TypeChecker::endVisit(IdentifierPath const& _identifierPath)
{
if (
dynamic_cast<CallableDeclaration const*>(_identifierPath.annotation().referencedDeclaration) &&
_identifierPath.path().size() == 1
)
_identifierPath.annotation().requiredLookup = VirtualLookup::Virtual;
else
_identifierPath.annotation().requiredLookup = VirtualLookup::Static;
}
void TypeChecker::endVisit(UserDefinedTypeName const& _userDefinedTypeName)
{
if (!_userDefinedTypeName.annotation().type)
_userDefinedTypeName.annotation().type = _userDefinedTypeName.pathNode().annotation().referencedDeclaration->type();
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
void TypeChecker::endVisit(ElementaryTypeNameExpression const& _expr)
{
Allow explicit conversion from address to address payable
2019-09-04 15:45:12 +00:00
_expr.annotation().type = TypeProvider::typeType(TypeProvider::fromElementaryTypeName(_expr.type().typeName(), _expr.type().stateMutability()));
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
_expr.annotation().isPure = true;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_expr.annotation().isLValue = false;
_expr.annotation().isConstant = false;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
void TypeChecker::endVisit(Literal const& _literal)
{
Warn about invalid checksums of addresses.
2017-01-24 16:38:06 +00:00
if (_literal.looksLikeAddress())
{
Enforce error on hex number combined with unit denomination
2018-07-05 13:48:57 +00:00
// Assign type here if it even looks like an address. This prevents double errors for invalid addresses
Disallow conversions from literals to payable address To get a payable address, one has to go through address. For example, `payable(address(0))`.
2020-12-03 21:36:56 +00:00
_literal.annotation().type = TypeProvider::address();
Change invalid (not exactly 160 bits long) address literal to error
2018-02-16 04:24:32 +00:00
Keep the 'if it not used as an address' helper message for all cases of address related warnings
2018-06-25 14:25:21 +00:00
string msg;
Fixes #5051 (introduced in #4684), effectively allowing underscores in address literals.
2018-10-01 12:36:57 +00:00
if (_literal.valueWithoutUnderscores().length() != 42) // "0x" + 40 hex digits
Better wording for invalid address literal error
2018-06-11 10:45:39 +00:00
// looksLikeAddress enforces that it is a hex literal starting with "0x"
Keep the 'if it not used as an address' helper message for all cases of address related warnings
2018-06-25 14:25:21 +00:00
msg =
Better wording for invalid address literal error
2018-06-11 10:45:39 +00:00
"This looks like an address but is not exactly 40 hex digits. It is " +
Fixes #5051 (introduced in #4684), effectively allowing underscores in address literals.
2018-10-01 12:36:57 +00:00
to_string(_literal.valueWithoutUnderscores().length() - 2) +
Keep the 'if it not used as an address' helper message for all cases of address related warnings
2018-06-25 14:25:21 +00:00
" hex digits.";
Change invalid (not exactly 160 bits long) address literal to error
2018-02-16 04:24:32 +00:00
else if (!_literal.passesAddressChecksum())
Keep the 'if it not used as an address' helper message for all cases of address related warnings
2018-06-25 14:25:21 +00:00
{
msg = "This looks like an address but has an invalid checksum.";
if (!_literal.getChecksummedAddress().empty())
msg += " Correct checksummed address: \"" + _literal.getChecksummedAddress() + "\".";
}
if (!msg.empty())
Change invalid (not exactly 160 bits long) address literal to error
2018-02-16 04:24:32 +00:00
m_errorReporter.syntaxError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9429_error,
Mention way to remove warning.
2017-03-06 12:31:57 +00:00
_literal.location(),
Keep the 'if it not used as an address' helper message for all cases of address related warnings
2018-06-25 14:25:21 +00:00
msg +
" If this is not used as an address, please prepend '00'. " +
Replace links to readthedocs.io with ones using the new domain
2020-11-18 14:20:34 +00:00
"For more information please see https://docs.soliditylang.org/en/develop/types.html#address-literals"
Mention way to remove warning.
2017-03-06 12:31:57 +00:00
);
Warn about invalid checksums of addresses.
2017-01-24 16:38:06 +00:00
}
The "year" denomination is deprecated
2018-04-23 13:54:45 +00:00
Deprecate using unit denominations in combination with hex numbers. Closes #3574.
2018-03-01 15:58:20 +00:00
if (_literal.isHexNumber() && _literal.subDenomination() != Literal::SubDenomination::None)
Enforce error on hex number combined with unit denomination
2018-07-05 13:48:57 +00:00
m_errorReporter.fatalTypeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5145_error,
Enforce error on hex number combined with unit denomination
2018-07-05 13:48:57 +00:00
_literal.location(),
"Hexadecimal numbers cannot be used with unit denominations. "
"You can use an expression of the form \"0x1234 * 1 day\" instead."
);
The "year" denomination is deprecated
2018-04-23 13:54:45 +00:00
if (_literal.subDenomination() == Literal::SubDenomination::Year)
Disallow the years unit denomination properly
2018-06-20 22:01:40 +00:00
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4820_error,
Disallow the years unit denomination properly
2018-06-20 22:01:40 +00:00
_literal.location(),
"Using \"years\" as a unit denomination is deprecated."
);
The "year" denomination is deprecated
2018-04-23 13:54:45 +00:00
Fix address literals not being treated as compile-time constants The early return implemented for address literals in TypeChecker was preventing the isPure annotation from getting applied. Closes #2441
2017-06-22 13:59:00 +00:00
if (!_literal.annotation().type)
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
_literal.annotation().type = TypeProvider::forLiteral(_literal);
Fix address literals not being treated as compile-time constants The early return implemented for address literals in TypeChecker was preventing the isPure annotation from getting applied. Closes #2441
2017-06-22 13:59:00 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
if (!_literal.annotation().type)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(2826_error, _literal.location(), "Invalid literal value.");
Fix address literals not being treated as compile-time constants The early return implemented for address literals in TypeChecker was preventing the isPure annotation from getting applied. Closes #2441
2017-06-22 13:59:00 +00:00
_literal.annotation().isPure = true;
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
_literal.annotation().isLValue = false;
_literal.annotation().isConstant = false;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Disallow ``using for`` directive for interfaces.
2020-08-27 12:39:52 +00:00
void TypeChecker::endVisit(UsingForDirective const& _usingFor)
{
if (m_currentContract->isInterface())
m_errorReporter.typeError(
9088_error,
_usingFor.location(),
"The \"using for\" directive is not allowed inside interfaces."
);
}
Syntax for custom errors.
2021-01-28 11:56:22 +00:00
void TypeChecker::checkErrorAndEventParameters(CallableDeclaration const& _callable)
{
string kind = dynamic_cast<EventDefinition const*>(&_callable) ? "event" : "error";
for (ASTPointer<VariableDeclaration> const& var: _callable.parameters())
{
if (type(*var)->containsNestedMapping())
Errors about nested mapping in event parameter are fatal. (Also applies for error parameters.)
2021-06-03 08:36:17 +00:00
m_errorReporter.fatalTypeError(
Syntax for custom errors.
2021-01-28 11:56:22 +00:00
3448_error,
var->location(),
"Type containing a (nested) mapping is not allowed as " + kind + " parameter type."
);
if (!type(*var)->interfaceType(false))
m_errorReporter.typeError(3417_error, var->location(), "Internal or recursive type is not allowed as " + kind + " parameter type.");
if (
!useABICoderV2() &&
!typeSupportedByOldABIEncoder(*type(*var), false /* isLibrary */)
)
m_errorReporter.typeError(
3061_error,
var->location(),
"This type is only supported in ABI coder v2. "
"Use \"pragma abicoder v2;\" to enable the feature."
);
}
}
Make some functions const.
2015-11-24 15:34:02 +00:00
Declaration const& TypeChecker::dereference(Identifier const& _identifier) const
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
solAssert(!!_identifier.annotation().referencedDeclaration, "Declaration not stored.");
return *_identifier.annotation().referencedDeclaration;
}
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
Declaration const& TypeChecker::dereference(IdentifierPath const& _path) const
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
{
Allow path syntax for super constructor calls
2020-08-11 09:18:22 +00:00
solAssert(!!_path.annotation().referencedDeclaration, "Declaration not stored.");
return *_path.annotation().referencedDeclaration;
Allow "new expressions" also for general type names. Breaking change: If you want to send value with a contract creation, you have to use parentheses now: `(new ContractName).value(2 ether)(arg1, arg2)`
2015-11-16 23:06:57 +00:00
}
Fixes crash on non-unsigned array index.
2018-10-10 17:33:45 +00:00
bool TypeChecker::expectType(Expression const& _expression, Type const& _expectedType)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
_expression.accept(*this);
Display BoolResult from implicit/explicit conversions for more clarity in error messages
2020-09-23 14:08:55 +00:00
BoolResult result = type(_expression)->isImplicitlyConvertibleTo(_expectedType);
if (!result)
reorganized tests and fixed mobile types and implicit conversions of rationals and fixed point types one final tweak check for null types
2016-05-05 22:47:08 +00:00
{
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
auto errorMsg = "Type " +
type(_expression)->toString() +
" is not implicitly convertible to expected type " +
_expectedType.toString();
reorganized tests and fixed mobile types and implicit conversions of rationals and fixed point types one final tweak check for null types
2016-05-05 22:47:08 +00:00
if (
type(_expression)->category() == Type::Category::RationalNumber &&
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
dynamic_cast<RationalNumberType const*>(type(_expression))->isFractional() &&
Prefer mobileType() to check rational range.
2016-05-10 08:26:53 +00:00
type(_expression)->mobileType()
reorganized tests and fixed mobile types and implicit conversions of rationals and fixed point types one final tweak check for null types
2016-05-05 22:47:08 +00:00
)
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
{
if (_expectedType.operator==(*type(_expression)->mobileType()))
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4426_error,
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
_expression.location(),
errorMsg + ", but it can be explicitly converted."
);
else
Display BoolResult from implicit/explicit conversions for more clarity in error messages
2020-09-23 14:08:55 +00:00
m_errorReporter.typeErrorConcatenateDescriptions(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2326_error,
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
_expression.location(),
errorMsg +
". Try converting to type " +
type(_expression)->mobileType()->toString() +
Display BoolResult from implicit/explicit conversions for more clarity in error messages
2020-09-23 14:08:55 +00:00
" or use an explicit conversion.",
result.message()
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
);
}
reorganized tests and fixed mobile types and implicit conversions of rationals and fixed point types one final tweak check for null types
2016-05-05 22:47:08 +00:00
else
Display BoolResult from implicit/explicit conversions for more clarity in error messages
2020-09-23 14:08:55 +00:00
m_errorReporter.typeErrorConcatenateDescriptions(
7407_error,
_expression.location(),
errorMsg + ".",
result.message()
);
Fixes crash on non-unsigned array index.
2018-10-10 17:33:45 +00:00
return false;
Warn if decimal literals are used in a bytesXX context Fixes #2349
2017-06-22 14:14:14 +00:00
}
Fixes crash on non-unsigned array index.
2018-10-10 17:33:45 +00:00
return true;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Validate immutable variables
2020-03-10 17:15:50 +00:00
void TypeChecker::requireLValue(Expression const& _expression, bool _ordinaryAssignment)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
Replaced all instances of lValueRequested to willBeWrittenTo
2020-04-09 10:48:57 +00:00
_expression.annotation().willBeWrittenTo = true;
Validate immutable variables
2020-03-10 17:15:50 +00:00
_expression.annotation().lValueOfOrdinaryAssignment = _ordinaryAssignment;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
_expression.accept(*this);
Improve error message when trying to modify constant variables
2016-12-13 02:59:53 +00:00
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (*_expression.annotation().isLValue)
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
return;
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +00:00
if (*_expression.annotation().isConstant)
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
return { 6520_error, "Cannot assign to a constant variable." };
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +00:00
if (auto indexAccess = dynamic_cast<IndexAccess const*>(&_expression))
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
{
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +00:00
if (type(indexAccess->baseExpression())->category() == Type::Category::FixedBytes)
Fixed seed for randomness, fixed conflicts in errorids
2020-05-26 12:37:31 +00:00
return { 4360_error, "Single bytes in fixed bytes arrays cannot be modified." };
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +00:00
else if (auto arrayType = dynamic_cast<ArrayType const*>(type(indexAccess->baseExpression())))
if (arrayType->dataStoredIn(DataLocation::CallData))
Fixed seed for randomness, fixed conflicts in errorids
2020-05-26 12:37:31 +00:00
return { 6182_error, "Calldata arrays are read-only." };
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
}
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +00:00
if (auto memberAccess = dynamic_cast<MemberAccess const*>(&_expression))
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
{
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +00:00
if (auto structType = dynamic_cast<StructType const*>(type(memberAccess->expression())))
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
{
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +00:00
if (structType->dataStoredIn(DataLocation::CallData))
Fixed seed for randomness, fixed conflicts in errorids
2020-05-26 12:37:31 +00:00
return { 4156_error, "Calldata structs are read-only." };
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
}
Makes array length access read-only.
2019-09-18 12:58:20 +00:00
else if (dynamic_cast<ArrayType const*>(type(memberAccess->expression())))
if (memberAccess->memberName() == "length")
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
return { 7567_error, "Member \"length\" is read-only and cannot be used to resize arrays." };
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
}
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +00:00
if (auto identifier = dynamic_cast<Identifier const*>(&_expression))
if (auto varDecl = dynamic_cast<VariableDeclaration const*>(identifier->annotation().referencedDeclaration))
if (varDecl->isExternalCallableParameter() && dynamic_cast<ReferenceType const*>(identifier->annotation().type))
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
return { 7128_error, "External function arguments of reference type are read-only." };
return { 4247_error, "Expression has to be an lvalue." };
}();
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
m_errorReporter.typeError(errorId, _expression.location(), description);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
Introduce abicoder pragma.
2020-10-22 17:19:14 +00:00
bool TypeChecker::useABICoderV2() const
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
{
solAssert(m_currentSourceUnit, "");
if (m_currentContract)
solAssert(m_currentSourceUnit == &m_currentContract->sourceUnit(), "");
Introduce abicoder pragma.
2020-10-22 17:19:14 +00:00
return *m_currentSourceUnit->annotation().useABICoderV2;
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
}
Reference in New Issue Copy Permalink