runtime: OperatingSystem.IsIOS API is problematic

I’ve been exploring options for this and I have an updated proposal. I found that the Platform Compatibility Analyzer does not currently respect SupportedOSPlatformGuard attributes on the System.OperatingSystem methods; it identifies this type specifically and infers the method’s platform guard. I also found flaws in the proposal of adding [SupportedOSPlatformGuard("ios")] to IsMacCatalyst, but the updated proposal is similar and addresses the flaws.

Acceptance Criteria

To consider the proposal of using SupportedOSPlatformGuard attributes on the OperatingSystem methods to achieve a relationship of MacCatalyst as a superset of IOS, we will utilize the following acceptance criteria.

1. APIs annotated as supported on IOS are available on MacCatalyst without warning
   • This allows existing APIs annotated as supported on IOS to be automatically supported on MacCatalyst
2. Guarding those calls only requires checking a single platform
   • OperatingSystem.IsIOS() matches both IOS and MacCatalyst
3. APIs can still be annotated as being being supported on one but not both IOS and MacCatalyst
   • OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst() matches only IOS but not MacCatalyst
   • OperatingSystem.IsMacCatalyst() matches only MacCatalyst but not IOS
4. New usage of [SupportedOSPlatformGuard] attributes is consistent with existing behavior
5. [UnsupportedOSPlatform] and [UnsupportedOSPlatformGuard] attributes must continue to work as expected
   • [UnsupportedOSPlatform] attributes must respect the platform relationship defined
   • This allows existing APIs annotated as unsupported on IOS to be automatically unsupported on MacCatalyst
6. The performance impact of the change must be negligible

There are a few other design considerations as well, although they are not required goals.

1. OperatingSystem methods should be treated like any other method with [SupportedOSPlatformGuard] attributes
2. Customers should be able to define their own platforms and relationships through extensibility
3. The existing “macos” / “osx” alias relationship should become modeled through attributes instead of hard-coded

Proposal Summary

1. Update OperatingSystem.IsIOS to return true when the platform is “ios” OR “maccatalyst”
2. Update the Platform Compatibility Analyzer to respect [SupportedOSPlatformGuard] attributes on System.OperatingSystem
   • Load these into a map during analyzer initialization
   • Use fallback logic of inferring the method’s platform guard from the method name if no attributes exist
3. Annotate OperatingSystem.IsIOS with [SupportedOSPlatformGuard("ios")] and [SupportedOSPlatformGuard("maccatalyst")]
   • Optionally, annotate all OperatingSystem.Is{Platform} methods with [SupportedOSPlatformGuard("{Platform}")] attributes
   • These attribute values could become the source of truth for casing of the platform names
4. Update the Platform Compatibility Analyzer such that when identifying an API’s supported/unsupported platforms, the platform set is expanded to include all platforms indicated through [SupportedOSPlatformGuard] attributes on that platform’s Is{Platform} method
5. Optionally, refactor the macOS/OSX alias logic to use this same mapping logic
   • This would require a new IsOsx member on OperatingSystem (either private or [Obsolete])

Illustration of Acceptance Criteria

