Merge pull request #24594 from davidungar/A5-7-ASTOOScope-rebased

[NameLookup] ASTOOScope ontology

Author: David Ungar

include/swift/AST/ASTScope.h

@@ -865,6 +865,7 @@ template <typename GraphT> class DotFileEmitter {
   void emitDotNode(StringRef id, StringRef label, StringRef shape,
                    StringRef fillColor, StringRef style = StringRef()) {
     auto inserted = nodeIDs.insert(id.str());
+    (void)inserted;
     assert(inserted.second && "NodeIDs must be unique.");
     out << "\"" << id << "\" [ "
         << "label = \"" << label << "\", "

include/swift/AST/ExperimentalDependencies.h

@@ -1009,8 +1009,6 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
     return Loc;
   }
   SourceLoc getTrailingQuoteLoc() const {
-    // Except when computing a SourceRange for an ASTScope. Then the range
-    // must be (Start - TrainingQuoteLoc).
     return TrailingQuoteLoc;
   }
 

include/swift/AST/Expr.h

@@ -46,7 +46,6 @@ namespace clang {
 namespace swift {
   enum class ArtificialMainKind : uint8_t;
   class ASTContext;
-  class ASTScope;
   class ASTWalker;
   class BraceStmt;
   class Decl;
@@ -80,10 +79,14 @@ namespace swift {
   class VarDecl;
   class VisibleDeclConsumer;
   class SyntaxParsingCache;
-  
-namespace syntax {
+  class ASTScope;
+
+  namespace syntax {
   class SourceFileSyntax;
 }
+namespace ast_scope {
+class ASTSourceFileScope;
+}
 
 /// Discriminator for file-units.
 enum class FileUnitKind {
@@ -989,7 +992,7 @@ class SourceFile final : public FileUnit {
   bool HasImplementationOnlyImports = false;
 
   /// The scope map that describes this source file.
-  ASTScope *Scope = nullptr;
+  std::unique_ptr<ASTScope> Scope;
 
   friend ASTContext;
   friend Impl;

include/swift/AST/Module.h

@@ -22,6 +22,8 @@
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Module.h"
+#include "swift/Basic/Compiler.h"
+#include "swift/Basic/NullablePtr.h"
 #include "swift/Basic/SourceLoc.h"
 
 namespace swift {
@@ -36,52 +38,89 @@ namespace swift {
   class TypeDecl;
   class ValueDecl;
   struct SelfBounds;
-
-/// LookupResultEntry - One result of unqualified lookup.
-struct LookupResultEntry {
-private:
-
-  /// The declaration context through which we found Value. For instance,
-  /// class BaseClass {
-  ///   func foo() {}
-  /// }
-  ///
-  /// class DerivedClass : BaseClass {
-  ///   func bar() {}
-  /// }
-  ///
-  /// When finding foo() from the body of DerivedClass, BaseDC is DerivedClass.
-  ///
-  /// Another example:
-  ///
-  /// class BaseClass {
-  ///   func bar() {}
-  ///   func foo() {}
-  /// }
-  ///
-  /// When finding bar() from the function body of foo(), BaseDC is the method
-  /// foo().
+  class NominalTypeDecl;
+
+  namespace ast_scope {
+  class ASTSourceFileScope;
+  class ASTScopeImpl;
+  } // namespace ast_scope
+
+  /// LookupResultEntry - One result of unqualified lookup.
+  struct LookupResultEntry {
+  private:
+    /// The declaration context through which we found \c Value. For instance,
+    /// \code
+    /// class BaseClass {
+    ///   func foo() {}
+    /// }
+    ///
+    /// class DerivedClass : BaseClass {
+    ///   func bar() {}
+    /// }
+    /// \endcode
+    ///
+    /// When finding \c foo() from the body of \c DerivedClass, \c BaseDC is \c
+    /// DerivedClass.
+    ///
+    /// Another example:
+    /// \code
+    /// class BaseClass {
+    ///   func bar() {}
+    ///   func foo() {}
+    /// }
+    /// \endcode
+    ///
+    /// When finding \c bar() from the function body of \c foo(), \c BaseDC is
+    /// the method \c foo().
+    ///
+    /// \c BaseDC will be the method if \c self is needed for the lookup,
+    /// and will be the type if not.
+    /// In other words: If \c baseDC is a method, it means you found an instance
+    /// member and you should add an implicit 'self.' (Each method has its own
+    /// implicit self decl.) There's one other kind of non-method context that
+    /// has a 'self.' -- a lazy property initializer, which unlike a non-lazy
+    /// property can reference \c self) Hence: \code
+    ///  class Outer {
+    ///    static func s()
+    ///    func i()
+    ///    class Inner {
+    ///      static func ss()
+    ///      func ii() {
+    ///        func F() {
+    ///          ii() // OK! implicitly self.ii; BaseDC is the method
+    ///          s()  // OK! s() is defined in an outer type; BaseDC is the type
+    ///          ss() // error: must write /Inner.ss() here since its static
+    ///          i()  // error: there's no outer 'self.'
+    ///        }
+    ///      }
+    /// \endcode
+    ///
+    /// To sum up:  The distinction is whether you need to know the run-time
+    /// value of \c self. It might be clearer if \code baseDC was always a type,
+    /// and there was an additional \c ParamDecl field in \c LookupResult which
+    /// would store the implicit self, if any. \c BaseDC is always one of your
+    /// outer DCs. if you're inside a type it should never be an extension of
+    /// that type. And if you're inside an extension it will always be an
+    /// extension (if it found something at that level).
   DeclContext *BaseDC;
 
   /// The declaration corresponds to the given name; i.e. the decl we are
   /// looking up.
   ValueDecl *Value;
 
 public:
-  LookupResultEntry(ValueDecl *value) : BaseDC(nullptr), Value(value) { }
+  LookupResultEntry(ValueDecl *value) : BaseDC(nullptr), Value(value) {}
 
   LookupResultEntry(DeclContext *baseDC, ValueDecl *value)
-    : BaseDC(baseDC), Value(value) { }
+    : BaseDC(baseDC), Value(value) {}
 
-  ValueDecl *getValueDecl() const {
-    return Value;
-  }
+  ValueDecl *getValueDecl() const { return Value; }
 
-  DeclContext *getDeclContext() const {
-    return BaseDC;
-  }
+  DeclContext *getDeclContext() const { return BaseDC; }
 
   ValueDecl *getBaseDecl() const;
+
+  void print(llvm::raw_ostream &) const;
 };
 
 /// This class implements and represents the result of performing
@@ -110,13 +149,15 @@ class UnqualifiedLookup {
   /// is used to determine which declarations in that body are visible.
   UnqualifiedLookup(DeclName Name, DeclContext *DC, LazyResolver *TypeResolver,
                     SourceLoc Loc = SourceLoc(), Options options = Options());
-
-  SmallVector<LookupResultEntry, 4> Results;
+  
+  using ResultsVector = SmallVector<LookupResultEntry, 4>;
+  ResultsVector Results;
+  
   /// The index of the first result that isn't from the innermost scope
   /// with results.
   ///
   /// That is, \c makeArrayRef(Results).take_front(IndexOfFirstOuterResults)
-  /// will be Results from the innermost scope that had results, and the
+  /// will be \c Results from the innermost scope that had results, and the
   /// remaining elements of Results will be from parent scopes of this one.
   ///
   /// Allows unqualified name lookup to return results from outer scopes.
@@ -136,7 +177,6 @@ inline UnqualifiedLookup::Options operator|(UnqualifiedLookup::Flags flag1,
   return UnqualifiedLookup::Options(flag1) | flag2;
 }
 
-
 /// Describes the reason why a certain declaration is visible.
 enum class DeclVisibilityKind {
   /// Declaration is a local variable or type.
@@ -536,8 +576,100 @@ class FindLocalVal : public StmtVisitor<FindLocalVal> {
   void visitCatchStmt(CatchStmt *S);
 
 };
+  
+  
+/// The bridge between the legacy UnqualifedLookupFactory and the new ASTScope
+/// lookup system
+class AbstractASTScopeDeclConsumer {
+public:
+  AbstractASTScopeDeclConsumer() {}
+
+  virtual ~AbstractASTScopeDeclConsumer() = default;
+
+  /// Called for every ValueDecl visible from the lookup.
+  /// Returns true if the lookup can be stopped at this point.
+  /// BaseDC is per legacy
+  /// Takes an array in order to batch the consumption before setting
+  /// IndexOfFirstOuterResult when necessary.
+  virtual bool consume(ArrayRef<ValueDecl *> values, DeclVisibilityKind vis,
+                       Optional<bool> isCascadingUse,
+                       NullablePtr<DeclContext> baseDC = nullptr) = 0;
+
+  /// Eventually this functionality should move into ASTScopeLookup
+  virtual std::pair<bool, Optional<bool>>
+  lookupInSelfType(NullablePtr<DeclContext> selfDC, DeclContext *const scopeDC,
+                   NominalTypeDecl *const nominal,
+                   Optional<bool> isCascadingUse) = 0;
+
+#ifndef NDEBUG
+  virtual void stopForDebuggingIfTargetLookup() = 0;
+#endif
+};
+  
+/// Just used to print
+/// Used to gather lookup results
+class ASTScopeDeclGatherer : public AbstractASTScopeDeclConsumer {
+  SmallVector<ValueDecl *, 32> values;
+
+public:
+  virtual ~ASTScopeDeclGatherer() = default;
+
+  bool consume(ArrayRef<ValueDecl *> values, DeclVisibilityKind vis,
+               Optional<bool> isCascadingUse,
+               NullablePtr<DeclContext> baseDC = nullptr) override;
+
+  /// Eventually this functionality should move into ASTScopeLookup
+  std::pair<bool, Optional<bool>>
+  lookupInSelfType(NullablePtr<DeclContext>, DeclContext *const,
+                   NominalTypeDecl *const,
+                   Optional<bool> isCascadingUse) override {
+    return std::make_pair(false, isCascadingUse);
+  }
 
+#ifndef NDEBUG
+  void stopForDebuggingIfTargetLookup() override {}
+#endif
+
+  ArrayRef<ValueDecl *> getDecls() { return values; }
+};
 } // end namespace namelookup
+
+/// The interface into the ASTScope subsystem
+class ASTScope {
+  friend class ast_scope::ASTScopeImpl;
+  ast_scope::ASTSourceFileScope *const impl;
+
+public:
+  ASTScope(SourceFile *);
+  static Optional<bool>
+  unqualifiedLookup(SourceFile *, DeclName, SourceLoc,
+                    const DeclContext *startingContext,
+                    Optional<bool> isCascadingUse,
+                    namelookup::AbstractASTScopeDeclConsumer &);
+
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
+                            "only for use within the debugger");
+  void print(llvm::raw_ostream &) const;
+  void dumpOneScopeMapLocation(std::pair<unsigned, unsigned>) const;
+
+  // Make vanilla new illegal for ASTScopes.
+  void *operator new(size_t bytes) = delete;
+  // Need this because have virtual destructors
+  void operator delete(void *data) {}
+
+  // Only allow allocation of scopes using the allocator of a particular source
+  // file.
+  void *operator new(size_t bytes, const ASTContext &ctx,
+                     unsigned alignment = alignof(ASTScope));
+  void *operator new(size_t Bytes, void *Mem) {
+    assert(Mem);
+    return Mem;
+  }
+
+private:
+  static ast_scope::ASTSourceFileScope *createScopeTree(SourceFile *);
+};
+
 } // end namespace swift
 
 #endif

include/swift/AST/NameLookup.h

@@ -240,6 +240,12 @@ namespace swift {
 
     /// Should we use \c ASTScope-based resolution for unqualified name lookup?
     bool EnableASTScopeLookup = false;
+    
+    /// Someday, ASTScopeLookup will supplant lookup in the parser
+    bool DisableParserLookup = false;
+
+    /// Sound we compare to ASTScope-based resolution for debugging?
+    bool CompareToASTScopeLookup = false;
 
     /// Whether to use the import as member inference system
     ///

include/swift/Basic/LangOptions.h

@@ -833,6 +833,13 @@ class RelationalOperationsBase {
     return !(left == right);
   }
 };
+  
+/// Cast a pointer to \c U  to a pointer to a supertype \c T.
+/// Example:  Wobulator *w = up_cast<Wobulator>(coloredWobulator)
+/// Useful with ?: where each arm is a different subtype.
+/// If \c U is not a subtype of \c T, the compiler will complain.
+template <typename T, typename U>
+T *up_cast(U *ptr) { return ptr; }
 
 /// Removes all runs of values that match \p pred from the range of \p begin
 /// to \p end.

include/swift/Basic/STLExtras.h

@@ -121,9 +121,9 @@ def enable_target_os_checking :
 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 compare_to_astscope_lookup : Flag<["-"], "compare-to-astscope-lookup">,
+  HelpText<"Compare legacy to ASTScope-based unqualified name lookup (for debugging)">;
 
 def print_clang_stats : Flag<["-"], "print-clang-stats">,
   HelpText<"Print Clang importer statistics">;

include/swift/Option/FrontendOptions.td

@@ -853,6 +853,13 @@ def sanitize_coverage_EQ : CommaJoined<["-"], "sanitize-coverage=">,
   HelpText<"Specify the type of coverage instrumentation for Sanitizers and"
   " additional options separated by commas">;
 
+def enable_astscope_lookup : Flag<["-"], "enable-astscope-lookup">,
+  Flags<[FrontendOption]>,
+  HelpText<"Enable ASTScope-based unqualified name lookup">;
+
+def disable_parser_lookup : Flag<["-"], "disable_parser_lookup">,
+  HelpText<"Disable parser lookup & use ast scope lookup only (experimental)">;
+
 def index_file : Flag<["-"], "index-file">,
   HelpText<"Produce index data for a source file">, ModeOpt,
   Flags<[NoInteractiveOption, DoesNotAffectIncrementalBuild]>;

include/swift/Option/Options.td

@@ -714,15 +714,15 @@ class Parser {
 
   /// Add the given Decl to the current scope.
   void addToScope(ValueDecl *D, bool diagnoseRedefinitions = true) {
-    if (Context.LangOpts.EnableASTScopeLookup)
+    if (Context.LangOpts.DisableParserLookup)
       return;
 
     getScopeInfo().addToScope(D, *this, diagnoseRedefinitions);
   }
 
   ValueDecl *lookupInScope(DeclName Name) {
-    if (Context.LangOpts.EnableASTScopeLookup)
-      return nullptr;
+    if (Context.LangOpts.DisableParserLookup)
+          return nullptr;
 
     return getScopeInfo().lookupValueName(Name);
   }