ASTOOScope ontology

Author: David Ungar

Diff for: include/swift/AST/ASTScope.h

@@ -0,0 +1,32 @@
+//===--- ASTScopeIgnoredNodes.def - Swift Scope Metaprogramming --*- C++-*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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 macros used for macro-metaprogramming with ASTScopes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef IGNORE_PARSED_STMT
+#define IGNORE_PARSED_STMT(DeclOrStmtKind)
+#endif
+
+
+
+IGNORE_PARSED_STMT(Break)
+IGNORE_PARSED_STMT(Continue)
+IGNORE_PARSED_STMT(Fallthrough)
+IGNORE_PARSED_STMT(Fail)
+IGNORE_PARSED_STMT(Throw)
+IGNORE_PARSED_STMT(PoundAssert)
+
+#undef IGNORE_PARSED_STMT
+
+

Diff for: include/swift/AST/ASTScopeNodes.def

@@ -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;
   }
 
@@ -4666,16 +4664,19 @@ class UnresolvedPatternExpr : public Expr {
 class EditorPlaceholderExpr : public Expr {
   Identifier Placeholder;
   SourceLoc Loc;
+  SourceLoc TrailingAngleBracketLoc;
   TypeLoc PlaceholderTy;
   TypeRepr *ExpansionTyR;
   Expr *SemanticExpr;
 
 public:
   EditorPlaceholderExpr(Identifier Placeholder, SourceLoc Loc,
+                        SourceLoc TrailingAngleBracketLoc,
                         TypeLoc PlaceholderTy,
                         TypeRepr *ExpansionTyR)
     : Expr(ExprKind::EditorPlaceholder, /*Implicit=*/false),
       Placeholder(Placeholder), Loc(Loc),
+      TrailingAngleBracketLoc(TrailingAngleBracketLoc),
       PlaceholderTy(PlaceholderTy),
       ExpansionTyR(ExpansionTyR),
       SemanticExpr(nullptr) {
@@ -4685,6 +4686,9 @@ class EditorPlaceholderExpr : public Expr {
   SourceRange getSourceRange() const { return Loc; }
   TypeLoc &getTypeLoc() { return PlaceholderTy; }
   TypeLoc getTypeLoc() const { return PlaceholderTy; }
+  SourceLoc getTrailingAngleBracketLoc() const {
+    return TrailingAngleBracketLoc;
+  }
 
   /// The TypeRepr to be considered for placeholder expansion.
   TypeRepr *getTypeForExpansion() const { return ExpansionTyR; }

Diff for: 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 {
@@ -1189,7 +1192,7 @@ class SourceFile final : public FileUnit {
   StringRef getFilename() const;
 
   /// Retrieve the scope that describes this source file.
-  ASTScope &getScope();
+  ASTScope *getScope();
 
   void dump() const;
   void dump(raw_ostream &os) const;

Diff for: include/swift/AST/Module.h

@@ -22,6 +22,7 @@
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Module.h"
+#include "swift/Basic/NullablePtr.h"
 #include "swift/Basic/SourceLoc.h"
 
 namespace swift {
@@ -36,52 +37,91 @@ namespace swift {
   class TypeDecl;
   class ValueDecl;
   struct SelfBounds;
+  class PatternBindingInitializer;
+  class DefaultArgumentInitializer;
+  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;
 
-/// 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().
-  DeclContext *BaseDC;
+    /// The declaration corresponds to the given name; i.e. the decl we are
+    /// looking up.
+    ValueDecl *Value;
 
-  /// 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) {}
 
-public:
-  LookupResultEntry(ValueDecl *value) : BaseDC(nullptr), Value(value) { }
+    LookupResultEntry(DeclContext *baseDC, ValueDecl *value)
+        : BaseDC(baseDC), Value(value) {}
 
-  LookupResultEntry(DeclContext *baseDC, ValueDecl *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;
 
-  ValueDecl *getBaseDecl() const;
+    void print(llvm::raw_ostream &) const;
 };
 
 /// This class implements and represents the result of performing
@@ -110,13 +150,13 @@ 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 +176,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 +575,91 @@ 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,
+                       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;
+
+  virtual void stopForDebuggingIfTargetLookup() = 0;
+};
+  
+/// 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,
+               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);
+  }
+
+  void stopForDebuggingIfTargetLookup() override {}
+
+  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(ast_scope::ASTSourceFileScope *sfs) : impl(sfs) {}
+  static ASTScope *createScopeTreeFor(SourceFile *);
+  static Optional<bool>
+  unqualifiedLookup(SourceFile *, DeclName, SourceLoc,
+                    const DeclContext *startingContext,
+                    Optional<bool> isCascadingUse,
+                    namelookup::AbstractASTScopeDeclConsumer &);
+
+  void dump() const;
+  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;
+  }
+};
+
 } // end namespace swift
 
 #endif

Diff for: include/swift/AST/NameLookup.h

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

Diff for: 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.

Diff for: 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">;