Implement typo correction for #keypath expressions.

Author: rjmccall

lib/AST/LookupVisibleDecls.cpp

@@ -293,12 +293,47 @@ static void doDynamicLookup(VisibleDeclConsumer &Consumer,
       if (D->getOverriddenDecl())
         return;
 
+      // Ensure that the declaration has a type.
+      if (!D->hasType()) {
+        if (!TypeResolver) return;
+        TypeResolver->resolveDeclSignature(D);
+        if (!D->hasType()) return;
+      }
+
+      switch (D->getKind()) {
+#define DECL(ID, SUPER) \
+      case DeclKind::ID:
+#define VALUE_DECL(ID, SUPER)
+#include "swift/AST/DeclNodes.def"
+        llvm_unreachable("not a ValueDecl!");
+
+      // Types cannot be found by dynamic lookup.
+      case DeclKind::GenericTypeParam:
+      case DeclKind::AssociatedType:
+      case DeclKind::TypeAlias:
+      case DeclKind::Enum:
+      case DeclKind::Class:
+      case DeclKind::Struct:
+      case DeclKind::Protocol:
+        return;
+
       // Initializers cannot be found by dynamic lookup.
-      if (isa<ConstructorDecl>(D))
+      case DeclKind::Constructor:
+      case DeclKind::Destructor:
+        return;
+
+      // These cases are probably impossible here but can also just
+      // be safely ignored.
+      case DeclKind::EnumElement:
+      case DeclKind::Param:
+      case DeclKind::Module:
         return;
 
-      // Check if we already reported a decl with the same signature.
-      if (auto *FD = dyn_cast<FuncDecl>(D)) {
+      // For other kinds of values, check if we already reported a decl
+      // with the same signature.
+
+      case DeclKind::Func: {
+        auto FD = cast<FuncDecl>(D);
         assert(FD->getImplicitSelfDecl() && "should not find free functions");
         (void)FD;
 
@@ -311,17 +346,23 @@ static void doDynamicLookup(VisibleDeclConsumer &Consumer,
         auto Signature = std::make_pair(D->getName(), T);
         if (!FunctionsReported.insert(Signature).second)
           return;
-      } else if (isa<SubscriptDecl>(D)) {
+        break;
+      }
+
+      case DeclKind::Subscript: {
         auto Signature = D->getType()->getCanonicalType();
         if (!SubscriptsReported.insert(Signature).second)
           return;
-      } else if (isa<VarDecl>(D)) {
+        break;
+      }
+
+      case DeclKind::Var: {
         auto Signature =
             std::make_pair(D->getName(), D->getType()->getCanonicalType());
         if (!PropertiesReported.insert(Signature).second)
           return;
-      } else {
-        llvm_unreachable("unhandled decl kind");
+        break;
+      }
       }
 
       if (isDeclVisibleInLookupMode(D, LS, CurrDC, TypeResolver))

lib/Sema/TypeCheckConstraints.cpp

@@ -458,8 +458,8 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
     // one, but we should also try to propagate labels into this.
     DeclNameLoc nameLoc = UDRE->getNameLoc();
 
-    performTypoCorrection(DC, UDRE->getRefKind(), Name, Loc, LookupOptions,
-                          Lookup);
+    performTypoCorrection(DC, UDRE->getRefKind(), Type(), Name, Loc,
+                          LookupOptions, Lookup);
 
     diagnose(Loc, diag::use_unresolved_identifier, Name, Name.isOperator())
       .highlight(UDRE->getSourceRange());

lib/Sema/TypeCheckExprObjC.cpp

@@ -212,17 +212,33 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
     // Look for this component.
     LookupResult lookup = performLookup(idx, componentName, componentNameLoc);
 
-    // If we didn't find anything, complain and bail out.
+    // If we didn't find anything, try to apply typo-correction.
+    bool resultsAreFromTypoCorrection = false;
     if (!lookup) {
-      // FIXME: Typo correction.
+      performTypoCorrection(dc, DeclRefKind::Ordinary, currentType,
+                            componentName, componentNameLoc,
+                            (currentType ? defaultMemberTypeLookupOptions
+                                         : defaultUnqualifiedLookupOptions),
+                            lookup);
+
       if (currentType)
         diagnose(componentNameLoc, diag::could_not_find_type_member,
                  currentType, componentName);
       else
         diagnose(componentNameLoc, diag::use_unresolved_identifier,
                  componentName, false);
+
+      // Note all the correction candidates.
+      for (auto &result : lookup) {
+        noteTypoCorrection(componentName, DeclNameLoc(componentNameLoc),
+                           result);
+      }
+
       isInvalid = true;
-      break;
+      if (!lookup) break;
+
+      // Remember that these are from typo correction.
+      resultsAreFromTypoCorrection = true;
     }
 
     // If we have more than one result, filter out unavailable or
@@ -243,6 +259,10 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
 
     // If we *still* have more than one result, fail.
     if (lookup.size() > 1) {
+      // Don't diagnose ambiguities if the results are from typo correction.
+      if (resultsAreFromTypoCorrection)
+        break;
+
       if (currentType)
         diagnose(componentNameLoc, diag::ambiguous_member_overload_set,
                  componentName);

lib/Sema/TypeCheckNameLookup.cpp

@@ -518,6 +518,7 @@ namespace {
 }
 
 void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
+                                        Type baseTypeOrNull,
                                         DeclName targetDeclName,
                                         SourceLoc nameLoc,
                                         NameLookupOptions lookupOptions,
@@ -554,7 +555,13 @@ void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
   });
 
   TypoCorrectionResolver resolver(*this, nameLoc);
-  lookupVisibleDecls(consumer, DC, &resolver, /*top level*/ true, nameLoc);
+  if (baseTypeOrNull) {
+    lookupVisibleMemberDecls(consumer, baseTypeOrNull, DC, &resolver,
+                             /*include instance members*/
+                               !(lookupOptions & NameLookupFlags::OnlyTypes));
+  } else {
+    lookupVisibleDecls(consumer, DC, &resolver, /*top level*/ true, nameLoc);
+  }
 
   // Impose a maximum distance from the best score.
   entries.filterMaxScoreRange(MaxCallEditDistanceFromBestCandidate);

lib/Sema/TypeChecker.h

@@ -1959,6 +1959,7 @@ class TypeChecker final : public LazyResolver {
   /// Check for a typo correction.
   void performTypoCorrection(DeclContext *DC,
                              DeclRefKind refKind,
+                             Type baseTypeOrNull,
                              DeclName name,
                              SourceLoc lookupLoc,
                              NameLookupOptions lookupOptions,

test/expr/unary/keypath/keypath.swift

@@ -6,7 +6,7 @@ import Foundation
 
 @objc class A : NSObject {
   @objc var propB: B = B()
-  @objc var propString: String = ""
+  @objc var propString: String = "" // expected-note {{did you mean 'propString'}}
   @objc var propArray: [String] = []
   @objc var propDict: [String: B] = [:]
   @objc var propSet: Set<String> = []
@@ -110,3 +110,7 @@ func testParseErrors() {
   let _: String = #keyPath(A.propString; // expected-error{{expected ')' to complete '#keyPath' expression}}
     // expected-note@-1{{to match this opening '('}}
 }
+
+func testTypoCorrection() {
+  let _: String = #keyPath(A.proString) // expected-error {{type 'A' has no member 'proString'}}
+}