code: def get_intersection(self, range_):
          
          result = []
  
          for entry in self.entries:
              package, value = entry
  
              if value is None:
                  continue  # package was blocked by package filters
  
              if package.version not in range_:
                  continue
  
              if isinstance(value, list):
                  variants = value
                  entry_ = _PackageEntry(package, variants, self.solver)
                  result.append(entry_)
                  continue
  
              # apply package filter
              if self.solver.package_filter:
                  rule = self.solver.package_filter.excludes(package)
                  if rule:
                      if config.debug_package_exclusions:
                          print_debug("Package '%s' was excluded by rule '%s'"
                                      % (package.qualified_name, str(rule)))
                      entry[1] = None
                      continue
  
              # expand package entry into list of variants
              if self.solver.package_load_callback:
                  self.solver.package_load_callback(package)
  
              variants_ = []
              for var in package.iter_variants():
                  variant = PackageVariant(var, self.solver.building)
                  variants_.append(variant)
  
              entry[1] = variants_
              entry_ = _PackageEntry(package, variants_, self.solver)
              result.append(entry_)
  
          return result or None
docs: Get a list of variants that intersect with the given range.
  
          Args:
              range_ (`VersionRange`): Package version range.
  
          Returns:
              List of `_PackageEntry` objects.