Merge pull request #4143 from slavapestov/name-lookup-cleanup

Sema: Clean up name lookup and fix a couple of bugs

Author: slavapestov

lib/Sema/CSSimplify.cpp

@@ -2767,6 +2767,11 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
     if (includeInaccessibleMembers)
       lookupOptions |= NameLookupFlags::IgnoreAccessibility;
 
+    // If a constructor is only visible as a witness for a protocol
+    // requirement, it must be an invalid override. Also, protocol
+    // extensions cannot yet define designated initializers.
+    lookupOptions -= NameLookupFlags::PerformConformanceCheck;
+
     LookupResult ctors = TC.lookupConstructors(DC, baseObjTy, lookupOptions);
     if (!ctors)
       return result;    // No result.

lib/Sema/TypeCheckDecl.cpp

@@ -5369,8 +5369,18 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
 
       if (members.empty()) {
-        NameLookupOptions lookupOptions =
-            defaultMemberLookupOptions - NameLookupFlags::DynamicLookup;
+        auto lookupOptions = defaultMemberLookupOptions;
+
+        // Class methods cannot override declarations only
+        // visible via dynamic dispatch.
+        lookupOptions -= NameLookupFlags::DynamicLookup;
+
+        // Class methods cannot override declarations only
+        // visible as protocol requirements or protocol
+        // extension members.
+        lookupOptions -= NameLookupFlags::ProtocolMembers;
+        lookupOptions -= NameLookupFlags::PerformConformanceCheck;
+
         members = TC.lookupMember(decl->getDeclContext(), superclassMetaTy,
                                   name, lookupOptions);
       }

lib/Sema/TypeCheckNameLookup.cpp