The following code simulates this behavior by using custom guard properties with [SupportedOSPlatformGuard] attributes and showing where [SupportedOSPlatform] and [UnsupportedOSPlatform] attributes would be inferred by the updated logic.

    // Guard methods that simulate the OperatingSystem members
    [SupportedOSPlatformGuard("ios")]
    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsIOS => OperatingSystem.IsIOS() || OperatingSystem.IsMacCatalyst();

    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsMacCatalyst => OperatingSystem.IsMacCatalyst();

    // This would be a new member added to OperatingSystem, but it could be
    // private or Obsolete as an error with EditorBrowsable: Never
    [SupportedOSPlatformGuard("macos")]
    [SupportedOSPlatformGuard("osx")]
    private bool IsOsx() => OperatingSystem.IsMacOS();

    [SupportedOSPlatformGuard("macos")]
    [SupportedOSPlatformGuard("osx")]
    bool IsMacOs => OperatingSystem.IsMacOS();


    // APIs for the scenarios
    [SupportedOSPlatform("ios")]
    // The following attribute would not exist in the code
    // but it would be inferred by the analyzer.
    [SupportedOSPlatform("maccatalyst")]
    void SupportedOnIOS() { }

    [SupportedOSPlatform("ios")]
    // The following attribute would exist in code, but
    // would be canceled out by the analyzer because
    // "maccatalyst" would be inferred as supported,
    // and then the unsupported attribute cancels it out.
    // [UnsupportedOSPlatform("maccatalyst")]
    void SupportedOnIOS_ButNotMacCatalyst() { }

    [SupportedOSPlatform("maccatalyst")]
    void SupportedOnMacCatalyst() { }

    [SupportedOSPlatform("ios")]
    [SupportedOSPlatform("maccatalyst")]
    void SupportedOnIOSOrMacCatalyst() { }

    [UnsupportedOSPlatform("ios")]
    // The following attribute would not exist in the code
    // but it would be inferred by the analyzer.
    [UnsupportedOSPlatform("maccatalyst")]
    void UnsupportedOnIOS() { }

    [UnsupportedOSPlatform("maccatalyst")]
    void UnsupportedOnMacCatalyst() { }

    [SupportedOSPlatform("macos")]
    // The following attribute would not exist in the code
    // but it would be inferred by the analyzer.
    [SupportedOSPlatform("osx")]
    void SupportedOnMacOS() { }

    [SupportedOSPlatform("osx")]
    // The following attribute would not exist in the code
    // but it would be inferred by the analyzer.
    [SupportedOSPlatform("macos")]
    void SupportedOnOsx() { }


    // Test cases
    void Main()
    {
        // This block is reachable on both IOS and MacCatalyst but not macOS/OSX
        if (IsIOS)
        {
            SupportedOnIOSOrMacCatalyst();      // Scenario 1a - No warning
            SupportedOnMacCatalyst();           // Scenario 1b - Warning
            SupportedOnIOS();                   // Scenario 1c - No warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 1d - Warning
            UnsupportedOnIOS();                 // Scenario 1e - Warning
            UnsupportedOnMacCatalyst();         // Scenario 1f - Warning
            SupportedOnMacOS();                 // Scenario 1g - Warning
            SupportedOnOsx();                   // Scenario 1h - Warning
        }

        // This block is reachable on MacCatalyst but not IOS or macOS/OSX
        if (IsMacCatalyst)
        {
            SupportedOnIOSOrMacCatalyst();      // Scenario 2a - No warning
            SupportedOnMacCatalyst();           // Scenario 2b - No warning
            SupportedOnIOS();                   // Scenario 2c - No warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 2d - Warning
            UnsupportedOnIOS();                 // Scenario 2e - Warning
            UnsupportedOnMacCatalyst();         // Scenario 2f - Warning
            SupportedOnMacOS();                 // Scenario 2g - Warning
            SupportedOnOsx();                   // Scenario 2h - Warning
        }

        // This code block is reachable on IOS but not MacCatalyst or macOS/OSX
        if (IsIOS && !IsMacCatalyst)
        {
            SupportedOnIOSOrMacCatalyst();      // Scenario 3a - No warning
            SupportedOnMacCatalyst();           // Scenario 3b - Warning
            SupportedOnIOS();                   // Scenario 3c - No warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 3d - No warning
            UnsupportedOnIOS();                 // Scenario 3e - Warning
            UnsupportedOnMacCatalyst();         // Scenario 3f - No warning
            SupportedOnMacOS();                 // Scenario 3g - Warning
            SupportedOnOsx();                   // Scenario 3h - Warning
        }

        // This code block is reachable on macOS/OSX but not IOS or MacCatalyst
        if (IsMacOs)
        {
            SupportedOnIOSOrMacCatalyst();      // Scenario 4a - Warning
            SupportedOnMacCatalyst();           // Scenario 4b - Warning
            SupportedOnIOS();                   // Scenario 4c - Warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 4d - Warning
            UnsupportedOnIOS();                 // Scenario 4e - No warning
            UnsupportedOnMacCatalyst();         // Scenario 4f - No warning
            SupportedOnMacOS();                 // Scenario 4g - No warning
            SupportedOnOsx();                   // Scenario 4h - No warning
        }

        // This code block is reachable on IOS, MacCatalyst, and macOS/OSX
        if (IsMacOs || IsIOS)
        {
            SupportedOnIOSOrMacCatalyst();      // Scenario 5a - Warning
            SupportedOnMacCatalyst();           // Scenario 5b - Warning
            SupportedOnIOS();                   // Scenario 5c - Warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 5d - Warning
            UnsupportedOnIOS();                 // Scenario 5e - Warning
            UnsupportedOnMacCatalyst();         // Scenario 5f - Warning
            SupportedOnMacOS();                 // Scenario 5g - Warning
            SupportedOnOsx();                   // Scenario 5h - Warning
        }
    }

