Merge pull request #16696 from apple/revert-16022-LinuxAsBridging

Revert "Turn on ‘as’ bridging on Linux."

Author: benlangmuir

lib/SIL/DynamicCasts.cpp

@@ -1134,19 +1134,22 @@ bool swift::canUseScalarCheckedCastInstructions(SILModule &M,
     if (!objectType.isAnyClassReferenceType())
       return false;
 
+    if (M.getASTContext().LangOpts.EnableObjCInterop) {
       auto super = archetype->getSuperclass();
       if (super.isNull())
         return false;
 
-    // A base class constraint that isn't NSError rules out the archetype being
-    // bound to NSError.
-    if (M.getASTContext().LangOpts.EnableObjCInterop) {
-      if (auto nserror = M.Types.getNSErrorType())
-         return !super->isEqual(nserror);
+      // A base class constraint that isn't NSError rules out the archetype being
+      // bound to NSError.
+        if (auto nserror = M.Types.getNSErrorType())
+          return !super->isEqual(nserror);
+      // If NSError wasn't loaded, any base class constraint must not be NSError.
+      return true;
+    } else {
+      // If ObjC bridging isn't enabled, we can do a scalar cast from any
+      // reference type to any class-constrained archetype.
+      return archetype->requiresClass();
     }
-    
-    // If NSError wasn't loaded, any base class constraint must not be NSError.
-    return true;
   }
 
   if (M.getASTContext().LangOpts.EnableObjCInterop

lib/Sema/CSApply.cpp

@@ -3686,7 +3686,10 @@ namespace {
       auto *locator = cs.getConstraintLocator(expr);
 
       if (!choice) {
-        choice = solution.getDisjunctionChoice(locator);
+        if (tc.Context.LangOpts.EnableObjCInterop)
+          choice = solution.getDisjunctionChoice(locator);
+        else
+          choice = 0;
       }
 
       // Handle the coercion/bridging of the underlying subexpression, where

lib/Sema/CSSimplify.cpp

@@ -3627,6 +3627,11 @@ ConstraintSystem::simplifyBridgingConstraint(Type type1,
                                              Type type2,
                                              TypeMatchOptions flags,
                                              ConstraintLocatorBuilder locator) {
+  // There's no bridging without ObjC interop, so we shouldn't have set up
+  // bridging constraints without it.
+  assert(TC.Context.LangOpts.EnableObjCInterop
+         && "bridging constraint w/o ObjC interop?!");
+  
   TypeMatchOptions subflags = getDefaultDecompositionOptions(flags);
 
   /// Form an unresolved result.
@@ -5071,11 +5076,14 @@ void ConstraintSystem::addExplicitConversionConstraint(
   coerceConstraint->setFavored();
   constraints.push_back(coerceConstraint);
 
-  // The source type can be explicitly converted to the destination type.
-  Constraint *bridgingConstraint =
-  Constraint::create(*this, ConstraintKind::BridgingConversion,
-                     fromType, toType, locatorPtr);
-  constraints.push_back(bridgingConstraint);
+  // Bridging.
+  if (getASTContext().LangOpts.EnableObjCInterop) {
+    // The source type can be explicitly converted to the destination type.
+    Constraint *bridgingConstraint =
+      Constraint::create(*this, ConstraintKind::BridgingConversion,
+                         fromType, toType, locatorPtr);
+    constraints.push_back(bridgingConstraint);
+  }
 
   if (allowFixes && shouldAttemptFixes()) {
     Constraint *downcastConstraint =
@@ -5086,8 +5094,8 @@ void ConstraintSystem::addExplicitConversionConstraint(
   }
 
   addDisjunctionConstraint(constraints, locator,
-                           allowFixes ? RememberChoice
-                                      : ForgetChoice);
+    getASTContext().LangOpts.EnableObjCInterop && allowFixes ? RememberChoice
+                                                             : ForgetChoice);
 }
 
 ConstraintSystem::SolutionKind

lib/Sema/Constraint.cpp

@@ -612,6 +612,10 @@ Constraint *Constraint::create(ConstraintSystem &cs, ConstraintKind kind,
   assert((kind != ConstraintKind::LiteralConformsTo) ||
          second->is<ProtocolType>());
 
+  // Bridging constraints require bridging to be enabled.
+  assert(kind != ConstraintKind::BridgingConversion
+         || cs.TC.Context.LangOpts.EnableObjCInterop);
+
   // Create the constraint.
   unsigned size = totalSizeToAlloc<TypeVariableType*>(typeVars.size());
   void *mem = cs.getAllocator().Allocate(size, alignof(Constraint));

lib/Sema/TypeCheckConstraints.cpp

@@ -2881,7 +2881,8 @@ bool TypeChecker::isExplicitlyConvertibleTo(Type type1, Type type2,
 
 bool TypeChecker::isObjCBridgedTo(Type type1, Type type2, DeclContext *dc,
                                   bool *unwrappedIUO) {
-  return (typesSatisfyConstraint(type1, type2,
+  return (Context.LangOpts.EnableObjCInterop &&
+          typesSatisfyConstraint(type1, type2,
                                  /*openArchetypes=*/false,
                                  ConstraintKind::BridgingConversion,
                                  dc, unwrappedIUO));
@@ -3393,8 +3394,9 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
   }
 
   // Check for a bridging conversion.
-  // Anything bridges to AnyObject.
-  if (toType->isAnyObject())
+  // Anything bridges to AnyObject in ObjC interop mode.
+  if (Context.LangOpts.EnableObjCInterop
+      && toType->isAnyObject())
     return CheckedCastKind::BridgingCoercion;
 
   // Do this check later in Swift 3 mode so that we check for NSNumber and

stdlib/public/SDK/ObjectiveC/ObjectiveC.swift

@@ -10,8 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if _runtime(_ObjC)
-
 @_exported
 import ObjectiveC
 import _SwiftObjectiveCOverlayShims
@@ -227,5 +225,3 @@ extension NSObject : CVarArg {
   }
 }
 
-#endif
-

stdlib/public/core/BridgeObjectiveC.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if _runtime(_ObjC)
 /// A Swift Array or Dictionary of types conforming to
 /// `_ObjectiveCBridgeable` can be passed to Objective-C as an NSArray or
 /// NSDictionary, respectively.  The elements of the resulting NSArray
@@ -82,8 +83,6 @@ public protocol _ObjectiveCBridgeable {
       -> Self
 }
 
-#if _runtime(_ObjC)
-
 //===--- Bridging for metatypes -------------------------------------------===//
 
 /// A stand-in for a value of metatype type.
@@ -641,200 +640,3 @@ public func _getObjCTypeEncoding<T>(_ type: T.Type) -> UnsafePointer<Int8> {
 }
 
 #endif
-
-//===--- Bridging without the ObjC runtime --------------------------------===//
-
-#if !_runtime(_ObjC)
-
-/// Convert `x` from its Objective-C representation to its Swift
-/// representation.
-/// COMPILER_INTRINSIC
-@_inlineable // FIXME(sil-serialize-all)
-public func _forceBridgeFromObjectiveC_bridgeable<T:_ObjectiveCBridgeable> (
-  _ x: T._ObjectiveCType,
-  _: T.Type
-) -> T {
-  var result: T?
-  T._forceBridgeFromObjectiveC(x, result: &result)
-  return result!
-}
-
-/// Attempt to convert `x` from its Objective-C representation to its Swift
-/// representation.
-/// COMPILER_INTRINSIC
-@_inlineable // FIXME(sil-serialize-all)
-public func _conditionallyBridgeFromObjectiveC_bridgeable<T:_ObjectiveCBridgeable>(
-  _ x: T._ObjectiveCType,
-  _: T.Type
-) -> T? {
-  var result: T?
-  T._conditionallyBridgeFromObjectiveC (x, result: &result)
-  return result
-}
-
-public // SPI(Foundation)
-protocol _NSSwiftValue: class {
-  init(_ value: Any)
-  var value: Any { get }
-  static var null: AnyObject { get }
-}
-
-@usableFromInline
-internal class _SwiftValue {
-  @usableFromInline
-  let value: Any
-  
-  @usableFromInline
-  init(_ value: Any) {
-    self.value = value
-  }
-  
-  @usableFromInline
-  static let null = _SwiftValue(Optional<Any>.none as Any)
-}
-
-/// COMPILER_INTRISIC
-@_silgen_name("swift_unboxFromSwiftValueWithType")
-public func swift_unboxFromSwiftValueWithType<T>(
-  _ source: inout AnyObject,
-  _ result: UnsafeMutablePointer<T>
-  ) -> Bool {
-
-  if source === _nullPlaceholder {
-    if let unpacked = Optional<Any>.none as? T {
-      result.initialize(to: unpacked)
-      return true
-    }
-  }
-    
-  if let box = source as? _SwiftValue {
-    if let value = box.value as? T {
-      result.initialize(to: value)
-      return true
-    }
-  } else if let box = source as? _NSSwiftValue {
-    if let value = box.value as? T {
-      result.initialize(to: value)
-      return true
-    }
-  }
-  
-  return false
-}
-
-@_silgen_name("_swift_extractDynamicValue")
-public func _extractDynamicValue<T>(_ value: T) -> AnyObject?
-
-@_silgen_name("_swift_bridgeToObjectiveCUsingProtocolIfPossible")
-public func _bridgeToObjectiveCUsingProtocolIfPossible<T>(_ value: T) -> AnyObject?
-
-@usableFromInline
-protocol _Unwrappable {
-  func unwrap() -> Any?
-}
-
-extension Optional: _Unwrappable {
-  func unwrap() -> Any? {
-    return self
-  }
-}
-
-// This is a best-effort tripmine for detecting the situation
-// (which should never happen) of Swift._SwiftValue and
-// Foundation._SwiftValue/Foundation.NSNull being used 
-// in the same process.
-
-@usableFromInline
-internal enum _SwiftValueFlavor: Equatable {
-  case stdlib
-  case foundation
-}
-
-@usableFromInline
-func _currentSwiftValueFlavor() -> _SwiftValueFlavor {
-  if _typeByName("Foundation._SwiftValue") as? _NSSwiftValue.Type != nil {
-    return .foundation
-  } else {
-    return .stdlib
-  }
-}
-
-@usableFromInline
-internal var _selectedSwiftValueFlavor: _SwiftValueFlavor = _currentSwiftValueFlavor()
-
-@usableFromInline
-internal func _assertSwiftValueFlavorIsConsistent() {
-  assert(_selectedSwiftValueFlavor == _currentSwiftValueFlavor())
-}
-
-@usableFromInline
-internal var _nullPlaceholder: AnyObject {
-  _assertSwiftValueFlavorIsConsistent()
-  if let foundationType = _typeByName("Foundation._SwiftValue") as? _NSSwiftValue.Type {
-    return foundationType.null
-  } else {
-    return _SwiftValue.null
-  }
-}
-
-@usableFromInline
-func _makeSwiftValue(_ value: Any) -> AnyObject {
-  _assertSwiftValueFlavorIsConsistent()
-  if let foundationType = _typeByName("Foundation._SwiftValue") as? _NSSwiftValue.Type {
-    return foundationType.init(value)
-  } else {
-    return _SwiftValue(value)
-  }
-}
-
-/// Bridge an arbitrary value to an Objective-C object.
-///
-/// - If `T` is a class type, it is always bridged verbatim, the function
-///   returns `x`;
-///
-/// - otherwise, if `T` conforms to `_ObjectiveCBridgeable`,
-///   returns the result of `x._bridgeToObjectiveC()`;
-///
-/// - otherwise, we use **boxing** to bring the value into Objective-C.
-///   The value is wrapped in an instance of a private Objective-C class
-///   that is `id`-compatible and dynamically castable back to the type of
-///   the boxed value, but is otherwise opaque.
-///
-/// COMPILER_INTRINSIC
-@inlinable // FIXME(sil-serialize-all)
-public func _bridgeAnythingToObjectiveC<T>(_ x: T) -> AnyObject {
-  var done = false
-  var result: AnyObject!
-  
-  var source: Any = x
-  
-  if let dynamicSource = _extractDynamicValue(x) {
-    result = dynamicSource as AnyObject
-    done = true 
-  }
-  
-  if !done, let wrapper = source as? _Unwrappable {
-    if let value = wrapper.unwrap() {
-      result = value as AnyObject
-    } else {
-      result = _nullPlaceholder
-    }
-    
-    done = true
-  }
-
-  if !done {
-    if type(of: source) as? AnyClass != nil {
-      result = unsafeBitCast(x, to: AnyObject.self)
-    } else if let object = _bridgeToObjectiveCUsingProtocolIfPossible(source) {
-      result = object
-    } else {
-      result = _makeSwiftValue(source)
-    }
-  }
-  
-  return result
-}
-
-#endif // !_runtime(_ObjC)
-

stdlib/public/core/Codable.swift.gyb

@@ -1171,7 +1171,7 @@ public enum EncodingError : Error {
   public var _userInfo: AnyObject? {
     // The error dictionary must be returned as an AnyObject. We can do this
     // only on platforms with bridging, unfortunately.
-    #if _runtime(_ObjC)
+    #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
       let context: Context
       switch self {
       case .invalidValue(_, let c): context = c
@@ -1281,7 +1281,7 @@ public enum DecodingError : Error {
   public var _userInfo: AnyObject? {
     // The error dictionary must be returned as an AnyObject. We can do this
     // only on platforms with bridging, unfortunately.
-    #if _runtime(_ObjC)
+    #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
       let context: Context
       switch self {
       case .keyNotFound(_,   let c): context = c