Function usingForDirectivesForType

libsolidity/ast/Types.cpp:345–383

{

std::vector<UsingForDirective const*> usingForDirectivesForType(Type const& _type, ASTNode const& _scope)
{
	std::vector<UsingForDirective const*> usingForDirectives;
	SourceUnit const* sourceUnit = dynamic_cast<SourceUnit const*>(&_scope);
	if (auto const* contract = dynamic_cast<ContractDefinition const*>(&_scope))
	{
		sourceUnit = &contract->sourceUnit();
		usingForDirectives += contract->usingForDirectives();
	}
	else
		solAssert(sourceUnit, "");
	usingForDirectives += ASTNode::filteredNodes<UsingForDirective>(sourceUnit->nodes());

	if (Declaration const* typeDefinition = _type.typeDefinition())
		if (auto const* sourceUnit = dynamic_cast<SourceUnit const*>(typeDefinition->scope()))
			for (auto usingFor: ASTNode::filteredNodes<UsingForDirective>(sourceUnit->nodes()))
				// We do not yet compare the type name because of normalization.
				if (usingFor->global() && usingFor->typeName())
					usingForDirectives.emplace_back(usingFor);

	// Normalise data location of type.
	DataLocation typeLocation = DataLocation::Storage;
	if (auto refType = dynamic_cast<ReferenceType const*>(&_type))
		typeLocation = refType->location();

	return usingForDirectives | ranges::views::filter([&](UsingForDirective const* _directive) -> bool {
		// Convert both types to pointers for comparison to see if the `using for` directive applies.
		// Note that at this point we don't yet know if the functions are actually usable with the type.
		// `_type` may not be convertible to the function parameter type.
		return
			!_directive->typeName() ||
			*TypeProvider::withLocationIfReference(typeLocation, &_type, true) ==
			*TypeProvider::withLocationIfReference(
				typeLocation,
				_directive->typeName()->annotation().type,
				true
			);
	}) | ranges::to<std::vector<UsingForDirective const*>>;
}

}