Sema: Implement DefaultWitnessChecker

Now that WitnessChecker is separate from ConformanceChecker, implement
a DefaultWitnessChecker subclass which performs default witness
resolution.

This populates the recently-added ProtocolDecl::DefaultWitnesses map.

Unlike ConformanceChecker, the DefaultWitnessChecker looks up the witness
in any protocol extensions of the protocol, matching the context archetypes
of the requirement against the witness.

For now, we infer default witnesses for all protocols, but don't do
anything with that information. An upcoming SILGen patch will start to
emit thunks and add tests.

Author: slavapestov

include/swift/Subsystems.h

@@ -165,6 +165,10 @@ namespace swift {
                            OptionSet<TypeCheckingFlags> Options,
                            unsigned StartElem = 0);
 
+  /// Once type checking is complete, this walks protocol requirements
+  /// to resolve default witnesses.
+  void finishTypeChecking(SourceFile &SF);
+
   /// Now that we have type-checked an entire module, perform any type
   /// checking that requires the full module, e.g., Objective-C method
   /// override checking.

lib/Frontend/Frontend.cpp

@@ -516,6 +516,11 @@ void CompilerInstance::performSema() {
       if (auto SF = dyn_cast<SourceFile>(File))
         performWholeModuleTypeChecking(*SF);
   }
+
+  for (auto File : MainModule->getFiles())
+    if (auto SF = dyn_cast<SourceFile>(File))
+      if (PrimaryBufferID == NO_SUCH_BUFFER || SF == PrimarySourceFile)
+        finishTypeChecking(*SF);
 }
 
 void CompilerInstance::performParseOnly() {

lib/Sema/TypeCheckProtocol.cpp

@@ -4137,6 +4137,74 @@ Type TypeChecker::deriveTypeWitness(DeclContext *DC,
   }
 }
 
+namespace {
+  class DefaultWitnessChecker : public WitnessChecker {
+    
+  public:
+    DefaultWitnessChecker(TypeChecker &tc,
+                          ProtocolDecl *proto)
+      : WitnessChecker(tc, proto, proto->getDeclaredType(), proto) { }
+
+    ResolveWitnessResult resolveWitnessViaLookup(ValueDecl *requirement);
+    void recordWitness(ValueDecl *requirement, const RequirementMatch &match);
+  };
+}
+
+ResolveWitnessResult
+DefaultWitnessChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
+  assert(!isa<AssociatedTypeDecl>(requirement) && "Must be a value witness");
+
+  // Find the best default witness for the requirement.
+  SmallVector<RequirementMatch, 4> matches;
+  unsigned numViable = 0;
+  unsigned bestIdx = 0;
+  bool doNotDiagnoseMatches = false;
+
+  if (findBestWitness(
+                 requirement, nullptr, nullptr,
+                 /* out parameters: */
+                 matches, numViable, bestIdx, doNotDiagnoseMatches)) {
+
+    auto &best = matches[bestIdx];
+
+    // Perform the same checks as conformance witness matching, but silently
+    // ignore the candidate instead of diagnosing anything.
+    auto check = checkWitness(Accessibility::Public, requirement, best);
+    if (check.Kind != CheckKind::Success)
+      return ResolveWitnessResult::ExplicitFailed;
+
+    // Record the match.
+    recordWitness(requirement, best);
+    return ResolveWitnessResult::Success;
+  }
+
+  // We have either no matches or an ambiguous match.
+  return ResolveWitnessResult::Missing;
+}
+
+void DefaultWitnessChecker::recordWitness(ValueDecl *requirement,
+                                          const RequirementMatch &match) {
+  Proto->setDefaultWitness(requirement, match.getWitness(TC.Context));
+
+  // FIXME: Synthesize accessors (or really, just materializeForSet) if this
+  // is a computed property?
+}
+
+void TypeChecker::inferDefaultWitnesses(ProtocolDecl *proto) {
+  DefaultWitnessChecker checker(*this, proto);
+
+  for (auto *requirement : proto->getMembers()) {
+    if (isa<AssociatedTypeDecl>(requirement))
+      continue;
+
+    if (requirement->isInvalid())
+      continue;
+
+    if (auto *valueDecl = dyn_cast<ValueDecl>(requirement))
+      checker.resolveWitnessViaLookup(valueDecl);
+  }
+}
+
 bool TypeChecker::isProtocolExtensionUsable(DeclContext *dc, Type type,
                                             ExtensionDecl *protocolExtension) {
   using namespace constraints;

lib/Sema/TypeChecker.cpp

@@ -624,6 +624,15 @@ void swift::performTypeChecking(SourceFile &SF, TopLevelContext &TLC,
   }
 }
 
+void swift::finishTypeChecking(SourceFile &SF) {
+  auto &Ctx = SF.getASTContext();
+  TypeChecker TC(Ctx);
+
+  for (auto D : SF.Decls)
+    if (auto PD = dyn_cast<ProtocolDecl>(D))
+      TC.inferDefaultWitnesses(PD);
+}
+
 void swift::performWholeModuleTypeChecking(SourceFile &SF) {
   auto &Ctx = SF.getASTContext();
   Ctx.diagnoseAttrsRequiringFoundation(SF);

lib/Sema/TypeChecker.h

@@ -895,6 +895,9 @@ class TypeChecker final : public LazyResolver {
   AnyFunctionType::ExtInfo
   applyFunctionTypeAttributes(AbstractFunctionDecl *func, unsigned i);
 
+  /// Infer default value witnesses for all requirements in the given protocol.
+  void inferDefaultWitnesses(ProtocolDecl *proto);
+
   /// Determine whether the given (potentially constrained) protocol extension
   /// is usable for the given type.
   bool isProtocolExtensionUsable(DeclContext *dc, Type type,

test/NameBinding/reference-dependencies.swift

@@ -126,7 +126,7 @@ private struct ThreeTildeTypeImpl : ThreeTildeType {
 func overloadedOnProto<T>(_: T) {}
 func overloadedOnProto<T: ThreeTildeType>(_: T) {}
 
-// CHECK-DAG: !private "~~~"
+// CHECK-DAG: - "~~~"
 private prefix func ~~~(_: ThreeTildeTypeImpl) {}
 
 var topLevelComputedProperty: Bool {