pex 2.61.1__py2.py3-none-any.whl → 2.62.0__py2.py3-none-any.whl

pex/resolve/target_system.py

@@ -6,6 +6,9 @@ from __future__ import absolute_import
 import operator
 import sys
 
+from pex import pex_warnings
+from pex.common import pluralize
+from pex.compatibility import string
 from pex.enum import Enum
 from pex.exceptions import production_assert, reportable_unexpected_error_msg
 from pex.interpreter_constraints import InterpreterConstraint, iter_compatible_versions
@@ -16,7 +19,7 @@ from pex.pep_503 import ProjectName
 from pex.sorted_tuple import SortedTuple
 from pex.third_party.packaging.markers import Marker, Variable
 from pex.third_party.packaging.specifiers import Specifier, SpecifierSet
-from pex.typing import TYPE_CHECKING, cast
+from pex.typing import TYPE_CHECKING, Generic, cast
 
 if TYPE_CHECKING:
     from typing import (
@@ -30,6 +33,7 @@ if TYPE_CHECKING:
         Optional,
         Sequence,
         Tuple,
+        TypeVar,
         Union,
     )
 
@@ -84,19 +88,132 @@ def _marker_items(marker):
     return cast("Iterable[Any]", marker._markers)
 
 
+class MarkerVisitor(Generic["_C"]):
+    def visit_and(
+        self,
+        marker,  # type: Marker
+        context,  # type: _C
+    ):
+        # type: (...) -> None
+        pass
+
+    def visit_or(
+        self,
+        marker,  # type: Marker
+        context,  # type: _C
+    ):
+        # type: (...) -> None
+        pass
+
+    def begin_visit_group(
+        self,
+        group,  # type: List[Any]
+        marker,  # type: Marker
+        context,  # type: _C
+    ):
+        # type: (...) -> Optional[_C]
+        return None
+
+    def end_visit_group(
+        self,
+        group,  # type: List[Any]
+        marker,  # type: Marker
+        context,  # type: _C
+        group_context,  # type: Optional[_C]
+    ):
+        # type: (...) -> None
+        pass
+
+    def visit_op(
+        self,
+        lhs,  # type: Any
+        op,  # type: Any
+        rhs,  # type: Any
+        marker,  # type: Marker
+        context,  # type: _C
+    ):
+        # type: (...) -> None
+        pass
+
+
+if TYPE_CHECKING:
+    _C = TypeVar("_C")
+
+
+class MarkerParser(Generic["_C"]):
+    def __init__(self, visitor):
+        # type: (MarkerVisitor["_C"]) -> None
+        self._visitor = visitor
+
+    def _parse_marker_item(
+        self,
+        item,  # type: Union[str, List, Tuple]
+        marker,  # type: Marker
+        context,  # type: _C
+    ):
+        # type: (...) -> None
+
+        if item == "and":
+            self._visitor.visit_and(marker, context)
+        elif item == "or":
+            self._visitor.visit_or(marker, context)
+        elif isinstance(item, list):
+            group_context = self._visitor.begin_visit_group(item, marker, context)
+            element_context = group_context if group_context is not None else context
+            for element in item:
+                self._parse_marker_item(element, marker, element_context)
+            self._visitor.end_visit_group(item, marker, context, group_context)
+        elif isinstance(item, tuple):
+            lhs, op, rhs = item
+            self._visitor.visit_op(lhs, op, rhs, marker, context)
+        else:
+            raise ValueError("Marker is invalid: {marker}".format(marker=marker))
+
+    def parse(
+        self,
+        marker,  # type: Marker
+        context,  # type: _C
+    ):
+        # type: (...) -> _C
+
+        for item in _marker_items(marker):
+            self._parse_marker_item(item, marker, context)
+        return context
+
+
+class HasMarkerVisitor(MarkerVisitor[None]):
+    def __init__(self, name):
+        # type: (str) -> None
+        self._name = name
+        self.has_marker = False
+
+    def visit_op(
+        self,
+        lhs,  # type: Any
+        op,  # type: Any
+        rhs,  # type: Any
+        marker,  # type: Marker
+        context,  # type: None
+    ):
+        # type: (...) -> None
+        if self.has_marker:
+            return
+
+        for term in lhs, rhs:
+            if is_variable(term) and self._name == str(term):
+                self.has_marker = True
+                break
+
+
 def has_marker(
     marker,  # type: Marker
     name,  # type: str
 ):
     # type: (...) -> bool
 