This approach and design meets all of the acceptance criteria defined above.

1. APIs annotated as supported on IOS are available on MacCatalyst without warning
2. Guarding those calls only requires checking a single platform (IsIOS())
3. APIs can still be annotated as being being supported on one but not both IOS and MacCatalyst
4. New usage of [SupportedOSPlatformGuard] attributes is consistent with existing behavior
5. [UnsupportedOSPlatform] and [UnsupportedOSPlatformGuard] attributes must continue to work as expected
6. The performance impact of the change must be negligible
   • This will be achieved by loading the map of SupportedOSPlatformGuard annotations during initialization
   • The map would be utilized during identification of supported/unsupported platforms on APIs
   • If the map is empty, then the current behavior of only identifying the specified platform would persist

The other design considerations can all be achieved as well.

1. OperatingSystem methods should be treated like any other method with SupportedOSPlatformGuard attributes
   • This is true
2. Customers should be able to define their own platforms and relationships through extensibility
   • Customers could define internal OperatingSystem implementations to augment/override built-in behavior
3. The existing “macos” / “osx” alias relationship should become modeled through attributes instead of hard-coded
   • This can be true if an IsOSX() method is added to OperatingSystem (private or [Obsolete])

    [SupportedOSPlatform("android")]
    void DoWork() { }

    void Main()
    {
        if (OperatingSystem.IsAndroid())
            DoWork();
    }

    [SupportedOSPlatformGuard("android")]
    bool IsSupported => OperatingSystem.IsAndroid();

    void Main()
    {
        if (IsSupported)
            DoWork();
    }

    [SupportedOSPlatform("android")]
    [SupportedOSPlatform("ios")]
    void DoWork() { }

    [SupportedOSPlatformGuard("android")]
    [SupportedOSPlatformGuard("ios")]
    bool IsSupported => OperatingSystem.IsAndroid() || OperatingSystem.IsIOS();

    void Main()
    {
        if (IsSupported)
            DoWork();
    }

    [SupportedOSPlatform("android")]
    void SupportedOnAndroid() { }

    [SupportedOSPlatform("ios")]
    [SupportedOSPlatform("maccatalyst")]
    void SupportedOnApplePlatforms() { }

    [SupportedOSPlatformGuard("ios")]
    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsApplePlatform => OperatingSystem.IsIOS() ||
                            OperatingSystem.IsMacCatalyst();

    [SupportedOSPlatformGuard("android")]
    [SupportedOSPlatformGuard("ios")]
    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsSupported => IsApplePlatform ||
                        OperatingSystem.IsAndroid();

    void Main()
    {
        if (IsSupported)
        {
            if (IsApplePlatform)
                SupportedOnApplePlatforms();
            else if (OperatingSystem.IsAndroid())
                SupportedOnAndroid();
        }
    }

    [SupportedOSPlatformGuard("ios")]
    public static bool IsIOS();

    [SupportedOSPlatformGuard("maccatalyst")]
    [SupportedOSPlatformGuard("ios")]
    public static bool IsMacCatalyst();

    [SupportedOSPlatformGuard("ios")]
    [SupportedOSPlatformGuard("maccatalyst")]
    public static bool IsIOS(); // returns true on either ios or maccatalyst

    [SupportedOSPlatformGuard("maccatalyst")]
    public static bool IsMacCatalyst(); // returns true only on maccatalyst

    [SupportedOSPlatform("ios")]
    [SupportedOSPlatform("maccatalyst")]
    void SupportedOnIOSOrMacCatalyst() { }

    [SupportedOSPlatform("ios")]
    void SupportedOnIOS() { }

    [SupportedOSPlatform("maccatalyst")]
    void SupportedOnMacCatalyst() { }

    [SupportedOSPlatformGuard("ios")]
    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsIOS => OperatingSystem.IsIOS() ||
                  OperatingSystem.IsMacCatalyst();

    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsMacCatalyst => OperatingSystem.IsMacCatalyst();

    void Main()
    {
        if (IsIOS)
        {
            // Correct: No warning
            SupportedOnIOSOrMacCatalyst();

            // Correct: Reachable on 'ios', only supported on 'maccatalyst'
            SupportedOnMacCatalyst();

            // INCORRECT: Reachable on 'maccatalyst', only supported on 'ios'
            SupportedOnIOS();
        }

        if (IsMacCatalyst)
        {
            // Correct: No warning
            SupportedOnIOSOrMacCatalyst();

            // Correct: No warning
            SupportedOnMacCatalyst();

            // INCORRECT: Reachable on 'maccatalyst', only supported on 'ios'
            SupportedOnIOS();
        }
    }

    [SupportedOSPlatformGuard("ios")]
    bool IsIOS => OperatingSystem.IsIOS() ||
                  OperatingSystem.IsMacCatalyst();

    [SupportedOSPlatformGuard("maccatalyst")]
    [SupportedOSPlatformGuard("ios")]
    bool IsMacCatalyst => OperatingSystem.IsMacCatalyst();

    void Main()
    {
        if (IsIOS)
        {
            // Correct: No warning
            SupportedOnIOSOrMacCatalyst();

            // Correct: Reachable on 'ios', only supported on 'maccatalyst'
            SupportedOnMacCatalyst();

            // Correct: No warning
            SupportedOnIOS();
        }

        if (IsMacCatalyst)
        {
            // Correct: No warning
            SupportedOnIOSOrMacCatalyst();

            // INCORRECT: Reachable on 'ios', only supported on 'maccatalyst'
            SupportedOnMacCatalyst();

            // INCORRECT: Reachable on 'maccatalyst', only supported on 'ios'
            SupportedOnIOS();
        }
    }

    [SupportedOSPlatformGuard("ios")]
    bool IsIOS => OperatingSystem.IsIOS() ||
                  OperatingSystem.IsMacCatalyst();

    [SupportedOSPlatformGuard("maccatalyst")]
    // [SupportedOSPlatformGuard("ios")] this would exist
    bool IsMacCatalyst => OperatingSystem.IsMacCatalyst();

    void Main()
    {
        if (IsIOS)
        {
            // Correct: No warning
            SupportedOnIOSOrMacCatalyst();

            // Correct: Reachable on 'ios', only supported on 'maccatalyst'
            SupportedOnMacCatalyst();

            // Correct: No warning
            SupportedOnIOS();
        }

        // Simulating the _AND_ logic that would be inferred from the
        // extra "ios" guard annotation on IsMacCatalyst
        if (IsMacCatalyst && IsIOS)
        {
            // Correct: No warnings
            SupportedOnIOSOrMacCatalyst();

            // Correct: No warnings
            SupportedOnMacCatalyst();

            // Correct: No warnings
            SupportedOnIOS();
        }
    }

    [SupportedOSPlatformGuard("ios")]
    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsIOS => OperatingSystem.IsIOS() ||
                  OperatingSystem.IsMacCatalyst();

    [SupportedOSPlatformGuard("maccatalyst")]
    bool IsMacCatalyst => OperatingSystem.IsMacCatalyst();

    void Main()
    {
        if (IsIOS)
        {
            SupportedOnIOSOrMacCatalyst(); // Scenario 1 - Should not warn
            SupportedOnMacCatalyst();      // Scenario 2 - Should warn
            SupportedOnIOS();              // Scenario 3 - Should not warn
        }

        if (IsMacCatalyst)
        {
            SupportedOnIOSOrMacCatalyst(); // Scenario 4 - Should not warn
            SupportedOnMacCatalyst();      // Scenario 5 - Should not warn
            SupportedOnIOS();              // Scenario 6 - Should not warn
        }
    }

