Merge pull request swiftlang#21116 from akyrtzi/break-dependency-cycles

[AST] Break dependency cycles of swiftAST against swiftSema and swiftClangImporter

Author: akyrtzi

include/swift/AST/Module.h

@@ -1315,6 +1315,9 @@ class LoadedFile : public FileUnit {
     return nullptr;
   }
 
+  /// Returns the Swift module that overlays a Clang module.
+  virtual ModuleDecl *getAdapterModule() const { return nullptr; }
+
   virtual bool isSystemModule() const { return false; }
 
   /// Retrieve the set of generic signatures stored within this module.

include/swift/AST/NameLookup.h

@@ -19,6 +19,7 @@
 
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "swift/AST/ASTVisitor.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Module.h"
 #include "swift/Basic/SourceLoc.h"
@@ -381,6 +382,85 @@ getDirectlyInheritedNominalTypeDecls(
 SelfBounds getSelfBoundsFromWhereClause(
     llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl);
 
+namespace namelookup {
+
+/// Performs a qualified lookup into the given module and, if necessary, its
+/// reexports, observing proper shadowing rules.
+void
+lookupVisibleDeclsInModule(ModuleDecl *M, ModuleDecl::AccessPathTy accessPath,
+                           SmallVectorImpl<ValueDecl *> &decls,
+                           NLKind lookupKind,
+                           ResolutionKind resolutionKind,
+                           LazyResolver *typeResolver,
+                           const DeclContext *moduleScopeContext,
+                           ArrayRef<ModuleDecl::ImportedModule> extraImports = {});
+
+/// Searches through statements and patterns for local variable declarations.
+class FindLocalVal : public StmtVisitor<FindLocalVal> {
+  friend class ASTVisitor<FindLocalVal>;
+
+  const SourceManager &SM;
+  SourceLoc Loc;
+  VisibleDeclConsumer &Consumer;
+
+public:
+  FindLocalVal(const SourceManager &SM, SourceLoc Loc,
+               VisibleDeclConsumer &Consumer)
+      : SM(SM), Loc(Loc), Consumer(Consumer) {}
+
+  void checkValueDecl(ValueDecl *D, DeclVisibilityKind Reason) {
+    Consumer.foundDecl(D, Reason);
+  }
+
+  void checkPattern(const Pattern *Pat, DeclVisibilityKind Reason);
+  
+  void checkParameterList(const ParameterList *params);
+
+  void checkGenericParams(GenericParamList *Params);
+
+  void checkSourceFile(const SourceFile &SF);
+
+private:
+  bool isReferencePointInRange(SourceRange R) {
+    return SM.rangeContainsTokenLoc(R, Loc);
+  }
+
+  void visitBreakStmt(BreakStmt *) {}
+  void visitContinueStmt(ContinueStmt *) {}
+  void visitFallthroughStmt(FallthroughStmt *) {}
+  void visitFailStmt(FailStmt *) {}
+  void visitReturnStmt(ReturnStmt *) {}
+  void visitYieldStmt(YieldStmt *) {}
+  void visitThrowStmt(ThrowStmt *) {}
+  void visitPoundAssertStmt(PoundAssertStmt *) {}
+  void visitDeferStmt(DeferStmt *DS) {
+    // Nothing in the defer is visible.
+  }
+
+  void checkStmtCondition(const StmtCondition &Cond);
+
+  void visitIfStmt(IfStmt *S);
+  void visitGuardStmt(GuardStmt *S);
+
+  void visitWhileStmt(WhileStmt *S);
+  void visitRepeatWhileStmt(RepeatWhileStmt *S);
+  void visitDoStmt(DoStmt *S);
+
+  void visitForEachStmt(ForEachStmt *S);
+
+  void visitBraceStmt(BraceStmt *S, bool isTopLevelCode = false);
+  
+  void visitSwitchStmt(SwitchStmt *S);
+
+  void visitCaseStmt(CaseStmt *S);
+
+  void visitDoCatchStmt(DoCatchStmt *S);
+  void visitCatchClauses(ArrayRef<CatchStmt*> clauses);
+  void visitCatchStmt(CatchStmt *S);
+  
+};
+
+} // end namespace namelookup
 } // end namespace swift
 
 #endif

include/swift/ClangImporter/ClangModule.h