-    for item in _marker_items(marker):
-        if isinstance(item, tuple):
-            lhs, _, rhs = item
-            for term in lhs, rhs:
-                if isinstance(term, Variable) and name == str(term):
-                    return True
-    return False
+    visitor = HasMarkerVisitor(name)
+    MarkerParser(visitor).parse(marker, None)
+    return visitor.has_marker
 
 
 if TYPE_CHECKING:
@@ -122,6 +239,17 @@ _VERSION_MARKER_OP_FLIPPED = {
     ">": "<",
 }
 
+_VERSION_CMP_OPS = {
+    "<",
+    "<=",
+    "==",
+    "!=",
+    ">=",
+    ">",
+    "~=",
+    "===",
+}
+
 
 class _Op(object):
     def __init__(self, lhs):
@@ -143,81 +271,159 @@ class _Or(_Op):
         return self.lhs(marker_env) or cast("EvalMarker", self.rhs)(marker_env)
 
 
-def _get_values_func(marker):
-    # type: (str) -> Optional[Callable[[MarkerEnv], Iterable[str]]]
-
-    if marker == "extra":
-        return lambda marker_env: marker_env.extras
-    elif marker == "os_name":
-        return lambda marker_env: marker_env.os_names
-    elif marker == "platform_system":
-        return lambda marker_env: marker_env.platform_systems
-    elif marker == "sys_platform":
-        return lambda marker_env: marker_env.sys_platforms
-    elif marker == "platform_python_implementation":
-        return lambda marker_env: marker_env.platform_python_implementations
-    elif marker == "python_version":
-        return lambda marker_env: marker_env.python_versions
-    elif marker == "python_full_version":
-        return lambda marker_env: marker_env.python_full_versions
-    return None
-
-
-def _parse_marker_item(
-    stack,  # type: List[EvalMarker]
-    item,  # type: Union[str, List, Tuple]
-    marker,  # type: Marker
-):
-    # type: (...) -> None
-
-    if item == "and":
-        stack.append(_And(stack.pop()))
-    elif item == "or":
-        stack.append(_Or(stack.pop()))
-    elif isinstance(item, list):
-        group = []  # type: List[EvalMarker]
-        for element in item:
-            _parse_marker_item(group, element, marker)
-        production_assert(len(group) == 1)
-        if stack:
-            production_assert(isinstance(stack[-1], _Op))
-            cast(_Op, stack[-1]).rhs = group[0]
-        else:
-            stack.extend(group)
-    elif isinstance(item, tuple):
-        lhs, op, rhs = item
-        check = EvalMarkerFunc.create(lhs, op, rhs)
-        if stack:
-            production_assert(isinstance(stack[-1], _Op))
-            cast(_Op, stack[-1]).rhs = check
+@attr.s(frozen=True)
+class Values(object):
+    @classmethod
+    def from_dict(cls, data):
+        # type: (Dict[str, Any]) -> Values
+        return cls(
+            marker_name=data.pop("marker_name"),
+            values=tuple(data.pop("values", ())),
+            inclusive=data.pop("inclusive", True),
+        )
+
+    marker_name = attr.ib()  # type: str
+    values = attr.ib(default=())  # type: Tuple[str, ...]
+    inclusive = attr.ib(default=True)  # type: bool
+
+    def to_dict(self):
+        # type: () -> Dict[str, Any]
+        return {"marker_name": self.marker_name, "values": self.values, "inclusive": self.inclusive}
+
+    def apply(self, func):
+        # type: (Callable[[str], bool]) -> bool
+        if len(self.values) == 0:
+            return self.marker_name != "extra"
+        if self.inclusive:
+            return any(map(func, self.values))
+        return all((not result) for result in map(func, self.values))
+
+    def __len__(self):
+        # type: () -> int
+        return len(self.values)
+
+    def __iter__(self):
+        # type: () -> Iterator[str]
+        return iter(self.values)
+
+
+def _get_values_func(marker_name):
+    # type: (str) -> Callable[[MarkerEnv], Values]
+
+    if marker_name == "extra":
+        return lambda marker_env: Values(marker_name, marker_env.extras)
+    elif marker_name == "os_name":
+        return lambda marker_env: Values(marker_name, marker_env.os_names)
+    elif marker_name == "platform_system":
+        return lambda marker_env: Values(marker_name, marker_env.platform_systems)
+    elif marker_name == "sys_platform":
+        return lambda marker_env: Values(marker_name, marker_env.sys_platforms)
+    elif marker_name == "platform_python_implementation":
+        return lambda marker_env: Values(marker_name, marker_env.platform_python_implementations)
+    elif marker_name == "python_version":
+        return lambda marker_env: Values(marker_name, marker_env.python_versions)
+    elif marker_name == "python_full_version":
+        return lambda marker_env: Values(marker_name, marker_env.python_full_versions)
+    return lambda marker_env: marker_env.extra_markers.get_values(marker_name)
+
+
+class UniversalMarkerVisitor(MarkerVisitor["List[EvalMarker]"]):
+    @classmethod
+    def parse_marker(cls, marker):
+        # type: (Marker) -> EvalMarker
+
+        checks = MarkerParser(cls()).parse(marker, context=[])
+        production_assert(len(checks) == 1)
+        return checks[0]
+
+    def visit_and(
+        self,
+        marker,  # type: Marker
+        context,  # type: List[EvalMarker]
+    ):
+        # type: (...) -> None
+        context.append(_And(context.pop()))
+
+    def visit_or(
+        self,
+        marker,  # type: Marker
+        context,  # type: List[EvalMarker]
+    ):
+        # type: (...) -> None
+        context.append(_Or(context.pop()))
+
+    def begin_visit_group(
+        self,
+        group,  # type: List[Any]
+        marker,  # type: Marker
+        context,  # type: List[EvalMarker]
+    ):
+        # type: (...) -> Optional[List[EvalMarker]]
+        return []
+
+    def end_visit_group(
+        self,
+        group,  # type: List[Any]
+        marker,  # type: Marker
+        context,  # type: List[EvalMarker]
+        group_context,  # type: Optional[List[EvalMarker]]
+    ):
+        # type: (...) -> None
+
+        if group_context is None or len(group_context) != 1:
+            raise AssertionError(reportable_unexpected_error_msg())
+
+        if context:
+            production_assert(isinstance(context[-1], _Op))
+            cast(_Op, context[-1]).rhs = group_context[0]
         else:
