diff options
| -rw-r--r-- | libsolidity/analysis/NameAndTypeResolver.cpp | 41 | ||||
| -rw-r--r-- | libsolidity/analysis/ReferencesResolver.cpp | 4 | ||||
| -rw-r--r-- | libsolidity/analysis/ReferencesResolver.h | 4 | ||||
| -rw-r--r-- | libsolidity/analysis/TypeChecker.cpp | 172 | ||||
| -rw-r--r-- | libsolidity/analysis/TypeChecker.h | 4 |
5 files changed, 116 insertions, 109 deletions
diff --git a/libsolidity/analysis/NameAndTypeResolver.cpp b/libsolidity/analysis/NameAndTypeResolver.cpp index 83107358..92ba25c6 100644 --- a/libsolidity/analysis/NameAndTypeResolver.cpp +++ b/libsolidity/analysis/NameAndTypeResolver.cpp @@ -65,15 +65,15 @@ bool NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract) m_currentScope = &m_scopes[nullptr]; ReferencesResolver resolver(m_errors, *this, &_contract, nullptr); - bool result = true; + bool success = true; for (ASTPointer<InheritanceSpecifier> const& baseContract: _contract.baseContracts()) - result = resolver.resolve(*baseContract); + if (!resolver.resolve(*baseContract)) + success = false; m_currentScope = &m_scopes[&_contract]; - if (result) + if (success) { - linearizeBaseContracts(_contract); std::vector<ContractDefinition const*> properBases( ++_contract.annotation().linearizedBaseContracts.begin(), @@ -84,21 +84,25 @@ bool NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract) importInheritedScope(*base); } - for (ASTPointer<StructDefinition> const& structDef: _contract.definedStructs()) - result = result && resolver.resolve(*structDef); + if (!resolver.resolve(*structDef)) + success = false; for (ASTPointer<EnumDefinition> const& enumDef: _contract.definedEnums()) - result = result && resolver.resolve(*enumDef); + if (!resolver.resolve(*enumDef)) + success = false; for (ASTPointer<VariableDeclaration> const& variable: _contract.stateVariables()) - result = result && resolver.resolve(*variable); + if (!resolver.resolve(*variable)) + success = false; for (ASTPointer<EventDefinition> const& event: _contract.events()) - result = result && resolver.resolve(*event); + if (!resolver.resolve(*event)) + success = false; // these can contain code, only resolve parameters for now for (ASTPointer<ModifierDefinition> const& modifier: _contract.functionModifiers()) { m_currentScope = &m_scopes[modifier.get()]; ReferencesResolver resolver(m_errors, *this, &_contract, nullptr); - result = result && resolver.resolve(*modifier); + if (!resolver.resolve(*modifier)) + success = false; } for (ASTPointer<FunctionDefinition> const& function: _contract.definedFunctions()) { @@ -109,7 +113,8 @@ bool NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract) &_contract, function->returnParameterList().get() ); - result = result && referencesResolver.resolve(*function); + if (!resolver.resolve(*function)) + success = false; } m_currentScope = &m_scopes[&_contract]; @@ -119,7 +124,8 @@ bool NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract) { m_currentScope = &m_scopes[modifier.get()]; ReferencesResolver resolver(m_errors, *this, &_contract, nullptr, true); - result = result && resolver.resolve(*modifier); + if (!resolver.resolve(*modifier)) + success = false; } for (ASTPointer<FunctionDefinition> const& function: _contract.definedFunctions()) { @@ -131,15 +137,16 @@ bool NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract) function->returnParameterList().get(), true ); - result = result && resolver.resolve(*function); + if (!resolver.resolve(*function)) + success = false; } - if (!result) - return false; +// if (!result) +// return false; } catch (FatalError const& _e) { - if (m_errors.empty()) - throw; // Something is weird here, rather throw again. +// if (m_errors.empty()) +// throw; // Something is weird here, rather throw again. return false; } return true; diff --git a/libsolidity/analysis/ReferencesResolver.cpp b/libsolidity/analysis/ReferencesResolver.cpp index 6ac6c923..cad67693 100644 --- a/libsolidity/analysis/ReferencesResolver.cpp +++ b/libsolidity/analysis/ReferencesResolver.cpp @@ -209,10 +209,10 @@ TypePointer ReferencesResolver::typeFor(TypeName const& _typeName) return _typeName.annotation().type = move(type); } -void ReferencesResolver::typeError(string const& _description) +void ReferencesResolver::typeError(string const& _description, SourceLocation const& _location) { auto err = make_shared<Error>(Error::Type::TypeError); - *err << errinfo_comment(_description); + *err << errinfo_sourceLocation(_location) << errinfo_comment(_description); m_errors.push_back(err); } diff --git a/libsolidity/analysis/ReferencesResolver.h b/libsolidity/analysis/ReferencesResolver.h index 13d5a47a..8d03dae1 100644 --- a/libsolidity/analysis/ReferencesResolver.h +++ b/libsolidity/analysis/ReferencesResolver.h @@ -60,7 +60,7 @@ public: bool resolve(ASTNode& _root) { _root.accept(*this); - return m_errors.empty(); + return true;//m_errors.empty(); } private: @@ -73,7 +73,7 @@ private: TypePointer typeFor(TypeName const& _typeName); /// Adds a new error to the list of errors. - void typeError(std::string const& _description); + void typeError(std::string const& _description, SourceLocation const& _location); /// Adds a new error to the list of errors and throws to abort type checking. void fatalTypeError(std::string const& _description); diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp index 6b12c57f..0990a9e4 100644 --- a/libsolidity/analysis/TypeChecker.cpp +++ b/libsolidity/analysis/TypeChecker.cpp @@ -71,7 +71,7 @@ bool TypeChecker::visit(ContractDefinition const& _contract) FunctionDefinition const* function = _contract.constructor(); if (function && !function->returnParameters().empty()) - typeError(*function->returnParameterList(), "Non-empty \"returns\" directive for constructor."); + typeError(function->returnParameterList()->location(), "Non-empty \"returns\" directive for constructor."); FunctionDefinition const* fallbackFunction = nullptr; for (ASTPointer<FunctionDefinition> const& function: _contract.definedFunctions()) @@ -88,7 +88,7 @@ bool TypeChecker::visit(ContractDefinition const& _contract) { fallbackFunction = function.get(); if (!fallbackFunction->parameters().empty()) - typeError(fallbackFunction->parameterList(), "Fallback function cannot take parameters."); + typeError(fallbackFunction->parameterList().location(), "Fallback function cannot take parameters."); } } if (!function->isImplemented()) @@ -108,7 +108,7 @@ bool TypeChecker::visit(ContractDefinition const& _contract) FixedHash<4> const& hash = it.first; if (hashes.count(hash)) typeError( - _contract, + _contract.location(), string("Function signature hash collision for ") + it.second->externalSignature() ); hashes.insert(hash); @@ -183,7 +183,7 @@ void TypeChecker::checkContractAbstractFunctions(ContractDefinition const& _cont else if (it->second) { if (!function->isImplemented()) - typeError(*function, "Redeclaring an already implemented function as abstract"); + typeError(function->location(), "Redeclaring an already implemented function as abstract"); } else if (function->isImplemented()) it->second = true; @@ -252,7 +252,7 @@ void TypeChecker::checkContractIllegalOverrides(ContractDefinition const& _contr continue; // constructors can neither be overridden nor override anything string const& name = function->name(); if (modifiers.count(name)) - typeError(*modifiers[name], "Override changes function to modifier."); + typeError(modifiers[name]->location(), "Override changes function to modifier."); FunctionType functionType(*function); // function should not change the return type for (FunctionDefinition const* overriding: functions[name]) @@ -265,7 +265,7 @@ void TypeChecker::checkContractIllegalOverrides(ContractDefinition const& _contr overriding->isDeclaredConst() != function->isDeclaredConst() || overridingType != functionType ) - typeError(*overriding, "Override changes extended function signature."); + typeError(overriding->location(), "Override changes extended function signature."); } functions[name].push_back(function.get()); } @@ -276,9 +276,9 @@ void TypeChecker::checkContractIllegalOverrides(ContractDefinition const& _contr if (!override) override = modifier.get(); else if (ModifierType(*override) != ModifierType(*modifier)) - typeError(*override, "Override changes modifier signature."); + typeError(override->location(), "Override changes modifier signature."); if (!functions[name].empty()) - typeError(*override, "Override changes modifier to function."); + typeError(override->location(), "Override changes modifier to function."); } } } @@ -310,7 +310,7 @@ void TypeChecker::checkContractExternalTypeClashes(ContractDefinition const& _co for (size_t j = i + 1; j < it.second.size(); ++j) if (!it.second[i].second->hasEqualArgumentTypes(*it.second[j].second)) typeError( - *it.second[j].first, + it.second[j].first->location(), "Function overload clash during conversion to external types for arguments." ); } @@ -319,11 +319,11 @@ void TypeChecker::checkLibraryRequirements(ContractDefinition const& _contract) { solAssert(_contract.isLibrary(), ""); if (!_contract.baseContracts().empty()) - typeError(_contract, "Library is not allowed to inherit."); + typeError(_contract.location(), "Library is not allowed to inherit."); for (auto const& var: _contract.stateVariables()) if (!var->isConstant()) - typeError(*var, "Library cannot have non-constant state variables"); + typeError(var->location(), "Library cannot have non-constant state variables"); } void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance) @@ -332,13 +332,13 @@ void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance) solAssert(base, "Base contract not available."); if (base->isLibrary()) - typeError(_inheritance, "Libraries cannot be inherited from."); + typeError(_inheritance.location(), "Libraries cannot be inherited from."); auto const& arguments = _inheritance.arguments(); TypePointers parameterTypes = ContractType(*base).constructorType()->parameterTypes(); if (!arguments.empty() && parameterTypes.size() != arguments.size()) typeError( - _inheritance, + _inheritance.location(), "Wrong argument count for constructor call: " + toString(arguments.size()) + " arguments given but expected " + @@ -349,7 +349,7 @@ void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance) for (size_t i = 0; i < arguments.size(); ++i) if (!type(*arguments[i])->isImplicitlyConvertibleTo(*parameterTypes[i])) typeError( - *arguments[i], + arguments[i]->location(), "Invalid type for argument in constructor call. " "Invalid implicit conversion from " + type(*arguments[i])->toString() + @@ -363,7 +363,7 @@ bool TypeChecker::visit(StructDefinition const& _struct) { for (ASTPointer<VariableDeclaration> const& member: _struct.members()) if (!type(*member)->canBeStored()) - typeError(*member, "Type cannot be used in struct."); + typeError(member->location(), "Type cannot be used in struct."); // Check recursion, fatal error if detected. using StructPointer = StructDefinition const*; @@ -371,7 +371,7 @@ bool TypeChecker::visit(StructDefinition const& _struct) function<void(StructPointer,StructPointersSet const&)> check = [&](StructPointer _struct, StructPointersSet const& _parents) { if (_parents.count(_struct)) - fatalTypeError(*_struct, "Recursive struct definition."); + fatalTypeError(_struct->location(), "Recursive struct definition."); StructPointersSet parents = _parents; parents.insert(_struct); for (ASTPointer<VariableDeclaration> const& member: _struct->members()) @@ -394,9 +394,9 @@ bool TypeChecker::visit(FunctionDefinition const& _function) for (ASTPointer<VariableDeclaration> const& var: _function.parameters() + _function.returnParameters()) { if (!type(*var)->canLiveOutsideStorage()) - typeError(*var, "Type is required to live outside storage."); + typeError(var->location(), "Type is required to live outside storage."); if (_function.visibility() >= FunctionDefinition::Visibility::Public && !(type(*var)->interfaceType(isLibraryFunction))) - fatalTypeError(*var, "Internal type is not allowed for public or external functions."); + fatalTypeError(var->location(), "Internal type is not allowed for public or external functions."); } for (ASTPointer<ModifierInvocation> const& modifier: _function.modifiers()) visitManually( @@ -424,9 +424,9 @@ bool TypeChecker::visit(VariableDeclaration const& _variable) if (_variable.isConstant()) { if (!dynamic_cast<ContractDefinition const*>(_variable.scope())) - typeError(_variable, "Illegal use of \"constant\" specifier."); + typeError(_variable.location(), "Illegal use of \"constant\" specifier."); if (!_variable.value()) - typeError(_variable, "Uninitialized \"constant\" variable."); + typeError(_variable.location(), "Uninitialized \"constant\" variable."); if (!varType->isValueType()) { bool constImplemented = false; @@ -434,7 +434,7 @@ bool TypeChecker::visit(VariableDeclaration const& _variable) constImplemented = arrayType->isByteArray(); if (!constImplemented) typeError( - _variable, + _variable.location(), "Illegal use of \"constant\" specifier. \"constant\" " "is not yet implemented for this type." ); @@ -446,13 +446,13 @@ bool TypeChecker::visit(VariableDeclaration const& _variable) { if (varType->dataStoredIn(DataLocation::Memory) || varType->dataStoredIn(DataLocation::CallData)) if (!varType->canLiveOutsideStorage()) - typeError(_variable, "Type " + varType->toString() + " is only valid in storage."); + typeError(_variable.location(), "Type " + varType->toString() + " is only valid in storage."); } else if ( _variable.visibility() >= VariableDeclaration::Visibility::Public && !FunctionType(_variable).interfaceFunctionType() ) - typeError(_variable, "Internal type is not allowed for public state variables."); + typeError(_variable.location(), "Internal type is not allowed for public state variables."); return false; } @@ -483,10 +483,10 @@ void TypeChecker::visitManually( break; } if (!parameters) - typeError(_modifier, "Referenced declaration is neither modifier nor base class."); + typeError(_modifier.location(), "Referenced declaration is neither modifier nor base class."); if (parameters->size() != arguments.size()) typeError( - _modifier, + _modifier.location(), "Wrong argument count for modifier invocation: " + toString(arguments.size()) + " arguments given but expected " + @@ -496,7 +496,7 @@ void TypeChecker::visitManually( for (size_t i = 0; i < _modifier.arguments().size(); ++i) if (!type(*arguments[i])->isImplicitlyConvertibleTo(*type(*(*parameters)[i]))) typeError( - *arguments[i], + arguments[i]->location(), "Invalid type for argument in modifier invocation. " "Invalid implicit conversion from " + type(*arguments[i])->toString() + @@ -514,13 +514,13 @@ bool TypeChecker::visit(EventDefinition const& _eventDef) if (var->isIndexed()) numIndexed++; if (_eventDef.isAnonymous() && numIndexed > 4) - typeError(_eventDef, "More than 4 indexed arguments for anonymous event."); + typeError(_eventDef.location(), "More than 4 indexed arguments for anonymous event."); else if (!_eventDef.isAnonymous() && numIndexed > 3) - typeError(_eventDef, "More than 3 indexed arguments for event."); + typeError(_eventDef.location(), "More than 3 indexed arguments for event."); if (!type(*var)->canLiveOutsideStorage()) - typeError(*var, "Type is required to live outside storage."); + typeError(var->location(), "Type is required to live outside storage."); if (!type(*var)->interfaceType(false)) - typeError(*var, "Internal type is not allowed as event parameter type."); + typeError(var->location(), "Internal type is not allowed as event parameter type."); } return false; } @@ -561,7 +561,7 @@ void TypeChecker::endVisit(Return const& _return) ParameterList const* params = _return.annotation().functionReturnParameters; if (!params) { - typeError(_return, "Return arguments not allowed."); + typeError(_return.location(), "Return arguments not allowed."); return; } TypePointers returnTypes; @@ -570,10 +570,10 @@ void TypeChecker::endVisit(Return const& _return) if (auto tupleType = dynamic_cast<TupleType const*>(type(*_return.expression()).get())) { if (tupleType->components().size() != params->parameters().size()) - typeError(_return, "Different number of arguments in return statement than in returns declaration."); + typeError(_return.location(), "Different number of arguments in return statement than in returns declaration."); else if (!tupleType->isImplicitlyConvertibleTo(TupleType(returnTypes))) typeError( - *_return.expression(), + _return.expression()->location(), "Return argument type " + type(*_return.expression())->toString() + " is not implicitly convertible to expected type " + @@ -582,13 +582,13 @@ void TypeChecker::endVisit(Return const& _return) ); } else if (params->parameters().size() != 1) - typeError(_return, "Different number of arguments in return statement than in returns declaration."); + typeError(_return.location(), "Different number of arguments in return statement than in returns declaration."); else { TypePointer const& expected = type(*params->parameters().front()); if (!type(*_return.expression())->isImplicitlyConvertibleTo(*expected)) typeError( - *_return.expression(), + _return.expression()->location(), "Return argument type " + type(*_return.expression())->toString() + " is not implicitly convertible to expected type (type of first return variable) " + @@ -604,10 +604,10 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement) { // No initial value is only permitted for single variables with specified type. if (_statement.declarations().size() != 1 || !_statement.declarations().front()) - fatalTypeError(_statement, "Assignment necessary for type detection."); + fatalTypeError(_statement.location(), "Assignment necessary for type detection."); VariableDeclaration const& varDecl = *_statement.declarations().front(); if (!varDecl.annotation().type) - fatalTypeError(_statement, "Assignment necessary for type detection."); + fatalTypeError(_statement.location(), "Assignment necessary for type detection."); if (auto ref = dynamic_cast<ReferenceType const*>(type(varDecl).get())) { if (ref->dataStoredIn(DataLocation::Storage)) @@ -642,7 +642,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement) { if (!valueTypes.empty()) fatalTypeError( - _statement, + _statement.location(), "Too many components (" + toString(valueTypes.size()) + ") in value for variable assignment (0) needed" @@ -650,7 +650,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement) } else if (valueTypes.size() != variables.size() && !variables.front() && !variables.back()) fatalTypeError( - _statement, + _statement.location(), "Wildcard both at beginning and end of variable declaration list is only allowed " "if the number of components is equal." ); @@ -659,7 +659,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement) --minNumValues; if (valueTypes.size() < minNumValues) fatalTypeError( - _statement, + _statement.location(), "Not enough components (" + toString(valueTypes.size()) + ") in value to assign all variables (" + @@ -667,7 +667,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement) ); if (valueTypes.size() > variables.size() && variables.front() && variables.back()) fatalTypeError( - _statement, + _statement.location(), "Too many components (" + toString(valueTypes.size()) + ") in value for variable assignment (" + @@ -697,7 +697,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement) valueComponentType->category() == Type::Category::IntegerConstant && !dynamic_pointer_cast<IntegerConstantType const>(valueComponentType)->integerType() ) - fatalTypeError(*_statement.initialValue(), "Invalid integer constant " + valueComponentType->toString() + "."); + fatalTypeError(_statement.initialValue()->location(), "Invalid integer constant " + valueComponentType->toString() + "."); var.annotation().type = valueComponentType->mobileType(); var.accept(*this); } @@ -706,7 +706,7 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement) var.accept(*this); if (!valueComponentType->isImplicitlyConvertibleTo(*var.annotation().type)) typeError( - _statement, + _statement.location(), "Type " + valueComponentType->toString() + " is not implicitly convertible to expected type " + @@ -722,7 +722,7 @@ void TypeChecker::endVisit(ExpressionStatement const& _statement) { if (type(_statement.expression())->category() == Type::Category::IntegerConstant) if (!dynamic_pointer_cast<IntegerConstantType const>(type(_statement.expression()))->integerType()) - typeError(_statement.expression(), "Invalid integer constant."); + typeError(_statement.expression().location(), "Invalid integer constant."); } bool TypeChecker::visit(Assignment const& _assignment) @@ -738,7 +738,7 @@ bool TypeChecker::visit(Assignment const& _assignment) } else if (t->category() == Type::Category::Mapping) { - typeError(_assignment, "Mappings cannot be assigned to."); + typeError(_assignment.location(), "Mappings cannot be assigned to."); _assignment.rightHandSide().accept(*this); } else if (_assignment.assignmentOperator() == Token::Assign) @@ -753,7 +753,7 @@ bool TypeChecker::visit(Assignment const& _assignment) ); if (!resultType || *resultType != *t) typeError( - _assignment, + _assignment.location(), "Operator " + string(Token::toString(_assignment.assignmentOperator())) + " not compatible with types " + @@ -789,7 +789,7 @@ bool TypeChecker::visit(TupleExpression const& _tuple) { // Outside of an lvalue-context, the only situation where a component can be empty is (x,). if (!components[i] && !(i == 1 && components.size() == 2)) - fatalTypeError(_tuple, "Tuple component cannot be empty."); + fatalTypeError(_tuple.location(), "Tuple component cannot be empty."); else if (components[i]) { components[i]->accept(*this); @@ -823,7 +823,7 @@ bool TypeChecker::visit(UnaryOperation const& _operation) if (!t) { typeError( - _operation, + _operation.location(), "Unary operator " + string(Token::toString(op)) + " cannot be applied to type " + @@ -843,7 +843,7 @@ void TypeChecker::endVisit(BinaryOperation const& _operation) if (!commonType) { typeError( - _operation, + _operation.location(), "Operator " + string(Token::toString(_operation.getOperator())) + " not compatible with types " + @@ -896,9 +896,9 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) TypeType const& t = dynamic_cast<TypeType const&>(*expressionType); TypePointer resultType = t.actualType(); if (arguments.size() != 1) - typeError(_functionCall, "Exactly one argument expected for explicit type conversion."); + typeError(_functionCall.location(), "Exactly one argument expected for explicit type conversion."); else if (!isPositionalCall) - typeError(_functionCall, "Type conversion cannot allow named arguments."); + typeError(_functionCall.location(), "Type conversion cannot allow named arguments."); else { TypePointer const& argType = type(*arguments.front()); @@ -907,7 +907,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) // (data location cannot yet be specified for type conversions) resultType = ReferenceType::copyForLocationIfReference(argRefType->location(), resultType); if (!argType->isExplicitlyConvertibleTo(*resultType)) - typeError(_functionCall, "Explicit type conversion not allowed."); + typeError(_functionCall.location(), "Explicit type conversion not allowed."); } _functionCall.annotation().type = resultType; @@ -932,7 +932,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) if (!functionType) { - typeError(_functionCall, "Type is not callable"); + typeError(_functionCall.location(), "Type is not callable"); _functionCall.annotation().type = make_shared<TupleType>(); return false; } @@ -957,7 +957,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) for (auto const& member: membersRemovedForStructConstructor) msg += " " + member; } - typeError(_functionCall, msg); + typeError(_functionCall.location(), msg); } else if (isPositionalCall) { @@ -969,11 +969,11 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) { if (auto t = dynamic_cast<IntegerConstantType const*>(argType.get())) if (!t->integerType()) - typeError(*arguments[i], "Integer constant too large."); + typeError(arguments[i]->location(), "Integer constant too large."); } else if (!type(*arguments[i])->isImplicitlyConvertibleTo(*parameterTypes[i])) typeError( - *arguments[i], + arguments[i]->location(), "Invalid type for argument in function call. " "Invalid implicit conversion from " + type(*arguments[i])->toString() + @@ -989,13 +989,13 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) auto const& parameterNames = functionType->parameterNames(); if (functionType->takesArbitraryParameters()) typeError( - _functionCall, + _functionCall.location(), "Named arguments cannnot be used for functions that take arbitrary parameters." ); else if (parameterNames.size() > argumentNames.size()) - typeError(_functionCall, "Some argument names are missing."); + typeError(_functionCall.location(), "Some argument names are missing."); else if (parameterNames.size() < argumentNames.size()) - typeError(_functionCall, "Too many arguments."); + typeError(_functionCall.location(), "Too many arguments."); else { // check duplicate names @@ -1005,7 +1005,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) if (*argumentNames[i] == *argumentNames[j]) { duplication = true; - typeError(*arguments[i], "Duplicate named argument."); + typeError(arguments[i]->location(), "Duplicate named argument."); } // check actual types @@ -1020,7 +1020,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) // check type convertible if (!type(*arguments[i])->isImplicitlyConvertibleTo(*parameterTypes[j])) typeError( - *arguments[i], + arguments[i]->location(), "Invalid type for argument in function call. " "Invalid implicit conversion from " + type(*arguments[i])->toString() + @@ -1033,7 +1033,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall) if (!found) typeError( - _functionCall, + _functionCall.location(), "Named argument does not match function declaration." ); } @@ -1048,9 +1048,9 @@ void TypeChecker::endVisit(NewExpression const& _newExpression) auto contract = dynamic_cast<ContractDefinition const*>(&dereference(_newExpression.contractName())); if (!contract) - fatalTypeError(_newExpression, "Identifier is not a contract."); + fatalTypeError(_newExpression.location(), "Identifier is not a contract."); if (!contract->annotation().isFullyImplemented) - typeError(_newExpression, "Trying to create an instance of an abstract contract."); + typeError(_newExpression.location(), "Trying to create an instance of an abstract contract."); auto scopeContract = _newExpression.contractName().annotation().contractScope; scopeContract->annotation().contractDependencies.insert(contract); @@ -1060,7 +1060,7 @@ void TypeChecker::endVisit(NewExpression const& _newExpression) ); if (contractDependenciesAreCyclic(*scopeContract)) typeError( - _newExpression, + _newExpression.location(), "Circular reference for contract creation (cannot create instance of derived or same contract)." ); @@ -1104,20 +1104,20 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess) ); if (!storageType->members().membersByName(memberName).empty()) fatalTypeError( - _memberAccess, + _memberAccess.location(), "Member \"" + memberName + "\" is not available in " + exprType->toString() + " outside of storage." ); fatalTypeError( - _memberAccess, + _memberAccess.location(), "Member \"" + memberName + "\" not found or not visible " "after argument-dependent lookup in " + exprType->toString() ); } else if (possibleMembers.size() > 1) fatalTypeError( - _memberAccess, + _memberAccess.location(), "Member \"" + memberName + "\" not unique " "after argument-dependent lookup in " + exprType->toString() ); @@ -1153,10 +1153,10 @@ bool TypeChecker::visit(IndexAccess const& _access) { ArrayType const& actualType = dynamic_cast<ArrayType const&>(*baseType); if (!index) - typeError(_access, "Index expression cannot be omitted."); + typeError(_access.location(), "Index expression cannot be omitted."); else if (actualType.isString()) { - typeError(_access, "Index access for string is not possible."); + typeError(_access.location(), "Index access for string is not possible."); index->accept(*this); } else @@ -1164,7 +1164,7 @@ bool TypeChecker::visit(IndexAccess const& _access) expectType(*index, IntegerType(256)); if (auto integerType = dynamic_cast<IntegerConstantType const*>(type(*index).get())) if (!actualType.isDynamicallySized() && actualType.length() <= integerType->literalValue(nullptr)) - typeError(_access, "Out of bounds array access."); + typeError(_access.location(), "Out of bounds array access."); } resultType = actualType.baseType(); isLValue = actualType.location() != DataLocation::CallData; @@ -1174,7 +1174,7 @@ bool TypeChecker::visit(IndexAccess const& _access) { MappingType const& actualType = dynamic_cast<MappingType const&>(*baseType); if (!index) - typeError(_access, "Index expression cannot be omitted."); + typeError(_access.location(), "Index expression cannot be omitted."); else expectType(*index, *actualType.keyType()); resultType = actualType.valueType(); @@ -1196,13 +1196,13 @@ bool TypeChecker::visit(IndexAccess const& _access) length->literalValue(nullptr) )); else - typeError(*index, "Integer constant expected."); + typeError(index->location(), "Integer constant expected."); } break; } default: fatalTypeError( - _access.baseExpression(), + _access.baseExpression().location(), "Indexed expression has to be a type, mapping or array (is " + baseType->toString() + ")" ); } @@ -1218,9 +1218,9 @@ bool TypeChecker::visit(Identifier const& _identifier) if (!annotation.referencedDeclaration) { if (!annotation.argumentTypes) - fatalTypeError(_identifier, "Unable to determine overloaded type."); + fatalTypeError(_identifier.location(), "Unable to determine overloaded type."); if (annotation.overloadedDeclarations.empty()) - fatalTypeError(_identifier, "No candidates for overload resolution found."); + fatalTypeError(_identifier.location(), "No candidates for overload resolution found."); else if (annotation.overloadedDeclarations.size() == 1) annotation.referencedDeclaration = *annotation.overloadedDeclarations.begin(); else @@ -1236,11 +1236,11 @@ bool TypeChecker::visit(Identifier const& _identifier) candidates.push_back(declaration); } if (candidates.empty()) - fatalTypeError(_identifier, "No matching declaration found after argument-dependent lookup."); + fatalTypeError(_identifier.location(), "No matching declaration found after argument-dependent lookup."); else if (candidates.size() == 1) annotation.referencedDeclaration = candidates.front(); else - fatalTypeError(_identifier, "No unique declaration found after argument-dependent lookup."); + fatalTypeError(_identifier.location(), "No unique declaration found after argument-dependent lookup."); } } solAssert( @@ -1250,7 +1250,7 @@ bool TypeChecker::visit(Identifier const& _identifier) annotation.isLValue = annotation.referencedDeclaration->isLValue(); annotation.type = annotation.referencedDeclaration->type(_identifier.annotation().contractScope); if (!annotation.type) - fatalTypeError(_identifier, "Declaration referenced before type could be determined."); + fatalTypeError(_identifier.location(), "Declaration referenced before type could be determined."); return false; } @@ -1263,7 +1263,7 @@ void TypeChecker::endVisit(Literal const& _literal) { _literal.annotation().type = Type::forLiteral(_literal); if (!_literal.annotation().type) - fatalTypeError(_literal, "Invalid literal value."); + fatalTypeError(_literal.location(), "Invalid literal value."); } bool TypeChecker::contractDependenciesAreCyclic( @@ -1294,7 +1294,7 @@ void TypeChecker::expectType(Expression const& _expression, Type const& _expecte if (!type(_expression)->isImplicitlyConvertibleTo(_expectedType)) typeError( - _expression, + _expression.location(), "Type " + type(_expression)->toString() + " is not implicitly convertible to expected type " + @@ -1308,21 +1308,21 @@ void TypeChecker::requireLValue(Expression const& _expression) _expression.annotation().lValueRequested = true; _expression.accept(*this); if (!_expression.annotation().isLValue) - typeError(_expression, "Expression has to be an lvalue."); + typeError(_expression.location(), "Expression has to be an lvalue."); } -void TypeChecker::typeError(ASTNode const& _node, string const& _description) +void TypeChecker::typeError(SourceLocation const& _location, string const& _description) { auto err = make_shared<Error>(Error::Type::TypeError); *err << - errinfo_sourceLocation(_node.location()) << + errinfo_sourceLocation(_location) << errinfo_comment(_description); m_errors.push_back(err); } -void TypeChecker::fatalTypeError(ASTNode const& _node, string const& _description) +void TypeChecker::fatalTypeError(SourceLocation const& _location, string const& _description) { - typeError(_node, _description); + typeError(_location, _description); BOOST_THROW_EXCEPTION(FatalError()); } diff --git a/libsolidity/analysis/TypeChecker.h b/libsolidity/analysis/TypeChecker.h index 9a568349..f163f47c 100644 --- a/libsolidity/analysis/TypeChecker.h +++ b/libsolidity/analysis/TypeChecker.h @@ -57,10 +57,10 @@ public: private: /// Adds a new error to the list of errors. - void typeError(ASTNode const& _node, std::string const& _description); + void typeError(SourceLocation const& _location, std::string const& _description); /// Adds a new error to the list of errors and throws to abort type checking. - void fatalTypeError(ASTNode const& _node, std::string const& _description); + void fatalTypeError(SourceLocation const& _location, std::string const& _description); virtual bool visit(ContractDefinition const& _contract) override; /// Checks that two functions defined in this contract with the same name have different |