Sema: Try to derive type witnesses before running inference

Sema can infer type witnesses for a small set of known conformances, to
RawRepresentable, CaseIterable, and Differentiable.

Previously, we would try to compute the type witness in this order:

1) First, via name lookup, to find an explicit nested type with the
   same name as an associated type.

2) Second, we would attempt inference.

3) Third, we would attempt derivation.

Instead, let's do 3) before 2). This avoids circularity errors in
situations where the witness can be derived, but inference fails.

This breaks source compatibility with enum declarations where the raw
type in the inheritance clause is a lie, and the user defines their
own witnesses with mismatched types. However, I suspect this does not
come up in practice, because if you don't synthesize witnesses, there
is no way to access the actual raw literal values of the enum cases.

Author: slavapestov

Diff for: lib/Sema/DerivedConformanceDifferentiable.cpp

@@ -814,7 +814,7 @@ static void checkAndDiagnoseImplicitNoDerivative(ASTContext &Context,
 }
 
 /// Get or synthesize `TangentVector` struct type.
-static Type
+static std::pair<Type, TypeDecl *>
 getOrSynthesizeTangentVectorStructType(DerivedConformance &derived) {
   auto *parentDC = derived.getConformanceContext();
   auto *nominal = derived.Nominal;
@@ -824,25 +824,28 @@ getOrSynthesizeTangentVectorStructType(DerivedConformance &derived) {
   auto *tangentStruct =
       getOrSynthesizeTangentVectorStruct(derived, C.Id_TangentVector);
   if (!tangentStruct)
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
+
   // Check and emit warnings for implicit `@noDerivative` members.
   checkAndDiagnoseImplicitNoDerivative(C, nominal, parentDC);
 
   // Return the `TangentVector` struct type.
-  return parentDC->mapTypeIntoContext(
-      tangentStruct->getDeclaredInterfaceType());
+  return std::make_pair(
+    parentDC->mapTypeIntoContext(
+      tangentStruct->getDeclaredInterfaceType()),
+    tangentStruct);
 }
 
 /// Synthesize the `TangentVector` struct type.
-static Type
+static std::pair<Type, TypeDecl *>
 deriveDifferentiable_TangentVectorStruct(DerivedConformance &derived) {
   auto *parentDC = derived.getConformanceContext();
   auto *nominal = derived.Nominal;
 
   // If nominal type can derive `TangentVector` as the contextual `Self` type,
   // return it.
   if (canDeriveTangentVectorAsSelf(nominal, parentDC))
-    return parentDC->getSelfTypeInContext();
+    return std::make_pair(parentDC->getSelfTypeInContext(), nullptr);
 
   // Otherwise, get or synthesize `TangentVector` struct type.
   return getOrSynthesizeTangentVectorStructType(derived);
@@ -883,16 +886,17 @@ ValueDecl *DerivedConformance::deriveDifferentiable(ValueDecl *requirement) {
   return nullptr;
 }
 
-Type DerivedConformance::deriveDifferentiable(AssociatedTypeDecl *requirement) {
+std::pair<Type, TypeDecl *>
+DerivedConformance::deriveDifferentiable(AssociatedTypeDecl *requirement) {
   // Diagnose unknown requirements.
   if (requirement->getBaseName() != Context.Id_TangentVector) {
     Context.Diags.diagnose(requirement->getLoc(),
                            diag::broken_differentiable_requirement);
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
   }
   // Diagnose conformances in disallowed contexts.
   if (checkAndDiagnoseDisallowedContext(requirement))
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
 
   // Start an error diagnostic before attempting derivation.
   // If derivation succeeds, cancel the diagnostic.
@@ -908,5 +912,5 @@ Type DerivedConformance::deriveDifferentiable(AssociatedTypeDecl *requirement) {
   }
 
   // Otherwise, return nullptr.
-  return nullptr;
+  return std::make_pair(nullptr, nullptr);
 }

Diff for: lib/Sema/DerivedConformances.h

@@ -122,7 +122,8 @@ class DerivedConformance {
   /// Derive a Differentiable type witness for a nominal type.
   ///
   /// \returns the derived member, which will also be added to the type.
-  Type deriveDifferentiable(AssociatedTypeDecl *assocType);
+  std::pair<Type, TypeDecl *>
+  deriveDifferentiable(AssociatedTypeDecl *assocType);
 
   /// Derive a CaseIterable requirement for an enum if it has no associated
   /// values for any of its cases.

Diff for: lib/Sema/TypeCheckProtocol.cpp

@@ -5579,29 +5579,30 @@ ValueDecl *TypeChecker::deriveProtocolRequirement(DeclContext *DC,
   llvm_unreachable("unknown derivable protocol kind");
 }
 
-Type TypeChecker::deriveTypeWitness(DeclContext *DC,
-                                    NominalTypeDecl *TypeDecl,
-                                    AssociatedTypeDecl *AssocType) {
+std::pair<Type, TypeDecl *>
+TypeChecker::deriveTypeWitness(DeclContext *DC,
+                               NominalTypeDecl *TypeDecl,
+                               AssociatedTypeDecl *AssocType) {
   auto *protocol = cast<ProtocolDecl>(AssocType->getDeclContext());
 
   auto knownKind = protocol->getKnownProtocolKind();
 
   if (!knownKind)
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
 
   auto Decl = DC->getInnermostDeclarationDeclContext();
 
   DerivedConformance derived(TypeDecl->getASTContext(), Decl, TypeDecl,
                              protocol);
   switch (*knownKind) {
   case KnownProtocolKind::RawRepresentable:
-    return derived.deriveRawRepresentable(AssocType);
+    return std::make_pair(derived.deriveRawRepresentable(AssocType), nullptr);
   case KnownProtocolKind::CaseIterable:
-    return derived.deriveCaseIterable(AssocType);
+    return std::make_pair(derived.deriveCaseIterable(AssocType), nullptr);
   case KnownProtocolKind::Differentiable:
     return derived.deriveDifferentiable(AssocType);
   default:
-    return nullptr;
+    return std::make_pair(nullptr, nullptr);
   }
 }
 

Diff for: lib/Sema/TypeCheckProtocol.h

@@ -822,7 +822,8 @@ class AssociatedTypeInference {
 
   /// Compute the "derived" type witness for an associated type that is
   /// known to the compiler.
-  Type computeDerivedTypeWitness(AssociatedTypeDecl *assocType);
+  std::pair<Type, TypeDecl *>
+  computeDerivedTypeWitness(AssociatedTypeDecl *assocType);
 
   /// Compute a type witness without using a specific potential witness,
   /// e.g., using a fixed type (from a refined protocol), default type

Diff for: lib/Sema/TypeCheckProtocolInference.cpp

@@ -868,32 +868,32 @@ Type AssociatedTypeInference::computeDefaultTypeWitness(
   return defaultType;
 }
 
-Type AssociatedTypeInference::computeDerivedTypeWitness(
+std::pair<Type, TypeDecl *>
+AssociatedTypeInference::computeDerivedTypeWitness(
                                               AssociatedTypeDecl *assocType) {
   if (adoptee->hasError())
-    return Type();
+    return std::make_pair(Type(), nullptr);
 
   // Can we derive conformances for this protocol and adoptee?
   NominalTypeDecl *derivingTypeDecl = adoptee->getAnyNominal();
   if (!DerivedConformance::derivesProtocolConformance(dc, derivingTypeDecl,
                                                       proto))
-    return Type();
+    return std::make_pair(Type(), nullptr);
 
   // Try to derive the type witness.
-  Type derivedType =
-      TypeChecker::deriveTypeWitness(dc, derivingTypeDecl, assocType);
-  if (!derivedType)
-    return Type();
+  auto result = TypeChecker::deriveTypeWitness(dc, derivingTypeDecl, assocType);
+  if (!result.first)
+    return std::make_pair(Type(), nullptr);
 
-  // Make sure that the derived type is sane.
-  if (checkTypeWitness(derivedType, assocType, conformance)) {
+  // Make sure that the derived type satisfies requirements.
+  if (checkTypeWitness(result.first, assocType, conformance)) {
     /// FIXME: Diagnose based on this.
     failedDerivedAssocType = assocType;
-    failedDerivedWitness = derivedType;
-    return Type();
+    failedDerivedWitness = result.first;
+    return std::make_pair(Type(), nullptr);
   }
 
-  return derivedType;
+  return result;
 }
 
 Type
@@ -908,10 +908,6 @@ AssociatedTypeInference::computeAbstractTypeWitness(
   if (Type defaultType = computeDefaultTypeWitness(assocType))
     return defaultType;
 
-  // If we can derive a type witness, do so.
-  if (Type derivedType = computeDerivedTypeWitness(assocType))
-    return derivedType;
-
   // If there is a generic parameter of the named type, use that.
   if (auto genericSig = dc->getGenericSignatureOfContext()) {
     for (auto gp : genericSig->getInnermostGenericParams()) {
@@ -1876,10 +1872,23 @@ auto AssociatedTypeInference::solve(ConformanceChecker &checker)
       continue;
 
     case ResolveWitnessResult::Missing:
-      // Note that we haven't resolved this associated type yet.
-      unresolvedAssocTypes.insert(assocType);
+      // We did not find the witness via name lookup. Try to derive
+      // it below.
       break;
     }
+
+    // Finally, try to derive the witness if we know how.
+    auto derivedType = computeDerivedTypeWitness(assocType);
+    if (derivedType.first) {
+      checker.recordTypeWitness(assocType,
+                                derivedType.first->mapTypeOutOfContext(),
+                                derivedType.second);
+      continue;
+    }
+
+    // We failed to derive the witness. We're going to go on to try
+    // to infer it from potential value witnesses next.
+    unresolvedAssocTypes.insert(assocType);
   }
 
   // Result variable to use for returns so that we get NRVO.

Diff for: lib/Sema/TypeChecker.h

@@ -911,8 +911,9 @@ ValueDecl *deriveProtocolRequirement(DeclContext *DC,
 /// Derive an implicit type witness for the given associated type in
 /// the conformance of the given nominal type to some known
 /// protocol.
-Type deriveTypeWitness(DeclContext *DC, NominalTypeDecl *nominal,
-                       AssociatedTypeDecl *assocType);
+std::pair<Type, TypeDecl *>
+deriveTypeWitness(DeclContext *DC, NominalTypeDecl *nominal,
+                  AssociatedTypeDecl *assocType);
 
 /// \name Name lookup
 ///

Diff for: test/Sema/enum_raw_representable.swift

@@ -46,7 +46,8 @@ var doubles: [Double] = serialize([Bar.a, .b, .c])
 var foos: [Foo] = deserialize([1, 2, 3])
 var bars: [Bar] = deserialize([1.2, 3.4, 5.6])
 
-// Infer RawValue from witnesses.
+// We reject enums where the raw type stated in the inheritance clause does not
+// match the types of the witnesses.
 enum Color : Int {
   case red
   case blue
@@ -56,11 +57,13 @@ enum Color : Int {
   }
 
   var rawValue: Double {
+  // expected-error@-1 {{invalid redeclaration of synthesized implementation for protocol requirement 'rawValue'}}
     return 1.0
   }
 }
 
 var colorRaw: Color.RawValue = 7.5
+// expected-error@-1 {{cannot convert value of type 'Double' to specified type 'Color.RawValue' (aka 'Int')}}
 
 // Mismatched case types
 

Diff for: test/Sema/enum_raw_representable_circularity.swift

@@ -0,0 +1,13 @@
+// RUN: %target-typecheck-verify-swift
+
+// This used to fail with "reference to invalid associated type 'RawValue' of type 'E'"
+_ = E(rawValue: 123)
+
+enum E : Int {
+  case a = 123
+
+  init?(rawValue: RawValue) {
+    self = .a
+  }
+}
+