Eliminate the -enable-id-as-any flag; it's always on now anyway.

Simplify e.g., ASTContext::getBridgedToObjC(), which no longer needs
the optional return.

Eliminate the now-unused constraint kind for checking bridging to
Objective-C.

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -522,13 +522,10 @@ class ASTContext {
   /// 
   /// \param dc The context in which bridging is occurring.
   /// \param type The Swift for which we are querying bridging behavior.
-  /// \param resolver The lazy resolver.
   /// \param bridgedValueType The specific value type that is bridged,
   /// which will usually by the same as \c type.
-  Optional<Type> getBridgedToObjC(const DeclContext *dc,
-                                  Type type,
-                                  LazyResolver *resolver,
-                                  Type *bridgedValueType = nullptr) const;
+  Type getBridgedToObjC(const DeclContext *dc, Type type,
+                        Type *bridgedValueType = nullptr) const;
 
   /// Determine whether the given Swift type is representable in a
   /// given foreign language.

include/swift/Basic/LangOptions.h

@@ -155,9 +155,6 @@ namespace swift {
     /// and methods.
     bool InferImportAsMember = false;
 
-    /// Should 'id' in Objective-C be imported as 'Any' in Swift?
-    bool EnableIdAsAny = true;
-
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

include/swift/Option/FrontendOptions.td

@@ -337,7 +337,4 @@ def enable_resilience : Flag<["-"], "enable-resilience">,
 def group_info_path : Separate<["-"], "group-info-path">,
   HelpText<"The path to collect the group information of the compiled module">;
 
-def enable_id_as_any: Flag<["-"], "enable-id-as-any">,
-  HelpText<"Enable importing ObjC 'id' as Swift 'Any' type">;
-
 } // end let Flags = [FrontendOption, NoDriverOption, HelpHidden]

lib/AST/ASTContext.cpp

@@ -3998,46 +3998,14 @@ bool ASTContext::isStandardLibraryTypeBridgedInFoundation(
           nominal->getName() == Id_CGFloat);
 }
 
-Optional<Type>
-ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
-                             LazyResolver *resolver,
-                             Type *bridgedValueType) const {
+Type ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
+                                  Type *bridgedValueType) const {
   if (type->isBridgeableObjectType()) {
     if (bridgedValueType) *bridgedValueType = type;
 
     return type;
   }
 
-  // Whitelist certain types even if Foundation is not imported, to ensure
-  // that casts from AnyObject to one of these types are not optimized away.
-  //
-  // Outside of these standard library types to which Foundation
-  // bridges, an _ObjectiveCBridgeable conformance can only be added
-  // in the same module where the Swift type itself is defined, so the
-  // optimizer will be guaranteed to see the conformance if it exists.
-  bool knownBridgedToObjC = false;
-  if (auto ntd = type->getAnyNominal())
-    knownBridgedToObjC = isStandardLibraryTypeBridgedInFoundation(ntd);
-
-  // TODO: Under id-as-any, container bridging is unconstrained. This check can
-  // go away.
-  if (!LangOpts.EnableIdAsAny) {
-    // If the type is generic, check whether its generic arguments are also
-    // bridged to Objective-C.
-    if (auto bgt = type->getAs<BoundGenericType>()) {
-      for (auto arg : bgt->getGenericArgs()) {
-        if (arg->hasTypeVariable())
-          continue;
-
-        if (!getBridgedToObjC(dc, arg, resolver))
-          return None;
-      }
-    }
-  } else {
-    // Under id-as-any, anything is bridged to objective c.
-    knownBridgedToObjC = true;
-  }
-
   if (auto metaTy = type->getAs<MetatypeType>())
     if (metaTy->getInstanceType()->mayHaveSuperclass())
       return type;
@@ -4065,7 +4033,8 @@ ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
       auto proto = getProtocol(known);
       if (!proto) return None;
 
-      return dc->getParentModule()->lookupConformance(type, proto, resolver);
+      return dc->getParentModule()->lookupConformance(type, proto,
+                                                      getLazyResolver());
     };
 
   // Do we conform to _ObjectiveCBridgeable?
@@ -4079,7 +4048,7 @@ ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
     if (conformance->isConcrete()) {
       return ProtocolConformance::getTypeWitnessByName(
                type, conformance->getConcrete(), Id_ObjectiveCType,
-               resolver);
+               getLazyResolver());
     } else {
       return type->castTo<ArchetypeType>()->getNestedType(Id_ObjectiveCType)
         .getValue();
@@ -4097,12 +4066,8 @@ ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
       return nsErrorDecl->getDeclaredInterfaceType();
   }
 