@@ -38,8 +38,6 @@ namespace {
     LookupResult &Result;
     DeclContext *DC;
     NameLookupOptions Options;
-    bool ConsiderProtocolMembers;
-    bool SearchingFromProtoExt;
     bool IsMemberLookup;
 
     /// The vector of found declarations.
@@ -50,11 +48,9 @@ namespace {
 
   public:
     LookupResultBuilder(TypeChecker &tc, LookupResult &result, DeclContext *dc,
-                        NameLookupOptions options, bool considerProtocolMembers,
-                        bool searchingFromProtoExt, bool isMemberLookup)
+                        NameLookupOptions options,
+                        bool isMemberLookup)
       : TC(tc), Result(result), DC(dc), Options(options),
-        ConsiderProtocolMembers(considerProtocolMembers),
-        SearchingFromProtoExt(searchingFromProtoExt),
         IsMemberLookup(isMemberLookup) { }
 
     ~LookupResultBuilder() {
@@ -118,67 +114,66 @@ namespace {
       DeclContext *foundDC = found->getDeclContext();
       auto foundProto = foundDC->getAsProtocolOrProtocolExtensionContext();
 
-      // Determine the nominal type through which we found the
-      // declaration.
-      NominalTypeDecl *baseNominal = nullptr;
-      if (!base) {
-        // Nothing to do.
-      } else if (auto baseParam = dyn_cast<ParamDecl>(base)) {
-        auto baseDC = baseParam->getDeclContext();
-        if (isa<AbstractFunctionDecl>(baseDC))
-          baseDC = baseDC->getParent();
-
-        baseNominal = baseDC->getAsNominalTypeOrNominalTypeExtensionContext();
-        assert(baseNominal && "Did not find nominal type");
-      } else {
-        baseNominal = cast<NominalTypeDecl>(base);
-      }
+      auto addResult = [&](ValueDecl *result) {
+        if (Known.insert({{result, base}, false}).second) {
+          Result.add({result, base});
+          FoundDecls.push_back(result);
+        }
+      };
 
       // If this isn't a protocol member to be given special
       // treatment, just add the result.
-      if (!ConsiderProtocolMembers ||
-          !isa<ProtocolDecl>(found->getDeclContext()) ||
-          SearchingFromProtoExt ||
+      if (!Options.contains(NameLookupFlags::ProtocolMembers) ||
+          !isa<ProtocolDecl>(foundDC) ||
           isa<GenericTypeParamDecl>(found) ||
-          (isa<FuncDecl>(found) && cast<FuncDecl>(found)->isOperator())) {
-        if (Known.insert({{found, base}, false}).second) {
-          Result.add({found, base});
-          FoundDecls.push_back(found);
-        }
+          (isa<FuncDecl>(found) && cast<FuncDecl>(found)->isOperator()) ||
+          foundInType->isAnyExistentialType()) {
+        addResult(found);
         return;
       }
 
+      assert(isa<ProtocolDecl>(foundDC));
+
       // If we found something within the protocol itself, and our
       // search began somewhere that is not in a protocol or extension
       // thereof, remap this declaration to the witness.
-      if (isa<ProtocolDecl>(foundDC) && !isa<ProtocolDecl>(baseNominal)) {
+      if (foundInType->is<ArchetypeType>() ||
+          Options.contains(NameLookupFlags::PerformConformanceCheck)) {
         // Dig out the protocol conformance.
         ProtocolConformance *conformance = nullptr;
         if (!TC.conformsToProtocol(foundInType, foundProto, DC,
-                                   conformanceOptions, &conformance) ||
-            !conformance)
+                                   conformanceOptions, &conformance))
           return;
 
+        // We have an abstract conformance of an archetype to a protocol.
+        // Just return the requirement.
+        if (!conformance) {
+          assert(foundInType->is<ArchetypeType>());
+          addResult(found);
+          return;
+        }
+
         // Dig out the witness.
         ValueDecl *witness;
         if (auto assocType = dyn_cast<AssociatedTypeDecl>(found)) {
           witness = conformance->getTypeWitnessSubstAndDecl(assocType, &TC)
             .second;
         } else if (isa<TypeAliasDecl>(found)) {
-          // No witness for typealiases.
+          // No witness for typealiases. This means typealiases in
+          // protocols cannot be found if PerformConformanceCheck
+          // is on.
+          //
+          // FIXME: Fix this.
           return;
         } else {
           witness = conformance->getWitness(found, &TC).getDecl();
         }
 
         // FIXME: the "isa<ProtocolDecl>()" check will be wrong for
         // default implementations in protocols.
-        if (witness && !isa<ProtocolDecl>(witness->getDeclContext())) {
-          if (Known.insert({{witness, base}, false}).second) {
-            Result.add({witness, base});
-            FoundDecls.push_back(witness);
-          }
-        }
+        if (witness && !isa<ProtocolDecl>(witness->getDeclContext()))
+          addResult(witness);
+
         return;
       }
     }
@@ -188,29 +183,14 @@ namespace {
 LookupResult TypeChecker::lookupUnqualified(DeclContext *dc, DeclName name,
                                             SourceLoc loc,
                                             NameLookupOptions options) {
-  // Determine whether we're searching from a protocol extension.
-  bool searchingFromProtoExt = false;
-  for (auto outerDC = dc; outerDC; outerDC = outerDC->getParent()) {
-    if (auto ext = dyn_cast<ExtensionDecl>(outerDC)) {
-      if (ext->getExtendedType() && ext->getExtendedType()->is<ProtocolType>()) {
-        searchingFromProtoExt = true;
-        break;
-      }
-    }
-  }
-
   UnqualifiedLookup lookup(name, dc, this,
                            options.contains(NameLookupFlags::KnownPrivate),
                            loc,
                            options.contains(NameLookupFlags::OnlyTypes),
                            options.contains(NameLookupFlags::ProtocolMembers));
 
   LookupResult result;
-  bool considerProtocolMembers
-    = options.contains(NameLookupFlags::ProtocolMembers);
   LookupResultBuilder builder(*this, result, dc, options,
-                              considerProtocolMembers,
-                              searchingFromProtoExt,
                               /*memberLookup*/false);
   for (const auto &found : lookup.Results) {
     // Determine which type we looked through to find this result.
@@ -263,11 +243,7 @@ LookupResult TypeChecker::lookupMember(DeclContext *dc,
   }
   NominalTypeDecl *nominalLookupType = lookupType->getAnyNominal();
 
-  /// Whether to consider protocol members or not.
-  bool considerProtocolMembers
-    = nominalLookupType && !isa<ProtocolDecl>(nominalLookupType) &&
-      options.contains(NameLookupFlags::ProtocolMembers);
-  if (considerProtocolMembers)
+  if (options.contains(NameLookupFlags::ProtocolMembers))
     subOptions |= NL_ProtocolMembers;
 
   // We handle our own overriding/shadowing filtering.
@@ -282,14 +258,12 @@ LookupResult TypeChecker::lookupMember(DeclContext *dc,
     result.clear();
 
     LookupResultBuilder builder(*this, result, dc, options,
-                                considerProtocolMembers,
-                                /*protocol extension*/false,
-                                /*member lookup*/true);
+                                /*memberLookup*/true);
     SmallVector<ValueDecl *, 4> lookupResults;
     dc->lookupQualified(type, name, subOptions, this, lookupResults);
 
     for (auto found : lookupResults) {
-      builder.add(found, nominalLookupType, type);
+      builder.add(found, nominalLookupType, lookupType);
     }
   };
 

lib/Sema/TypeCheckProtocol.cpp

@@ -1110,13 +1110,17 @@ WitnessChecker::lookupValueWitnesses(ValueDecl *req, bool *ignoringNames) {
     }
   } else {
     // Variable/function/subscript requirements.
-    auto metaType = MetatypeType::get(Adoptee);
-    auto candidates = TC.lookupMember(DC, metaType, req->getFullName());
+    auto lookupOptions = defaultMemberTypeLookupOptions;
+    lookupOptions -= NameLookupFlags::PerformConformanceCheck;
+
+    auto candidates = TC.lookupMember(DC, Adoptee, req->getFullName(),
+                                      lookupOptions);
 
     // If we didn't find anything with the appropriate name, look
     // again using only the base name.
     if (candidates.empty() && ignoringNames) {
-      candidates = TC.lookupMember(DC, metaType, req->getName());
+      candidates = TC.lookupMember(DC, Adoptee, req->getName(),
+                                   lookupOptions);
       *ignoringNames = true;
     }
 
@@ -1960,12 +1964,12 @@ void ConformanceChecker::recordTypeWitness(AssociatedTypeDecl *assocType,
                                                     TypeLoc::withoutLoc(type),
                                                     /*genericparams*/nullptr, 
                                                     DC);
-    Type metaType = MetatypeType::get(type);
     aliasDecl->computeType();
     aliasDecl->setImplicit();
     if (type->is<ErrorType>())
       aliasDecl->setInvalid();
-    if (metaType->hasArchetype()) {
+    if (type->hasArchetype()) {
+      Type metaType = MetatypeType::get(type);
       aliasDecl->setInterfaceType(
         ArchetypeBuilder::mapTypeOutOfContext(DC, metaType));
     }
@@ -2498,11 +2502,9 @@ static CheckTypeWitnessResult checkTypeWitness(TypeChecker &tc, DeclContext *dc,
 /// Attempt to resolve a type witness via member name lookup.
 ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
                        AssociatedTypeDecl *assocType) {
-  auto metaType = MetatypeType::get(Adoptee);
-
   // Look for a member type with the same name as the associated type.
-  auto candidates = TC.lookupMemberType(DC, metaType, assocType->getName(),
-                                        None);
+  auto candidates = TC.lookupMemberType(DC, Adoptee, assocType->getName(),
+                                        /*lookupOptions=*/None);
 
   // If there aren't any candidates, we're done.
   if (!candidates) {

lib/Sema/TypeCheckStmt.cpp

@@ -1347,8 +1347,15 @@ static bool checkSuperInit(TypeChecker &tc, ConstructorDecl *fromCtor,
   // only one designated initializer.
   if (implicitlyGenerated) {
     auto superclassTy = ctor->getExtensionType();
-    NameLookupOptions lookupOptions
-      = defaultConstructorLookupOptions | NameLookupFlags::KnownPrivate;
+    auto lookupOptions = defaultConstructorLookupOptions;
+    lookupOptions |= NameLookupFlags::KnownPrivate;
+
+    // If a constructor is only visible as a witness for a protocol
+    // requirement, it must be an invalid override. Also, protocol
+    // extensions cannot yet define designated initializers.
+    lookupOptions -= NameLookupFlags::ProtocolMembers;
+    lookupOptions -= NameLookupFlags::PerformConformanceCheck;
+
     for (auto member : tc.lookupConstructors(fromCtor, superclassTy,
                                              lookupOptions)) {
       auto superclassCtor = dyn_cast<ConstructorDecl>(member.Decl);

lib/Sema/TypeChecker.h

@@ -219,14 +219,22 @@ enum class NameLookupFlags {
   KnownPrivate = 0x01,
   /// Whether name lookup should be able to find protocol members.
   ProtocolMembers = 0x02,
+  /// Whether we should map the requirement to the witness if we
+  /// find a protocol member and the base type is a concrete type.
+  ///
+  /// If this is not set but ProtocolMembers is set, we will
+  /// find protocol extension members, but not protocol requirements
+  /// that do not yet have a witness (such as inferred associated
+  /// types, or witnesses for derived conformances).
+  PerformConformanceCheck = 0x04,
   /// Whether to perform 'dynamic' name lookup that finds @objc
   /// members of any class or protocol.
-  DynamicLookup = 0x04,
+  DynamicLookup = 0x08,
   /// Whether we're only looking for types.
-  OnlyTypes = 0x08,
+  OnlyTypes = 0x10,
   /// Whether to ignore access control for this lookup, allowing inaccessible
   /// results to be returned.
-  IgnoreAccessibility = 0x10,
+  IgnoreAccessibility = 0x20,
 };
 
 /// A set of options that control name lookup.
@@ -239,19 +247,24 @@ inline NameLookupOptions operator|(NameLookupFlags flag1,
 
 /// Default options for member name lookup.
 const NameLookupOptions defaultMemberLookupOptions
-  = NameLookupFlags::DynamicLookup | NameLookupFlags::ProtocolMembers;
+  = NameLookupFlags::DynamicLookup |
+    NameLookupFlags::ProtocolMembers |
+    NameLookupFlags::PerformConformanceCheck;
 
 /// Default options for constructor lookup.
 const NameLookupOptions defaultConstructorLookupOptions
-  = NameLookupFlags::ProtocolMembers;
+  = NameLookupFlags::ProtocolMembers |
+    NameLookupFlags::PerformConformanceCheck;
 
 /// Default options for member type lookup.
 const NameLookupOptions defaultMemberTypeLookupOptions
-  = NameLookupFlags::ProtocolMembers;
+  = NameLookupFlags::ProtocolMembers |
+    NameLookupFlags::PerformConformanceCheck;
 
 /// Default options for unqualified name lookup.
 const NameLookupOptions defaultUnqualifiedLookupOptions
-  = NameLookupFlags::ProtocolMembers;
+  = NameLookupFlags::ProtocolMembers |
+    NameLookupFlags::PerformConformanceCheck;
 
 /// Describes the result of comparing two entities, of which one may be better
 /// or worse than the other, or they are unordered.

test/Constraints/members.swift

@@ -181,6 +181,16 @@ extension P {
 
 protocol ClassP : class {
   func bas(_ x: Int)
+  func quux(_ x: Int)
+}
+
+class ClassC : ClassP {
+  func bas(_ x: Int) {}
+}
+
+extension ClassP {
+  func quux(_ x: Int) {}
+  func bing(_ x: Int) {}
 }
 
 func generic<T: P>(_ t: T) {
@@ -243,6 +253,14 @@ func genericClassP<T: ClassP>(_ t: T) {
   let _: () = id(T.bas(t)(1))
 }
 
+func genericClassC<C : ClassC>(_ c: C) {
+  // Make sure that we can find members of protocol extensions
+  // on a class-bound archetype
+  let _ = c.bas(123)
+  let _ = c.quux(123)
+  let _ = c.bing(123)
+}
+
 ////
 // Members of existentials
 ////

test/Generics/Inputs/associated_types_multi_file_helper.swift

@@ -1,5 +1,5 @@
 protocol Fooable {
-  associatedtype AssocType // expected-note {{did you mean 'AssocType'?}}
+  associatedtype AssocType
   func foo(x : AssocType)
 }
 

test/Generics/associated_types_multi_file.swift

@@ -2,5 +2,4 @@
 
 var x: X.AssocType = 0.0 as Float
 
-// FIXME: <rdar://problem/16123805> Inferred associated types can't be used in expression contexts
-var y = Y.AssocType() // expected-error{{type 'Y' has no member 'AssocType'}}
+var y = Y.AssocType()