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
e990b2016a
solidity/libsolidity/analysis/TypeChecker.cpp

3339 lines
114 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>
#include <libyul/AsmData.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>
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
#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
}
TypePointer const& TypeChecker::type(Expression const& _expression) const
{
solAssert(!!_expression.annotation().type, "Type requested but not present.");
return _expression.annotation().type;
}
TypePointer const& TypeChecker::type(VariableDeclaration const& _variable) const
{
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
{
TypePointer actualType = argTypeType->actualType();
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)
{
m_errorReporter.typeError(
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."
);
return {};
}
TypePointer 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();
if (
typeCategory != Type::Category::Contract &&
typeCategory != Type::Category::Integer
)
wrongType = true;
}
else
wrongType = true;
if (wrongType)
Syntax for meta type information.
2019-01-10 15:28:39 +00:00
{
m_errorReporter.typeError(
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
);
return {};
}
[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
if (base->isLibrary())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(2571_error, _inheritance.location(), "Libraries cannot be inherited from.");
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
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 (
!experimentalFeatureActive(ExperimentalFeature::ABIEncoderV2) &&
!typeSupportedByOldABIEncoder(*type(_var), _function.libraryFunction())
)
{
string message =
"This type is only supported in ABIEncoderV2. "
"Use \"pragma experimental ABIEncoderV2;\" to enable the feature.";
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
);
Disallow invoking the same modifier multiple times.
2017-06-23 16:55:47 +00:00
Declaration const* decl = &dereference(*modifier->name());
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.isReceive())
typeCheckReceiveFunction(_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.
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
TypePointer 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
Disallow variables of library types
2019-11-14 11:48:15 +00:00
if (auto contractType = dynamic_cast<ContractType const*>(varType))
if (contractType->contractDefinition().isLibrary())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1273_error, _variable.location(), "The type of a variable cannot be a library.");
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())
{
Disallow constants that are neither value types nor strings.
2017-03-03 18:26:54 +00:00
if (!_variable.type()->isValueType())
{
bool allowed = false;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto arrayType = dynamic_cast<ArrayType const*>(_variable.type()))
Allow constant byte arrays.
2017-09-18 10:31:55 +00:00
allowed = arrayType->isByteArray();
Disallow constants that are neither value types nor strings.
2017-03-03 18:26:54 +00:00
if (!allowed)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9259_error, _variable.location(), "Constants of non-value type not yet implemented.");
Disallow constants that are neither value types nor strings.
2017-03-03 18:26:54 +00:00
}
Disallow non-pure constant state variables in 0.5.0
2017-07-08 23:27:28 +00:00
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
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);
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
if (!experimentalFeatureActive(ExperimentalFeature::ABIEncoderV2))
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(),
Do not call ABIEncoderV2 experimental.
2019-12-11 16:05:44 +00:00
"The following types are only supported for getters in ABIEncoderV2: " +
Properly check getter types to be old-abi-coder-compatible.
2018-11-28 11:17:30 +00:00
joinHumanReadable(unsupportedTypes) +
". Either remove \"public\" or use \"pragma experimental ABIEncoderV2;\" to enable the feature."
);
}
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
{
Refactoring of errors and fixes for various ICEs.
2020-04-14 17:03:46 +00:00
auto result = referenceType->validForLocation(referenceType->location());
Assert that visibility of constructor is not queried.
2020-06-18 15:34:05 +00:00
if (result && (_variable.isConstructorParameter() || _variable.isPublicCallableParameter()))
Ensure that public callable parameters are valid for calldata.
2020-04-16 14:29:23 +00:00
result = referenceType->validForLocation(DataLocation::CallData);
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
Move modifier context check to PostTypeChecker refs #7566
2019-12-17 15:18:58 +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
auto const* declaration = &dereference(*_modifier.name());
vector<ASTPointer<VariableDeclaration>> emptyParameterList;
vector<ASTPointer<VariableDeclaration>> const* parameters = nullptr;
if (auto modifierDecl = dynamic_cast<ModifierDefinition const*>(declaration))
parameters = &modifierDecl->parameters();
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, "");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
unsigned numIndexed = 0;
for (ASTPointer<VariableDeclaration> const& var: _eventDef.parameters())
{
if (var->isIndexed())
numIndexed++;
Added containsNestedMapping()
2020-06-03 10:38:35 +00:00
if (type(*var)->containsNestedMapping())
m_errorReporter.typeError(
3448_error,
var->location(),
"Type containing a (nested) mapping is not allowed as event parameter type."
);
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (!type(*var)->interfaceType(false))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3417_error, var->location(), "Internal or recursive type is not allowed as event parameter type.");
Disallow structs in events without ABIEncoderV2
2018-08-01 17:01:50 +00:00
if (
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
!experimentalFeatureActive(ExperimentalFeature::ABIEncoderV2) &&
Packed Encoding: Disallow types in v2 that aren't allowed in v1
2019-02-04 17:13:41 +00:00
!typeSupportedByOldABIEncoder(*type(*var), false /* isLibrary */)
Disallow structs in events without ABIEncoderV2
2018-08-01 17:01:50 +00:00
)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
3061_error,
Disallow structs in events without ABIEncoderV2
2018-08-01 17:01:50 +00:00
var->location(),
Do not call ABIEncoderV2 experimental.
2019-12-11 16:05:44 +00:00
"This type is only supported in ABIEncoderV2. "
Disallow structs in events without ABIEncoderV2
2018-08-01 17:01:50 +00:00
"Use \"pragma experimental ABIEncoderV2;\" to enable the feature."
);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
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
}
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())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(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
Move lambda.
2017-02-23 16:38:42 +00:00
)
{
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, "");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
bool requiresStorage = identifierInfo.isSlot || identifierInfo.isOffset;
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())
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3773_error, _identifier.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
{
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
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3224_error, _identifier.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)
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6252_error, _identifier.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
}
else if (requiresStorage)
Support constant numbers in inline assembly.
2019-07-01 13:34:34 +00:00
{
Use `.slot` and `.offest` to access storage items.
2020-07-01 17:25:14 +00:00
m_errorReporter.typeError(6617_error, _identifier.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,
_identifier.location,
"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
))
{
m_errorReporter.typeError(7615_error, _identifier.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.");
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
if (requiresStorage)
{
if (!var->isStateVariable() && !var->type()->dataStoredIn(DataLocation::Storage))
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
{
Use `.slot` and `.offest` to access storage items.
2020-07-01 17:25:14 +00:00
m_errorReporter.typeError(3622_error, _identifier.location, "The suffixes .offset and .slot can only be used on storage variables.");
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
return false;
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
}
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
else if (_context == yul::IdentifierContext::LValue)
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
{
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
if (var->isStateVariable())
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4713_error, _identifier.location, "State variables cannot be assigned to - you have to use \"sstore()\".");
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
}
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
else if (identifierInfo.isOffset)
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
{
Use `.slot` and `.offest` to access storage items.
2020-07-01 17:25:14 +00:00
m_errorReporter.typeError(9739_error, _identifier.location, "Only .slot can be assigned to.");
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
}
else
Simplify inline assembly resolver.
2020-06-11 16:46:31 +00:00
solAssert(identifierInfo.isSlot, "");
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
{
Use `.slot` and `.offest` to access storage items.
2020-07-01 17:25:14 +00:00
m_errorReporter.typeError(1408_error, _identifier.location, "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
{
Use `.slot` and `.offest` to access storage items.
2020-07-01 17:25:14 +00:00
m_errorReporter.typeError(9068_error, _identifier.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
{
Issue proper warning trying to access calldata variables in inline assembly
2017-07-11 11:37:34 +00:00
if (var->type()->dataStoredIn(DataLocation::CallData))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(2370_error, _identifier.location, "Call data elements cannot be accessed directly. Copy to a local variable first or use \"calldataload\" or \"calldatacopy\" with manually determined offsets and sizes.");
Issue proper warning trying to access calldata variables in inline assembly
2017-07-11 11:37:34 +00:00
else
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9857_error, _identifier.location, "Only types that use one stack slot are supported.");
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
}
}
More precise error message if using non-variables with _slot/_offset
2018-08-07 12:17:56 +00:00
else if (requiresStorage)
{
Use `.slot` and `.offest` to access storage items.
2020-07-01 17:25:14 +00:00
m_errorReporter.typeError(7944_error, _identifier.location, "The suffixes .offset and .slot can only be used on storage 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
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1990_error, _identifier.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))
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.declarationError(2025_error, _identifier.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
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4977_error, _identifier.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."
);
size_t len = min(returnTypes.size(), parameters.size());
for (size_t i = 0; i < len; ++i)
{
solAssert(returnTypes[i], "");
if (parameters[i] && *parameters[i]->annotation().type != *returnTypes[i])
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
6509_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
parameters[i]->location(),
"Invalid type, expected " +
returnTypes[i]->toString(false) +
" but got " +
parameters[i]->annotation().type->toString() +
"."
);
}
}
TryCatchClause const* errorClause = nullptr;
TryCatchClause const* lowLevelClause = nullptr;
for (size_t i = 1; i < _tryStatement.clauses().size(); ++i)
{
TryCatchClause const& clause = *_tryStatement.clauses()[i];
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 { ... }`."
);
}
}
else if (clause.errorName() == "Error")
{
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 { ... }`."
);
if (errorClause)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1036_error,
Type Checker for try/catch.
2019-09-05 18:02:34 +00:00
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()
)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(2943_error, clause.location(), "Expected `catch Error(string memory ...) { ... }`.");
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(),
"Invalid catch clause name. Expected either `catch (...)` or `catch Error(...)`."
);
}
}
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
{
TypePointer 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
}
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.");
Multi-variable declarations.
2015-10-09 18:44:56 +00:00
TypePointer 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
cond-expr: use the mobile type instead of the original type
2016-01-11 16:00:14 +00:00
TypePointer trueType = type(_conditional.trueExpression())->mobileType();
TypePointer 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
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
TypePointer 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);
Fix #8711, #8277
2020-04-23 03:48:02 +00:00
auto const& types = tupleType && tupleExpression->components().size() != 1 ? tupleType->components() : vector<TypePointer> { &_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
);
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
TypePointer t = type(_assignment.leftHandSide());
_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);
TypePointer 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,
Make annotations ``SetOnce`` or ``optional`` where feasible
2020-09-10 10:01:23 +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
types.push_back(TypePointer());
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;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
TypePointer 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);
TypePointer const& subExprType = type(_operation.subExpression());
TypePointer t = type(_operation.subExpression())->unaryOperatorResult(op);
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;
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)
{
TypePointer const& leftType = type(_operation.leftExpression());
TypePointer 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);
TypePointer 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
)
if ((
commonType->category() == Type::Category::Integer &&
dynamic_cast<IntegerType const&>(*commonType).numBits() != 256
) || (
commonType->category() == Type::Category::FixedPoint &&
dynamic_cast<FixedPointType const&>(*commonType).numBits() != 256
))
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.warning(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9085_error,
Warn about literal constant base in exponentiation.
2017-03-07 12:44:11 +00:00
_operation.location(),
Warn about shift of literals.
2017-08-16 11:52:06 +00:00
"Result of " + operation + " has type " + commonType->toString() + " and thus "
Warn about literal constant base in exponentiation.
2017-03-07 12:44:11 +00:00
"might overflow. Silence this warning by converting the literal to the "
"expected type."
);
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
}
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
TypePointer TypeChecker::typeCheckTypeConversionAndRetrieveReturnType(
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, "");
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
TypePointer 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
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
TypePointer resultType = dynamic_cast<TypeType const&>(*expressionType).actualType();
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
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
auto resultArrayType = dynamic_cast<ArrayType const*>(resultType);
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(!!resultArrayType, "");
solAssert(
argArrayType->location() != DataLocation::Storage ||
(
(
resultArrayType->isPointer() ||
(argArrayType->isByteArray() && resultArrayType->isByteArray())
) &&
resultArrayType->location() == DataLocation::Storage
),
"Invalid explicit conversion to storage type."
);
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
);
}
Allow explicit conversion from address to address payable
2019-09-04 15:45:12 +00:00
if (auto addressType = dynamic_cast<AddressType const*>(resultType))
if (addressType->stateMutability() != StateMutability::Payable)
{
bool payable = false;
if (argType->category() != Type::Category::Address)
payable = argType->isExplicitlyConvertibleTo(*TypeProvider::payableAddress());
resultType = payable ? TypeProvider::payableAddress() : TypeProvider::address();
}
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\".");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (!_function.returnParameters().empty())
{
if (_function.returnParameters().size() > 1 || *type(*_function.returnParameters().front()) != *TypeProvider::bytesMemory())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(5570_error, _function.returnParameterList()->location(), "Fallback function can only have a single \"bytes memory\" return value.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
else
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6151_error, _function.returnParameterList()->location(), "Return values for fallback functions are not yet implemented.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
}
if (!_function.parameters().empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3978_error, _function.parameterList().location(), "Fallback function cannot take parameters.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
}
void TypeChecker::typeCheckReceiveFunction(FunctionDefinition const& _function)
{
solAssert(_function.isReceive(), "");
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(4549_error, _function.location(), "Libraries cannot have receive ether functions.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (_function.stateMutability() != StateMutability::Payable)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
7793_error,
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
_function.location(),
"Receive ether function must be 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(4095_error, _function.location(), "Receive ether function must be defined as \"external\".");
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(6899_error, _function.returnParameterList()->location(), "Receive ether function cannot return values.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (!_function.parameters().empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6857_error, _function.parameterList().location(), "Receive ether function cannot take parameters.");
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
Directly determine if experimental feature active.
2020-06-11 22:16:24 +00:00
bool const abiEncoderV2 = experimentalFeatureActive(ExperimentalFeature::ABIEncoderV2);
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
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)
return { isVariadic ? 1123_error : 9755_error, msg };
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
{
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
if (arguments.empty())
return {
isVariadic ? 7653_error : 6138_error,
msg +
" This function requires a single bytes argument."
" Use \"\" as argument to provide empty calldata."
};
else
return {
isVariadic ? 9390_error : 8922_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."
};
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
)
return {
isVariadic ? 1220_error : 4323_error,
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."
};
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");
if (!type(*paramArgMap[i])->isImplicitlyConvertibleTo(*parameterTypes[i]))
{
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.";
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
}
}
}
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;
// 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 &&
functionType->isPure();
Add push() for dynamic storage arrays
2019-09-13 22:54:51 +00:00
if (
functionType->kind() == FunctionType::Kind::ArrayPush ||
functionType->kind() == FunctionType::Kind::ByteArrayPush
)
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
TypePointer const& actualType = dynamic_cast<TypeType const&>(*expressionType).actualType();
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
funcCallAnno.kind = FunctionCallKind::TypeConversion;
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,
experimentalFeatureActive(ExperimentalFeature::ABIEncoderV2)
);
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;
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;
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;
}
auto setCheckOption = [&](bool& _option, string const&& _name, bool _alreadySet = false)
{
if (_option || _alreadySet)
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(),
_alreadySet ?
"Option \"" + std::move(_name) + "\" has already been set." :
"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)
{
setCheckOption(setSalt, "salt", expressionFunctionType->saltSet());
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());
setCheckOption(setValue, "value", expressionFunctionType->valueSet());
}
}
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());
setCheckOption(setGas, "gas", expressionFunctionType->gasSet());
}
}
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)
{
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
TypePointer type = _newExpression.typeName().annotation().type;
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;
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()))
{
auto contract = dynamic_cast<ContractDefinition const*>(&dereference(*contractName));
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
Free functions.
2020-05-04 16:38:00 +00:00
if (m_currentContract)
{
// TODO this is not properly detecting creation-cycles if they go through
// internal library functions or free functions. It will be caught at
// code generation time, but it would of course be better to catch it here.
m_currentContract->annotation().contractDependencies.insert(contract);
solAssert(
!contract->annotation().linearizedBaseContracts.empty(),
"Linearized base contracts not yet available."
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
);
Free functions.
2020-05-04 16:38:00 +00:00
if (contractDependenciesAreCyclic(*m_currentContract))
m_errorReporter.typeError(
4579_error,
_newExpression.location(),
"Circular reference for contract creation (cannot create instance of derived or same contract)."
);
}
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +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 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.");
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);
TypePointer exprType = type(_memberAccess.expression());
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())
if (auto contractType = dynamic_cast<ContractType const*>(exprType))
requiredLookup = contractType->isSuper() ? VirtualLookup::Super : VirtualLookup::Virtual;
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
}
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());
if (
memberName == "runtimeCode" &&
!accessedContractType.immutableVariables().empty()
)
m_errorReporter.typeError(
9274_error,
_memberAccess.location(),
"\"runtimeCode\" is not available for contracts containing immutable variables."
);
Free functions.
2020-05-04 16:38:00 +00:00
if (m_currentContract)
{
// TODO in the same way as with ``new``,
// this is not properly detecting creation-cycles if they go through
// internal library functions or free functions. It will be caught at
// code generation time, but it would of course be better to catch it here.
m_currentContract->annotation().contractDependencies.insert(&accessedContractType.contractDefinition());
if (contractDependenciesAreCyclic(*m_currentContract))
m_errorReporter.typeError(
4224_error,
_memberAccess.location(),
"Circular reference for contract code access."
);
}
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;
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
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);
TypePointer baseType = type(_access.baseExpression());
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
TypePointer 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);
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (dynamic_cast<ContractType const*>(typeType.actualType()))
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(2876_error, _access.location(), "Index access for contracts or libraries is 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;
Initial introduction of array slices with partial implementation for dynamic calldata arrays.
2019-09-03 16:30:00 +00:00
TypePointer exprType = type(_access.baseExpression());
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.");
for (TypePointer parameter: functionType->parameterTypes() + functionType->returnParameterTypes())
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();
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;
}
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
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
_literal.annotation().type = TypeProvider::payableAddress();
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'. " +
Improves address literal checksum error message
2017-10-05 13:28:25 +00:00
"For more information please see https://solidity.readthedocs.io/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."
);
}
Resolve binary dependencies properly.
2015-10-07 13:57:17 +00:00
bool TypeChecker::contractDependenciesAreCyclic(
ContractDefinition const& _contract,
std::set<ContractDefinition const*> const& _seenContracts
) const
{
// Naive depth-first search that remembers nodes already seen.
if (_seenContracts.count(&_contract))
return true;
set<ContractDefinition const*> seen(_seenContracts);
seen.insert(&_contract);
for (auto const* c: _contract.annotation().contractDependencies)
if (contractDependenciesAreCyclic(*c, seen))
return true;
return false;
}
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;
}
Make some functions const.
2015-11-24 15:34:02 +00:00
Declaration const& TypeChecker::dereference(UserDefinedTypeName const& _typeName) 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
{
solAssert(!!_typeName.annotation().referencedDeclaration, "Declaration not stored.");
return *_typeName.annotation().referencedDeclaration;
}
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
bool TypeChecker::experimentalFeatureActive(ExperimentalFeature _feature) const
{
solAssert(m_currentSourceUnit, "");
if (m_currentContract)
solAssert(m_currentSourceUnit == &m_currentContract->sourceUnit(), "");
return m_currentSourceUnit->annotation().experimentalFeatures.count(_feature);
}
Reference in New Issue Copy Permalink