---

yaml
---
r: 284157
b: refs/heads/swift-5.1-branch
c: 3c27d9d
h: refs/heads/master
i:
  284155: f5779c1

Author: Harlan Haskins

[refs]

@@ -1242,7 +1242,7 @@ refs/heads/marcrasi-astverifier-disable: 3fac766a23a77ebd0640296bfd7fc116ea60a4e
 refs/heads/revert-22227-a-tall-white-fountain-played: adfce60b2eaa54903ea189bed8a783bca609fa53
 refs/heads/revert-22300-revert-22227-a-tall-white-fountain-played: 5f92040224df7dd4e618fdfb367349df64d8acad
 refs/heads/swift-5.1-old-llvm-branch: 9cef8175146f25b72806154b8a0f4a3f52e3e400
-refs/heads/swift-5.1-branch: b2904fbf994864adc5d351721497abee2d75cede
+refs/heads/swift-5.1-branch: 3c27d9de85c499699faba7f315c07807e64ce493
 refs/tags/swift-4.2.2-RELEASE: e429d1f1aaf59e69d38207a96e56265c7f6fccec
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-02-a: 3e5a03d32ff3b1e9af90d6c1198c14f938379a6e
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-03-a: 4591c933063ddcb0d6cd6d0cdd01086b2f9b244d

branches/swift-5.1-branch/include/swift/AST/AccessScopeChecker.h