-            stack.append(check)
-    else:
-        raise ValueError("Marker is invalid: {marker}".format(marker=marker))
+            context.extend(group_context)
 
+    def visit_op(
+        self,
+        lhs,  # type: Any
+        op,  # type: Any
+        rhs,  # type: Any
+        marker,  # type: Marker
+        context,  # type: List[EvalMarker]
+    ):
+        # type: (...) -> None
 
-def _parse_marker_check(marker):
-    # type: (Marker) -> EvalMarker
-    checks = []  # type: List[EvalMarker]
-    for item in _marker_items(marker):
-        _parse_marker_item(checks, item, marker)
-    production_assert(len(checks) == 1)
-    return checks[0]
+        check = EvalMarkerFunc.create(lhs, op, rhs)
+        if context:
+            production_assert(isinstance(context[-1], _Op))
+            cast(_Op, context[-1]).rhs = check
+        else:
+            context.append(check)
 
 
-_MARKER_CHECKS = {}  # type: Dict[str, EvalMarker]
+_MARKER_CHECKS = {}  # type: Dict[Union[Marker, str], EvalMarker]
 
 
 def _parse_marker(marker):
     # type: (Marker) -> EvalMarker
-    maker_str = str(marker)
-    eval_marker = _MARKER_CHECKS.get(maker_str)
+    eval_marker = _MARKER_CHECKS.get(marker)
     if not eval_marker:
-        eval_marker = _parse_marker_check(marker)
-        _MARKER_CHECKS[maker_str] = eval_marker
+        marker_str = str(marker)
+        eval_marker = _MARKER_CHECKS.get(marker_str)
+        if not eval_marker:
+            eval_marker = UniversalMarkerVisitor.parse_marker(marker)
+            _MARKER_CHECKS[marker] = eval_marker
+            _MARKER_CHECKS[marker_str] = eval_marker
     return eval_marker
 
 
+def is_variable(value):
+    # type: (Any) -> bool
+
+    if isinstance(value, Variable):
+        return True
+
+    # N.B.: This allows interop with Pip vendored packaging which has the same types in a different
+    # namespace.
+    return type(value).__name__ == "Variable"
+
+
 class EvalMarkerFunc(object):
     @classmethod
     def create(
@@ -228,39 +434,32 @@ class EvalMarkerFunc(object):
     ):
         # type: (...) -> Callable[[MarkerEnv], bool]
 
