Sema: Remove TypeResolutionFlags::AllowUnavailable{,Protocol}

Author: slavapestov

lib/Sema/PreCheckExpr.cpp

@@ -1326,11 +1326,8 @@ TypeExpr *PreCheckExpression::simplifyNestedTypeExpr(UnresolvedDotExpr *UDE) {
   // Fold 'T.U' into a nested type.
   if (auto *ITR = dyn_cast<IdentTypeRepr>(InnerTypeRepr)) {
     // Resolve the TypeRepr to get the base type for the lookup.
-    // Disable availability diagnostics here, because the final
-    // TypeRepr will be resolved again when generating constraints.
     const auto options =
-        TypeResolutionOptions(TypeResolverContext::InExpression) |
-        TypeResolutionFlags::AllowUnavailable;
+        TypeResolutionOptions(TypeResolverContext::InExpression);
     const auto resolution =
         TypeResolution::forContextual(DC, options, [](auto unboundTy) {
           // FIXME: Don't let unbound generic types escape type resolution.

lib/Sema/TypeCheckRequestFunctions.cpp

@@ -30,31 +30,27 @@ Type InheritedTypeRequest::evaluate(
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
     unsigned index, TypeResolutionStage stage) const {
   // Figure out how to resolve types.
-  TypeResolutionOptions options = None;
   DeclContext *dc;
   if (auto typeDecl = decl.dyn_cast<const TypeDecl *>()) {
     if (auto nominal = dyn_cast<NominalTypeDecl>(typeDecl)) {
       dc = (DeclContext *)nominal;
-
-      options |= TypeResolutionFlags::AllowUnavailableProtocol;
     } else {
       dc = typeDecl->getDeclContext();
     }
   } else {
     dc = (DeclContext *)decl.get<const ExtensionDecl *>();
-    options |= TypeResolutionFlags::AllowUnavailableProtocol;
   }
 
   Optional<TypeResolution> resolution;
   switch (stage) {
   case TypeResolutionStage::Structural:
     resolution =
-        TypeResolution::forStructural(dc, options, /*unboundTyOpener*/ nullptr);
+        TypeResolution::forStructural(dc, None, /*unboundTyOpener*/ nullptr);
     break;
 
   case TypeResolutionStage::Interface:
     resolution =
-        TypeResolution::forInterface(dc, options, /*unboundTyOpener*/ nullptr);
+        TypeResolution::forInterface(dc, None, /*unboundTyOpener*/ nullptr);
     break;
 
   case TypeResolutionStage::Contextual: {

lib/Sema/TypeCheckType.cpp

@@ -575,7 +575,6 @@ static TypeResolutionOptions
 adjustOptionsForGenericArgs(TypeResolutionOptions options) {
   options.setContext(None);
   options -= TypeResolutionFlags::SILType;
-  options -= TypeResolutionFlags::AllowUnavailableProtocol;
 
   return options;
 }
@@ -1878,9 +1877,6 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
     options.setContext(None);
   }
 
-  if (getASTContext().LangOpts.DisableAvailabilityChecking)
-    options |= TypeResolutionFlags::AllowUnavailable;
-
   bool isDirect = false;
   if ((options & TypeResolutionFlags::Direct) && !isa<SpecifierTypeRepr>(repr)){
     isDirect = true;

lib/Sema/TypeCheckType.h

@@ -36,37 +36,31 @@ enum class TypeResolutionFlags : uint16_t {
   /// Whether to allow unspecified types within a pattern.
   AllowUnspecifiedTypes = 1 << 0,
 
-  /// Whether an unavailable protocol can be referenced.
-  AllowUnavailableProtocol = 1 << 1,
-
-  /// Whether we should allow references to unavailable types.
-  AllowUnavailable = 1 << 2,
-
   /// Whether the given type can override the type of a typed pattern.
-  OverrideType = 1 << 3,
+  OverrideType = 1 << 1,
 
   /// Whether we are validating the type for SIL.
   // FIXME: Move this flag to TypeResolverContext.
-  SILType = 1 << 4,
+  SILType = 1 << 2,
 
   /// Whether we are parsing a SIL file.  Not the same as SILType,
   /// because the latter is not set if we're parsing an AST type.
-  SILMode = 1 << 5,
+  SILMode = 1 << 3,
 
   /// Whether this is a resolution based on a non-inferred type pattern.
-  FromNonInferredPattern = 1 << 6,
+  FromNonInferredPattern = 1 << 4,
 
   /// Whether we are at the direct base of a type expression.
-  Direct = 1 << 7,
+  Direct = 1 << 5,
 
   /// Whether we should not produce diagnostics if the type is invalid.
-  SilenceErrors = 1 << 8,
+  SilenceErrors = 1 << 6,
 
   /// Whether to allow module declaration types.
-  AllowModule = 1 << 9,
+  AllowModule = 1 << 7,
 
   /// Make internal @usableFromInline and @inlinable decls visible.
-  AllowInlinable = 1 << 10,
+  AllowInlinable = 1 << 8,
 };
 
 /// Type resolution contexts that require special handling.