Separate TypeDeclFinder from AccessScopeChecker (#23957)

...and move the latter into lib/Sema as TypeAccessScopeChecker, since
it's not interesting outside of Sema anyway.

No functionality change.

Author: jrose-apple

include/swift/AST/AccessScopeChecker.h renamed to include/swift/AST/TypeDeclFinder.h

@@ -1,53 +1,28 @@
-//===--- AccessScopeChecker.h - Access calculation helpers -----*- C++ -*-===//
+//===--- TypeDeclFinder.h - Finds TypeDecls in Types/TypeReprs --*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-//
-//  This file defines helpers for access-control calculation.
-//
-//===----------------------------------------------------------------------===//
-#ifndef SWIFT_ACCESS_SCOPE_CHECKER_H
-#define SWIFT_ACCESS_SCOPE_CHECKER_H
+#ifndef SWIFT_AST_TYPEDECLFINDER_H
+#define SWIFT_AST_TYPEDECLFINDER_H
 
-#include "swift/AST/AccessScope.h"
-#include "swift/AST/AttrKind.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/TypeWalker.h"
+#include "llvm/ADT/STLExtras.h"
 
 namespace swift {
 
 class BoundGenericType;
 class ComponentIdentTypeRepr;
 class NominalType;
-class SourceFile;
 class TypeAliasType;
 
-class AccessScopeChecker {
-  const SourceFile *File;
-  bool TreatUsableFromInlineAsPublic;
-
-  Optional<AccessScope> Scope = AccessScope::getPublic();
-
-  AccessScopeChecker(const DeclContext *useDC,
-                     bool treatUsableFromInlineAsPublic);
-  bool visitDecl(const ValueDecl *VD);
-
-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 {

lib/AST/AccessScopeChecker.cpp

@@ -14,7 +14,6 @@ else()
 endif()
 
 add_swift_host_library(swiftAST STATIC
-  AccessScopeChecker.cpp
   AccessRequests.cpp
   ASTContext.cpp
   ASTDemangler.cpp
@@ -68,6 +67,7 @@ add_swift_host_library(swiftAST STATIC
   SwiftNameTranslation.cpp
   Type.cpp
   TypeCheckRequests.cpp
+  TypeDeclFinder.cpp
   TypeJoinMeet.cpp
   TypeRefinementContext.cpp
   TypeRepr.cpp

lib/AST/CMakeLists.txt

@@ -0,0 +1,57 @@
+//===--- TypeDeclFinder.cpp - Finds TypeDecls inside Types/TypeReprs ------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/TypeDeclFinder.h"
+#include "swift/AST/Decl.h"
+#include "swift/AST/TypeRepr.h"
+#include "swift/AST/Types.h"
+
+using namespace swift;
+
+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;
+}
+
+TypeWalker::Action
+SimpleTypeDeclFinder::visitNominalType(NominalType *ty) {
+  return Callback(ty->getDecl());
+}
+
+TypeWalker::Action
+SimpleTypeDeclFinder::visitBoundGenericType(BoundGenericType *ty) {
+  return Callback(ty->getDecl());
+}
+
+TypeWalker::Action
+SimpleTypeDeclFinder::visitTypeAliasType(TypeAliasType *ty) {
+  return Callback(ty->getDecl());
+}
+
+bool TypeReprIdentFinder::walkToTypeReprPost(TypeRepr *TR) {
+  auto CITR = dyn_cast<ComponentIdentTypeRepr>(TR);
+  if (!CITR || !CITR->getBoundDecl())
+    return true;
+  return Callback(CITR);
+}

lib/AST/TypeDeclFinder.cpp

@@ -16,12 +16,12 @@
 
 #include "TypeChecker.h"
 #include "TypeCheckAvailability.h"
-#include "swift/AST/AccessScopeChecker.h"
 #include "swift/AST/Attr.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DeclContext.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/TypeDeclFinder.h"
 
 using namespace swift;
 using FragileFunctionKind = TypeChecker::FragileFunctionKind;

lib/Sema/ResilienceDiagnostics.cpp

@@ -0,0 +1,74 @@
+//===--- TypeAccessScopeChecker.h - Computes access for Types ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SEMA_TYPEACCESSSCOPECHECKER_H
+#define SWIFT_SEMA_TYPEACCESSSCOPECHECKER_H
+
+#include "swift/AST/Decl.h"
+#include "swift/AST/DeclContext.h"
+#include "swift/AST/Type.h"
+#include "swift/AST/TypeDeclFinder.h"
+#include "swift/AST/TypeRepr.h"
+
+namespace swift {
+class SourceFile;
+
+/// Computes the access scope where a Type or TypeRepr is available, which is
+/// the intersection of all the scopes where the declarations referenced in the
+/// Type or TypeRepr are available.
+class TypeAccessScopeChecker {
+  const SourceFile *File;
+  bool TreatUsableFromInlineAsPublic;
+
+  Optional<AccessScope> Scope = AccessScope::getPublic();
+
+  TypeAccessScopeChecker(const DeclContext *useDC,
+                         bool treatUsableFromInlineAsPublic)
+      : File(useDC->getParentSourceFile()),
+  TreatUsableFromInlineAsPublic(treatUsableFromInlineAsPublic) {}
+
+  bool visitDecl(const ValueDecl *VD) {
+    if (isa<GenericTypeParamDecl>(VD))
+      return true;
+
+    auto AS = VD->getFormalAccessScope(File, TreatUsableFromInlineAsPublic);
+    Scope = Scope->intersectWith(AS);
+    return Scope.hasValue();
+  }
+
+public:
+  static Optional<AccessScope>
+  getAccessScope(TypeRepr *TR, const DeclContext *useDC,
+                 bool treatUsableFromInlineAsPublic = false) {
+    TypeAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
+    TR->walk(TypeReprIdentFinder([&](const ComponentIdentTypeRepr *typeRepr) {
+      return checker.visitDecl(typeRepr->getBoundDecl());
+    }));
+    return checker.Scope;
+  }
+
+  static Optional<AccessScope>
+  getAccessScope(Type T, const DeclContext *useDC,
+                 bool treatUsableFromInlineAsPublic = false) {
+    TypeAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
+    T.walk(SimpleTypeDeclFinder([&](const ValueDecl *VD) {
+      if (checker.visitDecl(VD))
+        return TypeWalker::Action::Continue;
+      return TypeWalker::Action::Stop;
+    }));
+    return checker.Scope;
+  }
+};
+
+} // end namespace swift
+
+#endif

lib/Sema/TypeAccessScopeChecker.h

@@ -16,14 +16,15 @@
 
 #include "TypeChecker.h"
 #include "TypeCheckAccess.h"
-#include "swift/AST/AccessScopeChecker.h"
+#include "TypeAccessScopeChecker.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/TypeCheckRequests.h"
+#include "swift/AST/TypeDeclFinder.h"
 
 using namespace swift;
 
@@ -204,7 +205,8 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
   AccessScope problematicAccessScope = AccessScope::getPublic();
   if (type) {
     Optional<AccessScope> typeAccessScope =
-      AccessScopeChecker::getAccessScope(type, useDC, checkUsableFromInline);
+        TypeAccessScopeChecker::getAccessScope(type, useDC,
+                                               checkUsableFromInline);
 
     // Note: This means that the type itself is invalid for this particular
     // context, because it references declarations from two incompatible scopes.
@@ -225,8 +227,8 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
       return;
 
     Optional<AccessScope> typeReprAccessScope =
-        AccessScopeChecker::getAccessScope(typeRepr, useDC,
-                                           checkUsableFromInline);
+        TypeAccessScopeChecker::getAccessScope(typeRepr, useDC,
+                                               checkUsableFromInline);
     if (!typeReprAccessScope.hasValue())
       return;
 
@@ -253,8 +255,8 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
       //
       // Downgrade the error to a warning in this case for source compatibility.
       Optional<AccessScope> typeReprAccessScope =
-          AccessScopeChecker::getAccessScope(typeRepr, useDC,
-                                             checkUsableFromInline);
+          TypeAccessScopeChecker::getAccessScope(typeRepr, useDC,
+                                                 checkUsableFromInline);
       assert(typeReprAccessScope && "valid Type but not valid TypeRepr?");
       if (contextAccessScope.hasEqualDeclContextWith(*typeReprAccessScope) ||
           contextAccessScope.isChildOf(*typeReprAccessScope)) {