-
-  // If we haven't imported Foundation but this is a whitelisted type,
-  // behave as above.
-  if (knownBridgedToObjC)
-    return Type();
-  return None;
+  // No special bridging to Objective-C, but this can become an 'Any'.
+  return Type();
 }
 
 std::pair<ArchetypeBuilder *, ArchetypeBuilder::PotentialArchetype *>

lib/AST/Decl.cpp

@@ -3970,10 +3970,7 @@ ObjCSubscriptKind SubscriptDecl::getObjCSubscriptKind(
   if (Type objectTy = indexTy->getAnyOptionalObjectType())
     indexTy = objectTy;
 
-  if (getASTContext().getBridgedToObjC(getDeclContext(), indexTy, resolver))
-    return ObjCSubscriptKind::Keyed;
-
-  return ObjCSubscriptKind::None;
+  return ObjCSubscriptKind::Keyed;
 }
 
 SourceRange SubscriptDecl::getSourceRange() const {

lib/AST/Type.cpp

@@ -2067,12 +2067,10 @@ getObjCObjectRepresentable(Type type, const DeclContext *dc) {
     return ForeignRepresentableKind::Object;
 
   // Any can be bridged to id.
-  if (type->getASTContext().LangOpts.EnableIdAsAny) {
-    if (type->isAny()) {
-      return ForeignRepresentableKind::Bridged;
-    }
+  if (type->isAny()) {
+    return ForeignRepresentableKind::Bridged;
   }
-  
+
   // Class-constrained generic parameters, from ObjC generic classes.
   if (auto tyContext = dc->getInnermostTypeContext())
     if (auto clas = tyContext->getAsClassOrClassExtensionContext())

lib/ClangImporter/ImportDecl.cpp

@@ -1037,6 +1037,19 @@ static bool addErrorDomain(NominalTypeDecl *swiftDecl,
   return addErrorDomain(swiftDecl, clangNamedDecl, importer);
 }
 
+/// Determine whether this is the declaration of Objective-C's 'id' type.
+static bool isObjCId(ASTContext &ctx, const clang::Decl *decl) {
+  if (!ctx.LangOpts.EnableObjCInterop) return false;
+
+  auto typedefDecl = dyn_cast<clang::TypedefNameDecl>(decl);
+  if (!typedefDecl) return false;
+
+  if (!typedefDecl->getDeclContext()->getRedeclContext()->isTranslationUnit())
+    return false;
+
+  return typedefDecl->getName() == "id";
+}
+
 namespace {
   /// \brief Convert Clang declarations into the corresponding Swift
   /// declarations.
@@ -1537,36 +1550,6 @@ namespace {
 
       Type SwiftType;
       if (Decl->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
-        // Ignore the 'id' typedef. We want to bridge the underlying
-        // ObjCId type.
-        //
-        // When we remove the EnableIdAsAny staging flag, the 'id' entry
-        // should be removed from MappedTypes.def, and this conditional should
-        // become unnecessary.
-        if (Name.str() == "id" && Impl.SwiftContext.LangOpts.EnableIdAsAny) {
-          Impl.SpecialTypedefNames[Decl->getCanonicalDecl()] =
-              MappedTypeNameKind::DoNothing;
-
-          auto DC = Impl.importDeclContextOf(Decl, importedName.EffectiveContext);
-          if (!DC) return nullptr;
-
-          auto loc = Impl.importSourceLoc(Decl->getLocStart());
-          
-          // Leave behind a typealias for 'id' marked unavailable, to instruct
-          // people to use Any instead.
-          auto unavailableAlias = Impl.createDeclWithClangNode<TypeAliasDecl>(
-                          Decl, Accessibility::Public, loc, Name, loc,
-                          TypeLoc::withoutLoc(Impl.SwiftContext.TheAnyType),
-                          /*genericparams*/nullptr, DC);
-
-          auto attr = AvailableAttr::createUnconditional(
-                        Impl.SwiftContext, "'id' is not available in Swift; use 'Any'",
-                        "", UnconditionalAvailabilityKind::UnavailableInSwift);
-
-          unavailableAlias->getAttrs().add(attr);
-          return nullptr;
-        }
-      
         bool IsError;
         StringRef StdlibTypeName;
         MappedTypeNameKind NameMapping;
@@ -1719,6 +1702,17 @@ namespace {
                                       TypeLoc::withoutLoc(SwiftType),
                                       /*genericparams*/nullptr, DC);
       Result->computeType();
+
+      // Make Objective-C's 'id' unavailable.
+      ASTContext &ctx = DC->getASTContext();
+      if (isObjCId(ctx, Decl)) {
+        auto attr = AvailableAttr::createUnconditional(
+                      ctx,
+                      "'id' is not available in Swift; use 'Any'", "",
+                      UnconditionalAvailabilityKind::UnavailableInSwift);
+        Result->getAttrs().add(attr);
+      }
+
       return Result;
     }
 
@@ -6508,6 +6502,9 @@ void ClangImporter::Implementation::importAttributes(
 
 bool ClangImporter::Implementation::isUnavailableInSwift(
     const clang::Decl *decl) {
+  // 'id' is always unavailable in Swift.
+  if (isObjCId(SwiftContext, decl)) return true;
+
   // FIXME: Somewhat duplicated from importAttributes(), but this is a
   // more direct path.
   if (decl->getAvailability() == clang::AR_Unavailable) return true;

lib/ClangImporter/ImportType.cpp

@@ -985,11 +985,9 @@ namespace {
 
       // id maps to Any in bridgeable contexts, AnyObject otherwise.
       if (type->isObjCIdType()) {
-        if (Impl.SwiftContext.LangOpts.EnableIdAsAny)
-          return {proto->getDeclaredType(),
-                  ImportHint(ImportHint::ObjCBridged,
-                             Impl.SwiftContext.TheAnyType)};
-        return {proto->getDeclaredType(), ImportHint::ObjCPointer};
+        return {proto->getDeclaredType(),
+                ImportHint(ImportHint::ObjCBridged,
+                           Impl.SwiftContext.TheAnyType)};
       }
 
       // Class maps to AnyObject.Type.

lib/ClangImporter/MappedTypes.def

@@ -144,7 +144,6 @@ MAP_TYPE("__swift_shims_dispatch_data_t", ObjCId, 0, "Dispatch", "dispatch_data_
 // Objective-C types.
 MAP_TYPE("BOOL", ObjCBool, 8, "ObjectiveC", "ObjCBool", false, DoNothing)
 MAP_TYPE("SEL",  ObjCSel, 0, "ObjectiveC", "Selector", false, DoNothing)
-MAP_STDLIB_TYPE("id", ObjCId, 0, "AnyObject", false, DoNothing)
 MAP_STDLIB_TYPE("Class", ObjCClass, 0, "AnyClass", false, DoNothing)
 MAP_STDLIB_TYPE(
   Impl.SwiftContext.getSwiftName(KnownFoundationEntity::NSInteger),

lib/Frontend/CompilerInvocation.cpp

@@ -775,7 +775,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.InferImportAsMember |= Args.hasArg(OPT_enable_infer_import_as_member);
 
   Opts.EnableThrowWithoutTry |= Args.hasArg(OPT_enable_throw_without_try);
-  Opts.EnableIdAsAny |= Args.hasArg(OPT_enable_id_as_any);
 
   if (auto A = Args.getLastArg(OPT_enable_objc_attr_requires_foundation_module,
                                OPT_disable_objc_attr_requires_foundation_module)) {

lib/PrintAsObjC/PrintAsObjC.cpp

@@ -1193,7 +1193,7 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
         SD != ctx.getDictionaryDecl() &&
         SD != ctx.getSetDecl() &&
         !isSwiftNewtype(SD)) {
-      ty = *ctx.getBridgedToObjC(&M, ty, /*resolver*/nullptr);
+      ty = ctx.getBridgedToObjC(&M, ty);
     }
 
     assert(ty && "unknown bridged type");

lib/SIL/Bridging.cpp

@@ -171,7 +171,7 @@ Type TypeConverter::getLoweredCBridgedType(AbstractionPattern pattern,
   }
 
   // `Any` can bridge to `AnyObject` (`id` in ObjC).
-  if (Context.LangOpts.EnableIdAsAny && t->isAny()) {
+  if (t->isAny()) {
     return Context.getProtocol(KnownProtocolKind::AnyObject)->getDeclaredType();
   }
 

lib/SIL/DynamicCasts.cpp

@@ -30,19 +30,8 @@ static unsigned getAnyMetatypeDepth(CanType type) {
 
 static bool
 mayBridgeToObjectiveC(Module *M, CanType T) {
-  // If the target type is either an unknown dynamic type, or statically
-  // known to bridge, the cast may succeed.
-  // TODO: We could be more precise with the bridged-to type.
-  if (T->hasArchetype())
-    return true;
-  
-  if (T->isAnyExistentialType())
-    return true;
-  
-  if (M->getASTContext().getBridgedToObjC(M, T, nullptr))
-    return true;
-
-  return false;
+  // FIXME: Disable when we don't support Objective-C interoperability?
+  return true;
 }
 
 static bool
@@ -61,14 +50,7 @@ mustBridgeToSwiftValueBox(Module *M, CanType T) {
     if (M->getASTContext().isStandardLibraryTypeBridgedInFoundation(N))
       return false;
 
-  auto bridgeTy  = M->getASTContext().getBridgedToObjC(M, T, nullptr);
-  if (!bridgeTy.hasValue())
-    return false;
-
-  if (bridgeTy->isNull())
-    return true;
-
-  return false;
+  return !M->getASTContext().getBridgedToObjC(M, T);
 }
 
 static bool canClassOrSuperclassesHaveExtensions(ClassDecl *CD,
@@ -532,13 +514,11 @@ swift::classifyDynamicCast(Module *M,
   if (source->isBridgeableObjectType() && mayBridgeToObjectiveC(M, target)) {
     // Try to get the ObjC type which is bridged to target type.
     assert(!target.isAnyExistentialType());
-    Optional<Type> ObjCTy = M->getASTContext().getBridgedToObjC(
-        M, target, nullptr);
-    if (ObjCTy && ObjCTy.getValue()) {
+    if (Type ObjCTy = M->getASTContext().getBridgedToObjC(M, target)) {
       // If the bridged ObjC type is known, check if
       // source type can be cast into it.
       return classifyDynamicCast(M, source,
-          ObjCTy.getValue().getCanonicalTypeOrNull(),
+          ObjCTy.getCanonicalTypeOrNull(),
           /* isSourceTypeExact */ false, isWholeModuleOpts);
     }
     return DynamicCastFeasibility::MaySucceed;
@@ -547,13 +527,11 @@ swift::classifyDynamicCast(Module *M,
   if (target->isBridgeableObjectType() && mayBridgeToObjectiveC(M, source)) {
     // Try to get the ObjC type which is bridged to source type.
     assert(!source.isAnyExistentialType());
-    Optional<Type> ObjCTy = M->getASTContext().getBridgedToObjC(
-        M, source, nullptr);
-    if (ObjCTy && ObjCTy.getValue()) {
+    if (Type ObjCTy = M->getASTContext().getBridgedToObjC(M, source)) {
       // If the bridged ObjC type is known, check if
       // this type can be cast into target type.
       return classifyDynamicCast(M,
-          ObjCTy.getValue().getCanonicalTypeOrNull(),
+          ObjCTy.getCanonicalTypeOrNull(),
           target,
           /* isSourceTypeExact */ false, isWholeModuleOpts);
     }

lib/SILGen/SILGenBridging.cpp

@@ -451,12 +451,9 @@ static ManagedValue emitNativeToCBridgedNonoptionalValue(SILGenFunction &gen,
 
   // Fall back to dynamic Any-to-id bridging.
   // The destination type should be AnyObject in this case.
-  //
-  // TODO: Should only get here if -enable-id-as-any is active.
-  assert(gen.getASTContext().LangOpts.EnableIdAsAny
-         && loweredBridgedTy->isEqual(
-              gen.getASTContext().getProtocol(KnownProtocolKind::AnyObject)
-                ->getDeclaredType()));
+  assert(loweredBridgedTy->isEqual(
+           gen.getASTContext().getProtocol(KnownProtocolKind::AnyObject)
+             ->getDeclaredType()));
 
   // If the input argument is known to be an existential, save the runtime
   // some work by opening it.

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -1038,13 +1038,6 @@ static void emitMatchingRCAdjustmentsForCall(ApplyInst *Call, SILValue OnX) {
     Builder.createReleaseValue(Call->getLoc(), OnX, Atomicity::Atomic);
 }
 
-static bool isCastTypeKnownToSucceed(SILType Type, SILModule &Mod) {
-  auto *M = Mod.getSwiftModule();
-  return M->getASTContext()
-      .getBridgedToObjC(M, Type.getSwiftRValueType(), nullptr)
-      .hasValue();
-}
-
 /// Replace an application of a cast composition f_inverse(f(x)) by x.
 bool SILCombiner::optimizeIdentityCastComposition(ApplyInst *FInverse,
                                               StringRef FInverseName,
@@ -1057,12 +1050,6 @@ bool SILCombiner::optimizeIdentityCastComposition(ApplyInst *FInverse,
   if (!knowHowToEmitReferenceCountInsts(FInverse))
     return false;
 
-  // We need to know that the cast will succeed.
-  if (!isCastTypeKnownToSucceed(FInverse->getArgument(0)->getType(),
-                                FInverse->getModule()) ||
-      !isCastTypeKnownToSucceed(FInverse->getType(), FInverse->getModule()))
-    return false;
-
   // Need to have a matching 'f'.
   auto *F = dyn_cast<ApplyInst>(FInverse->getArgument(0));
   if (!F)