Here’s a representation of what I think can be inferred for the guard attributes:

[SupportedOSPlatformGuard("ios")] // specified
// [SupportedOSPlatformGuard("maccatalyst")] cannot be inferred, because
// it's possible for IsIOS() to be true while IsMacCatalyst() is false.
public bool WorksOnIOS => OperatingSystem.IsIOS();


[SupportedOSPlatformGuard("maccatalyst")] // specified
[SupportedOSPlatformGuard("ios")] // can be inferred, because
// if IsMacCatalyst() returns true, then IsIOS() will also return true.
public bool WorksOnMacCatalyst => OperatingSystem.IsMacCatalyst();


[UnsupportedOSPlatformGuard("ios")] // specified
[UnsupportedOSPlatformGuard("maccatalyst")] // can be inferred, because
// if IsIOS() returns false, then IsMacCatalyst() will also return false.
public bool DoesNotWorkOnIOS => !OperatingSystem.IsIOS();

[UnsupportedOSPlatformGuard("maccatalyst")] // specified
// [UnsupportedOSPlatformGuard("ios")] cannot be inferred, because
// it's possible for IsMacCatalyst() to be false while IsIOS() is true.
public bool DoesNotWorkOnMacCatalyst => !OperatingSystem.IsMacCatalyst();

So the trick is how to add the support to the analyzer to understand the platform relationships.

