Copy get_supported into packaging.tags-like functions

packaging.tags provides a simple `sys_tags` function for getting
applicable tags for the running interpreter, but it does not allow
customization of arguments.

packaging.tags provides three functions for getting custom tags:

1. `cpython_tags` - for CPython only
2. `generic_tags` - for any non-CPython Python implementation
3. `compatible_tags` - tags that are not specific to an interpreter
   implementation

Since pip allows users to provide explicit impl, platform, abi, and
version, we have to use these functions.

`cpython_tags` and `generic_tags` are mutually exclusive, and return tags
that are the highest priority. These capture the most specific tags.

`compatible_tags` are always applicable, and a lower priority since they
may just be compatible with e.g. the Python language version, but lack
any optimizations available in the interpreter-specific tags.

To be able to do a meaningful comparison between our current
implementation and the above functions, we need to segment the pip code
into pieces that look like them.

To that end, we now have copies of the current `get_supported` function,
one for each of the functions provided by packaging.tags, and will walk
through converting them to rely on packaging.tags. For each
simplification step, if desired, we can compare the implementation in
the packaging.tags function with what we're replacing in pip.

Specifically, for each function in turn, we will:

1. Refactor it locally, taking into account its new, more limited,
   responsibilities
2. Introduce the packaging.tags function for the case where there are no
   custom arguments provided
3. Customize arguments one-by-one and delegate to the packaging.tags
   function
4. When there is no pip-specific logic left, remove the intermediate
   function and use the packaging.tags function directly in
   `get_supported`

In the end all these functions will be gone again and we'll be left with
an implementation that relies solely on the tag generation in
packaging.tags.

src/pip/_internal/pep425tags.py

@@ -294,6 +294,201 @@ def _get_custom_platforms(arch, platform):
     return arches
 
 
