wip: fix parameter matching

Author: rudkx

include/swift/AST/Types.h

@@ -765,6 +765,15 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// \p matchOptions.
   bool matches(Type other, TypeMatchOptions matchOptions);
 
+  bool matchesParameter(Type other, TypeMatchOptions matchMode);
+
+  /// \brief Determines whether this function type is similar to \p
+  /// other as defined by \p matchOptions and the callback \p
+  /// paramsAndResultMatch which determines in a client-specific way
+  /// whether the parameters and result of the types match.
+  bool matchesFunctionType(Type other, TypeMatchOptions matchOptions,
+                           std::function<bool()> paramsAndResultMatch);
+
   /// \brief Determines whether this type has a retainable pointer
   /// representation, i.e. whether it is representable as a single,
   /// possibly nil pointer that can be unknown-retained and

lib/AST/Decl.cpp

@@ -4936,6 +4936,7 @@ static bool requiresNewVTableEntry(const AbstractFunctionDecl *decl) {
   auto overrideInterfaceTy = selfInterfaceTy->adjustSuperclassMemberDeclType(
       base, decl, baseInterfaceTy);
 
+  // FIXME: IUO
   return !derivedInterfaceTy->matches(overrideInterfaceTy,
                                       TypeMatchFlags::AllowABICompatible);
 }

lib/AST/Type.cpp

@@ -2178,10 +2178,10 @@ namespace {
   };
 } // end anonymous namespace
 
-static bool matchFunctionTypes(CanAnyFunctionType fn1, CanAnyFunctionType fn2,
-                               TypeMatchOptions matchMode,
-                               OptionalUnwrapping insideOptional,
-                               std::function<bool()> paramsAndResultMatch) {
+static bool matchesFunctionType(CanAnyFunctionType fn1, CanAnyFunctionType fn2,
+                                TypeMatchOptions matchMode,
+                                OptionalUnwrapping insideOptional,
+                                std::function<bool()> paramsAndResultMatch) {
   // FIXME: Handle generic functions in non-ABI matches.
   if (!matchMode.contains(TypeMatchFlags::AllowABICompatible)) {
     if (!isa<FunctionType>(fn1) || !isa<FunctionType>(fn2))
@@ -2299,8 +2299,8 @@ static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
                       OptionalUnwrapping::None));
     };
 
-    return matchFunctionTypes(fn1, fn2, matchMode, insideOptional,
-                              paramsAndResultMatch);
+    return matchesFunctionType(fn1, fn2, matchMode, insideOptional,
+                               paramsAndResultMatch);
   }
 
   if (matchMode.contains(TypeMatchFlags::AllowNonOptionalForIUOParam) &&
@@ -2331,6 +2331,21 @@ bool TypeBase::matches(Type other, TypeMatchOptions matchMode) {
                    ParameterPosition::NotParameter, OptionalUnwrapping::None);
 }
 
+bool TypeBase::matchesParameter(Type other, TypeMatchOptions matchMode) {
+  return ::matches(getCanonicalType(), other->getCanonicalType(), matchMode,
+                   ParameterPosition::Parameter, OptionalUnwrapping::None);
+}
+
+bool TypeBase::matchesFunctionType(Type other, TypeMatchOptions matchMode,
+                                   std::function<bool()> paramsAndResultMatch) {
+  auto thisFnTy = dyn_cast<AnyFunctionType>(getCanonicalType());
+  auto otherFnTy = dyn_cast<AnyFunctionType>(other->getCanonicalType());
+
+  assert(thisFnTy && otherFnTy);
+  return ::matchesFunctionType(thisFnTy, otherFnTy, matchMode,
+                               OptionalUnwrapping::None, paramsAndResultMatch);
+}
+
 /// getNamedElementId - If this tuple has a field with the specified name,
 /// return the field index, otherwise return -1.
 int TupleType::getNamedElementId(Identifier I) const {

lib/SIL/SILFunctionType.cpp

@@ -2137,6 +2137,7 @@ SILParameterInfo TypeConverter::getConstantSelfParameter(SILDeclRef constant) {
 // @guaranteed or whatever.
 static bool checkASTTypeForABIDifferences(CanType type1,
                                           CanType type2) {
+  // FIXME: IUO
   return !type1->matches(type2, TypeMatchFlags::AllowABICompatible);
 }
 

lib/Sema/TypeCheckDecl.cpp

@@ -5934,6 +5934,61 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
   }
 
+  static bool parameterTypesMatch(const ValueDecl *derivedDecl,
+                                  const ValueDecl *baseDecl,
+                                  TypeMatchOptions matchMode) {
+    const ParameterList *derivedParams;
+    const ParameterList *baseParams;
+    if (auto *derived = dyn_cast<AbstractFunctionDecl>(derivedDecl)) {
+      auto *base = dyn_cast<AbstractFunctionDecl>(baseDecl);
+      if (!base)
+        return false;
+      baseParams = base->getParameterList(1);
+      derivedParams = derived->getParameterList(1);
+    } else {
+      auto *base = dyn_cast<SubscriptDecl>(baseDecl);
+      if (!base)
+        return false;
+      baseParams = base->getIndices();
+      derivedParams = cast<SubscriptDecl>(derivedDecl)->getIndices();
+    }
+
+    if (baseParams->size() != derivedParams->size())
+      return false;
+
+    auto subs = SubstitutionMap::getOverrideSubstitutions(baseDecl, derivedDecl,
+                                                          /*derivedSubs=*/None);
+
+    for (auto i : indices(baseParams->getArray())) {
+      auto *baseParam = baseParams->get(i);
+      auto baseParamTy = baseParam->getInterfaceType();
+      auto baseParamMappedTy = baseDecl->getDeclContext()->mapTypeIntoContext(baseParamTy);
+      auto baseParamSubstTy = baseParamMappedTy.subst(subs);
+
+      auto *derivedParam = derivedParams->get(i);
+      auto derivedParamTy = derivedParam->getInterfaceType();
+
+      // Attempt contravariant match.
+      if (baseParamSubstTy->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)) {
+        baseParamSubstTy = baseParamSubstTy->getAnyOptionalObjectType();
+        if (baseParamSubstTy->matches(derivedParamTy, matchMode))
+          continue;
+      }
+
+      // If there is no match, then we're done.
+      return false;
+    }
+
+    return true;
+  }
+
   /// Determine which method or subscript this method or subscript overrides
   /// (if any).
   ///
@@ -6146,8 +6201,22 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
               TypeMatchFlags::IgnoreNonEscapingForOptionalFunctionParam;
         }
 
-        if (declTy->matches(parentDeclTy, matchMode)) {
-          // If the Objective-C selectors match, always call it exact.
+        auto declFnTy = declTy->getAs<AnyFunctionType>();
+        auto parentDeclFnTy = parentDeclTy->getAs<AnyFunctionType>();
+        if (declFnTy && parentDeclFnTy) {
+          auto paramsAndResultMatch = [=]() -> bool {
+            return parameterTypesMatch(decl, parentDecl, matchMode) &&
+                   declFnTy->getResult()->matches(parentDeclFnTy->getResult(),
+                                                  matchMode);
+          };
+
+          if (declFnTy->matchesFunctionType(parentDeclFnTy, matchMode,
+                                            paramsAndResultMatch)) {
+            matches.push_back({parentDecl, objCMatch, parentDeclTy});
+            hadExactMatch |= objCMatch;
+            continue;
+          }
+        } else if (declTy->matches(parentDeclTy, matchMode)) {
           matches.push_back({parentDecl, objCMatch, parentDeclTy});
           hadExactMatch |= objCMatch;
           continue;