Agreed, that’s inescapable IMHO.

I’d prefer for that to be data-driven and not have those specific relationships coded into the analyzer.

Agreed

Are you proposing the analyzer would read the guard attributes in the OperatingSystem class to glean the relationships?

@buyaa-n Correct.

Note that there could be some APIs (none in dotnet/runtime AFAIK; few in Xamarin bindings) which exist on iOS and don’t exist in Mac Catalyst. In that case I would expect an annotation like this to work:

[SupportedOSPlatform("ios")]
[UnsupportedOSPlatform("maccatalyst")]

This is mostly covering frameworks that don’t make sense outside of the phone environment (CoreTelephony, CoreNFC, ARKit, VisionKit, HealthKit, HealthKitUI, AddressBookUI, CarPlay, …). It’s feasible that some of them may appear at later time if Apple decides to do so.

I guess the same apply to the attributes: [SupportedOSPlatform("iOS")] cover iOS and MacCatalyst [SupportedOSPlatform("maccatalyst")] only cover MacCatalyst [UnsupportedOSPlatform("iOS")] cover iOS and MacCatalyst [UnsupportedOSPlatform("maccatalyst")] only cover MacCatalyst

Here’s my understanding of the desired experience:

@filipnavara does that match your expectations?

Note that the Android/Linux behavior has already been changed in #53034.

If iOS is supposed to map to MacCatalyst versions 1:1

It is. There are multiple versions available on MacCatalyst (Darwin, macOS, iOS) but this API and Evironment.OSVersion operates on the iOS one (consistent with Apple and documentation).

My vote would be for Proposal A since it matches the underlying platform model.

Thanks everyone!

For step 4 filed an issue, this one can be closed now

Makes sense, @buyaa-n; thanks. I forgot that the guards produce OR logic.

Here’s a representation of what I think can be inferred for the guard attributes:

Thanks, @jeffhandley, all looked right initially, but now I think the section covering the SupportedOSPlatformGuard part needs update because multiple SupportedOSPlatformGuard attributes produce OR logic

[SupportedOSPlatformGuard("ios")] // specified
[SupportedOSPlatformGuard("maccatalyst")] // both specified
// The guard attributes would produce OperatingSystem.IsIOS() || OperatingSystem.IsMacCatalyst() logic
public bool WorksOnIOSMacCatalyst => true;

// And because the guard method OperatingSystem.IsIOS() now has [SupportedOSPlatformGuard("maccatalyst")] 
// OperatingSystem.IsIOS()  is now infer OperatingSystem.IsIOS() || OperatingSystem.IsMacCatalyst();
// therefore [SupportedOSPlatformGuard("ios")] snould inferl [SupportedOSPlatformGuard("maccatalyst")]  too

// Further as OperatingSystem.IsMacCatalyst() has no attribute and it only infer  OperatingSystem.IsMacCatalyst()
[SupportedOSPlatformGuard("maccatalyst")] // specified
// [SupportedOSPlatformGuard("ios")] // can not be inferred, therefore to guard ios user need to add the attribute explicitly
public bool WorksOnMacCatalyst => OperatingSystem.IsMacCatalyst();

Do guard methods provide the same stacking behavior as the supported attributes do? If so, then @jeffhandley’s logic should apply to guard methods too.

In fact, they probably should be mirrors because the guard methods are supposed to be used before calling the annotated APIs, so I’d say it would be odd if guard attributes can’t be stacked like this.

Modified Illustration of Acceptance Criteria

I have modified the proposal with exact use case scenarios with have agreed to add within 6.0 (like excluding macOS/OSX scenario we moved to 7.0).

public class OperatingSystem
{
    // Guard methods that simulate the OperatingSystem members
    // [SupportedOSPlatformGuard("ios")] this annotation is not needed as the method name express that it is iOS guard 
    [SupportedOSPlatformGuard("maccatalyst")]
    public static bool IsIOS() => IsIOS() || IsMacCatalyst();

    // [SupportedOSPlatformGuard("maccatalyst")] for same reason annotation doesn't need
    public static bool IsMacCatalyst() => IsMacCatalyst();
    ...
}