+def _cpython_tags(
+    version=None,  # type: Optional[str]
+    platform=None,  # type: Optional[str]
+    impl=None,  # type: Optional[str]
+    abi=None,  # type: Optional[str]
+):
+    # type: (...) -> List[Tuple[str, str, str]]
+    supported = []  # type: List[Tuple[str, str, str]]
+
+    # Versions must be given with respect to the preference
+    if version is None:
+        version_info = get_impl_version_info()
+        versions = get_all_minor_versions_as_strings(version_info)
+    else:
+        versions = [version]
+    current_version = versions[0]
+    other_versions = versions[1:]
+
+    impl = impl or interpreter_name()
+
+    abis = []  # type: List[str]
+
+    abi = abi or get_abi_tag()
+    if abi:
+        abis[0:0] = [abi]
+
+    supports_abi3 = not PY2 and impl == "cp"
+
+    if supports_abi3:
+        abis.append("abi3")
+
+    abis.append('none')
+
+    arches = _get_custom_platforms(platform or get_platform(), platform)
+
+    # Current version, current API (built specifically for our Python):
+    for abi in abis:
+        for arch in arches:
+            supported.append(('%s%s' % (impl, current_version), abi, arch))
+
+    # abi3 modules compatible with older version of Python
+    if supports_abi3:
+        for version in other_versions:
+            # abi3 was introduced in Python 3.2
+            if version in {'31', '30'}:
+                break
+            for arch in arches:
+                supported.append(("%s%s" % (impl, version), "abi3", arch))
+
+    # Has binaries, does not use the Python API:
+    for arch in arches:
+        supported.append(('py%s' % (current_version[0]), 'none', arch))
+
+    # No abi / arch, but requires our implementation:
+    supported.append(('%s%s' % (impl, current_version), 'none', 'any'))
+
+    # No abi / arch, generic Python
+    supported.append(('py%s' % (current_version,), 'none', 'any'))
+    supported.append(('py%s' % (current_version[0]), 'none', 'any'))
+    for version in other_versions:
+        supported.append(('py%s' % (version,), 'none', 'any'))
+
+    return supported
+
+
+def _generic_tags(
+    version=None,  # type: Optional[str]
+    platform=None,  # type: Optional[str]
+    impl=None,  # type: Optional[str]
+    abi=None,  # type: Optional[str]
+):
+    # type: (...) -> List[Tuple[str, str, str]]
+    supported = []  # type: List[Tuple[str, str, str]]
+
+    # Versions must be given with respect to the preference
+    if version is None:
+        version_info = get_impl_version_info()
+        versions = get_all_minor_versions_as_strings(version_info)
+    else:
+        versions = [version]
+    current_version = versions[0]
+    other_versions = versions[1:]
+
+    impl = impl or interpreter_name()
+
+    abis = []  # type: List[str]
+
+    abi = abi or get_abi_tag()
+    if abi:
+        abis[0:0] = [abi]
+
+    supports_abi3 = not PY2 and impl == "cp"
+
+    if supports_abi3:
+        abis.append("abi3")
+
+    abis.append('none')
+
+    arches = _get_custom_platforms(platform or get_platform(), platform)
+
+    # Current version, current API (built specifically for our Python):
+    for abi in abis:
+        for arch in arches:
+            supported.append(('%s%s' % (impl, current_version), abi, arch))
+
+    # abi3 modules compatible with older version of Python
+    if supports_abi3:
+        for version in other_versions:
+            # abi3 was introduced in Python 3.2
+            if version in {'31', '30'}:
+                break
+            for arch in arches:
+                supported.append(("%s%s" % (impl, version), "abi3", arch))
+
+    # Has binaries, does not use the Python API:
+    for arch in arches:
+        supported.append(('py%s' % (current_version[0]), 'none', arch))
+
+    # No abi / arch, but requires our implementation:
+    supported.append(('%s%s' % (impl, current_version), 'none', 'any'))
+
+    # No abi / arch, generic Python
+    supported.append(('py%s' % (current_version,), 'none', 'any'))
+    supported.append(('py%s' % (current_version[0]), 'none', 'any'))
+    for version in other_versions:
+        supported.append(('py%s' % (version,), 'none', 'any'))
+
+    return supported
+
+
+def _compatible_tags(
+    version=None,  # type: Optional[str]
+    platform=None,  # type: Optional[str]
+    impl=None,  # type: Optional[str]
+    abi=None,  # type: Optional[str]
+):
+    # type: (...) -> List[Tuple[str, str, str]]
+    supported = []  # type: List[Tuple[str, str, str]]
+
+    # Versions must be given with respect to the preference
+    if version is None:
+        version_info = get_impl_version_info()
+        versions = get_all_minor_versions_as_strings(version_info)
+    else:
+        versions = [version]
+    current_version = versions[0]
+    other_versions = versions[1:]
+
+    impl = impl or interpreter_name()
+
+    abis = []  # type: List[str]
+
+    abi = abi or get_abi_tag()
+    if abi:
+        abis[0:0] = [abi]
+
+    supports_abi3 = not PY2 and impl == "cp"
+
+    if supports_abi3:
+        abis.append("abi3")
+
+    abis.append('none')
+
+    arches = _get_custom_platforms(platform or get_platform(), platform)
+
+    # Current version, current API (built specifically for our Python):
+    for abi in abis:
+        for arch in arches:
+            supported.append(('%s%s' % (impl, current_version), abi, arch))
+
+    # abi3 modules compatible with older version of Python
+    if supports_abi3:
+        for version in other_versions:
+            # abi3 was introduced in Python 3.2
+            if version in {'31', '30'}:
+                break
+            for arch in arches:
+                supported.append(("%s%s" % (impl, version), "abi3", arch))
+
+    # Has binaries, does not use the Python API:
+    for arch in arches:
+        supported.append(('py%s' % (current_version[0]), 'none', arch))
+
+    # No abi / arch, but requires our implementation:
+    supported.append(('%s%s' % (impl, current_version), 'none', 'any'))
+
+    # No abi / arch, generic Python
+    supported.append(('py%s' % (current_version,), 'none', 'any'))
+    supported.append(('py%s' % (current_version[0]), 'none', 'any'))
+    for version in other_versions:
+        supported.append(('py%s' % (version,), 'none', 'any'))
+
+    return supported
+
+
 def get_supported(
     version=None,  # type: Optional[str]
     platform=None,  # type: Optional[str]