Override checking: use an enum instead of a boolean flag.

No functionality change, but the next commit will add another
case to the enum.

Author: jrose-apple

include/swift/AST/Types.h

@@ -221,6 +221,16 @@ enum class TypeTraitResult {
   Is,
 };
 
+/// Specifies which normally-unsafe type mismatches should be accepted when
+/// checking overrides.
+enum class OverrideMatchMode {
+  /// Only accept overrides that are properly covariant.
+  Strict,
+  /// Allow a parameter with IUO type to be overridden by a parameter with non-
+  /// optional type.
+  AllowNonOptionalForIUOParam,
+};
+
 /// TypeBase - Base class for all types in Swift.
 class alignas(1 << TypeAlignInBits) TypeBase {
 
@@ -653,7 +663,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
 
   /// \brief Determines whether this type is permitted as a method override
   /// of the \p other.
-  bool canOverride(Type other, bool allowUnsafeParameterOverride,
+  bool canOverride(Type other, OverrideMatchMode matchMode,
                    LazyResolver *resolver);
 
   /// \brief Determines whether this type has a retainable pointer

lib/AST/Type.cpp

@@ -2232,7 +2232,7 @@ bool TypeBase::isTriviallyRepresentableIn(ForeignLanguage language,
 /// Is t1 not just a subtype of t2, but one such that its values are
 /// trivially convertible to values of the other?
 static bool canOverride(CanType t1, CanType t2,
-                        bool allowUnsafeParameterOverride,
+                        OverrideMatchMode matchMode,
                         bool isParameter,
                         bool insideOptional,
                         LazyResolver *resolver) {
@@ -2246,7 +2246,7 @@ static bool canOverride(CanType t1, CanType t2,
     if (!tuple1 || tuple1->getNumElements() != tuple2->getNumElements()) {
       if (tuple2->getNumElements() == 1)
         return canOverride(t1, tuple2.getElementType(0),
-                           allowUnsafeParameterOverride,
+                           matchMode,
                            isParameter,
                            /*insideOptional=*/false,
                            resolver);
@@ -2256,7 +2256,7 @@ static bool canOverride(CanType t1, CanType t2,
     for (auto i : indices(tuple1.getElementTypes())) {
       if (!canOverride(tuple1.getElementType(i),
                        tuple2.getElementType(i),
-                       allowUnsafeParameterOverride,
+                       matchMode,
                        isParameter,
                        /*insideOptional=*/false,
                        resolver))
@@ -2283,12 +2283,12 @@ static bool canOverride(CanType t1, CanType t2,
 
     // Inputs are contravariant, results are covariant.
     return (canOverride(fn2.getInput(), fn1.getInput(),
-                        allowUnsafeParameterOverride,
+                        matchMode,
                         /*isParameter=*/true,
                         /*insideOptional=*/false,
                         resolver) &&
             canOverride(fn1.getResult(), fn2.getResult(),
-                        allowUnsafeParameterOverride,
+                        matchMode,
                         /*isParameter=*/false,
                         /*insideOptional=*/false,
                         resolver));
@@ -2301,22 +2301,23 @@ static bool canOverride(CanType t1, CanType t2,
       // Optional-to-optional.
       if (auto obj1 = t1.getAnyOptionalObjectType()) {
         // Allow T? and T! to freely override one another.
-        return canOverride(obj1, obj2, allowUnsafeParameterOverride,
+        return canOverride(obj1, obj2, matchMode,
                            /*isParameter=*/false,
                            /*insideOptional=*/true,
                            resolver);
       }
 
       // Value-to-optional.
-      return canOverride(t1, obj2, allowUnsafeParameterOverride,
+      return canOverride(t1, obj2, matchMode,
                          /*isParameter=*/false,
                          /*insideOptional=*/true,
                          resolver);
     }
   }
 
   // Allow T to override T! in certain cases.
-  if (allowUnsafeParameterOverride && isParameter && !insideOptional) {
+  if (matchMode == OverrideMatchMode::AllowNonOptionalForIUOParam &&
+      isParameter && !insideOptional) {
     if (auto obj1 = t1->getImplicitlyUnwrappedOptionalObjectType()) {
       t1 = obj1->getCanonicalType();
       if (t1 == t2) return true;
@@ -2327,10 +2328,10 @@ static bool canOverride(CanType t1, CanType t2,
   return t2->isExactSuperclassOf(t1, resolver);
 }
 
-bool TypeBase::canOverride(Type other, bool allowUnsafeParameterOverride,
+bool TypeBase::canOverride(Type other, OverrideMatchMode matchMode,
                            LazyResolver *resolver) {
   return ::canOverride(getCanonicalType(), other->getCanonicalType(),
-                       allowUnsafeParameterOverride,
+                       matchMode,
                        /*isParameter=*/false,
                        /*insideOptional=*/false,
                        resolver);

lib/Sema/TypeCheckDecl.cpp

@@ -4847,7 +4847,10 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
 
       // Failing that, check for subtyping.
-      if (declTy->canOverride(parentDeclTy, parentDecl->isObjC(), &TC)) {
+      auto matchMode = OverrideMatchMode::Strict;
+      if (parentDecl->isObjC())
+        matchMode = OverrideMatchMode::AllowNonOptionalForIUOParam;
+      if (declTy->canOverride(parentDeclTy, matchMode, &TC)) {
         // If the Objective-C selectors match, always call it exact.
         matches.push_back(
             std::make_tuple(parentDecl, objCMatch, parentDeclTy));
@@ -4996,7 +4999,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         auto parentPropertyTy = adjustSuperclassMemberDeclType(TC, matchDecl,
                                                                superclass);
 
-        if (!propertyTy->canOverride(parentPropertyTy, false, &TC)) {
+        if (!propertyTy->canOverride(parentPropertyTy,
+                                     OverrideMatchMode::Strict,
+                                     &TC)) {
           TC.diagnose(property, diag::override_property_type_mismatch,
                       property->getName(), propertyTy, parentPropertyTy);
           TC.diagnose(matchDecl, diag::property_override_here);