[SR7111] allow nested optional overrides

lib/AST/Type.cpp

@@ -2209,8 +2209,10 @@ static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
   if (t1 == t2) return true;
 
   // First try unwrapping optionals.
-  // Make sure we only unwrap at most one layer of optional.
-  if (insideOptional == OptionalUnwrapping::None) {
+  // Unwrap optional as much as possible.
+  if (insideOptional == OptionalUnwrapping::None ||
+      insideOptional == OptionalUnwrapping::OptionalToOptional ||
+      insideOptional == OptionalUnwrapping::ValueToOptional) {
     // Value-to-optional and optional-to-optional.
     if (auto obj2 = t2.getOptionalObjectType()) {
       // Optional-to-optional.

test/decl/class/override.swift

@@ -18,11 +18,11 @@ class A {
   func ret_subclass_uoptional_rev() -> B { return B() }
   func ret_subclass_optional_uoptional() -> A? { return .none }
   func ret_subclass_optional_uoptional_rev() -> B! { return B() }
-  func ret_nonclass_nested_optional() -> Int?? { return .none } // expected-note{{potential overridden instance method 'ret_nonclass_nested_optional()'}}
+  func ret_nonclass_nested_optional() -> Int?? { return .none }
   func ret_nonclass_nested_optional_rev() -> Int { return 0 }
-  func ret_class_nested_optional() -> B?? { return .none } // expected-note{{potential overridden instance method 'ret_class_nested_optional()'}}
+  func ret_class_nested_optional() -> B?? { return .none }
   func ret_class_nested_optional_rev() -> A { return self }
-  func ret_subclass_nested_optional() -> A?? { return .none } // expected-note{{potential overridden instance method 'ret_subclass_nested_optional()'}}
+  func ret_subclass_nested_optional() -> A?? { return .none }
   func ret_subclass_nested_optional_rev() -> B { return B() }
 
   func param_sametype(_ x : Int) {}
@@ -42,11 +42,11 @@ class A {
   func param_subclass_uoptional_rev(_ x : A!) {}
   func param_subclass_optional_uoptional(_ x : B!) {}
   func param_subclass_optional_uoptional_rev(_ x : A?) {}
-  func param_nonclass_nested_optional(_ x : Int) {} // expected-note{{potential overridden instance method 'param_nonclass_nested_optional'}}
+  func param_nonclass_nested_optional(_ x : Int) {}
   func param_nonclass_nested_optional_rev(_ x : Int??) {}
-  func param_class_nested_optional(_ x : B) {} // expected-note{{potential overridden instance method 'param_class_nested_optional'}}
+  func param_class_nested_optional(_ x : B) {}
   func param_class_nested_optional_rev(_ x : B??) {}
-  func param_subclass_nested_optional(_ x : B) {} // expected-note{{potential overridden instance method 'param_subclass_nested_optional'}}
+  func param_subclass_nested_optional(_ x : B) {}
   func param_subclass_nested_optional_rev(_ x : A??) {}
 }
 
@@ -68,11 +68,11 @@ class B : A {
   func ret_subclass_uoptional_rev() -> A! { return self }
   override func ret_subclass_optional_uoptional() -> B! { return self }
   func ret_subclass_optional_uoptional_rev() -> A? { return self }
-  override func ret_nonclass_nested_optional() -> Int { return 0 } // expected-error{{method does not override any method from its superclass}}
+  override func ret_nonclass_nested_optional() -> Int { return 0 }
   func ret_nonclass_nested_optional_rev() -> Int? { return 0 }
-  override func ret_class_nested_optional() -> B { return self } // expected-error{{method does not override any method from its superclass}}
+  override func ret_class_nested_optional() -> B { return self }
   func ret_class_nested_optional_rev() -> A? { return self }
-  override func ret_subclass_nested_optional() -> B { return self } // expected-error{{method does not override any method from its superclass}}
+  override func ret_subclass_nested_optional() -> B { return self }
   func ret_subclass_nested_optional_rev() -> A? { return self }
 
   override func param_sametype(_ x : Int) {}
@@ -92,11 +92,11 @@ class B : A {
   func param_subclass_uoptional_rev(_ x : B) {}
   override func param_subclass_optional_uoptional(_ x : A?) {}
   func param_subclass_optional_uoptional_rev(_ x : B!) {}
-  override func param_nonclass_nested_optional(_ x : Int??) {} // expected-error{{method does not override any method from its superclass}}
+  override func param_nonclass_nested_optional(_ x : Int??) {}
   func param_nonclass_nested_optional_rev(_ x : Int) {}
-  override func param_class_nested_optional(_ x : B??) {} // expected-error{{method does not override any method from its superclass}}
+  override func param_class_nested_optional(_ x : B??) {}
   func param_class_nested_optional_rev(_ x : B) {}
-  override func param_subclass_nested_optional(_ x : A??) {} // expected-error{{method does not override any method from its superclass}}
+  override func param_subclass_nested_optional(_ x : A??) {}
   func param_subclass_nested_optional_rev(_ x : B) {}
 }