BuildSettingCondition for Embedded Swift

[grynspan]

In order for the Swift Testing package to build for Embedded Swift, we need to toggle a bunch of settings. It would be helpful if there were something like .when(platform: [.embedded]) or .when(.embedded) or some such thing that we could use to modify our Swift/C++ settings in the package description.

[dschaefer2]

Which settings are they? Are they common enough that they should be in the toolset.json file so every module gets them?

[grynspan]

Various knobs and levers within Swift Testing, not general compiler settings that need to change for all Embedded Swift targets. For example, we don't expect/intend to support exit tests with Embedded Swift, so we'd want to disable the feature in Swift Testing by setting our SWT_NO_EXIT_TESTS flag (which we also set for iOS, Wasm, etc.)

So no, I don't think this is solved by toolset.json changes.

[dschaefer2]

If it's just defines, I'm wondering why #if hasFeature(Embedded) doesn't work for you? I see in your PR, swiftlang/swift-testing#1043, you actually do use it in a lot of cases.

[dschaefer2]

I'm not saying no, we're just at the beginning of rethinking how we define platforms and SDKs. SwiftPM is full of things tacked on for special cases which is making it hard to work in. If this is a requirement for the future, I want make sure we do it right at the beginning.

[grynspan]

Because it doesn't scale and makes our code harder to maintain. We define the availability of various bits of our code based on flags we set in our manifest, instead of always writing #if os(macOS) || os(Linux) || os(QNX) || os(NewtonOS) || ... because it's impossible for a human to reason about which defines need to change if we add support for that feature to a new platform.

Let's say we have a feature, "frobbles", that today only works on macOS. Next Tuesday at lunch, somebody figures out how to make it work on Windows. It is non-trivial to audit all our code to find the places where we don't say os(Windows) and add that OS, at least compared to #if SWT_NO_FROBBLES.

We can treat hasFeature(Embedded) like it were os(Embedded) for this purpose, but it runs into the same sort of scalability problems.

[grynspan]

And FWIW I agree, let's try to do it right the first time! I am not trying to suggest one specific technical solution here, but something along the lines of .when(.embedded) would generally work for us.

For comparison, you can write .when(platforms: [.macCatalyst]) today even though Mac Catalyst is treated as a target environment rather than an OS in Swift proper. I don't know if that's an argument for or against any particular solution here—just worth thinking about as a similar situation.

[jakepetroules]

@grynspan What target triple(s) does Swift Embedded use?

[grynspan]

Discussed with Jake offline—in short, Embedded Swift mode is orthogonal to the triple.

[jakepetroules]

Thanks to @grynspan filling me in offline to get a better idea of how Embedded Swift works.

Given that Embedded Swift is part of the language, it may be reasonable to consider having dedicated API for it in SwiftPM, and possibly also some higher level flags on swift build to indicate that a build should be for Embedded Swift. I think a reasonable API might be a BuildSettingCondition that behaves kind of the same as platform - since it shares some characteristics of platformness, in that you're expected to build all targets in a particular build operation as Embedded Swift (or not). But not PlatformCondition itself as it's not a distinct target triple or anything like that.

Not clear yet to me whether the best representation would be some sort of language "mode" enum (that terminology is overloaded already), or an entirely dedicated flag specifically for Swift Embedded like .when(swiftEmbedded: true).

[grynspan]

Having the ability to write .when(x || y) would be useful too if this is on a different axis from the platform, but it's not necessarily critical (just may avoid redundancy.)

[dschaefer2]

Yes, embedded is also orthogonal to the current concept of platform. You may want to build something in embedded mode and run it on a server platform, for example, to keep memory down. I think I'm in favour adding it to the BuildSettingCondition as a boolean setting. But we should really run this by @rauhul and @kubamracek and community to make sure it aligns with the direction for embedded.