-        if isinstance(lhs, Variable):
-            marker_name = str(lhs)
+        for var, operand, operand_side in ((lhs, rhs, "rhs"), (rhs, lhs, "lhs")):
+            if not is_variable(var):
+                continue
+            marker_name = str(var)
             get_values = _get_values_func(marker_name)
-            if get_values:
-                value = str(rhs)
-                if marker_name == "extra":
-                    value = ProjectName(value).normalized
-                return cls(
-                    get_values=get_values,
-                    op=str(op),
-                    rhs=value,
-                    is_version_comparison=marker_name in ("python_version", "python_full_version"),
-                )
-
-        if isinstance(rhs, Variable):
-            marker_name = str(rhs)
-            get_values = _get_values_func(marker_name)
-            if get_values:
-                value = str(lhs)
-                if marker_name == "extra":
-                    value = ProjectName(value).normalized
-                return cls(
-                    get_values=get_values,
-                    op=str(op),
-                    lhs=value,
-                    is_version_comparison=marker_name in ("python_version", "python_full_version"),
-                )
+            value = str(operand)
+            if marker_name == "extra":
+                value = ProjectName(value).normalized
+            op_string = str(op)
+            operand_side_arg = {operand_side: value}
+            return cls(
+                get_values=get_values,
+                op=op_string,
+                is_version_comparison=(
+                    marker_name
+                    in ("python_version", "python_full_version", "implementation_version")
+                    and op_string in _VERSION_CMP_OPS
+                ),
+                **operand_side_arg
+            )
 
         return lambda _: True
 
     def __init__(
         self,
-        get_values,  # type: Callable[[MarkerEnv], Iterable[str]]
+        get_values,  # type: Callable[[MarkerEnv], Values]
         op,  # type: str
         lhs=None,  # type: Optional[str]
         rhs=None,  # type: Optional[str]
@@ -275,7 +474,13 @@ class EvalMarkerFunc(object):
                     "{flipped_op}{lhs}".format(lhs=lhs, flipped_op=flipped_op)
                 )
                 self._func = lambda value: cast(
-                    bool, version_specifier.contains(value, prereleases=True)
+                    bool,
+                    version_specifier.contains(
+                        # N.B.: This handles `implementation_version` for Python dev releases in the
+                        # same way `packaging` does.
+                        (value + "local") if value.endswith("+") else value,
+                        prereleases=True,
+                    ),
                 )
             else:
                 oper = _OPERATORS[op]
@@ -284,7 +489,13 @@ class EvalMarkerFunc(object):
             if is_version_comparison:
                 version_specifier = Specifier("{op}{rhs}".format(op=op, rhs=rhs))
                 self._func = lambda value: cast(
-                    bool, version_specifier.contains(value, prereleases=True)
+                    bool,
+                    version_specifier.contains(
+                        # N.B.: This handles `implementation_version` for Python dev releases in the
+                        # same way `packaging` does.
+                        (value + "local") if value.endswith("+") else value,
+                        prereleases=True,
+                    ),
                 )
             else:
                 oper = _OPERATORS[op]
@@ -299,8 +510,158 @@ class EvalMarkerFunc(object):
     def __call__(self, marker_env):
         # type: (MarkerEnv) -> bool
 
