Suppress Embedded Restriction diagnostics in code that won't be compiled as Embedded

When emitting diagnostics for the Embedded Swift restrictions outside
of Embedded Swift mode, consider `#if $Embedded` and `#if
hasFeature(Embedded)` configurations. If the code where we would emit
the diagnostic would be disabled in Embedded Swift by one of those
checks, don't emit the diagnostic. This helps code that can compile
either with Embedded or regular Swift stay within the restrictions on
Embedded Swift.

Author: DougGregor

include/swift/Bridging/ASTGen.h

@@ -117,6 +117,11 @@ intptr_t swift_ASTGen_configuredRegions(
 void swift_ASTGen_freeConfiguredRegions(
     BridgedIfConfigClauseRangeInfo *_Nullable regions, intptr_t numRegions);
 
+intptr_t swift_ASTGen_activeInEmbeddedSwift(
+    BridgedASTContext astContext,
+    void *_Nonnull sourceFile,
+    swift::SourceLoc location);
+
 bool swift_ASTGen_validateUnqualifiedLookup(
     void *_Nonnull sourceFile,
     BridgedASTContext astContext,

lib/ASTGen/Sources/ASTGen/CMakeLists.txt

@@ -9,6 +9,7 @@ add_pure_swift_host_library(swiftASTGen STATIC CXX_INTEROP
   Decls.swift
   Diagnostics.swift
   DiagnosticsBridge.swift
+  EmbeddedSupport.swift
   Exprs.swift
   Fingerprint.swift
   Generics.swift

lib/ASTGen/Sources/ASTGen/EmbeddedSupport.swift

@@ -0,0 +1,142 @@
+//===--- EmbeddedSupport.swift --------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import ASTBridging
+import BasicBridging
+import SwiftIfConfig
+import SwiftSyntax
+
+extension ExportedSourceFile {
+  /// Return the configured regions for this source file.
+  mutating func configuredRegionsIfEmbedded(astContext: BridgedASTContext) -> ConfiguredRegions {
+    if let _configuredRegionsIfEmbedded {
+      return _configuredRegionsIfEmbedded
+    }
+
+    // Ensure that we've already computed the configured regions, which can
+    // emit diagnostics.
+    _ = configuredRegions(astContext: astContext)
+
+    let configuration = EmbeddedBuildConfiguration(
+      ctx: astContext,
+      sourceBuffer: buffer
+    )
+
+    let regions = syntax.configuredRegions(in: configuration)
+    _configuredRegionsIfEmbedded = regions
+    return regions
+  }
+}
+
+/// Determine whether the given source location is active when this source
+/// file is compiled in Embedded Swift.
+@_cdecl("swift_ASTGen_activeInEmbeddedSwift")
+public func activeInEmbeddedSwift(
+  astContext: BridgedASTContext,
+  sourceFilePtr: UnsafeMutableRawPointer,
+  at location: SourceLoc
+) -> Int {
+  guard let token = findToken(
+    in: UnsafeRawPointer(sourceFilePtr),
+    at: location.raw?.assumingMemoryBound(to: UInt8.self)
+  ) else {
+    return 0
+  }
+
+  let sourceFile = sourceFilePtr.assumingMemoryBound(to: ExportedSourceFile.self)
+  let regions = sourceFile.pointee.configuredRegionsIfEmbedded(astContext: astContext)
+  return regions.isActive(token) == .active ? 1 : 0
+}
+
+/// A build configuration that is a thin shim over the
+/// CompilerBuildConfiguration that enables the Embedded language feature,
+/// allowing the compiler to determine whether code we're in will be available
+/// in an embedded context or not.
+struct EmbeddedBuildConfiguration: BuildConfiguration {
+  let configuration: CompilerBuildConfiguration
+
+  init(ctx: BridgedASTContext, sourceBuffer: UnsafeBufferPointer<UInt8>) {
+    self.configuration = .init(ctx: ctx, sourceBuffer: sourceBuffer)
+  }
+
+  func isCustomConditionSet(name: String) throws -> Bool {
+    // $Embedded is set when building Embedded Swift
+    if name == "$Embedded" {
+      return true
+    }
+
+    return try configuration.isCustomConditionSet(name: name)
+  }
+
+  func hasFeature(name: String) throws -> Bool {
+    // The "Embedded" feature is set when building Embedded Swift.
+    if name == "Embedded" {
+      return true
+    }
+
+    return try configuration.hasFeature(name: name)
+  }
+
+  func hasAttribute(name: String) throws -> Bool {
+    return try configuration.hasAttribute(name: name)
+  }
+
+  func canImport(
+    importPath: [(TokenSyntax, String)],
+    version: CanImportVersion
+  ) throws -> Bool {
+    // FIXME: We would prefer to call the underlying canImport in some kind of
+    // "replay" mode that is not allowed to produce diagnostics or trigger any
+    // loading.
+    return false
+  }
+
+  func isActiveTargetOS(name: String) throws -> Bool {
+    return try configuration.isActiveTargetOS(name: name)
+  }
+
+  func isActiveTargetArchitecture(name: String) throws -> Bool {
+    return try configuration.isActiveTargetArchitecture(name: name)
+  }
+
+  func isActiveTargetEnvironment(name: String) throws -> Bool {
+    return try configuration.isActiveTargetEnvironment(name: name)
+  }
+
+  func isActiveTargetRuntime(name: String) throws -> Bool {
+    return try configuration.isActiveTargetRuntime(name: name)
+  }
+
+  func isActiveTargetPointerAuthentication(name: String) throws -> Bool {
+    return try configuration.isActiveTargetPointerAuthentication(name: name)
+  }
+
+  var targetPointerBitWidth: Int {
+    return configuration.targetPointerBitWidth
+  }
+
+  var targetAtomicBitWidths: [Int] {
+    return configuration.targetAtomicBitWidths
+  }
+
+  var endianness: Endianness {
+    return configuration.endianness
+  }
+
+  var languageVersion: VersionTuple {
+    return configuration.languageVersion
+  }
+
+  var compilerVersion: VersionTuple {
+    return configuration.compilerVersion
+  }
+}

lib/ASTGen/Sources/ASTGen/SourceFile.swift

@@ -43,6 +43,14 @@ public struct ExportedSourceFile {
   /// This is a cached value; access via configuredRegions(astContext:).
   var _configuredRegions: ConfiguredRegions? = nil
 
+  /// Configured regions for this source file assuming if it were being treated
+  /// as Embedded Swift. This is used only when we are compiling non-Embedded
+  /// Swift but diagnosing uses of constructs that aren't allowed in Embedded
+  /// Swift.
+  ///
+  /// This is a cached value; access via configuredRegionsAsEmbedded(astContext:).
+  var _configuredRegionsIfEmbedded: ConfiguredRegions? = nil
+
   public func position(of location: SourceLoc) -> AbsolutePosition? {
     let sourceFileBaseAddress = UnsafeRawPointer(buffer.baseAddress!)
     guard let rawAddress = location.raw else {

lib/Sema/TypeCheckEmbedded.cpp

@@ -19,7 +19,10 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/Effects.h"
+#include "swift/AST/SourceFile.h"
 #include "swift/AST/Types.h"
+#include "swift/Basic/SourceLoc.h"
+#include "swift/Bridging/ASTGen.h"
 
 using namespace swift;
 
@@ -40,6 +43,20 @@ swift::shouldDiagnoseEmbeddedLimitations(const DeclContext *dc, SourceLoc loc,
   if (diags.isIgnoredDiagnostic(diag::untyped_throws_in_embedded_swift.ID))
     return std::nullopt;
 
+#if SWIFT_BUILD_SWIFT_SYNTAX
+  // If we are not in Embedded Swift, check whether the location we are
+  // diagnosing at is likely to be active when compiling Embedded Swift. If not,
+  // suppress the diagnostic.
+  auto sourceFile = dc->getParentSourceFile();
+  if (!dc->getASTContext().LangOpts.hasFeature(Feature::Embedded) &&
+      sourceFile &&
+      !swift_ASTGen_activeInEmbeddedSwift(sourceFile->getASTContext(),
+                                          sourceFile->getExportedSourceFile(),
+                                          loc)) {
+    return std::nullopt;
+  }
+#endif
+
   // If this was always an error in Embedded Swift, we aren't in Embedded Swift
   // now, so downgrade to a warning.
   if (wasAlwaysEmbeddedError)

test/embedded/restrictions.swift

@@ -63,3 +63,22 @@ public struct MyStruct {
 
   unowned(unsafe) var unownedUnsafe: MyClass
 }
+
+// ---------------------------------------------------------------------------
+// #if handling to suppress diagnostics for non-Embedded-only code
+// ---------------------------------------------------------------------------
+
+#if $Embedded
+
+// expected-embedded-warning@+1{{untyped throws is not available in Embedded Swift; add a thrown error type with '(type)'}}{{31-31=(<#thrown error type#>)}}
+func stillProblematic() throws { }
+
+#else
+
+func notProblematicAtAll() throws { }
+
+#endif
+
+#if !hasFeature(Embedded)
+func stillNotProblematicAtAll() throws { }
+#endif