Sema: Fix override matching of inout and vararg parameters

First, if the base parameter is inout or vararg, the derived parameter
must be too. Second, we do not allow covariant overrides of inout or
vararg parameters.

Fixes <https://bugs.swift.org/browse/SR-10231>.

Author: slavapestov

lib/Sema/TypeCheckDeclOverride.cpp

@@ -560,25 +560,37 @@ static bool parameterTypesMatch(const ValueDecl *derivedDecl,
                                                         /*derivedSubs=*/None);
 
   for (auto i : indices(baseParams->getArray())) {
-    auto baseItfTy = baseParams->get(i)->getInterfaceType();
-    auto baseParamTy =
-        baseDecl->getAsGenericContext()->mapTypeIntoContext(baseItfTy);
-    baseParamTy = baseParamTy.subst(subs);
-    auto derivedParamTy = derivedParams->get(i)->getInterfaceType();
+    auto *baseParam = baseParams->get(i);
+    auto *derivedParam = derivedParams->get(i);
 
-    // Attempt contravariant match.
-    if (baseParamTy->matchesParameter(derivedParamTy, matchMode))
-      continue;
+    // Make sure inout-ness and varargs match.
+    if (baseParam->isInOut() != derivedParam->isInOut() ||
+        baseParam->isVariadic() != derivedParam->isVariadic()) {
+      return false;
+    }
+
+    auto baseParamTy = baseParam->getInterfaceType();
+    baseParamTy = baseParamTy.subst(subs);
+    auto derivedParamTy = derivedParam->getInterfaceType();
 
-    // Try once more for a match, using the underlying type of an
-    // IUO if we're allowing that.
-    if (baseParams->get(i)
-            ->getAttrs()
-            .hasAttribute<ImplicitlyUnwrappedOptionalAttr>() &&
-        matchMode.contains(TypeMatchFlags::AllowNonOptionalForIUOParam)) {
-      baseParamTy = baseParamTy->getOptionalObjectType();
-      if (baseParamTy->matches(derivedParamTy, matchMode))
+    if (baseParam->isInOut() || baseParam->isVariadic()) {
+      // Inout and vararg parameters must match exactly.
+      if (baseParamTy->isEqual(derivedParamTy))
         continue;
+    } else {
+      // Attempt contravariant match.
+      if (baseParamTy->matchesParameter(derivedParamTy, matchMode))
+        continue;
+
+      // Try once more for a match, using the underlying type of an
+      // IUO if we're allowing that.
+      if (baseParam->getAttrs()
+              .hasAttribute<ImplicitlyUnwrappedOptionalAttr>() &&
+          matchMode.contains(TypeMatchFlags::AllowNonOptionalForIUOParam)) {
+        baseParamTy = baseParamTy->getOptionalObjectType();
+        if (baseParamTy->matches(derivedParamTy, matchMode))
+          continue;
+      }
     }
 
     // If there is no match, then we're done.

test/decl/class/override.swift

@@ -316,7 +316,6 @@ class GenericSubscriptDerived : GenericSubscriptBase {
 
 
 // @escaping
-
 class CallbackBase {
   func perform(handler: @escaping () -> Void) {} // expected-note * {{here}}
   func perform(optHandler: (() -> Void)?) {} // expected-note * {{here}}
@@ -339,6 +338,31 @@ class CallbackSubC : CallbackBase {
   override func perform(nonescapingHandler: @escaping () -> Void) {} // expected-error {{method does not override any method from its superclass}}
 }
 
+// inout, varargs
+class HasFlagsBase {
+  func modify(x: inout B) {} // expected-note 2{{potential overridden instance method 'modify(x:)' here}}
+  func tweak(x: inout A) {} // expected-note 2{{potential overridden instance method 'tweak(x:)' here}}
+  func collect(x: B...) {} // expected-note 2{{potential overridden instance method 'collect(x:)' here}}
+}
+
+class HasFlagsDerivedGood : HasFlagsBase {
+  override func modify(x: inout B) {}
+  override func tweak(x: inout A) {}
+  override func collect(x: B...) {}
+}
+
+class HasFlagsDerivedBad1 : HasFlagsBase {
+  override func modify(x: inout A) {} // expected-error {{method does not override any method from its superclass}}
+  override func tweak(x: inout B) {} // expected-error {{method does not override any method from its superclass}}
+  override func collect(x: A...) {} // expected-error {{method does not override any method from its superclass}}
+}
+
+class HasFlagsDerivedBad2 : HasFlagsBase {
+  override func modify(x: B) {} // expected-error {{method does not override any method from its superclass}}
+  override func tweak(x: A) {} // expected-error {{method does not override any method from its superclass}}
+  override func collect(x: [B]) {} // expected-error {{method does not override any method from its superclass}}
+}
+
 // Issues with overrides of internal(set) and fileprivate(set) members
 public class BaseWithInternalSetter {
     public internal(set) var someValue: Int = 0