-        values = self._get_values(marker_env)
-        return any(map(self._func, values)) if values else True
+        return self._get_values(marker_env).apply(self._func)
+
+
+class ExtraMarkersVisitor(MarkerVisitor[str]):
+    def __init__(self):
+        # type: () -> None
+        self.conflicts = OrderedSet()  # type: OrderedSet[str]
+        self._marker_values = {}  # type: Dict[str, Tuple[str, OrderedSet[str], bool]]
+
+    def visit_op(
+        self,
+        lhs,  # type: Any
+        op,  # type: Any
+        rhs,  # type: Any
+        marker,  # type: Marker
+        context,  # type: str
+    ):
+        # type: (...) -> None
+
+        op_symbol = str(op)
+        if is_variable(lhs):
+            name = str(lhs)
+            value = str(rhs)
+        elif is_variable(rhs):
+            name = str(rhs)
+            value = str(lhs)
+        else:
+            return
+
+        if name in (
+            "extra",
+            "os_name",
+            "platform_system",
+            "sys_platform",
+            "platform_python_implementation",
+            "python_version",
+            "python_full_version",
+        ):
+            return
+
+        if op_symbol == "==":
+            requirement, values, inclusive = self._marker_values.setdefault(
+                name, (context, OrderedSet(), True)
+            )
+            if not inclusive:
+                self.conflicts.add(
+                    "The requirement {context} includes {value} for {name} but the requirement "
+                    "{requirement} established {name} as an exclusive set with values: "
+                    "{values}.".format(
+                        context=context,
+                        value=value,
+                        name=name,
+                        requirement=requirement,
+                        values=" ".join(values),
+                    )
+                )
+            else:
+                values.add(value)
+        elif op_symbol == "!=":
+            requirement, values, inclusive = self._marker_values.setdefault(
+                name, (context, OrderedSet(), False)
+            )
+            if inclusive:
+                self.conflicts.add(
+                    "The requirement {context} excludes {value} for {name} but the requirement "
+                    "{requirement} established {name} as an inclusive set with values: "
+                    "{values}.".format(
+                        context=context,
+                        value=value,
+                        name=name,
+                        requirement=requirement,
+                        values=" ".join(values),
+                    )
+                )
+            else:
+                values.add(value)
+        else:
+            pex_warnings.warn(
+                "Cannot split universal lock on all clauses of the marker in `{requirement}`.\n"
+                "The clause `{lhs} {op} {rhs}` uses comparison `{op}` but only `==` and `!=` are "
+                "supported for splitting on '{name}'.\n"
+                "Ignoring this clause in split calculations; lock results may be "
+                "unexpected.".format(requirement=context, lhs=lhs, op=op, rhs=rhs, name=name)
+            )
+
+    def marker_values(self):
+        # type: () -> Tuple[Values, ...]
+        return tuple(
+            Values(marker_name=name, values=tuple(values), inclusive=inclusive)
+            for name, (_, values, inclusive) in self._marker_values.items()
+        )
+
+
+@attr.s(frozen=True)
+class ExtraMarkers(object):
+    @classmethod
+    def extract(cls, requirements):
+        # type: (Iterable[Tuple[Marker, str]]) -> Optional[ExtraMarkers]
+
+        visitor = ExtraMarkersVisitor()
+        marker_parser = MarkerParser(visitor)
+
+        markers = []  # type: List[Marker]
+        for marker, provenance in requirements:
+            marker_parser.parse(marker, context=provenance)
+            markers.append(marker)
+
+        if visitor.conflicts:
+            raise ValueError(
+                "Encountered {count} {conflicts} when extracting universal lock splits from "
+                "top-level requirement markers:\n{items}".format(
+                    count=len(visitor.conflicts),
+                    conflicts=pluralize(visitor.conflicts, "conflict"),
+                    items="\n".join(
+                        "{index}. {conflict}".format(index=index, conflict=conflict)
+                        for index, conflict in enumerate(visitor.conflicts, start=1)
+                    ),
+                )
+            )
+
+        return cls(markers=tuple(markers), marker_values=visitor.marker_values())
+
+    @classmethod
+    def from_dict(cls, data):
+        # type: (Dict[str, Any]) -> ExtraMarkers
+        return cls(
+            markers=tuple(Marker(marker) for marker in data.pop("markers", ())),
+            marker_values=tuple(
+                Values.from_dict(marker_values) for marker_values in data.pop("marker_values", ())
+            ),
+        )
+
+    markers = attr.ib(default=())  # type: Tuple[Marker, ...]
+    marker_values = attr.ib(default=())  # type: Tuple[Values, ...]
+
+    def to_dict(self):
+        # type: () -> Dict[str, Any]
+        return {
+            "markers": [str(marker) for marker in self.markers],
+            "marker_values": [values.to_dict() for values in self.marker_values],
+        }
+
+    def get_values(self, marker_name):
+        # type: (str) -> Values
+        for values in self.marker_values:
+            if marker_name == values.marker_name:
+                return values
+        return Values(marker_name)
+
+    def __iter__(self):
+        # type: () -> Iterator[Marker]
+        return iter(self.markers)
 
 
 @attr.s(frozen=True)
@@ -353,7 +714,7 @@ class MarkerEnv(object):
                 sys_platforms.append("win32")
 
         return cls(
-            extras=SortedTuple(ProjectName(extra).normalized for extra in (extras or [""])),
+            extras=SortedTuple(ProjectName(extra).normalized for extra in extras),
             os_names=SortedTuple(os_names),
             platform_systems=SortedTuple(platform_systems),
             sys_platforms=SortedTuple(sys_platforms),
@@ -365,23 +726,17 @@ class MarkerEnv(object):
                 ".".join(map(str, python_full_version))
                 for python_full_version in python_full_versions
             ),
