Sema: Change lookupUnqualifiedType() to return a LookupResult

This will allow callers of lookupUnqualifiedType() to know what
DeclContext a lookup result came from.

Author: slavapestov

lib/Sema/TypeCheckAttr.cpp

@@ -1204,7 +1204,8 @@ void AttributeChecker::checkApplicationMainAttribute(DeclAttribute *attr,
                                            SourceLoc(),
                                            lookupOptions);
     if (lookup.size() == 1)
-      ApplicationDelegateProto = dyn_cast<ProtocolDecl>(lookup[0]);
+      ApplicationDelegateProto = dyn_cast<ProtocolDecl>(
+        lookup[0].getValueDecl());
   }
 
   if (!ApplicationDelegateProto ||

lib/Sema/TypeCheckNameLookup.cpp

@@ -204,43 +204,42 @@ LookupResult TypeChecker::lookupUnqualified(DeclContext *dc, DeclName name,
   return result;
 }
 
-SmallVector<TypeDecl *, 1>
+LookupResult
 TypeChecker::lookupUnqualifiedType(DeclContext *dc, DeclName name,
                                    SourceLoc loc,
                                    NameLookupOptions options) {
-  SmallVector<TypeDecl *, 1> decls;
-
-  // Try lookup without ProtocolMembers first.
-  UnqualifiedLookup lookup(
+  {
+    // Try lookup without ProtocolMembers first.
+    UnqualifiedLookup lookup(
       name, dc, this,
-      options.contains(NameLookupFlags::KnownPrivate),
-      loc,
-      /*IsTypeLookup=*/true,
-      /*AllowProtocolMembers=*/false,
-      options.contains(NameLookupFlags::IgnoreAccessibility));
-  for (auto found : lookup.Results)
-    decls.push_back(cast<TypeDecl>(found.getValueDecl()));
+        options.contains(NameLookupFlags::KnownPrivate),
+        loc,
+        /*IsTypeLookup=*/true,
+        /*AllowProtocolMembers=*/false,
+        options.contains(NameLookupFlags::IgnoreAccessibility));
 
-  if (decls.empty() &&
-      options.contains(NameLookupFlags::ProtocolMembers)) {
+    if (!lookup.Results.empty() ||
+        !options.contains(NameLookupFlags::ProtocolMembers)) {
+      return LookupResult(lookup.Results);
+    }
+  }
+
+  {
     // Try again, this time with protocol members.
     //
     // FIXME: Fix the problem where if NominalTypeDecl::getAllProtocols()
     // is called too early, we start resolving extensions -- even those
-    // which do provide conformances.
+    // which do provide not conformances.
     UnqualifiedLookup lookup(
-        name, dc, this,
+      name, dc, this,
         options.contains(NameLookupFlags::KnownPrivate),
         loc,
         /*IsTypeLookup=*/true,
         /*AllowProtocolMembers=*/true,
         options.contains(NameLookupFlags::IgnoreAccessibility));
 
-    for (auto found : lookup.Results)
-      decls.push_back(cast<TypeDecl>(found.getValueDecl()));
+    return LookupResult(lookup.Results);
   }
-
-  return decls;
 }
 
 LookupResult TypeChecker::lookupMember(DeclContext *dc,

lib/Sema/TypeCheckType.cpp

@@ -900,14 +900,14 @@ static Type diagnoseUnknownType(TypeChecker &tc, DeclContext *dc,
                                  relookupOptions);
     if (!inaccessibleResults.empty()) {
       // FIXME: What if the unviable candidates have different levels of access?
-      auto first = cast<TypeDecl>(inaccessibleResults.front());
+      auto first = cast<TypeDecl>(inaccessibleResults.front().getValueDecl());
       tc.diagnose(comp->getIdLoc(), diag::candidate_inaccessible,
                   comp->getIdentifier(), first->getFormalAccess());
 
       // FIXME: If any of the candidates (usually just one) are in the same
       // module we could offer a fix-it.
       for (auto lookupResult : inaccessibleResults)
-        tc.diagnose(lookupResult, diag::type_declared_here);
+        tc.diagnose(lookupResult.getValueDecl(), diag::type_declared_here);
 
       // Don't try to recover here; we'll get more access-related diagnostics
       // downstream if we do.
@@ -1202,7 +1202,8 @@ resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
   Type current;
   TypeDecl *currentDecl = nullptr;
   bool isAmbiguous = false;
-  for (const auto &typeDecl : globals) {
+  for (const auto entry : globals) {
+    auto *typeDecl = cast<TypeDecl>(entry.getValueDecl());
 
     // If necessary, add delayed members to the declaration.
     if (auto nomDecl = dyn_cast<NominalTypeDecl>(typeDecl)) {
@@ -1243,8 +1244,8 @@ resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
       TC.diagnose(comp->getIdLoc(), diag::ambiguous_type_base,
                   comp->getIdentifier())
         .highlight(comp->getIdLoc());
-      for (auto typeDecl : globals) {
-        TC.diagnose(typeDecl, diag::found_candidate);
+      for (auto entry : globals) {
+        TC.diagnose(entry.getValueDecl(), diag::found_candidate);
       }
     }
 

lib/Sema/TypeChecker.h

@@ -87,6 +87,12 @@ class LookupResult {
   SmallVector<LookupResultEntry, 4> Results;
 
 public:
+  LookupResult() {}
+
+  explicit
+  LookupResult(const SmallVectorImpl<LookupResultEntry> &Results)
+    : Results(Results.begin(), Results.end()) {}
+
   typedef SmallVectorImpl<LookupResultEntry>::iterator iterator;
   iterator begin() { return Results.begin(); }
   iterator end() { return Results.end(); }
@@ -2012,7 +2018,7 @@ class TypeChecker final : public LazyResolver {
   /// \param name The name of the entity to look for.
   /// \param loc The source location at which name lookup occurs.
   /// \param options Options that control name lookup.
-  SmallVector<TypeDecl *, 1>
+  LookupResult
   lookupUnqualifiedType(DeclContext *dc, DeclName name, SourceLoc loc,
                         NameLookupOptions options
                           = defaultUnqualifiedLookupOptions);