|
| 1 | +use itertools::Itertools; |
| 2 | +use serde::{de, Deserialize, Deserializer, Serialize, Serializer}; |
1 | 3 | use std::cmp::Ordering;
|
2 | 4 | use std::fmt::{self, Display, Formatter};
|
3 | 5 | use std::ops::{Bound, Deref};
|
4 | 6 | use std::str::FromStr;
|
5 |
| - |
6 |
| -use itertools::Itertools; |
7 |
| -use serde::{de, Deserialize, Deserializer, Serialize, Serializer}; |
| 7 | +use std::sync::LazyLock; |
8 | 8 | use uv_normalize::ExtraName;
|
9 | 9 | use uv_pep440::{Version, VersionParseError, VersionSpecifier};
|
10 | 10 | use version_ranges::Ranges;
|
@@ -685,6 +685,186 @@ impl MarkerTree {
|
685 | 685 | self.0.is_false()
|
686 | 686 | }
|
687 | 687 |
|
| 688 | + /// Whether the marker is known to be unsatisfiable. |
| 689 | + /// |
| 690 | + /// For example, while the marker specification and grammar do not _forbid_ it, we know that |
| 691 | + /// both `sys_platform == 'win32'` and `platform_system == 'Darwin'` will never true at the |
| 692 | + /// same time. |
| 693 | + /// |
| 694 | + /// This method thus encodes assumptions about the environment that are not guaranteed by the |
| 695 | + /// PEP 508 specification alone. |
| 696 | + pub fn is_conflicting(&self) -> bool { |
| 697 | + static MUTUAL_EXCLUSIONS: LazyLock<MarkerTree> = LazyLock::new(|| { |
| 698 | + let mut tree = MarkerTree::FALSE; |
| 699 | + for (a, b) in [ |
| 700 | + // sys_platform == 'darwin' and platform_system == 'Windows' |
| 701 | + ( |
| 702 | + MarkerExpression::String { |
| 703 | + key: MarkerValueString::SysPlatform, |
| 704 | + operator: MarkerOperator::Equal, |
| 705 | + value: "darwin".to_string(), |
| 706 | + }, |
| 707 | + MarkerExpression::String { |
| 708 | + key: MarkerValueString::PlatformSystem, |
| 709 | + operator: MarkerOperator::Equal, |
| 710 | + value: "Windows".to_string(), |
| 711 | + }, |
| 712 | + ), |
| 713 | + // sys_platform == 'darwin' and platform_system == 'Linux' |
| 714 | + ( |
| 715 | + MarkerExpression::String { |
| 716 | + key: MarkerValueString::SysPlatform, |
| 717 | + operator: MarkerOperator::Equal, |
| 718 | + value: "darwin".to_string(), |
| 719 | + }, |
| 720 | + MarkerExpression::String { |
| 721 | + key: MarkerValueString::PlatformSystem, |
| 722 | + operator: MarkerOperator::Equal, |
| 723 | + value: "Linux".to_string(), |
| 724 | + }, |
| 725 | + ), |
| 726 | + // sys_platform == 'win32' and platform_system == 'Darwin' |
| 727 | + ( |
| 728 | + MarkerExpression::String { |
| 729 | + key: MarkerValueString::SysPlatform, |
| 730 | + operator: MarkerOperator::Equal, |
| 731 | + value: "win32".to_string(), |
| 732 | + }, |
| 733 | + MarkerExpression::String { |
| 734 | + key: MarkerValueString::PlatformSystem, |
| 735 | + operator: MarkerOperator::Equal, |
| 736 | + value: "Darwin".to_string(), |
| 737 | + }, |
| 738 | + ), |
| 739 | + // sys_platform == 'win32' and platform_system == 'Linux' |
| 740 | + ( |
| 741 | + MarkerExpression::String { |
| 742 | + key: MarkerValueString::SysPlatform, |
| 743 | + operator: MarkerOperator::Equal, |
| 744 | + value: "win32".to_string(), |
| 745 | + }, |
| 746 | + MarkerExpression::String { |
| 747 | + key: MarkerValueString::PlatformSystem, |
| 748 | + operator: MarkerOperator::Equal, |
| 749 | + value: "Linux".to_string(), |
| 750 | + }, |
| 751 | + ), |
| 752 | + // sys_platform == 'linux' and platform_system == 'Darwin' |
| 753 | + ( |
| 754 | + MarkerExpression::String { |
| 755 | + key: MarkerValueString::SysPlatform, |
| 756 | + operator: MarkerOperator::Equal, |
| 757 | + value: "linux".to_string(), |
| 758 | + }, |
| 759 | + MarkerExpression::String { |
| 760 | + key: MarkerValueString::PlatformSystem, |
| 761 | + operator: MarkerOperator::Equal, |
| 762 | + value: "Darwin".to_string(), |
| 763 | + }, |
| 764 | + ), |
| 765 | + // sys_platform == 'linux' and platform_system == 'Windows' |
| 766 | + ( |
| 767 | + MarkerExpression::String { |
| 768 | + key: MarkerValueString::SysPlatform, |
| 769 | + operator: MarkerOperator::Equal, |
| 770 | + value: "linux".to_string(), |
| 771 | + }, |
| 772 | + MarkerExpression::String { |
| 773 | + key: MarkerValueString::PlatformSystem, |
| 774 | + operator: MarkerOperator::Equal, |
| 775 | + value: "Windows".to_string(), |
| 776 | + }, |
| 777 | + ), |
| 778 | + // os_name == 'nt' and sys_platform == 'darwin' |
| 779 | + ( |
| 780 | + MarkerExpression::String { |
| 781 | + key: MarkerValueString::OsName, |
| 782 | + operator: MarkerOperator::Equal, |
| 783 | + value: "nt".to_string(), |
| 784 | + }, |
| 785 | + MarkerExpression::String { |
| 786 | + key: MarkerValueString::SysPlatform, |
| 787 | + operator: MarkerOperator::Equal, |
| 788 | + value: "darwin".to_string(), |
| 789 | + }, |
| 790 | + ), |
| 791 | + // os_name == 'nt' and sys_platform == 'linux' |
| 792 | + ( |
| 793 | + MarkerExpression::String { |
| 794 | + key: MarkerValueString::OsName, |
| 795 | + operator: MarkerOperator::Equal, |
| 796 | + value: "nt".to_string(), |
| 797 | + }, |
| 798 | + MarkerExpression::String { |
| 799 | + key: MarkerValueString::SysPlatform, |
| 800 | + operator: MarkerOperator::Equal, |
| 801 | + value: "linux".to_string(), |
| 802 | + }, |
| 803 | + ), |
| 804 | + // os_name == 'posix' and sys_platform == 'win32' |
| 805 | + ( |
| 806 | + MarkerExpression::String { |
| 807 | + key: MarkerValueString::OsName, |
| 808 | + operator: MarkerOperator::Equal, |
| 809 | + value: "posix".to_string(), |
| 810 | + }, |
| 811 | + MarkerExpression::String { |
| 812 | + key: MarkerValueString::SysPlatform, |
| 813 | + operator: MarkerOperator::Equal, |
| 814 | + value: "win32".to_string(), |
| 815 | + }, |
| 816 | + ), |
| 817 | + // os_name == 'nt' and platform_system == 'Darwin' |
| 818 | + ( |
| 819 | + MarkerExpression::String { |
| 820 | + key: MarkerValueString::OsName, |
| 821 | + operator: MarkerOperator::Equal, |
| 822 | + value: "nt".to_string(), |
| 823 | + }, |
| 824 | + MarkerExpression::String { |
| 825 | + key: MarkerValueString::PlatformSystem, |
| 826 | + operator: MarkerOperator::Equal, |
| 827 | + value: "Darwin".to_string(), |
| 828 | + }, |
| 829 | + ), |
| 830 | + // os_name == 'nt' and platform_system == 'Linux' |
| 831 | + ( |
| 832 | + MarkerExpression::String { |
| 833 | + key: MarkerValueString::OsName, |
| 834 | + operator: MarkerOperator::Equal, |
| 835 | + value: "nt".to_string(), |
| 836 | + }, |
| 837 | + MarkerExpression::String { |
| 838 | + key: MarkerValueString::PlatformSystem, |
| 839 | + operator: MarkerOperator::Equal, |
| 840 | + value: "Linux".to_string(), |
| 841 | + }, |
| 842 | + ), |
| 843 | + // os_name == 'posix' and platform_system == 'Windows' |
| 844 | + ( |
| 845 | + MarkerExpression::String { |
| 846 | + key: MarkerValueString::OsName, |
| 847 | + operator: MarkerOperator::Equal, |
| 848 | + value: "posix".to_string(), |
| 849 | + }, |
| 850 | + MarkerExpression::String { |
| 851 | + key: MarkerValueString::PlatformSystem, |
| 852 | + operator: MarkerOperator::Equal, |
| 853 | + value: "Windows".to_string(), |
| 854 | + }, |
| 855 | + ), |
| 856 | + ] { |
| 857 | + let mut a = MarkerTree::expression(a); |
| 858 | + let b = MarkerTree::expression(b); |
| 859 | + a.and(b); |
| 860 | + tree.or(a); |
| 861 | + } |
| 862 | + tree.negate() |
| 863 | + }); |
| 864 | + |
| 865 | + self.is_disjoint(&MUTUAL_EXCLUSIONS) |
| 866 | + } |
| 867 | + |
688 | 868 | /// Returns a new marker tree that is the negation of this one.
|
689 | 869 | #[must_use]
|
690 | 870 | pub fn negate(&self) -> MarkerTree {
|
|
0 commit comments