+            extra_markers=universal_target.extra_markers if universal_target else ExtraMarkers(),
         )
 
-    extras = attr.ib(converter=SortedTuple, default=SortedTuple())  # type: SortedTuple[str]
-    os_names = attr.ib(converter=SortedTuple, default=SortedTuple())  # type: SortedTuple[str]
-    platform_systems = attr.ib(
-        converter=SortedTuple, default=SortedTuple()
-    )  # type: SortedTuple[str]
-    sys_platforms = attr.ib(converter=SortedTuple, default=SortedTuple())  # type: SortedTuple[str]
-    platform_python_implementations = attr.ib(
-        converter=SortedTuple, default=SortedTuple()
-    )  # type: SortedTuple[str]
-    python_versions = attr.ib(
-        converter=SortedTuple, default=SortedTuple()
-    )  # type: SortedTuple[str]
-    python_full_versions = attr.ib(
-        converter=SortedTuple, default=SortedTuple()
-    )  # type: SortedTuple[str]
+    extras = attr.ib()  # type: SortedTuple[str]
+    os_names = attr.ib()  # type: SortedTuple[str]
+    platform_systems = attr.ib()  # type: SortedTuple[str]
+    sys_platforms = attr.ib()  # type: SortedTuple[str]
+    platform_python_implementations = attr.ib()  # type: SortedTuple[str]
+    python_versions = attr.ib()  # type: SortedTuple[str]
+    python_full_versions = attr.ib()  # type: SortedTuple[str]
+    extra_markers = attr.ib()  # type: ExtraMarkers
 
     def as_dict(self):
         # type: () -> Dict[str, Any]
@@ -426,9 +781,46 @@ def _as_python_version_marker(specifier):
 
 @attr.s(frozen=True)
 class UniversalTarget(object):
+    @classmethod
+    def from_dict(cls, data):
+        # type: (Dict[str, Any]) -> UniversalTarget
+
+        raw_implementation = data.pop("implementation", None)
+        implementation = None  # type: Optional[InterpreterImplementation.Value]
+        if raw_implementation:
+            if not isinstance(raw_implementation, string):
+                raise AssertionError(
+                    reportable_unexpected_error_msg(
+                        "Expected UniversalTarget `implementation` value to be a str, found "
+                        "{value} of type {type}.",
+                        value=raw_implementation,
+                        type=type(raw_implementation),
+                    )
+                )
+            implementation = InterpreterImplementation.for_value(raw_implementation)
+
+        return cls(
+            implementation=implementation,
+            requires_python=tuple(
+                SpecifierSet(specifier) for specifier in data.pop("requires_python", ())
+            ),
+            systems=tuple(TargetSystem.for_value(system) for system in data.pop("systems", ())),
+            extra_markers=ExtraMarkers.from_dict(data.pop("extra_markers", {})),
+        )
+
     implementation = attr.ib(default=None)  # type: Optional[InterpreterImplementation.Value]
     requires_python = attr.ib(default=())  # type: Tuple[SpecifierSet, ...]
     systems = attr.ib(default=())  # type: Tuple[TargetSystem.Value, ...]
+    extra_markers = attr.ib(default=ExtraMarkers())  # type: ExtraMarkers
+
+    def to_dict(self):
+        # type: () -> Dict[str, Any]
+        return {
+            "implementation": str(self.implementation) if self.implementation else None,
+            "requires_python": [str(specifier) for specifier in self.requires_python],
+            "systems": [str(system) for system in self.systems],
+            "extra_markers": self.extra_markers.to_dict(),
+        }
 
     def iter_interpreter_constraints(self):
         # type: () -> Iterator[InterpreterConstraint]
@@ -456,8 +848,8 @@ class UniversalTarget(object):
         marker_envs = OrderedSet(
             MarkerEnv.create(
                 extras=(),
-                universal_target=UniversalTarget(
-                    implementation=self.implementation,
+                universal_target=attr.evolve(
+                    self,
                     requires_python=tuple(
                         [SpecifierSet("=={version}".format(version=".".join(map(str, version))))]
                     ),
@@ -512,4 +904,5 @@ class UniversalTarget(object):
             clauses.append(
                 "({requires_pythons})".format(requires_pythons=" or ".join(python_version_markers))
             )
+        clauses.extend("({marker})".format(marker=marker) for marker in self.extra_markers)
         return Marker(" and ".join(clauses)) if clauses else None