Merge pull request #9619 from allevato/synthesize-equatable-hashable

Synthesize Equatable/Hashable for complex enums, structs

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -481,6 +481,13 @@ class ASTContext {
   /// Retrieve the declaration of Swift.==(Int, Int) -> Bool.
   FuncDecl *getEqualIntDecl() const;
 
+  /// Retrieve the declaration of
+  /// Swift._mixForSynthesizedHashValue (Int, Int) -> Int.
+  FuncDecl *getMixForSynthesizedHashValueDecl() const;
+
+  /// Retrieve the declaration of Swift._mixInt(Int) -> Int.
+  FuncDecl *getMixIntDecl() const;
+
   /// Retrieve the declaration of Array.append(element:)
   FuncDecl *getArrayAppendElementDecl() const;
 

include/swift/AST/Decl.h

@@ -2949,14 +2949,6 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// conformances.
   void registerProtocolConformance(ProtocolConformance *conformance);
 
-  /// \brief True if the type can implicitly derive a conformance for the given
-  /// protocol.
-  ///
-  /// If true, explicit conformance checking will synthesize implicit
-  /// declarations for requirements of the protocol that are not satisfied by
-  /// the type's explicit members.
-  bool derivesProtocolConformance(ProtocolDecl *protocol) const;
-
   void setConformanceLoader(LazyMemberLoader *resolver, uint64_t contextData);
 
   /// classifyAsOptionalType - Decide whether this declaration is one

include/swift/AST/DeclContext.h

@@ -65,6 +65,7 @@ namespace swift {
   class SerializedPatternBindingInitializer;
   class SerializedDefaultArgumentInitializer;
   class SerializedTopLevelCodeDecl;
+  class StructDecl;
 
 enum class DeclContextKind : uint8_t {
   AbstractClosureExpr,
@@ -255,6 +256,10 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// EnumDecl, otherwise return null.
   EnumDecl *getAsEnumOrEnumExtensionContext() const;
 
+  /// If this DeclContext is a struct, or an extension on a struct, return the
+  /// StructDecl, otherwise return null.
+  StructDecl *getAsStructOrStructExtensionContext() const;
+
   /// If this DeclContext is a protocol, or an extension on a
   /// protocol, return the ProtocolDecl, otherwise return null.
   ProtocolDecl *getAsProtocolOrProtocolExtensionContext() const;

include/swift/AST/KnownIdentifiers.def

@@ -116,6 +116,7 @@ IDENTIFIER_WITH_NAME(NativeClassLayout, "_NativeClass")
 IDENTIFIER_WITH_NAME(MatchOperator, "~=")
 IDENTIFIER_WITH_NAME(EqualsOperator, "==")
 IDENTIFIER_WITH_NAME(derived_enum_equals, "__derived_enum_equals")
+IDENTIFIER_WITH_NAME(derived_struct_equals, "__derived_struct_equals")
 
 // Precedence groups
 IDENTIFIER(AssignmentPrecedence)

lib/AST/ASTContext.cpp

@@ -192,6 +192,12 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
   /// func ==(Int, Int) -> Bool
   FuncDecl *EqualIntDecl = nullptr;
 
+  /// func _mixForSynthesizedHashValue(Int, Int) -> Int
+  FuncDecl *MixForSynthesizedHashValueDecl = nullptr;
+
+  /// func _mixInt(Int) -> Int
+  FuncDecl *MixIntDecl = nullptr;
+  
   /// func append(Element) -> void
   FuncDecl *ArrayAppendElementDecl = nullptr;
 
@@ -935,27 +941,78 @@ static bool isBuiltinWordType(Type type) {
   return false;
 }
 
-FuncDecl *ASTContext::getGetBoolDecl(LazyResolver *resolver) const {
-  if (Impl.GetBoolDecl)
-    return Impl.GetBoolDecl;
+/// Looks up all implementations of an operator (globally and declared in types)
+/// and passes potential matches to the given callback. The search stops when
+/// the callback returns true (in which case the matching function declaration
+/// is returned); otherwise, nullptr is returned if there are no matches.
+/// \p C The AST context.
+/// \p oper The name of the operator.
+/// \p contextType If the operator is declared on a type, then only operators
+///     defined on this type should be considered.
+/// \p callback A callback that takes as its two arguments the input type and
+///     result type of a candidate function declaration and returns true if the
+///     function matches the desired criteria.
+/// \return The matching function declaration, or nullptr if there was no match.
+template <int ExpectedCandidateCount, typename MatchFuncCallback>
+static FuncDecl *lookupOperatorFunc(const ASTContext &ctx, StringRef oper,
+                                    Type contextType,
+                                    MatchFuncCallback &callback) {
+  SmallVector<ValueDecl *, ExpectedCandidateCount> candidates;
+  ctx.lookupInSwiftModule(oper, candidates);
+
+  for (auto candidate : candidates) {
+    // All operator declarations should be functions, but make sure.
+    auto *funcDecl = dyn_cast<FuncDecl>(candidate);
+    if (!funcDecl)
+      continue;
 
-  // Look for the function.
-  Type input, output;
-  auto decl = findLibraryIntrinsic(*this, "_getBool", resolver);
-  if (!decl ||
-      !isNonGenericIntrinsic(decl, /*allowTypeMembers=*/false, input, output))
-    return nullptr;
+    if (funcDecl->getDeclContext()->isTypeContext()) {
+      auto contextTy = funcDecl->getDeclContext()->getDeclaredInterfaceType();
+      if (!contextTy->isEqual(contextType)) continue;
+    }
 
-  // Input must be Builtin.Int1
-  if (!isBuiltinInt1Type(input))
-    return nullptr;
+    if (auto resolver = ctx.getLazyResolver())
+      resolver->resolveDeclSignature(funcDecl);
 
-  // Output must be a global type named Bool.
-  if (!output->isEqual(getBoolDecl()->getDeclaredType()))
+    Type inputType, resultType;
+    if (!isNonGenericIntrinsic(funcDecl, /*allowTypeMembers=*/true, inputType,
+                               resultType))
+      continue;
+
+    if (callback(inputType, resultType))
+      return funcDecl;
+  }
+
+  return nullptr;
+}
+
+/// Looks up the implementation (assumed to be singular) of a globally-defined
+/// standard library intrinsic function and passes the potential match to the
+/// given callback if it was found. If the callback returns true, then the
+/// match is returned; otherwise, nullptr is returned.
+/// \p ctx The AST context.
+/// \p name The name of the function.
+/// \p resolver The lazy resolver.
+/// \p callback A callback that takes as its two arguments the input type and
+///     result type of the candidate function declaration and returns true if
+///     the function matches the desired criteria.
+/// \return The matching function declaration, or nullptr if there was no match.
+template <typename MatchFuncCallback>
+static FuncDecl *lookupLibraryIntrinsicFunc(const ASTContext &ctx,
+                                            StringRef name,
+                                            LazyResolver *resolver,
+                                            MatchFuncCallback &callback) {
+  Type inputType, resultType;
+  auto decl = findLibraryIntrinsic(ctx, name, resolver);
+  if (!decl ||
+      !isNonGenericIntrinsic(decl, /*allowTypeMembers=*/false, inputType,
+                             resultType))
     return nullptr;
 
-  Impl.GetBoolDecl = decl;
-  return decl;
+  if (callback(inputType, resultType))
+    return decl;
+
+  return nullptr;
 }
 
 FuncDecl *ASTContext::getEqualIntDecl() const {
@@ -967,45 +1024,74 @@ FuncDecl *ASTContext::getEqualIntDecl() const {
 
   auto intType = getIntDecl()->getDeclaredType();
   auto boolType = getBoolDecl()->getDeclaredType();
-  SmallVector<ValueDecl *, 30> equalFuncs;
-  lookupInSwiftModule("==", equalFuncs);
-  
-  // Find the overload for Int.
-  for (ValueDecl *vd : equalFuncs) {
-    // All "==" decls should be functions, but who knows...
-    auto *funcDecl = dyn_cast<FuncDecl>(vd);
-    if (!funcDecl)
-      continue;
+  auto callback = [&](Type inputType, Type resultType) {
+    // Check for the signature: (Int, Int) -> Bool
+    auto tupleType = dyn_cast<TupleType>(inputType.getPointer());
+    assert(tupleType);
+    return tupleType->getNumElements() == 2 &&
+        tupleType->getElementType(0)->isEqual(intType) &&
+        tupleType->getElementType(1)->isEqual(intType) &&
+        resultType->isEqual(boolType);
+  };
 
-    if (funcDecl->getDeclContext()->isTypeContext()) {
-      auto contextTy = funcDecl->getDeclContext()->getDeclaredInterfaceType();
-      if (!contextTy->isEqual(intType)) continue;
-    }
+  auto decl = lookupOperatorFunc<32>(*this, "==", intType, callback);
+  Impl.EqualIntDecl = decl;
+  return decl;
+}
 
-    if (auto resolver = getLazyResolver())
-      resolver->resolveDeclSignature(funcDecl);
+FuncDecl *ASTContext::getGetBoolDecl(LazyResolver *resolver) const {
+  if (Impl.GetBoolDecl)
+    return Impl.GetBoolDecl;
 
-    Type input, resultType;
-    if (!isNonGenericIntrinsic(funcDecl, /*allowTypeMembers=*/true, input,
-                               resultType))
-      continue;
-    
-    // Check for the signature: (Int, Int) -> Bool
-    auto tupleType = dyn_cast<TupleType>(input.getPointer());
+  auto callback = [&](Type inputType, Type resultType) {
+    // Look for the signature (Builtin.Int1) -> Bool
+    return isBuiltinInt1Type(inputType) &&
+        resultType->isEqual(getBoolDecl()->getDeclaredType());
+  };
+
+  auto decl = lookupLibraryIntrinsicFunc(*this, "_getBool", resolver, callback);
+  Impl.GetBoolDecl = decl;
+  return decl;
+}
+
+FuncDecl *ASTContext::getMixForSynthesizedHashValueDecl() const {
+  if (Impl.MixForSynthesizedHashValueDecl)
+    return Impl.MixForSynthesizedHashValueDecl;
+
+  auto resolver = getLazyResolver();
+  auto intType = getIntDecl()->getDeclaredType();
+
+  auto callback = [&](Type inputType, Type resultType) {
+    // Look for the signature (Int, Int) -> Int
+    auto tupleType = dyn_cast<TupleType>(inputType.getPointer());
     assert(tupleType);
-    if (tupleType->getNumElements() != 2)
-      continue;
+    return tupleType->getNumElements() == 2 &&
+        tupleType->getElementType(0)->isEqual(intType) &&
+        tupleType->getElementType(1)->isEqual(intType) &&
+        resultType->isEqual(intType);
+  };
 
-    auto argType1 = tupleType->getElementType(0);
-    auto argType2 = tupleType->getElementType(1);
-    if (argType1->isEqual(intType) &&
-        argType2->isEqual(intType) &&
-        resultType->isEqual(boolType)) {
-      Impl.EqualIntDecl = funcDecl;
-      return funcDecl;
-    }
-  }
-  return nullptr;
+  auto decl = lookupLibraryIntrinsicFunc(
+      *this, "_mixForSynthesizedHashValue", resolver, callback);
+  Impl.MixForSynthesizedHashValueDecl = decl;
+  return decl;
+}
+
+FuncDecl *ASTContext::getMixIntDecl() const {
+  if (Impl.MixIntDecl)
+    return Impl.MixIntDecl;
+
+  auto resolver = getLazyResolver();
+  auto intType = getIntDecl()->getDeclaredType();
+
+  auto callback = [&](Type inputType, Type resultType) {
+    // Look for the signature (Int) -> Int
+    return inputType->isEqual(intType) && resultType->isEqual(intType);
+  };
+
+  auto decl = lookupLibraryIntrinsicFunc(*this, "_mixInt", resolver, callback);
+  Impl.MixIntDecl = decl;
+  return decl;
 }
 
 FuncDecl *ASTContext::getArrayAppendElementDecl() const {

lib/AST/Decl.cpp

@@ -2264,72 +2264,6 @@ bool NominalTypeDecl::hasFixedLayout(ModuleDecl *M,
   llvm_unreachable("bad resilience expansion");
 }
 
-
-bool NominalTypeDecl::derivesProtocolConformance(ProtocolDecl *protocol) const {
-  // Only known protocols can be derived.
-  auto knownProtocol = protocol->getKnownProtocolKind();
-  if (!knownProtocol)
-    return false;
-
-  if (auto *enumDecl = dyn_cast<EnumDecl>(this)) {
-    switch (*knownProtocol) {
-    // The presence of a raw type is an explicit declaration that
-    // the compiler should derive a RawRepresentable conformance.
-    case KnownProtocolKind::RawRepresentable:
-      return enumDecl->hasRawType();
-    
-    // Enums without associated values can implicitly derive Equatable and
-    // Hashable conformance.
-    case KnownProtocolKind::Equatable:
-    case KnownProtocolKind::Hashable:
-      return enumDecl->hasCases()
-          && enumDecl->hasOnlyCasesWithoutAssociatedValues();
-
-    // @objc enums can explicitly derive their _BridgedNSError conformance.
-    case KnownProtocolKind::BridgedNSError:
-      return isObjC() && enumDecl->hasCases()
-          && enumDecl->hasOnlyCasesWithoutAssociatedValues();
-
-    // Enums without associated values and enums with a raw type of String
-    // or Int can explicitly derive CodingKey conformance.
-    case KnownProtocolKind::CodingKey: {
-      Type rawType = enumDecl->getRawType();
-      if (rawType) {
-        auto parentDC = enumDecl->getDeclContext();
-        ASTContext &C = parentDC->getASTContext();
-
-        auto nominal = rawType->getAnyNominal();
-        return nominal == C.getStringDecl() || nominal == C.getIntDecl();
-      }
-
-      // hasOnlyCasesWithoutAssociatedValues will return true for empty enums;
-      // empty enumas are allowed to conform as well.
-      return enumDecl->hasOnlyCasesWithoutAssociatedValues();
-    }
-
-    default:
-      return false;
-    }
-  } else if (isa<StructDecl>(this) || isa<ClassDecl>(this)) {
-    // Structs and classes can explicitly derive Encodable and Decodable
-    // conformance (explicitly meaning we can synthesize an implementation if
-    // a type conforms manually).
-    if (*knownProtocol == KnownProtocolKind::Encodable ||
-        *knownProtocol == KnownProtocolKind::Decodable) {
-      // FIXME: This is not actually correct. We cannot promise to always
-      // provide a witness here for all structs and classes. Unfortunately,
-      // figuring out whether this is actually possible requires much more
-      // context -- a TypeChecker and the parent decl context at least -- and is
-      // tightly coupled to the logic within DerivedConformance.
-      // This unfortunately means that we expect a witness even if one will not
-      // be produced, which requires DerivedConformance::deriveCodable to output
-      // its own diagnostics.
-      return true;
-    }
-  }
-  return false;
-}
-
 void NominalTypeDecl::computeType() {
   ASTContext &ctx = getASTContext();
 

lib/AST/DeclContext.cpp

@@ -92,6 +92,10 @@ EnumDecl *DeclContext::getAsEnumOrEnumExtensionContext() const {
   return dyn_cast_or_null<EnumDecl>(getAsTypeOrTypeExtensionContext());
 }
 
+StructDecl *DeclContext::getAsStructOrStructExtensionContext() const {
+  return dyn_cast_or_null<StructDecl>(getAsTypeOrTypeExtensionContext());
+}
+
 ProtocolDecl *DeclContext::getAsProtocolOrProtocolExtensionContext() const {
   return dyn_cast_or_null<ProtocolDecl>(getAsTypeOrTypeExtensionContext());
 }