Merge pull request #4636 from DougGregor/astscope-lookup

Author: swift-ci

include/swift/AST/ASTScope.h

@@ -75,8 +75,9 @@ enum class ASTScopeKind : uint8_t {
   PatternBinding,
   /// The scope introduced for an initializer of a pattern binding.
   PatternInitializer,
-  /// The scope introduced by a particular clause in a pattern binding
-  /// declaration.
+  /// The scope following a particular clause in a pattern binding declaration,
+  /// which is the outermost scope in which the variables introduced by that
+  /// clause will be visible.
   AfterPatternBinding,
   /// The scope introduced by a brace statement.
   BraceStmt,
@@ -543,6 +544,18 @@ class ASTScope {
   /// \seealso getDeclContext().
   DeclContext *getInnermostEnclosingDeclContext() const;
 
+  /// Retrueve the declarations whose names are directly bound by this scope.
+  ///
+  /// The declarations bound in this scope aren't available in the immediate
+  /// parent of this scope, but will still be visible in child scopes (unless
+  /// shadowed there).
+  ///
+  /// Note that this routine does not produce bindings for anything that can
+  /// be found via qualified name lookup in a \c DeclContext, such as nominal
+  /// type declarations or extensions thereof, or the source file itself. The
+  /// client can perform such lookups using the result of \c getDeclContext().
+  SmallVector<ValueDecl *, 4> getLocalBindings() const;
+
   /// Expand the entire scope map.
   ///
   /// Normally, the scope map will be expanded only as needed by its queries,

include/swift/Basic/LangOptions.h

@@ -141,6 +141,9 @@ namespace swift {
     /// new enough?
     bool EnableTargetOSChecking = true;
 
+    /// Should we use \c ASTScope-based resolution for unqualified name lookup?
+    bool EnableASTScopeLookup = false;
+
     /// Whether to use the import as member inference system
     ///
     /// When importing a global, try to infer whether we can import it as a

include/swift/Option/FrontendOptions.td

@@ -102,6 +102,9 @@ def disable_target_os_checking :
   Flag<["-"], "disable-target-os-checking">,
   HelpText<"Disable checking the target OS of serialized modules">;
 
+def enable_astscope_lookup : Flag<["-"], "enable-astscope-lookup">,
+  HelpText<"Enable ASTScope-based unqualified name lookup">;
+
 def print_clang_stats : Flag<["-"], "print-clang-stats">,
   HelpText<"Print Clang importer statistics">;
 

include/swift/Parse/Parser.h

@@ -541,6 +541,9 @@ class Parser {
   }
 
   ValueDecl *lookupInScope(DeclName Name) {
+    if (Context.LangOpts.EnableASTScopeLookup)
+      return nullptr;
+
     return getScopeInfo().lookupValueName(Name);
   }
 

lib/AST/ASTScope.cpp

@@ -1568,7 +1568,7 @@ DeclContext *ASTScope::getDeclContext() const {
 
   case ASTScopeKind::Accessors:
     // FIXME: Somewhat odd modeling because Subscripts don't have their
-    // own nodes. Maybe that should.
+    // own nodes. Maybe they should.
     if (auto subscript = dyn_cast<SubscriptDecl>(abstractStorageDecl))
       return subscript;
 
@@ -1607,6 +1607,89 @@ DeclContext *ASTScope::getInnermostEnclosingDeclContext() const {
   llvm_unreachable("Top-most scope is a declaration context");
 }
 
+SmallVector<ValueDecl *, 4> ASTScope::getLocalBindings() const {
+  SmallVector<ValueDecl *, 4> result;
+
+  auto handlePattern = [&](const Pattern *pattern) {
+    if (!pattern) return;
+    pattern->forEachVariable([&](VarDecl *var) {
+        result.push_back(var);
+      });
+  };
+
+  switch (getKind()) {
+  case ASTScopeKind::Preexpanded:
+  case ASTScopeKind::SourceFile:
+  case ASTScopeKind::TypeOrExtensionBody:
+  case ASTScopeKind::AbstractFunctionDecl:
+  case ASTScopeKind::DefaultArgument:
+  case ASTScopeKind::PatternBinding:
+  case ASTScopeKind::PatternInitializer:
+  case ASTScopeKind::BraceStmt:
+  case ASTScopeKind::IfStmt:
+  case ASTScopeKind::GuardStmt:
+  case ASTScopeKind::RepeatWhileStmt:
+  case ASTScopeKind::ForEachStmt:
+  case ASTScopeKind::DoCatchStmt:
+  case ASTScopeKind::SwitchStmt:
+  case ASTScopeKind::ForStmt:
+  case ASTScopeKind::Accessors:
+  case ASTScopeKind::TopLevelCode:
+    // No local declarations.
+    break;
+
+  case ASTScopeKind::GenericParams:
+    result.push_back(genericParams.params->getParams()[genericParams.index]);
+    break;
+
+  case ASTScopeKind::AbstractFunctionParams:
+    result.push_back(abstractFunctionParams.decl->getParameterList(
+                         abstractFunctionParams.listIndex)
+                       ->get(abstractFunctionParams.paramIndex));
+    break;
+
+  case ASTScopeKind::AfterPatternBinding:
+    handlePattern(patternBinding.decl->getPattern(patternBinding.entry));
+    break;
+
+  case ASTScopeKind::LocalDeclaration:
+    result.push_back(cast<ValueDecl>(localDeclaration));
+    break;
+
+  case ASTScopeKind::ConditionalClause:
+    handlePattern(conditionalClause.stmt->getCond()[conditionalClause.index]
+                    .getPatternOrNull());
+    break;
+
+  case ASTScopeKind::ForEachPattern:
+    handlePattern(forEach->getPattern());
+    break;
+
+  case ASTScopeKind::CatchStmt:
+    handlePattern(catchStmt->getErrorPattern());
+    break;
+
+  case ASTScopeKind::CaseStmt:
+    for (const auto &item : caseStmt->getCaseLabelItems())
+      handlePattern(item.getPattern());
+    break;
+
+  case ASTScopeKind::ForStmtInitializer:
+    for (auto decl : forStmt->getInitializerVarDecls())
+      result.push_back(cast<ValueDecl>(decl));
+    break;
+
+  case ASTScopeKind::Closure:
+    // Note: Parameters all at once is different from functions, but it's not
+    // relevant because there are no default arguments.
+    for (auto param : *closure->getParameters())
+      result.push_back(param);
+    break;
+  }
+
+  return result;
+}
+
 void ASTScope::expandAll() const {
   if (!isExpanded())
     expand();