@@ -54,7 +54,7 @@ class ClangModuleUnit final : public LoadedFile {
   bool isTopLevel() const;
 
   /// Returns the Swift module that overlays this Clang module.
-  ModuleDecl *getAdapterModule() const;
+  ModuleDecl *getAdapterModule() const override;
 
   /// Retrieve the "exported" name of the module, which is usually the module
   /// name, but might be the name of the public module through which this

lib/AST/CMakeLists.txt

@@ -37,7 +37,6 @@ add_swift_host_library(swiftAST STATIC
   Identifier.cpp
   InlinableText.cpp
   LayoutConstraint.cpp
-  LookupVisibleDecls.cpp
   Module.cpp
   ModuleLoader.cpp
   ModuleNameLookup.cpp

lib/AST/ModuleNameLookup.cpp

@@ -10,7 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "NameLookupImpl.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/LazyResolver.h"

lib/AST/NameLookup.cpp

@@ -14,7 +14,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "NameLookupImpl.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTScope.h"
@@ -25,6 +24,7 @@
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/NameLookupRequests.h"
+#include "swift/AST/ParameterList.h"
 #include "swift/AST/ReferencedNameTracker.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
@@ -37,6 +37,11 @@
 #define DEBUG_TYPE "namelookup"
 
 using namespace swift;
+using namespace swift::namelookup;
+
+void VisibleDeclConsumer::anchor() {}
+void VectorDeclConsumer::anchor() {}
+void NamedDeclConsumer::anchor() {}
 
 ValueDecl *LookupResultEntry::getBaseDecl() const {
   if (BaseDC == nullptr)
@@ -2690,3 +2695,191 @@ swift::getDirectlyInheritedNominalTypeDecls(
 
   return result;
 }
+
+void FindLocalVal::checkPattern(const Pattern *Pat, DeclVisibilityKind Reason) {
+  switch (Pat->getKind()) {
+  case PatternKind::Tuple:
+    for (auto &field : cast<TuplePattern>(Pat)->getElements())
+      checkPattern(field.getPattern(), Reason);
+    return;
+  case PatternKind::Paren:
+  case PatternKind::Typed:
+  case PatternKind::Var:
+    return checkPattern(Pat->getSemanticsProvidingPattern(), Reason);
+  case PatternKind::Named:
+    return checkValueDecl(cast<NamedPattern>(Pat)->getDecl(), Reason);
+  case PatternKind::EnumElement: {
+    auto *OP = cast<EnumElementPattern>(Pat);
+    if (OP->hasSubPattern())
+      checkPattern(OP->getSubPattern(), Reason);
+    return;
+  }
+  case PatternKind::OptionalSome:
+    checkPattern(cast<OptionalSomePattern>(Pat)->getSubPattern(), Reason);
+    return;
+
+  case PatternKind::Is: {
+    auto *isPat = cast<IsPattern>(Pat);
+    if (isPat->hasSubPattern())
+      checkPattern(isPat->getSubPattern(), Reason);
+    return;
+  }
+
+  // Handle non-vars.
+  case PatternKind::Bool:
+  case PatternKind::Expr:
+  case PatternKind::Any:
+    return;
+  }
+}
+  
+void FindLocalVal::checkParameterList(const ParameterList *params) {
+  for (auto param : *params) {
+    checkValueDecl(param, DeclVisibilityKind::FunctionParameter);
+  }
+}
+
+void FindLocalVal::checkGenericParams(GenericParamList *Params) {
+  if (!Params)
+    return;
+
+  for (auto P : *Params)
+    checkValueDecl(P, DeclVisibilityKind::GenericParameter);
+}
+
+void FindLocalVal::checkSourceFile(const SourceFile &SF) {
+  for (Decl *D : SF.Decls)
+    if (auto *TLCD = dyn_cast<TopLevelCodeDecl>(D))
+      visitBraceStmt(TLCD->getBody(), /*isTopLevel=*/true);
+}
+
+void FindLocalVal::checkStmtCondition(const StmtCondition &Cond) {
+  SourceLoc start = SourceLoc();
+  for (auto entry : Cond) {
+    if (start.isInvalid())
+      start = entry.getStartLoc();
+    if (auto *P = entry.getPatternOrNull()) {
+      SourceRange previousConditionsToHere = SourceRange(start, entry.getEndLoc());
+      if (!isReferencePointInRange(previousConditionsToHere))
+        checkPattern(P, DeclVisibilityKind::LocalVariable);
+    }
+  }
+}
+
+void FindLocalVal::visitIfStmt(IfStmt *S) {
+  if (!isReferencePointInRange(S->getSourceRange()))
+    return;
+
+  if (!S->getElseStmt() ||
+      !isReferencePointInRange(S->getElseStmt()->getSourceRange())) {
+    checkStmtCondition(S->getCond());
+  }
+
+  visit(S->getThenStmt());
+  if (S->getElseStmt())
+    visit(S->getElseStmt());
+}
+
+void FindLocalVal::visitGuardStmt(GuardStmt *S) {
+  if (SM.isBeforeInBuffer(Loc, S->getStartLoc()))
+    return;
+
+  // Names in the guard aren't visible until after the body.
+  if (!isReferencePointInRange(S->getBody()->getSourceRange()))
+    checkStmtCondition(S->getCond());
+
+  visit(S->getBody());
+}
+
+void FindLocalVal::visitWhileStmt(WhileStmt *S) {
+  if (!isReferencePointInRange(S->getSourceRange()))
+    return;
+
+  checkStmtCondition(S->getCond());
+  visit(S->getBody());
+}
+void FindLocalVal::visitRepeatWhileStmt(RepeatWhileStmt *S) {
+  visit(S->getBody());
+}
+void FindLocalVal::visitDoStmt(DoStmt *S) {
+  visit(S->getBody());
+}
+
+void FindLocalVal::visitForEachStmt(ForEachStmt *S) {
+  if (!isReferencePointInRange(S->getSourceRange()))
+    return;
+  visit(S->getBody());
+  if (!isReferencePointInRange(S->getSequence()->getSourceRange()))
+    checkPattern(S->getPattern(), DeclVisibilityKind::LocalVariable);
+}
+
+void FindLocalVal::visitBraceStmt(BraceStmt *S, bool isTopLevelCode) {
+  if (isTopLevelCode) {
+    if (SM.isBeforeInBuffer(Loc, S->getStartLoc()))
+      return;
+  } else {
+    if (!isReferencePointInRange(S->getSourceRange()))
+      return;
+  }
+
+  for (auto elem : S->getElements()) {
+    if (auto *S = elem.dyn_cast<Stmt*>())
+      visit(S);
+  }
+  for (auto elem : S->getElements()) {
+    if (auto *D = elem.dyn_cast<Decl*>()) {
+      if (auto *VD = dyn_cast<ValueDecl>(D))
+        checkValueDecl(VD, DeclVisibilityKind::LocalVariable);
+    }
+  }
+}
+  
+void FindLocalVal::visitSwitchStmt(SwitchStmt *S) {
+  if (!isReferencePointInRange(S->getSourceRange()))
+    return;
+  for (CaseStmt *C : S->getCases()) {
+    visit(C);
+  }
+}
+
+void FindLocalVal::visitCaseStmt(CaseStmt *S) {
+  if (!isReferencePointInRange(S->getSourceRange()))
+    return;
+  // Pattern names aren't visible in the patterns themselves,
+  // just in the body or in where guards.
+  bool inPatterns = isReferencePointInRange(S->getLabelItemsRange());
+  auto items = S->getCaseLabelItems();
+  if (inPatterns) {
+    for (const auto &CLI : items) {
+      auto guard = CLI.getGuardExpr();
+      if (guard && isReferencePointInRange(guard->getSourceRange())) {
+        checkPattern(CLI.getPattern(), DeclVisibilityKind::LocalVariable);
+        break;
+      }
+    }
+  }
+  if (!inPatterns && !items.empty())
+    checkPattern(items[0].getPattern(), DeclVisibilityKind::LocalVariable);
+  visit(S->getBody());
+}
+
+void FindLocalVal::visitDoCatchStmt(DoCatchStmt *S) {
+  if (!isReferencePointInRange(S->getSourceRange()))
+    return;
+  visit(S->getBody());
+  visitCatchClauses(S->getCatches());
+}
+void FindLocalVal::visitCatchClauses(ArrayRef<CatchStmt*> clauses) {
+  // TODO: some sort of binary search?
+  for (auto clause : clauses) {
+    visitCatchStmt(clause);
+  }
+}
+void FindLocalVal::visitCatchStmt(CatchStmt *S) {
+  if (!isReferencePointInRange(S->getSourceRange()))
+    return;
+  // Names in the pattern aren't visible until after the pattern.
+  if (!isReferencePointInRange(S->getErrorPattern()->getSourceRange()))
+    checkPattern(S->getErrorPattern(), DeclVisibilityKind::LocalVariable);
+  visit(S->getBody());
+}