def METHOD_NAME(self, root_reqs, check_supported_wheels):
    # type: (List[InstallRequirement], bool) -> RequirementSet
    # FIXME: Implement constraints.
    if any(r.constraint for r in root_reqs):
        raise InstallationError("Constraints are not yet supported.")
    provider = PipProvider(
        factory=self.factory,
        ignore_dependencies=self.ignore_dependencies,
    )
    reporter = BaseReporter()
    resolver = RLResolver(provider, reporter)
    requirements = [
        self.factory.make_requirement_from_install_req(r)
        for r in root_reqs
    ]
    try:
        self._result = resolver.METHOD_NAME(requirements)
    except ResolutionImpossible as e:
        error = self.factory.get_installation_error(e)
        if not error:
            # TODO: This needs fixing, we need to look at the
            # factory.get_installation_error infrastructure, as that
            # doesn't really allow for the logger.critical calls I'm
            # using here.
            for req, parent in e.causes:
                logger.critical(
                    "Could not find a version that satisfies " +
                    "the requirement " +
                    str(req) +
                    ("" if parent is None else " (from {})".format(
                        parent.name
                    ))
                )
            raise InstallationError(
                "No matching distribution found for " +
                ", ".join([r.name for r, _ in e.causes])
            )
            raise
        six.raise_from(error, e)
    req_set = RequirementSet(check_supported_wheels=check_supported_wheels)
    for candidate in self._result.mapping.values():
        ireq = provider.get_install_requirement(candidate)
        if ireq is None:
            continue
        ireq.should_reinstall = self.factory.should_reinstall(candidate)
        req_set.add_named_requirement(ireq)
    return req_set