public class AnnotationScenarios    // APIs for the scenarios
{
    // The [SupportedOSPlatform("maccatalyst")] attribute would not exist in the code
    // but it would be inferred by the analyzer.
    [SupportedOSPlatform("ios")]
    void SupportedOnIOSAndMacCatalyst() { }

    // Having the [SupportedOSPlatform("maccatalyst")] explicitly
    // has no effect, it is same as above annotation
    [SupportedOSPlatform("maccatalyst")]
    [SupportedOSPlatform("ios")]
    void SupportedOnIOSAndMacCatalyst() { }

    [SupportedOSPlatform("ios")]
    // The following attribute could be used
    // to cancel the inferred "maccatalyst" support
    [UnsupportedOSPlatform("maccatalyst")]
    void SupportedOnIOS_ButNotMacCatalyst() { }

    // Unlike the [SupportedOSPlatform("ios")] 
    // this will not infer iOS support, only support  maccatalyst
    [SupportedOSPlatform("maccatalyst")]
    void SupportedOnMacCatalyst() { }

    [UnsupportedOSPlatform("ios")]
    // The following attribute would not exist in the code
    // but it would be inferred by the analyzer.
    // that also [UnsupportedOSPlatform("maccatalyst")]
    void UnsupportedOnIOSAndMacCatalyst() { }

    // only unsupported on maccatalyst
    [UnsupportedOSPlatform("maccatalyst")]
    void UnsupportedOnMacCatalyst() { }

    void Main()
    {
        // This block is reachable on both IOS and MacCatalyst
        if (OperatingSystem.IsIOS())
        {
            SupportedOnIOSAndMacCatalyst();      // Scenario 1a - No warning
            SupportedOnMacCatalyst();           // Scenario 1b - Warning
            SupportedOnIOS();                   // Scenario 1c - No warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 1d - Warning
            UnsupportedOnIOS();                 // Scenario 1e - Warning
            UnsupportedOnMacCatalyst();         // Scenario 1f - Warning
        }

        // This block is reachable on MacCatalyst but not IOS
        if (OperatingSystem.IsMacCatalyst())
        {
            SupportedOnIOSAndMacCatalyst();      // Scenario 2a - No warning
            SupportedOnMacCatalyst();           // Scenario 2b - No warning
            SupportedOnIOS();                   // Scenario 2c - No warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 2d - Warning
            UnsupportedOnIOS();                 // Scenario 2e - Warning
            UnsupportedOnMacCatalyst();         // Scenario 2f - Warning
        }

        // This code block is reachable on IOS but not MacCatalyst
        if (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst())
        {
            SupportedOnIOSAndMacCatalyst();      // Scenario 3a - No warning
            SupportedOnMacCatalyst();           // Scenario 3b - Warning
            SupportedOnIOS();                   // Scenario 3c - No warning
            SupportedOnIOS_ButNotMacCatalyst(); // Scenario 3d - UPDATE: NO WARNING
            UnsupportedOnIOS();                 // Scenario 3e - Warning
            UnsupportedOnMacCatalyst();         // Scenario 3f - No warning
        }
    }
}

Should these relationships be defined within the runtime, or within the tooling? In other words, if the analyzer gets the data from the OperatingSystem methods, then the relationship wouldn’t be understood when targeting net5.0.

That seems fine because if you target .NET 5 you can’t see OperatingSystem.IsMacCatalyst() anyway.

Gotcha; thanks, @terrajobst. OK, I’m doing a proof of concept of the guard attributes being applied to the methods to make sure the analyzer will respect those as implemented now. I’ll follow up once I have those findings and we can explore what it would look like for the analyzer to consume that data (during initialization) to understand platform aliases/relationships.

One question though…

Should these relationships be defined within the runtime, or within the tooling? In other words, if the analyzer gets the data from the OperatingSystem methods, then the relationship wouldn’t be understood when targeting net5.0.

1. That we use the guard attributes on the OperatingSystem methods – ✔️
2. In order to communicate the compat relationship to the analyzer – _for the OperatingSystem methods, yes – ✔️
3. We still need to add the generic support to the analyzer to understand the idea of “if I’m running on this OS I can also run on this other OS” – that’s where our communication break down is
4. Otherwise everyone who has to apply these attributes would need special case both as well, which isn’t desirable ✔️

So the trick is how to add the support to the analyzer to understand the platform relationships. I’d prefer for that to be data-driven and not have those specific relationships coded into the analyzer. Are you proposing the analyzer would read the guard attributes in the OperatingSystem class to glean the relationships?

@filipnavara does that match your expectations?

Yes