---

yaml
---
r: 340331
b: refs/heads/rxwei-patch-1
c: 5d59600
h: refs/heads/master
i:
  340329: 0cf5b92
  340327: 66b3d16

Author: slavapestov

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: ae5a427193a42b9e7427d3f12453d3c03a9dcb12
+refs/heads/rxwei-patch-1: 5d59600a534cff62a515724aae44209c5d25d4e3
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSema.def

@@ -2538,6 +2538,12 @@ NOTE(decodable_suggest_overriding_init_here,none,
 NOTE(codable_suggest_overriding_init_here,none,
      "did you mean to override 'init(from:)' and 'encode(to:)'?", ())
 
+NOTE(missing_member_type_conformance_prevents_synthesis, none,
+     "%select{associated value|stored property}0 type %1 does not conform to "
+     "protocol %2, preventing synthesized conformance "
+     "of %3 to %2",
+     (unsigned, Type, Type, Type))
+
 // Dynamic Self
 ERROR(dynamic_self_non_method,none,
       "%select{global|local}0 function cannot return 'Self'", (bool))

branches/rxwei-patch-1/lib/AST/Decl.cpp

@@ -5444,9 +5444,6 @@ PropertyWrapperTypeInfo VarDecl::getAttachedPropertyWrapperTypeInfo() const {
 
 Type VarDecl::getAttachedPropertyWrapperType() const {
   auto &ctx = getASTContext();
-  if (!ctx.getLazyResolver())
-    return nullptr;
-
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(ctx.evaluator,
                            AttachedPropertyWrapperTypeRequest{mutableThis},
@@ -5455,9 +5452,6 @@ Type VarDecl::getAttachedPropertyWrapperType() const {
 
 Type VarDecl::getPropertyWrapperBackingPropertyType() const {
   ASTContext &ctx = getASTContext();
-  if (!ctx.getLazyResolver())
-    return nullptr;
-
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(
       ctx.evaluator, PropertyWrapperBackingPropertyTypeRequest{mutableThis},
@@ -5467,9 +5461,6 @@ Type VarDecl::getPropertyWrapperBackingPropertyType() const {
 PropertyWrapperBackingPropertyInfo
 VarDecl::getPropertyWrapperBackingPropertyInfo() const {
   auto &ctx = getASTContext();
-  if (!ctx.getLazyResolver())
-    return PropertyWrapperBackingPropertyInfo();
-
   auto mutableThis = const_cast<VarDecl *>(this);
   return evaluateOrDefault(
       ctx.evaluator,

branches/rxwei-patch-1/lib/AST/TypeCheckRequests.cpp

@@ -648,6 +648,7 @@ void PropertyWrapperBackingPropertyTypeRequest::noteCycleStep(
     DiagnosticEngine &diags) const {
   std::get<0>(getStorage())->diagnose(diag::circular_reference_through);
 }
+
 bool PropertyWrapperBackingPropertyInfoRequest::isCached() const {
   auto var = std::get<0>(getStorage());
   return !var->getAttrs().isEmpty();

branches/rxwei-patch-1/lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -32,15 +32,21 @@
 
 using namespace swift;
 
-/// Returns true if, for every element of the given enum, it either has no
-/// associated values or all of them conform to a protocol.
+enum NonconformingMemberKind {
+  AssociatedValue,
+  StoredProperty
+};
+
+/// Returns the ParamDecl for each associated value of the given enum whose type
+/// does not conform to a protocol
 /// \p theEnum The enum whose elements and associated values should be checked.
 /// \p protocol The protocol being requested.
-/// \return True if all associated values of all elements of the enum conform.
-static bool allAssociatedValuesConformToProtocol(DeclContext *DC,
-                                                 EnumDecl *theEnum,
-                                                 ProtocolDecl *protocol) {
+/// \return The ParamDecl of each associated value whose type does not conform.
+static SmallVector<ParamDecl *, 3>
+associatedValuesNotConformingToProtocol(DeclContext *DC, EnumDecl *theEnum,
+                                        ProtocolDecl *protocol) {
   auto lazyResolver = DC->getASTContext().getLazyResolver();
+  SmallVector<ParamDecl *, 3> nonconformingAssociatedValues;
   for (auto elt : theEnum->getAllElements()) {
     if (!elt->hasInterfaceType())
       lazyResolver->resolveDeclSignature(elt);
@@ -53,38 +59,62 @@ static bool allAssociatedValuesConformToProtocol(DeclContext *DC,
       auto type = param->getInterfaceType();
       if (!TypeChecker::conformsToProtocol(DC->mapTypeIntoContext(type),
                                            protocol, DC, None)) {
-        return false;
+        nonconformingAssociatedValues.push_back(param);
       }
     }
   }
-  return true;
+  return nonconformingAssociatedValues;
 }
 
-/// Returns true if every stored property in the given struct conforms to the
-/// protocol (or, vacuously, if it has no stored properties).
-/// \p theStruct The struct whose stored properties should be checked.
+/// Returns true if, for every element of the given enum, it either has no
+/// associated values or all of them conform to a protocol.
+/// \p theEnum The enum whose elements and associated values should be checked.
 /// \p protocol The protocol being requested.
-/// \return True if all stored properties of the struct conform.
-static bool allStoredPropertiesConformToProtocol(DeclContext *DC,
-                                                 StructDecl *theStruct,
+/// \return True if all associated values of all elements of the enum conform.
+static bool allAssociatedValuesConformToProtocol(DeclContext *DC,
+                                                 EnumDecl *theEnum,
                                                  ProtocolDecl *protocol) {
+  return associatedValuesNotConformingToProtocol(DC, theEnum, protocol).empty();
+}
+
+/// Returns the VarDecl of each stored property in the given struct whose type
+/// does not conform to a protocol.
+/// \p theStruct The struct whose stored properties should be checked.
+/// \p protocol The protocol being requested.
+/// \return The VarDecl of each stored property whose type does not conform.
+static SmallVector<VarDecl *, 3>
+storedPropertiesNotConformingToProtocol(DeclContext *DC, StructDecl *theStruct,
+                                        ProtocolDecl *protocol) {
   auto lazyResolver = DC->getASTContext().getLazyResolver();
   auto storedProperties =
-    theStruct->getStoredProperties(/*skipInaccessible=*/true);
+      theStruct->getStoredProperties(/*skipInaccessible=*/true);
+  SmallVector<VarDecl *, 3> nonconformingProperties;
   for (auto propertyDecl : storedProperties) {
     if (!propertyDecl->hasInterfaceType())
       lazyResolver->resolveDeclSignature(propertyDecl);
     if (!propertyDecl->hasInterfaceType())
-      return false;
+      nonconformingProperties.push_back(propertyDecl);
 
     auto type = propertyDecl->getValueInterfaceType();
 
-    if (!TypeChecker::conformsToProtocol(DC->mapTypeIntoContext(type),
-                                         protocol, DC, None)) {
-      return false;
+    if (!TypeChecker::conformsToProtocol(DC->mapTypeIntoContext(type), protocol,
+                                         DC, None)) {
+      nonconformingProperties.push_back(propertyDecl);
     }
   }
-  return true;
+  return nonconformingProperties;
+}
+
+/// Returns true if every stored property in the given struct conforms to the
+/// protocol (or, vacuously, if it has no stored properties).
+/// \p theStruct The struct whose stored properties should be checked.
+/// \p protocol The protocol being requested.
+/// \return True if all stored properties of the struct conform.
+static bool allStoredPropertiesConformToProtocol(DeclContext *DC,
+                                                 StructDecl *theStruct,
+                                                 ProtocolDecl *protocol) {
+  return storedPropertiesNotConformingToProtocol(DC, theStruct, protocol)
+      .empty();
 }
 
 /// Common preconditions for Equatable and Hashable.
@@ -106,6 +136,39 @@ static bool canDeriveConformance(DeclContext *DC,
   return false;
 }
 
+/// Diagnose failed conformance synthesis caused by a member type not conforming
+/// to the same protocol
+void diagnoseFailedDerivation(DeclContext *DC, NominalTypeDecl *nominal,
+                              ProtocolDecl *protocol) {
+  ASTContext &ctx = DC->getASTContext();
+
+  if (auto *enumDecl = dyn_cast<EnumDecl>(nominal)) {
+    auto nonconformingAssociatedTypes =
+        associatedValuesNotConformingToProtocol(DC, enumDecl, protocol);
+    for (auto *typeToDiagnose : nonconformingAssociatedTypes) {
+      ctx.Diags.diagnose(
+          typeToDiagnose->getTypeLoc().getLoc(),
+          diag::missing_member_type_conformance_prevents_synthesis,
+          NonconformingMemberKind::AssociatedValue,
+          typeToDiagnose->getInterfaceType(), protocol->getDeclaredType(),
+          nominal->getDeclaredInterfaceType());
+    }
+  }
+
+  if (auto *structDecl = dyn_cast<StructDecl>(nominal)) {
+    auto nonconformingStoredProperties =
+        storedPropertiesNotConformingToProtocol(DC, structDecl, protocol);
+    for (auto *propertyToDiagnose : nonconformingStoredProperties) {
+      ctx.Diags.diagnose(
+          propertyToDiagnose->getLoc(),
+          diag::missing_member_type_conformance_prevents_synthesis,
+          NonconformingMemberKind::StoredProperty,
+          propertyToDiagnose->getInterfaceType(), protocol->getDeclaredType(),
+          nominal->getDeclaredInterfaceType());
+    }
+  }
+}
+
 /// Creates a named variable based on a prefix character and a numeric index.
 /// \p prefixChar The prefix character for the variable's name.
 /// \p index The numeric index to append to the variable's name.
@@ -722,6 +785,13 @@ ValueDecl *DerivedConformance::deriveEquatable(ValueDecl *requirement) {
   return nullptr;
 }
 
+void DerivedConformance::tryDiagnoseFailedEquatableDerivation(
+    DeclContext *DC, NominalTypeDecl *nominal) {
+  ASTContext &ctx = DC->getASTContext();
+  auto *equatableProto = ctx.getProtocol(KnownProtocolKind::Equatable);
+  diagnoseFailedDerivation(DC, nominal, equatableProto);
+}
+
 /// Returns a new \c CallExpr representing
 ///
 ///   hasher.combine(hashable)
@@ -1055,18 +1125,41 @@ deriveBodyHashable_hashValue(AbstractFunctionDecl *hashValueDecl, void *) {
 
   // return _hashValue(for: self)
   auto *hashFunc = C.getHashValueForDecl();
-  auto hashExpr = new (C) DeclRefExpr(hashFunc, DeclNameLoc(),
+  if (!hashFunc->hasInterfaceType())
+    C.getLazyResolver()->resolveDeclSignature(hashFunc);
+
+  auto selfType = hashValueDecl->mapTypeIntoContext(
+    parentDC->getSelfInterfaceType());
+  auto hashableProto = C.getProtocol(KnownProtocolKind::Hashable);
+  auto conformance = TypeChecker::conformsToProtocol(selfType, hashableProto,
+                                                     parentDC, None);
+  auto subs = SubstitutionMap::get(hashFunc->getGenericSignature(),
+                                   ArrayRef<Type>(selfType),
+                                   ArrayRef<ProtocolConformanceRef>(*conformance));
+  ConcreteDeclRef hashRef(hashFunc, subs);
+
+  auto hashExpr = new (C) DeclRefExpr(hashRef, DeclNameLoc(),
                                       /*implicit*/ true);
+
+  Type intType = C.getIntDecl()->getDeclaredType();
+  hashExpr->setType(FunctionType::get(AnyFunctionType::Param(selfType),
+                                      intType));
+
   auto selfDecl = hashValueDecl->getImplicitSelfDecl();
   auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(),
                                      /*implicit*/ true);
-  auto callExpr = CallExpr::createImplicit(C, hashExpr,
-                                           { selfRef }, { C.Id_for });
+  selfRef->setType(selfType);
+
+  auto callExpr = CallExpr::createImplicit(C, hashExpr, { selfRef }, { });
+  callExpr->setType(intType);
+  callExpr->setThrows(false);
+
   auto returnStmt = new (C) ReturnStmt(SourceLoc(), callExpr);
 
   auto body = BraceStmt::create(C, SourceLoc(), {returnStmt}, SourceLoc(),
                                 /*implicit*/ true);
   hashValueDecl->setBody(body);
+  hashValueDecl->setBodyTypeCheckedIfPresent();
 }
 
 /// Derive a 'hashValue' implementation.
@@ -1185,6 +1278,13 @@ bool DerivedConformance::canDeriveHashable(NominalTypeDecl *type) {
   return true;
 }
 
+void DerivedConformance::tryDiagnoseFailedHashableDerivation(
+    DeclContext *DC, NominalTypeDecl *nominal) {
+  ASTContext &ctx = DC->getASTContext();
+  auto *hashableProto = ctx.getProtocol(KnownProtocolKind::Hashable);
+  diagnoseFailedDerivation(DC, nominal, hashableProto);
+}
+
 ValueDecl *DerivedConformance::deriveHashable(ValueDecl *requirement) {
   ASTContext &C = ConformanceDecl->getASTContext();
 
@@ -1218,6 +1318,13 @@ ValueDecl *DerivedConformance::deriveHashable(ValueDecl *requirement) {
         ConformanceDecl->diagnose(diag::type_does_not_conform,
                                   Nominal->getDeclaredType(),
                                   hashableProto->getDeclaredType());
+        // Ideally, this would be diagnosed in
+        // ConformanceChecker::resolveWitnessViaLookup. That doesn't work for
+        // Hashable because DerivedConformance::canDeriveHashable returns true
+        // even if the conformance can't be derived. See the note there for
+        // details.
+        auto *dc = ConformanceDecl->getDeclContext();
+        tryDiagnoseFailedHashableDerivation(dc, Nominal);
         return nullptr;
       }
 

branches/rxwei-patch-1/lib/Sema/DerivedConformances.cpp

@@ -137,6 +137,22 @@ bool DerivedConformance::derivesProtocolConformance(DeclContext *DC,
   return false;
 }
 
+void DerivedConformance::tryDiagnoseFailedDerivation(DeclContext *DC,
+                                                     NominalTypeDecl *nominal,
+                                                     ProtocolDecl *protocol) {
+  auto knownProtocol = protocol->getKnownProtocolKind();
+  if (!knownProtocol)
+    return;
+
+  if (*knownProtocol == KnownProtocolKind::Equatable) {
+    tryDiagnoseFailedEquatableDerivation(DC, nominal);
+  }
+
+  if (*knownProtocol == KnownProtocolKind::Hashable) {
+    tryDiagnoseFailedHashableDerivation(DC, nominal);
+  }
+}
+
 ValueDecl *DerivedConformance::getDerivableRequirement(TypeChecker &tc,
                                                        NominalTypeDecl *nominal,
                                                        ValueDecl *requirement) {

branches/rxwei-patch-1/lib/Sema/DerivedConformances.h

@@ -69,6 +69,18 @@ class DerivedConformance {
                                          NominalTypeDecl *nominal,
                                          ProtocolDecl *protocol);
 
+  /// Diagnose problems, if any, preventing automatic derivation of protocol
+  /// requirements
+  ///
+  /// \param nominal The nominal type for which we would like to diagnose
+  /// derivation failures
+  ///
+  /// \param protocol The protocol with requirements we would like to diagnose
+  /// derivation failures for
+  static void tryDiagnoseFailedDerivation(DeclContext *DC,
+                                          NominalTypeDecl *nominal,
+                                          ProtocolDecl *protocol);
+
   /// Determine the derivable requirement that would satisfy the given
   /// requirement, if there is one.
   ///
@@ -128,6 +140,14 @@ class DerivedConformance {
   /// \returns the derived member, which will also be added to the type.
   ValueDecl *deriveEquatable(ValueDecl *requirement);
 
+  /// Diagnose problems, if any, preventing automatic derivation of Equatable
+  /// requirements
+  ///
+  /// \param nominal The nominal type for which we would like to diagnose
+  /// derivation failures
+  static void tryDiagnoseFailedEquatableDerivation(DeclContext *DC,
+                                                   NominalTypeDecl *nominal);
+
   /// Determine if a Hashable requirement can be derived for a type.
   ///
   /// This is implemented for enums without associated values or all-Hashable
@@ -144,6 +164,14 @@ class DerivedConformance {
   /// \returns the derived member, which will also be added to the type.
   ValueDecl *deriveHashable(ValueDecl *requirement);
 
+  /// Diagnose problems, if any, preventing automatic derivation of Hashable
+  /// requirements
+  ///
+  /// \param nominal The nominal type for which we would like to diagnose
+  /// derivation failures
+  static void tryDiagnoseFailedHashableDerivation(DeclContext *DC,
+                                                  NominalTypeDecl *nominal);
+
   /// Derive a _BridgedNSError requirement for an @objc enum type.
   ///
   /// \returns the derived member, which will also be added to the type.

branches/rxwei-patch-1/lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -371,12 +371,15 @@ AttachedPropertyWrapperTypeRequest::evaluate(Evaluator &evaluator,
   if (!customAttr)
     return Type();
 
+  ASTContext &ctx = var->getASTContext();
+  if (!ctx.getLazyResolver())
+    return nullptr;
+
   auto resolution =
       TypeResolution::forContextual(var->getDeclContext());
   TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
   options |= TypeResolutionFlags::AllowUnboundGenerics;
 
-  ASTContext &ctx = var->getASTContext();
   auto &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
   if (tc.validateType(customAttr->getTypeLoc(), resolution, options))
     return ErrorType::get(ctx);
@@ -409,10 +412,13 @@ PropertyWrapperBackingPropertyTypeRequest::evaluate(
   if (!binding)
     return Type();
 
+  ASTContext &ctx = var->getASTContext();
+  if (!ctx.getLazyResolver())
+    return Type();
+
   // If there's an initializer of some sort, checking it will determine the
   // property wrapper type.
   unsigned index = binding->getPatternEntryIndexForVarDecl(var);
-  ASTContext &ctx = var->getASTContext();
   TypeChecker &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
   if (binding->isInitialized(index)) {
     tc.validateDecl(var);