@@ -23,79 +23,47 @@
 
 namespace swift {
 
-class BoundGenericType;
-class ComponentIdentTypeRepr;
-class NominalType;
+class AbstractStorageDecl;
+class ExtensionDecl;
 class SourceFile;
-class TypeAliasType;
+class ValueDecl;
 
 class AccessScopeChecker {
   const SourceFile *File;
   bool TreatUsableFromInlineAsPublic;
 
+protected:
+  ASTContext &Context;
   Optional<AccessScope> Scope = AccessScope::getPublic();
 
   AccessScopeChecker(const DeclContext *useDC,
                      bool treatUsableFromInlineAsPublic);
-  bool visitDecl(const ValueDecl *VD);
+  bool visitDecl(ValueDecl *VD);
+};
+
+class TypeReprAccessScopeChecker : private ASTWalker, AccessScopeChecker {
+  TypeReprAccessScopeChecker(const DeclContext *useDC,
+                             bool treatUsableFromInlineAsPublic);
+
+  bool walkToTypeReprPre(TypeRepr *TR) override;
+  bool walkToTypeReprPost(TypeRepr *TR) override;
 
 public:
   static Optional<AccessScope>
   getAccessScope(TypeRepr *TR, const DeclContext *useDC,
                  bool treatUsableFromInlineAsPublic = false);
-  static Optional<AccessScope>
-  getAccessScope(Type T, const DeclContext *useDC,
-                 bool treatUsableFromInlineAsPublic = false);
 };
 
-/// Walks a Type to find all NominalTypes, BoundGenericTypes, and
-/// TypeAliasTypes.
-class TypeDeclFinder : public TypeWalker {
-  Action walkToTypePre(Type T) override;
-
-public:
-  virtual Action visitNominalType(const NominalType *ty) {
-    return Action::Continue;
-  }
-  virtual Action visitBoundGenericType(const BoundGenericType *ty) {
-    return Action::Continue;
-  }
-  virtual Action visitTypeAliasType(const TypeAliasType *ty) {
-    return Action::Continue;
-  }
-};
+class TypeAccessScopeChecker : private TypeWalker, AccessScopeChecker {
+  TypeAccessScopeChecker(const DeclContext *useDC,
+                         bool treatUsableFromInlineAsPublic);
 
-/// A TypeDeclFinder for use cases where all types should be treated
-/// equivalently and where generic arguments can be walked to separately from
-/// the generic type.
-class SimpleTypeDeclFinder : public TypeDeclFinder {
-  /// The function to call when a ComponentIdentTypeRepr is seen.
-  llvm::function_ref<Action(const TypeDecl *)> Callback;
-
-  Action visitNominalType(const NominalType *ty) override;
-  Action visitBoundGenericType(const BoundGenericType *ty) override;
-  Action visitTypeAliasType(const TypeAliasType *ty) override;
+  Action walkToTypePre(Type T);
 
 public:
-  explicit SimpleTypeDeclFinder(
-      llvm::function_ref<Action(const TypeDecl *)> callback)
-    : Callback(callback) {}
-};
-
-/// Walks a TypeRepr to find all ComponentIdentTypeReprs with bound TypeDecls.
-///
-/// Subclasses can either override #visitTypeDecl if they only care about
-/// types on their own, or #visitComponentIdentTypeRepr if they want to keep
-/// the TypeRepr around.
-class TypeReprIdentFinder : public ASTWalker {
-  /// The function to call when a ComponentIdentTypeRepr is seen.
-  llvm::function_ref<bool(const ComponentIdentTypeRepr *)> Callback;
-
-  bool walkToTypeReprPost(TypeRepr *TR) override;
-public:
-  explicit TypeReprIdentFinder(
-      llvm::function_ref<bool(const ComponentIdentTypeRepr *)> callback)
-    : Callback(callback) {}
+  static Optional<AccessScope>
+  getAccessScope(Type T, const DeclContext *useDC,
+                 bool treatUsableFromInlineAsPublic = false);
 };
 
 }

branches/swift-5.1-branch/include/swift/AST/DiagnosticsSema.def

@@ -2397,11 +2397,6 @@ NOTE(enum_raw_value_incrementing_from_zero,none,
 NOTE(construct_raw_representable_from_unwrapped_value,none,
      "construct %0 from unwrapped %1 value", (Type, Type))
 
-ERROR(decl_from_implementation_only_module,none,
-      "cannot use %0 here; %1 has been imported as "
-      "'@_implementationOnly'",
-      (DeclName, Identifier))
-
 // Derived conformances
 ERROR(cannot_synthesize_init_in_extension_of_nonfinal,none,
       "implementation of %0 for non-final class cannot be automatically "
@@ -4109,11 +4104,6 @@ WARNING(resilience_decl_unavailable_warn,
         "should not be referenced from " FRAGILE_FUNC_KIND "3",
         (DescriptiveDeclKind, DeclName, AccessLevel, unsigned, bool))
 
-ERROR(inlinable_decl_ref_implementation_only,
-      none, "%0 %1 cannot be used in an inlinable "
-      "function because its module was imported implementation-only",
-      (DescriptiveDeclKind, DeclName))
-
 #undef FRAGILE_FUNC_KIND
 
 NOTE(resilience_decl_declared_here_public,

branches/swift-5.1-branch/include/swift/AST/Module.h

@@ -959,10 +959,6 @@ class SourceFile final : public FileUnit {
   /// May be -1, to indicate no association with a buffer.
   int BufferID;
 
-  /// Does this source file have any implementation-only imports?
-  /// If not, we can fast-path module checks.
-  bool HasImplementationOnlyImports = false;
-
   /// The list of protocol conformances that were "used" within this
   /// source file.
   llvm::SetVector<NormalProtocolConformance *> UsedConformances;
@@ -1051,12 +1047,6 @@ class SourceFile final : public FileUnit {
   hasTestableOrPrivateImport(AccessLevel accessLevel, const ValueDecl *ofDecl,
                              ImportQueryKind kind = TestableAndPrivate) const;
 
-  bool hasImplementationOnlyImports() const {
-    return HasImplementationOnlyImports;
-  }
-
-  bool isImportedImplementationOnly(const ModuleDecl *module) const;
-
   void clearLookupCache();
 
   void cacheVisibleDecls(SmallVectorImpl<ValueDecl *> &&globals) const;

branches/swift-5.1-branch/include/swift/Serialization/SerializedModuleLoader.h

@@ -51,6 +51,18 @@ class SerializedModuleLoaderBase : public ModuleLoader {
                   std::unique_ptr<llvm::MemoryBuffer> *moduleDocBuffer,
                   bool &isFramework);
 
+  /// Attempts to search the provided directory for a loadable serialized
+  /// .swiftmodule with the provided `ModuleFilename`. Subclasses must
+  /// override this method to perform their custom module lookup behavior.
+  ///
+  /// If such a module could not be loaded, the subclass must return a
+  /// `std::error_code` indicating the failure. There are two specific error
+  /// codes that will be treated specially:
+  /// - `errc::no_such_file_or_directory`: The module loader will stop looking
+  ///   for loadable modules and will diagnose the lookup failure.
+  /// - `errc::not_supported`: The module loader will stop looking for loadable
+  ///   modules and will defer to the remaining module loaders to look up this
+  ///   module.
   virtual std::error_code findModuleFilesInDirectory(
       AccessPathElem ModuleID, StringRef DirPath, StringRef ModuleFilename,
       StringRef ModuleDocFilename,

branches/swift-5.1-branch/lib/AST/AccessScopeChecker.cpp

@@ -24,76 +24,68 @@ using namespace swift;
 AccessScopeChecker::AccessScopeChecker(const DeclContext *useDC,
                                        bool treatUsableFromInlineAsPublic)
   : File(useDC->getParentSourceFile()),
-    TreatUsableFromInlineAsPublic(treatUsableFromInlineAsPublic) {}
+    TreatUsableFromInlineAsPublic(treatUsableFromInlineAsPublic),
+    Context(File->getASTContext()) {}
 
 bool
-AccessScopeChecker::visitDecl(const ValueDecl *VD) {
-  if (isa<GenericTypeParamDecl>(VD))
+AccessScopeChecker::visitDecl(ValueDecl *VD) {
+  if (!VD || isa<GenericTypeParamDecl>(VD))
     return true;
 
   auto AS = VD->getFormalAccessScope(File, TreatUsableFromInlineAsPublic);
   Scope = Scope->intersectWith(AS);
   return Scope.hasValue();
 }
 
-bool TypeReprIdentFinder::walkToTypeReprPost(TypeRepr *TR) {
-  auto CITR = dyn_cast<ComponentIdentTypeRepr>(TR);
-  if (!CITR || !CITR->getBoundDecl())
-    return true;
-  return Callback(CITR);
+TypeReprAccessScopeChecker::TypeReprAccessScopeChecker(const DeclContext *useDC,
+                                                       bool treatUsableFromInlineAsPublic)
+  : AccessScopeChecker(useDC, treatUsableFromInlineAsPublic) {
 }
 
-Optional<AccessScope>
-AccessScopeChecker::getAccessScope(TypeRepr *TR, const DeclContext *useDC,
-                                   bool treatUsableFromInlineAsPublic) {
-  AccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
-  TR->walk(TypeReprIdentFinder([&](const ComponentIdentTypeRepr *typeRepr) {
-    return checker.visitDecl(typeRepr->getBoundDecl());
-  }));
-  return checker.Scope;
+bool
+TypeReprAccessScopeChecker::walkToTypeReprPre(TypeRepr *TR) {
+  if (auto CITR = dyn_cast<ComponentIdentTypeRepr>(TR))
+    return visitDecl(CITR->getBoundDecl());
+  return true;
 }
 
-TypeWalker::Action TypeDeclFinder::walkToTypePre(Type T) {
-  if (auto *TAT = dyn_cast<TypeAliasType>(T.getPointer()))
-    return visitTypeAliasType(TAT);
-
-  // FIXME: We're looking through sugar here so that we visit, e.g.,
-  // Swift.Array when we see `[Int]`. But that means we do redundant work when
-  // we see sugar that's purely structural, like `(Int)`. Fortunately, paren
-  // types are the only such purely structural sugar at the time this comment
-  // was written, and they're not so common in the first place.
-  if (auto *BGT = T->getAs<BoundGenericType>())
-    return visitBoundGenericType(BGT);
-  if (auto *NT = T->getAs<NominalType>())
-    return visitNominalType(NT);
-
-  return Action::Continue;
+bool
+TypeReprAccessScopeChecker::walkToTypeReprPost(TypeRepr *TR) {
+  return Scope.hasValue();
 }
 
-TypeWalker::Action
-SimpleTypeDeclFinder::visitNominalType(const NominalType *ty) {
-  return Callback(ty->getDecl());
+Optional<AccessScope>
+TypeReprAccessScopeChecker::getAccessScope(TypeRepr *TR, const DeclContext *useDC,
+                                           bool treatUsableFromInlineAsPublic) {
+  TypeReprAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
+  TR->walk(checker);
+  return checker.Scope;
 }
 
-TypeWalker::Action
-SimpleTypeDeclFinder::visitBoundGenericType(const BoundGenericType *ty) {
-  return Callback(ty->getDecl());
-}
+TypeAccessScopeChecker::TypeAccessScopeChecker(const DeclContext *useDC,
+                                               bool treatUsableFromInlineAsPublic)
+  : AccessScopeChecker(useDC, treatUsableFromInlineAsPublic) {}
 
 TypeWalker::Action
-SimpleTypeDeclFinder::visitTypeAliasType(const TypeAliasType *ty) {
-  return Callback(ty->getDecl());
-}
+TypeAccessScopeChecker::walkToTypePre(Type T) {
+  ValueDecl *VD;
+  if (auto *BNAD = dyn_cast<TypeAliasType>(T.getPointer()))
+    VD = BNAD->getDecl();
+  else if (auto *NTD = T->getAnyNominal())
+    VD = NTD;
+  else
+    VD = nullptr;
+
+  if (!visitDecl(VD))
+    return Action::Stop;
 
+  return Action::Continue;
+}
 
 Optional<AccessScope>
-AccessScopeChecker::getAccessScope(Type T, const DeclContext *useDC,
-                                   bool treatUsableFromInlineAsPublic) {
-  AccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
-  T.walk(SimpleTypeDeclFinder([&](const ValueDecl *VD) {
-    if (checker.visitDecl(VD))
-      return TypeWalker::Action::Continue;
-    return TypeWalker::Action::Stop;
-  }));
+TypeAccessScopeChecker::getAccessScope(Type T, const DeclContext *useDC,
+                                       bool treatUsableFromInlineAsPublic) {
+  TypeAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
+  T.walk(checker);
   return checker.Scope;
 }

branches/swift-5.1-branch/lib/AST/Module.cpp

@@ -1421,14 +1421,6 @@ void SourceFile::addImports(ArrayRef<ImportedModuleDesc> IM) {
   assert(iter == newBuf.end());
 
   Imports = newBuf;
-
-  // Update the HasImplementationOnlyImports flag.
-  if (!HasImplementationOnlyImports) {
-    for (auto &desc : IM) {
-      if (desc.importOptions.contains(ImportFlags::ImplementationOnly))
-        HasImplementationOnlyImports = true;
-    }
-  }
 }
 
 bool SourceFile::hasTestableOrPrivateImport(
@@ -1493,43 +1485,6 @@ bool SourceFile::hasTestableOrPrivateImport(
                      });
 }
 
-bool SourceFile::isImportedImplementationOnly(const ModuleDecl *module) const {
-  // Implementation-only imports are (currently) always source-file-specific,
-  // so if we don't have any, we know the search is complete.
-  if (!hasImplementationOnlyImports())
-    return false;
-
-  auto isImportedBy = [](const ModuleDecl *dest, const ModuleDecl *src) {
-    // Fast path.
-    if (dest == src) return true;
-
-    // Walk the transitive imports, respecting visibility.
-    // This return true if the search *didn't* short-circuit, and it short
-    // circuits if we found `dest`, so we need to invert the sense before
-    // returning.
-    return !const_cast<ModuleDecl*>(src)
-              ->forAllVisibleModules({}, [dest](ModuleDecl::ImportedModule im) {
-      // Continue searching as long as we haven't found `dest` yet.
-      return im.second != dest;
-    });
-  };
-
-  // Look at the imports of this source file.
-  for (auto &desc : Imports) {
-    // Ignore implementation-only imports.
-    if (desc.importOptions.contains(ImportFlags::ImplementationOnly))
-      continue;
-
-    // If the module is imported this way, it's not imported
-    // implementation-only.
-    if (isImportedBy(module, desc.module.second))
-      return false;
-  }
-
-  // Now check this file's enclosing module in case there are re-exports.
-  return !isImportedBy(module, getParentModule());
-}
-
 void SourceFile::clearLookupCache() {
   if (!Cache)
     return;