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

3268 lines
112 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
*/
/**
* @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>
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 type system to allow multiple entry points.
2017-01-27 22:29:03 +00:00
bool TypeChecker::checkTypeRequirements(ASTNode const& _contract)
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
{
Catch FatalError in CompilerStack::analysis to cover all the analysis tests
2018-04-05 12:23:36 +00:00
_contract.accept(*this);
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)
{
Make members context-sensitive.
2015-11-19 17:02:04 +00:00
m_scope = &_contract;
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
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.");
Prohibit interfaces inheriting from non-interfaces
2020-01-02 21:32:35 +00:00
if (m_scope->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
}
void TypeChecker::endVisit(UsingForDirective const& _usingFor)
{
ContractDefinition const* library = dynamic_cast<ContractDefinition const*>(
_usingFor.libraryName().annotation().referencedDeclaration
);
if (!library || !library->isLibrary())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(4357_error, _usingFor.libraryName().location(), "Library name expected.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
virtual modifiers (in Abstract contracts) allow empty bodies
2020-04-15 10:42:15 +00:00
void TypeChecker::endVisit(ModifierDefinition const& _modifier)
{
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)
{
Move ContractKind from ContractDefinition to file-scope
2020-01-07 14:11:29 +00:00
bool isLibraryFunction = _function.inContractKind() == ContractKind::Library;
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
Disallow use of virtual and private together
2019-11-27 13:02:52 +00:00
if (_function.markedVirtual())
{
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\"");
Move Visibility out of Declaration.
2019-12-10 14:54:09 +00:00
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.");
Added error message for virtual (library) functions; test case
2020-04-03 07:56:57 +00:00
if (isLibraryFunction)
Merge remote-tracking branch 'origin/develop' into breaking
2020-05-12 15:47:41 +00:00
m_errorReporter.typeError(1878_error, _function.location(), "Library functions cannot be \"virtual\".");
Disallow use of virtual and private together
2019-11-27 13:02:52 +00:00
}
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())
{
if (isLibraryFunction)
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.");
Split fallback function and introduce "fallback()" and "receive()" syntax.
2019-09-09 16:22:02 +00:00
if (_function.isOrdinary() && !_function.isPartOfExternalInterface())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(5587_error, _function.location(), "Internal functions cannot be payable.");
Merged in changes from chriseth/payable
2016-08-26 18:37:10 +00:00
}
Refactor TypeChecker::visit(FunctionDefinition const&).
2019-01-17 15:37:36 +00:00
auto checkArgumentAndReturnParameter = [&](VariableDeclaration const& var) {
if (type(var)->category() == Type::Category::Mapping)
Allow mapping arguments for public and external library functions.
2018-11-08 10:22:57 +00:00
{
Fix check that mappings can only have storage location
2019-02-05 14:51:19 +00:00
if (var.referenceLocation() != VariableDeclaration::Location::Storage)
{
if (!isLibraryFunction && _function.isPublic())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3442_error, var.location(), "Mapping types can only have a data location of \"storage\" and thus only be parameters or return variables for internal or library functions.");
Fix check that mappings can only have storage location
2019-02-05 14:51:19 +00:00
else
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(5380_error, var.location(), "Mapping types can only have a data location of \"storage\"." );
Fix check that mappings can only have storage location
2019-02-05 14:51:19 +00:00
}
else
{
solAssert(isLibraryFunction || !_function.isPublic(), "Mapping types for parameters or return variables can only be used in internal or library functions.");
}
Allow mapping arguments for public and external library functions.
2018-11-08 10:22:57 +00:00
}
else
{
Refactor TypeChecker::visit(FunctionDefinition const&).
2019-01-17 15:37:36 +00:00
if (!type(var)->canLiveOutsideStorage() && _function.isPublic())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3312_error, var.location(), "Type is required to live outside storage.");
Disallow internal function types as parameters for public/external library function
2019-03-07 16:12:10 +00:00
if (_function.isPublic())
{
auto iType = type(var)->interfaceType(isLibraryFunction);
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (!iType)
Disallow internal function types as parameters for public/external library function
2019-03-07 16:12:10 +00:00
{
solAssert(!iType.message().empty(), "Expected detailed error message!");
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(4103_error, var.location(), iType.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
}
Allow mapping arguments and return values in internal library functions.
2018-08-10 13:13:12 +00:00
if (
Allow mapping arguments for public and external library functions.
2018-11-08 10:22:57 +00:00
_function.isPublic() &&
Fix multi-dimensional arrays in the ABI.
2018-02-19 17:21:02 +00:00
!_function.sourceUnit().annotation().experimentalFeatures.count(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), isLibraryFunction)
Suggest the experimental ABI encoder if using structs as function parameters
2017-12-02 01:01:55 +00:00
)
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4957_error,
Refactor TypeChecker::visit(FunctionDefinition const&).
2019-01-17 15:37:36 +00:00
var.location(),
Do not call ABIEncoderV2 experimental.
2019-12-11 16:05:44 +00:00
"This type is only supported in ABIEncoderV2. "
Suggest the experimental ABI encoder if using structs as function parameters
2017-12-02 01:01:55 +00:00
"Use \"pragma experimental ABIEncoderV2;\" to enable the feature."
);
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
}
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
{
Disallow call of same-class-ctor as modifier
2019-10-22 10:26:26 +00:00
auto baseContracts = dynamic_cast<ContractDefinition const&>(*_function.scope()).annotation().linearizedBaseContracts;
// Delete first base which is just the main contract itself
baseContracts.erase(baseContracts.begin());
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);
}
Add ContractDefinition::isInterface.
2019-01-17 11:59:11 +00:00
if (m_scope->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
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(1560_error, _function.location(), "Functions in interfaces must be declared external.");
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.");
Simplify interface checks for FunctionDefinition
2017-03-17 17:01:13 +00:00
}
Move ContractKind from ContractDefinition to file-scope
2020-01-07 14:11:29 +00:00
else if (m_scope->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.");
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.");
Some changes to "abstract".
2019-11-04 13:12:58 +00:00
else if (isLibraryFunction)
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())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
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)
{
Fix SMT Checker crash due to missing type information
2019-02-27 10:55:59 +00:00
if (_variable.typeName())
_variable.typeName()->accept(*this);
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
{
if (_variable.isStateVariable() && dynamic_cast<MappingType const*>(varType))
{
m_errorReporter.typeError(6280_error, _variable.location(), "Mappings cannot be assigned to.");
_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.");
Type checking for pure expressions.
2017-03-01 18:12:40 +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())
{
if (varType->dataStoredIn(DataLocation::Memory) || varType->dataStoredIn(DataLocation::CallData))
if (!varType->canLiveOutsideStorage())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(4061_error, _variable.location(), "Type " + varType->toString() + " is only valid in storage.");
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);
if (!_variable.sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::ABIEncoderV2))
{
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
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());
Ensure that public callable parameters are valid for calldata.
2020-04-16 14:29:23 +00:00
if (result && _variable.isPublicCallableParameter())
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());
Refactoring of errors and fixes for various ICEs.
2020-04-14 17:03:46 +00:00
}
Dynamic type as mapping key returns error instead of assertion fail
2018-07-31 09:44:39 +00:00
}
Issue error properly for oversized arrays for calldata
2017-07-11 20:56:09 +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::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++;
if (!type(*var)->canLiveOutsideStorage())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3448_error, var->location(), "Type is required to live outside storage.");
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 (
!_eventDef.sourceUnit().annotation().experimentalFeatures.count(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.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
return false;
}
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())
Split external identifier access into resolving and code generation.
2017-03-14 14:41:23 +00:00
return size_t(-1);
Declaration const* declaration = ref->second.declaration;
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
solAssert(!!declaration, "");
More precise error message if using non-variables with _slot/_offset
2018-08-07 12:17:56 +00:00
bool requiresStorage = ref->second.isSlot || ref->second.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.");
Parsing of immutable state variable.
2020-02-27 15:13:55 +00:00
return size_t(-1);
}
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.");
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
return size_t(-1);
}
Replaced "assert" with "if" (incorrect contract code is not supposed to trigger asserts).
2020-03-10 23:32:01 +00:00
else if (!var || !type(*var)->isValueType() || (
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
dynamic_cast<Literal const*>(var->value().get()) == nullptr &&
type(*var->value())->category() != Type::Category::RationalNumber
))
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7615_error, _identifier.location, "Only direct number constants and references to such constants are supported by inline assembly.");
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
return size_t(-1);
}
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.");
Cope with constants without value in inline assembly.
2019-07-09 09:11:40 +00:00
return size_t(-1);
}
else if (requiresStorage)
Support constant numbers in inline assembly.
2019-07-01 13:34:34 +00:00
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(6617_error, _identifier.location, "The suffixes _offset and _slot can only be used on non-constant storage variables.");
Support constant numbers in inline assembly.
2019-07-01 13:34:34 +00:00
return size_t(-1);
}
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
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(3622_error, _identifier.location, "The suffixes _offset and _slot can only be used on storage variables.");
Storage access from inline assembly.
2017-04-21 17:13:46 +00:00
return size_t(-1);
}
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()\".");
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
return size_t(-1);
}
else if (ref->second.isOffset)
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9739_error, _identifier.location, "Only _slot can be assigned to.");
Allow access to ``_slot`` for local storage pointer variables.
2020-02-24 14:53:32 +00:00
return size_t(-1);
}
else
solAssert(ref->second.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
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(1408_error, _identifier.location, "Only local variables are supported. To access storage variables, use the _slot and _offset suffixes.");
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
return size_t(-1);
}
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
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9068_error, _identifier.location, "You have to use the _slot or _offset suffix to access storage reference variables.");
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
return size_t(-1);
}
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.");
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
return size_t(-1);
}
}
More precise error message if using non-variables with _slot/_offset
2018-08-07 12:17:56 +00:00
else if (requiresStorage)
{
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7944_error, _identifier.location, "The suffixes _offset and _slot can only be used on storage variables.");
More precise error message if using non-variables with _slot/_offset
2018-08-07 12:17:56 +00:00
return size_t(-1);
}
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))
return size_t(-1);
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.");
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
return size_t(-1);
}
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.");
Disallow access to functions from inline assembly.
2020-03-31 01:01:50 +00:00
return size_t(-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
}
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.");
Split external identifier access into resolving and code generation.
2017-03-14 14:41:23 +00:00
return size_t(-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
}
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
}
else
Split external identifier access into resolving and code generation.
2017-03-14 14:41:23 +00:00
return size_t(-1);
Code generation (missing external access and source locations).
2016-03-01 21:56:39 +00:00
}
Only allow access to local variables and only if they have a stack size of one.
2017-04-11 19:12:17 +00:00
ref->second.valueSize = 1;
return size_t(1);
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());
if (!externalCall || externalCall->annotation().kind != FunctionCallKind::FunctionCall)
{
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 (
_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
}
Coding style.
2018-07-10 20:20:10 +00:00
namespace
{
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
/**
Coding style.
2018-07-10 20:20:10 +00:00
* @returns a suggested left-hand-side of a multi-variable declaration contairing
* the variable declarations given in @a _decls.
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
*/
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
string createTupleDecl(vector<ASTPointer<VariableDeclaration>> const& _decls)
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
{
vector<string> components;
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
for (ASTPointer<VariableDeclaration> const& decl: _decls)
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
if (decl)
Fix declaration suggestion for var with different number of components
2018-08-04 13:16:23 +00:00
{
solAssert(decl->annotation().type, "");
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
components.emplace_back(decl->annotation().type->toString(false) + " " + decl->name());
Fix declaration suggestion for var with different number of components
2018-08-04 13:16:23 +00:00
}
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
else
components.emplace_back();
Coding style.
2018-07-10 20:20:10 +00:00
if (_decls.size() == 1)
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
return components.front();
else
return "(" + boost::algorithm::join(components, ", ") + ")";
}
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
bool typeCanBeExpressed(vector<ASTPointer<VariableDeclaration>> const& decls)
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
{
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
for (ASTPointer<VariableDeclaration> const& decl: decls)
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
{
// skip empty tuples (they can be expressed of course)
if (!decl)
continue;
Fix declaration suggestion for var with different number of components
2018-08-04 13:16:23 +00:00
if (!decl->annotation().type)
return false;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto functionType = dynamic_cast<FunctionType const*>(decl->annotation().type))
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
if (
functionType->kind() != FunctionType::Kind::Internal &&
functionType->kind() != FunctionType::Kind::External
)
return false;
}
return true;
}
Coding style.
2018-07-10 20:20:10 +00:00
}
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +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.
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
{
Replace boost/algorithm/cxx11 with C++11 features
2020-05-11 11:05:39 +00:00
if (std::all_of(
_statement.declarations().begin(),
_statement.declarations().end(),
[](ASTPointer<VariableDeclaration> const& declaration) { return declaration == nullptr; }
))
Ensures an empty use of var keyword is caught with the proper error message.
2018-07-12 14:17:30 +00:00
{
// The syntax checker has already generated an error for this case (empty LHS tuple).
solAssert(m_errorReporter.hasErrors(), "");
// 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;
}
else
// Bailing out *fatal* here, as those (untyped) vars may be used later, and diagnostics wouldn't be helpful then.
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(4626_error, _statement.location(), "Use of the \"var\" keyword is disallowed.");
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();
if (!varDecl.annotation().type)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(6983_error, _statement.location(), "Use of the \"var\" keyword is disallowed.");
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
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
bool autoTypeDeductionNeeded = false;
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, "");
if (!var.annotation().type)
{
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
autoTypeDeductionNeeded = true;
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
// Infer type from value.
solAssert(!var.typeName(), "");
var.annotation().type = valueComponentType->mobileType();
Prefer mobileType() to check rational range.
2016-05-10 08:26:53 +00:00
if (!var.annotation().type)
Remove unused tests and add asserts for not implemented parts in code generation. quick fix on christian's rational change so that ubuntu will stop yelling be more specific with rational declaration for Windows sake rational in namespace correction for windows
2016-05-10 12:57:29 +00:00
{
Prefer mobileType() to check rational range.
2016-05-10 08:26:53 +00:00
if (valueComponentType->category() == Type::Category::RationalNumber)
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
6963_error,
Prefer mobileType() to check rational range.
2016-05-10 08:26:53 +00:00
_statement.initialValue()->location(),
"Invalid rational " +
valueComponentType->toString() +
Unary operators and division.
2017-10-05 13:23:25 +00:00
" (absolute value too large or division by zero)."
Prefer mobileType() to check rational range.
2016-05-10 08:26:53 +00:00
);
else
solAssert(false, "");
Remove unused tests and add asserts for not implemented parts in code generation. quick fix on christian's rational change so that ubuntu will stop yelling be more specific with rational declaration for Windows sake rational in namespace correction for windows
2016-05-10 12:57:29 +00:00
}
[libsolidity] TypeProvider: eliminate redundant "Type" suffix in provider function signatures.
2019-04-17 11:40:50 +00:00
else if (*var.annotation().type == *TypeProvider::emptyTuple())
Turn unreachable error statements into asserts
2019-02-06 12:11:04 +00:00
solAssert(false, "Cannot declare variable with void (empty tuple) type.");
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
else if (valueComponentType->category() == Type::Category::RationalNumber)
{
string typeName = var.annotation().type->toString(true);
string extension;
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (auto type = dynamic_cast<IntegerType const*>(var.annotation().type))
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
{
Change numBits to unsigned IntegerType
2018-04-30 21:56:30 +00:00
unsigned numBits = type->numBits();
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
bool isSigned = type->isSigned();
Change numBits to unsigned IntegerType
2018-04-30 21:56:30 +00:00
solAssert(numBits > 0, "");
Give min and max values in warning message.
2017-06-26 07:49:45 +00:00
string minValue;
string maxValue;
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
if (isSigned)
Give min and max values in warning message.
2017-06-26 07:49:45 +00:00
{
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
numBits--;
Give min and max values in warning message.
2017-06-26 07:49:45 +00:00
minValue = "-" + bigint(bigint(1) << numBits).str();
}
else
minValue = "0";
maxValue = bigint((bigint(1) << numBits) - 1).str();
extension = ", which can hold values between " + minValue + " and " + maxValue;
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
}
else
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
solAssert(dynamic_cast<FixedPointType const*>(var.annotation().type), "Unknown type.");
Warn if using var x = 0
2017-06-22 14:08:59 +00:00
}
Introduced tuple type and added multi variable declarations to type checker.
2015-10-09 17:35:41 +00:00
var.accept(*this);
}
else
{
var.accept(*this);
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
BoolResult result = valueComponentType->isImplicitlyConvertibleTo(*var.annotation().type);
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 " +
valueComponentType->toString() +
" is not implicitly convertible to expected type " +
var.annotation().type->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 (
valueComponentType->category() == Type::Category::RationalNumber &&
Simplify interface of RationalNumber.
2016-05-10 12:30:24 +00:00
dynamic_cast<RationalNumberType const&>(*valueComponentType).isFractional() &&
Prefer mobileType() to check rational range.
2016-05-10 08:26:53 +00:00
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
)
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
{
if (var.annotation().type->operator==(*valueComponentType->mobileType()))
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
5107_error,
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
_statement.location(),
errorMsg + ", but it can be explicitly converted."
);
else
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4486_error,
Add tests for implcit conversions from literals to fixed-point numbers.
2018-11-30 09:39:21 +00:00
_statement.location(),
errorMsg +
". Try converting to type " +
valueComponentType->mobileType()->toString() +
" or use an explicit conversion."
);
}
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
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
m_errorReporter.typeErrorConcatenateDescriptions(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
9574_error,
Prepare code to output errors returned by isImplicitlyConvertibleTo()
2019-03-04 17:59:03 +00:00
_statement.location(),
errorMsg + ".",
result.message()
);
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
}
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());
}
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
if (autoTypeDeductionNeeded)
{
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
if (!typeCanBeExpressed(variables))
Coding style.
2018-07-10 20:20:10 +00:00
m_errorReporter.syntaxError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
3478_error,
Coding style.
2018-07-10 20:20:10 +00:00
_statement.location(),
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
"Use of the \"var\" keyword is disallowed. "
Coding style.
2018-07-10 20:20:10 +00:00
"Type cannot be expressed in syntax."
);
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
else
Coding style.
2018-07-10 20:20:10 +00:00
m_errorReporter.syntaxError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
1719_error,
Coding style.
2018-07-10 20:20:10 +00:00
_statement.location(),
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
"Use of the \"var\" keyword is disallowed. "
Disallow multi variable declarations with mismatching number of values.
2018-07-04 16:34:24 +00:00
"Use explicit declaration `" + createTupleDecl(variables) + " = ...´ instead."
Coding style.
2018-07-10 20:20:10 +00:00
);
semantics: Suggest auto-deduced type when user declares variable with `var` keyword.
2018-07-02 15:00:09 +00:00
}
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() +
" doesn't match false expression's type " +
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
[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 =
_conditional.condition().annotation().isPure &&
_conditional.trueExpression().annotation().isPure &&
_conditional.falseExpression().annotation().isPure;
[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(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
2212_error,
[cond-expr] don't allow conditional as left value for the first stage
2016-01-11 07:08:28 +00:00
_conditional.location(),
"Conditional expression as left value is not supported yet."
);
[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
}
else if (_type.category() == Type::Category::Mapping)
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)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9214_error, _expression.location(), "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;
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)
{
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,
_tuple.annotation().lValueOfOrdinaryAssignment
);
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;
}
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
}
Removed a redundant else clause.
2020-04-08 21:40:29 +00:00
if (!components[i]->annotation().isPure)
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."
);
Disallow inline arrays of mapping type.
2018-11-29 18:44:33 +00:00
else if (!inlineArrayType->canLiveOutsideStorage())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(1545_error, _tuple.location(), "Type " + inlineArrayType->toString() + " 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
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;
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
_operation.annotation().isPure = !modifying && _operation.subExpression().annotation().isPure;
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 =
_operation.leftExpression().annotation().isPure &&
_operation.rightExpression().annotation().isPure;
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
{
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(_functionCall.annotation().kind == FunctionCallKind::TypeConversion, "");
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());
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->isExplicitlyConvertibleTo(*resultType))
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
m_errorReporter.typeError(
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() +
"\"."
);
}
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)
{
Fix calling unimplemented base function.
2020-03-06 09:44:51 +00:00
if (
m_scope->derivesFrom(*_functionType->declaration().annotation().contract) &&
!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(), "");
Move ContractKind from ContractDefinition to file-scope
2020-01-07 14:11:29 +00:00
if (_function.inContractKind() == ContractKind::Library)
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(), "");
Move ContractKind from ContractDefinition to file-scope
2020-01-07 14:11:29 +00:00
if (_function.inContractKind() == ContractKind::Library)
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.markedVirtual())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7001_error, _function.location(), "Constructors cannot be virtual.");
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()) +
"\"."
);
Move Visibility out of Declaration.
2019-12-10 14:54:09 +00:00
if (_function.visibility() != Visibility::Public && _function.visibility() != Visibility::Internal)
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9239_error, _function.location(), "Constructor must be public or internal.");
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
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 abiEncoderV2 = m_scope->sourceUnit().annotation().experimentalFeatures.count(
ExperimentalFeature::ABIEncoderV2
);
// 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();
solAssert(
!isVariadic || _functionCall.annotation().kind == FunctionCallKind::FunctionCall,
"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 =
_functionCall.annotation().kind == FunctionCallKind::StructConstructorCall;
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
// Extend error message in case we try to construct a struct with mapping member.
if (isStructConstructorCall)
{
/// For error message: Struct members that were removed during conversion to memory.
TypePointer const expressionType = type(_functionCall.expression());
auto const& t = dynamic_cast<TypeType const&>(*expressionType);
auto const& structType = dynamic_cast<StructType const&>(*t.actualType());
set<string> membersRemovedForStructConstructor = structType.membersMissingInMemory();
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 (!membersRemovedForStructConstructor.empty())
{
msg += " Members that have to be skipped in memory:";
for (auto const& member: membersRemovedForStructConstructor)
msg += " " + member;
}
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
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;
for (size_t i = 0; i < paramArgMap.size(); i++)
{
size_t j;
for (j = 0; j < argumentNames.size(); j++)
if (parameterNames[i] == *argumentNames[j])
break;
if (j < argumentNames.size())
paramArgMap[i] = arguments[j].get();
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
paramArgMap[i] = nullptr;
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);
if (!argument->annotation().isPure)
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;
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 &&
_functionCall.expression().annotation().isPure &&
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
)
funcCallAnno.isLValue = functionType->parameterTypes().empty();
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)
{
functionType = dynamic_cast<StructType const&>(*actualType).constructorType();
funcCallAnno.kind = FunctionCallKind::StructConstructorCall;
funcCallAnno.isPure = argumentsArePure;
}
else
{
funcCallAnno.kind = FunctionCallKind::TypeConversion;
funcCallAnno.isPure = argumentsArePure;
}
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");
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::Unset;
funcCallAnno.isPure = argumentsArePure;
break;
}
// Determine return types
switch (funcCallAnno.kind)
{
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:
{
bool const abiEncoderV2 =
m_scope->sourceUnit().annotation().experimentalFeatures.count(
ExperimentalFeature::ABIEncoderV2
);
returnTypes = typeCheckABIDecodeAndRetrieveReturnType(_functionCall, abiEncoderV2);
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;
}
case FunctionCallKind::Unset: // fall-through
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!");
_functionCallOptions.expression().accept(*this);
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.");
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.");
Move public constructor property into AST itself.
2017-03-06 13:12:20 +00:00
if (!contract->constructorIsPublic())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(9054_error, _newExpression.location(), "Contract with internal constructor cannot be created directly.");
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
Make members context-sensitive.
2015-11-19 17:02:04 +00:00
solAssert(!!m_scope, "");
m_scope->annotation().contractDependencies.insert(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
solAssert(
!contract->annotation().linearizedBaseContracts.empty(),
"Linearized base contracts not yet available."
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
);
Make members context-sensitive.
2015-11-19 17:02:04 +00:00
if (contractDependenciesAreCyclic(*m_scope))
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
4579_error,
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
_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);
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
{
Type checking for creating new arrays.
2015-11-17 00:47:47 +00:00
if (!type->canLiveOutsideStorage())
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(),
"Type cannot live outside storage."
);
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();
// Retrieve the types of the arguments if this is used to call a function.
Fix function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
auto const& arguments = _memberAccess.annotation().arguments;
Make members context-sensitive.
2015-11-19 17:02:04 +00:00
MemberList::MemberMap possibleMembers = exprType->members(m_scope).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
auto& annotation = _memberAccess.annotation();
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
);
Improve error message for failed member lookup.
2018-04-18 18:40:46 +00:00
if (!storageType->members(m_scope).membersByName(memberName).empty())
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
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."
);
}
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
)
annotation.isPure = _memberAccess.expression().annotation().isPure;
}
analysis: determine if a member access on a contract is an l-value
2016-10-24 17:22:09 +00:00
}
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()))
{
annotation.isPure = parentAccess->expression().annotation().isPure;
if (auto const* exprInt = dynamic_cast<Identifier const*>(&parentAccess->expression()))
if (exprInt->name() == "this" || exprInt->name() == "super")
annotation.isPure = true;
}
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());
m_scope->annotation().contractDependencies.insert(&accessedContractType.contractDefinition());
if (
memberName == "runtimeCode" &&
!accessedContractType.immutableVariables().empty()
)
m_errorReporter.typeError(
9274_error,
_memberAccess.location(),
"\"runtimeCode\" is not available for contracts containing immutable variables."
);
Add code access dependency.
2019-01-14 23:14:10 +00:00
if (contractDependenciesAreCyclic(*m_scope))
m_errorReporter.typeError(
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
4224_error,
Add code access dependency.
2019-01-14 23:14:10 +00:00
_memberAccess.location(),
"Circular reference for contract code access."
);
}
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
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)
{
_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;
Type checking for pure expressions.
2017-03-01 18:12:40 +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;
Type checking for pure expressions.
2017-03-01 18:12:40 +00:00
if (index && !index->annotation().isPure)
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)
{
_access.baseExpression().accept(*this);
bool isLValue = false; // TODO: set this correctly when implementing slices for memory and storage arrays
bool isPure = _access.baseExpression().annotation().isPure;
if (Expression const* start = _access.startExpression())
{
expectType(*start, *TypeProvider::uint256());
if (!start->annotation().isPure)
isPure = false;
}
if (Expression const* end = _access.endExpression())
{
expectType(*end, *TypeProvider::uint256());
if (!end->annotation().isPure)
isPure = false;
}
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);
_access.annotation().isLValue = isLValue;
_access.annotation().isPure = isPure;
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 function calls with named arguments for overloaded functions
2019-03-19 16:12:21 +00:00
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
}
else if (annotation.overloadedDeclarations.empty())
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.fatalTypeError(7593_error, _identifier.location(), "No candidates for overload resolution found.");
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
else if (annotation.overloadedDeclarations.size() == 1)
annotation.referencedDeclaration = *annotation.overloadedDeclarations.begin();
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."
);
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))
annotation.isPure = annotation.isConstant = variableDeclaration->isConstant();
else if (dynamic_cast<MagicVariableDeclaration const*>(annotation.referencedDeclaration))
Detect custom type expressions that have no effect
2019-02-18 17:19:55 +00:00
{
libsolidity: Introducing TypeProvider API, for clear type system ownership.
2019-04-15 13:33:39 +00:00
if (dynamic_cast<FunctionType const*>(annotation.type))
Warn about side-effect free statements.
2017-04-21 09:13:10 +00:00
annotation.isPure = true;
Detect custom type expressions that have no effect
2019-02-18 17:19:55 +00:00
}
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;
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;
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;
Refactoring: Check types outside of AST and recover from some errors.
2015-09-16 14:56:30 +00:00
}
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);
if (!type(_expression)->isImplicitlyConvertibleTo(_expectedType))
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
m_errorReporter.typeError(
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() +
" or use an explicit conversion."
);
}
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
Add unique IDs to error reporting calls
2020-05-05 22:38:28 +00:00
m_errorReporter.typeError(7407_error, _expression.location(), errorMsg + ".");
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
Better error messages when writing to expressions that cannot be written to.
2019-08-12 15:06:10 +00:00
if (_expression.annotation().isLValue)
return;
Refactor TypeChecker to assign different IDs to different errors
2020-05-21 01:49:31 +00:00
auto [errorId, description] = [&]() -> tuple<ErrorId, string> {
Extract reasonOfFailure to lambda function.
2019-08-13 16:58:50 +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
}
Reference in New Issue Copy Permalink