Merge remote-tracking branch 'origin/master' into master-rebranch

Author: swift-ci

include/swift/AST/DeclContext.h

@@ -487,15 +487,11 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// \param options Options that control name lookup, based on the
   /// \c NL_* constants in \c NameLookupOptions.
   ///
-  /// \param typeResolver Used to resolve types, usually for overload purposes.
-  /// May be null.
-  ///
   /// \param[out] decls Will be populated with the declarations found by name
   /// lookup.
   ///
   /// \returns true if anything was found.
   bool lookupQualified(Type type, DeclName member, NLOptions options,
-                       LazyResolver *typeResolver,
                        SmallVectorImpl<ValueDecl *> &decls) const;
 
   /// Look for the set of declarations with the given name within the

include/swift/AST/NameLookup.h

@@ -32,7 +32,6 @@ namespace swift {
   class DeclName;
   class Expr;
   class GenericSignatureBuilder;
-  class LazyResolver;
   class TupleType;
   class Type;
   class TypeDecl;
@@ -147,7 +146,7 @@ class UnqualifiedLookup {
   ///
   /// If the current DeclContext is nested in a function body, the SourceLoc
   /// is used to determine which declarations in that body are visible.
-  UnqualifiedLookup(DeclName Name, DeclContext *DC, LazyResolver *TypeResolver,
+  UnqualifiedLookup(DeclName Name, DeclContext *DC,
                     SourceLoc Loc = SourceLoc(), Options options = Options());
 
   using ResultsVector = SmallVector<LookupResultEntry, 4>;
@@ -394,7 +393,6 @@ bool removeShadowedDecls(SmallVectorImpl<ValueDecl*> &decls,
 /// are visible.
 void lookupVisibleDecls(VisibleDeclConsumer &Consumer,
                         const DeclContext *DC,
-                        LazyResolver *typeResolver,
                         bool IncludeTopLevel,
                         SourceLoc Loc = SourceLoc());
 
@@ -405,7 +403,6 @@ void lookupVisibleDecls(VisibleDeclConsumer &Consumer,
 void lookupVisibleMemberDecls(VisibleDeclConsumer &Consumer,
                               Type BaseTy,
                               const DeclContext *CurrDC,
-                              LazyResolver *typeResolver,
                               bool includeInstanceMembers,
                               GenericSignatureBuilder *GSB = nullptr);
 
@@ -433,16 +430,13 @@ enum class ResolutionKind {
 /// \param[out] decls Any found decls will be added to this vector.
 /// \param lookupKind Whether this lookup is qualified or unqualified.
 /// \param resolutionKind What sort of decl is expected.
-/// \param typeResolver The type resolver for decls that need to be
-///        type-checked. This is needed for shadowing resolution.
 /// \param moduleScopeContext The top-level context from which the lookup is
 ///        being performed, for checking access. This must be either a
 ///        FileUnit or a Module.
 /// \param extraImports Private imports to include in this search.
 void lookupInModule(ModuleDecl *module, ModuleDecl::AccessPathTy accessPath,
                     DeclName name, SmallVectorImpl<ValueDecl *> &decls,
                     NLKind lookupKind, ResolutionKind resolutionKind,
-                    LazyResolver *typeResolver,
                     const DeclContext *moduleScopeContext,
                     ArrayRef<ModuleDecl::ImportedModule> extraImports = {});
 
@@ -508,7 +502,6 @@ lookupVisibleDeclsInModule(ModuleDecl *M, ModuleDecl::AccessPathTy accessPath,
                            SmallVectorImpl<ValueDecl *> &decls,
                            NLKind lookupKind,
                            ResolutionKind resolutionKind,
-                           LazyResolver *typeResolver,
                            const DeclContext *moduleScopeContext,
                            ArrayRef<ModuleDecl::ImportedModule> extraImports = {});
 

include/swift/Basic/Statistics.def

@@ -138,6 +138,28 @@ FRONTEND_STATISTIC(AST, NumPrefixOperators)
 /// Number of precedence groups in the AST context.
 FRONTEND_STATISTIC(AST, NumPrecedenceGroups)
 
+/// Number of qualified lookups into a nominal type.
+FRONTEND_STATISTIC(AST, NumLookupQualifiedInNominal)
+
+/// Number of qualified lookups into a module.
+FRONTEND_STATISTIC(AST, NumLookupQualifiedInModule)
+
+/// Number of qualified lookups into AnyObject.
+FRONTEND_STATISTIC(AST, NumLookupQualifiedInAnyObject)
+
+/// Number of lookups into a module and its imports.
+FRONTEND_STATISTIC(AST, NumLookupInModule)
+
+/// Number of local lookups into a module.
+FRONTEND_STATISTIC(AST, NumModuleLookupValue)
+
+/// Number of unqualified lookups.
+FRONTEND_STATISTIC(AST, NumUnqualifiedLookup)
+
+/// Number of local lookups into a module's class members, for
+/// AnyObject lookup.
+FRONTEND_STATISTIC(AST, NumModuleLookupClassMember)
+
 /// Number of full function bodies parsed.
 FRONTEND_STATISTIC(Parse, NumFunctionsParsed)
 
@@ -227,6 +249,8 @@ FRONTEND_STATISTIC(Sema, NumTypesValidated)
 /// Number of lazy iterable declaration contexts left unloaded.
 FRONTEND_STATISTIC(Sema, NumUnloadedLazyIterableDeclContexts)
 
+/// Number of lookups into a module and its imports.
+
 /// All type check requests go into the Sema area.
 #define SWIFT_TYPEID(NAME) FRONTEND_STATISTIC(Sema, NAME)
 #include "swift/AST/AccessTypeIDZone.def"

include/swift/ClangImporter/ClangModule.h

@@ -35,7 +35,7 @@ class ClangModuleUnit final : public LoadedFile {
   ClangImporter::Implementation &owner;
   const clang::Module *clangModule;
   llvm::PointerIntPair<ModuleDecl *, 1, bool> overlayModule;
-  mutable ArrayRef<ModuleDecl::ImportedModule> importedModulesForLookup;
+  mutable Optional<ArrayRef<ModuleDecl::ImportedModule>> importedModulesForLookup;
   /// The metadata of the underlying Clang module.
   clang::ExternalASTSource::ASTSourceDescriptor ASTSourceDescriptor;
 

lib/AST/ASTContext.cpp

@@ -871,7 +871,7 @@ ClassDecl *ASTContext::get##NAME##Decl() const { \
       /* Note: use unqualified lookup so we find NSError regardless of */ \
       /* whether it's defined in the Foundation module or the Clang */ \
       /* Foundation module it imports. */ \
-      UnqualifiedLookup lookup(getIdentifier(#NAME), M, nullptr); \
+      UnqualifiedLookup lookup(getIdentifier(#NAME), M); \
       if (auto type = lookup.getSingleTypeResult()) { \
         if (auto classDecl = dyn_cast<ClassDecl>(type)) { \
           if (classDecl->getGenericParams() == nullptr) { \

lib/AST/DeclContext.cpp

@@ -476,20 +476,15 @@ unsigned DeclContext::getSemanticDepth() const {
 }
 
 bool DeclContext::mayContainMembersAccessedByDynamicLookup() const {
-  // Dynamic lookup can only find class and protocol members, or extensions of
-  // classes.
-  if (auto *NTD = dyn_cast<NominalTypeDecl>(this)) {
-    if (isa<ClassDecl>(NTD))
-      if (!isGenericContext())
-        return true;
-    if (auto *PD = dyn_cast<ProtocolDecl>(NTD))
-      if (PD->getAttrs().hasAttribute<ObjCAttr>())
-        return true;
-  } else if (auto *ED = dyn_cast<ExtensionDecl>(this)) {
-    if (auto *CD = dyn_cast<ClassDecl>(ED->getExtendedNominal()))
-      if (!CD->isGenericContext())
-        return true;
-  }
+  // Members of non-generic classes and class extensions can be found by
+  /// dynamic lookup.
+  if (auto *CD = getSelfClassDecl())
+    return !CD->isGenericContext();
+
+  // Members of @objc protocols (but not protocol extensions) can be
+  // found by dynamic lookup.
+  if (auto *PD = dyn_cast<ProtocolDecl>(this))
+      return PD->getAttrs().hasAttribute<ObjCAttr>();
 
   return false;
 }

lib/AST/Module.cpp

@@ -454,8 +454,11 @@ static bool isParsedModule(const ModuleDecl *mod) {
 void ModuleDecl::lookupValue(AccessPathTy AccessPath, DeclName Name,
                              NLKind LookupKind, 
                              SmallVectorImpl<ValueDecl*> &Result) const {
+  auto *stats = getASTContext().Stats;
+  if (stats)
+    stats->getFrontendCounters().NumModuleLookupValue++;
+
   if (isParsedModule(this)) {
-    FrontendStatsTracer tracer(getASTContext().Stats, "source-file-lookup-value");
     getSourceLookupCache().lookupValue(AccessPath, Name, LookupKind, Result);
     return;
   }
@@ -604,6 +607,10 @@ void SourceFile::lookupClassMembers(ModuleDecl::AccessPathTy accessPath,
 void ModuleDecl::lookupClassMember(AccessPathTy accessPath,
                                    DeclName name,
                                    SmallVectorImpl<ValueDecl*> &results) const {
+  auto *stats = getASTContext().Stats;
+  if (stats)
+    stats->getFrontendCounters().NumModuleLookupClassMember++;
+
   if (isParsedModule(this)) {
     FrontendStatsTracer tracer(getASTContext().Stats, "source-file-lookup-class-member");
     auto &cache = getSourceLookupCache();

lib/AST/ModuleNameLookup.cpp

@@ -54,7 +54,6 @@ class ModuleNameLookup {
                                                 TinyPtrVector<ValueDecl *>, 32>;
 
   ModuleLookupCache cache;
-  LazyResolver * const typeResolver;
   const ResolutionKind resolutionKind;
   const bool respectAccessControl;
 
@@ -106,10 +105,9 @@ class ModuleNameLookup {
       ArrayRef<ModuleDecl::ImportedModule> extraImports);
 
 public:
-  ModuleNameLookup(LazyResolver *typeResolver, ModuleDecl *M,
-                   ResolutionKind resolutionKind)
-      : typeResolver(typeResolver), resolutionKind(resolutionKind),
-        respectAccessControl(!M->getASTContext().isAccessControlDisabled()) {}
+  ModuleNameLookup(ASTContext &ctx, ResolutionKind resolutionKind)
+      : resolutionKind(resolutionKind),
+        respectAccessControl(!ctx.isAccessControlDisabled()) {}
 
   /// Performs a qualified lookup into the given module and, if necessary, its
   /// reexports, observing proper shadowing rules.
@@ -133,9 +131,9 @@ class LookupByName : public ModuleNameLookup<LookupByName> {
   const NLKind lookupKind;
 
 public:
-  LookupByName(LazyResolver *typeResolver, ModuleDecl *M,
-               ResolutionKind resolutionKind, DeclName name, NLKind lookupKind)
-    : Super(typeResolver, M, resolutionKind), name(name),
+  LookupByName(ASTContext &ctx, ResolutionKind resolutionKind,
+               DeclName name, NLKind lookupKind)
+    : Super(ctx, resolutionKind), name(name),
       lookupKind(lookupKind) {}
 
 private:
@@ -194,9 +192,9 @@ class LookupVisibleDecls : public ModuleNameLookup<LookupVisibleDecls> {
   const NLKind lookupKind;
 
 public:
-  LookupVisibleDecls(LazyResolver *typeResolver, ModuleDecl *M,
-                     ResolutionKind resolutionKind, NLKind lookupKind)
-    : ModuleNameLookup(typeResolver, M, resolutionKind),
+  LookupVisibleDecls(ASTContext &ctx, ResolutionKind resolutionKind,
+                     NLKind lookupKind)
+    : ModuleNameLookup(ctx, resolutionKind),
       lookupKind(lookupKind) {}
 
 private:
@@ -276,7 +274,7 @@ bool ModuleNameLookup<LookupStrategy>::recordImportDecls(
     llvm::copy_if(newDecls, std::back_inserter(results),
                   [&](ValueDecl *result) -> bool {
       if (!result->hasInterfaceType()) {
-        if (typeResolver) {
+        if (auto *typeResolver = result->getASTContext().getLazyResolver()) {
           typeResolver->resolveDeclSignature(result);
           if (result->isInvalid())
             return true;
@@ -451,12 +449,17 @@ void namelookup::lookupInModule(ModuleDecl *startModule,
                                 SmallVectorImpl<ValueDecl *> &decls,
                                 NLKind lookupKind,
                                 ResolutionKind resolutionKind,
-                                LazyResolver *typeResolver,
                                 const DeclContext *moduleScopeContext,
                                 ArrayRef<ModuleDecl::ImportedModule> extraImports) {
+  auto &ctx = startModule->getASTContext();
+  auto *stats = ctx.Stats;
+  if (stats)
+    stats->getFrontendCounters().NumLookupInModule++;
+
+  FrontendStatsTracer tracer(stats, "lookup-in-module");
+
   assert(moduleScopeContext && moduleScopeContext->isModuleScopeContext());
-  LookupByName lookup(typeResolver, startModule, resolutionKind, name,
-                      lookupKind);
+  LookupByName lookup(ctx, resolutionKind, name, lookupKind);
   lookup.lookupInModule(decls, startModule, topAccessPath, moduleScopeContext,
                         extraImports);
 }
@@ -467,11 +470,11 @@ void namelookup::lookupVisibleDeclsInModule(
     SmallVectorImpl<ValueDecl *> &decls,
     NLKind lookupKind,
     ResolutionKind resolutionKind,
-    LazyResolver *typeResolver,
     const DeclContext *moduleScopeContext,
     ArrayRef<ModuleDecl::ImportedModule> extraImports) {
+  auto &ctx = M->getASTContext();
   assert(moduleScopeContext && moduleScopeContext->isModuleScopeContext());
-  LookupVisibleDecls lookup(typeResolver, M, resolutionKind, lookupKind);
+  LookupVisibleDecls lookup(ctx, resolutionKind, lookupKind);
   lookup.lookupInModule(decls, M, accessPath, moduleScopeContext, extraImports);
 }
 

lib/AST/NameLookup.cpp

@@ -1437,7 +1437,6 @@ static void extractDirectlyReferencedNominalTypes(
 bool DeclContext::lookupQualified(Type type,
                                   DeclName member,
                                   NLOptions options,
-                                  LazyResolver *typeResolver,
                                   SmallVectorImpl<ValueDecl *> &decls) const {
   using namespace namelookup;
   assert(decls.empty() && "additive lookup not supported");
@@ -1464,6 +1463,10 @@ bool DeclContext::lookupQualified(ArrayRef<NominalTypeDecl *> typeDecls,
   using namespace namelookup;
   assert(decls.empty() && "additive lookup not supported");
 
+  auto *stats = getASTContext().Stats;
+  if (stats)
+    stats->getFrontendCounters().NumLookupQualifiedInNominal++;
+
   // Configure lookup and dig out the tracker.
   ReferencedNameTracker *tracker = nullptr;
   bool isLookupCascading;
@@ -1600,20 +1603,23 @@ bool DeclContext::lookupQualified(ModuleDecl *module, DeclName member,
                                   SmallVectorImpl<ValueDecl *> &decls) const {
   using namespace namelookup;
 
+  auto *stats = getASTContext().Stats;
+  if (stats)
+    stats->getFrontendCounters().NumLookupQualifiedInModule++;
+
   // Configure lookup and dig out the tracker.
   ReferencedNameTracker *tracker = nullptr;
   bool isLookupCascading;
   configureLookup(this, options, tracker, isLookupCascading);
 
-  ASTContext &ctx = getASTContext();
   auto topLevelScope = getModuleScopeContext();
   if (module == topLevelScope->getParentModule()) {
     if (tracker) {
       recordLookupOfTopLevelName(topLevelScope, member, isLookupCascading);
     }
     lookupInModule(module, /*accessPath=*/{}, member, decls,
                    NLKind::QualifiedLookup, ResolutionKind::Overloadable,
-                   ctx.getLazyResolver(), topLevelScope);
+                   topLevelScope);
   } else {
     // Note: This is a lookup into another module. Unless we're compiling
     // multiple modules at once, or if the other module re-exports this one,
@@ -1627,7 +1633,7 @@ bool DeclContext::lookupQualified(ModuleDecl *module, DeclName member,
         return true;
       lookupInModule(import.second, import.first, member, decls,
                      NLKind::QualifiedLookup, ResolutionKind::Overloadable,
-                     ctx.getLazyResolver(), topLevelScope);
+                     topLevelScope);
       // If we're able to do an unscoped lookup, we see everything. No need
       // to keep going.
       return !import.first.empty();
@@ -1671,6 +1677,10 @@ bool DeclContext::lookupAnyObject(DeclName member, NLOptions options,
   if (options & NL_OnlyTypes)
     return false;
 
+  auto *stats = getASTContext().Stats;
+  if (stats)
+    stats->getFrontendCounters().NumLookupQualifiedInAnyObject++;
+
   // Collect all of the visible declarations.
   SmallVector<ValueDecl *, 4> allDecls;
   forAllVisibleModules(this, [&](ModuleDecl::ImportedModule import) {
@@ -1821,11 +1831,11 @@ resolveTypeDeclsToNominal(Evaluator &evaluator,
 
 /// Perform unqualified name lookup for types at the given location.
 static DirectlyReferencedTypeDecls
-directReferencesForUnqualifiedTypeLookup(ASTContext &ctx, DeclName name,
+directReferencesForUnqualifiedTypeLookup(DeclName name,
                                          SourceLoc loc, DeclContext *dc) {
   DirectlyReferencedTypeDecls results;
   UnqualifiedLookup::Options options = UnqualifiedLookup::Flags::TypeLookup;
-  UnqualifiedLookup lookup(name, dc, ctx.getLazyResolver(), loc, options);
+  UnqualifiedLookup lookup(name, dc, loc, options);
   for (const auto &result : lookup.Results) {
     if (auto typeDecl = dyn_cast<TypeDecl>(result.getValueDecl()))
       results.push_back(typeDecl);
@@ -1897,8 +1907,7 @@ directReferencesForIdentTypeRepr(Evaluator &evaluator,
     // For the first component, perform unqualified name lookup.
     if (current.empty()) {
       current =
-        directReferencesForUnqualifiedTypeLookup(ctx,
-                                                 component->getIdentifier(),
+        directReferencesForUnqualifiedTypeLookup(component->getIdentifier(),
                                                  component->getIdLoc(),
                                                  dc);