---

yaml
---
r: 341230
b: refs/heads/rxwei-patch-1
c: 1fa5a67
h: refs/heads/master

Author: nkcsgexi

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: a29a980419504bf21de50299cecb1180b284135e
+refs/heads/rxwei-patch-1: 1fa5a6786025b69338ed7b93cb52c6675a0889b5
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/include/swift/AST/ASTScope.h

@@ -116,6 +116,12 @@ class AnyFunctionRef {
     return TheFunction.dyn_cast<AbstractClosureExpr*>();
   }
 
+  bool isDeferBody() const {
+    if (auto *fd = dyn_cast_or_null<FuncDecl>(getAbstractFunctionDecl()))
+      return fd->isDeferBody();
+    return false;
+  }
+
   /// Return true if this closure is passed as an argument to a function and is
   /// known not to escape from that function.  In this case, captures can be
   /// more efficient.

branches/rxwei-patch-1/include/swift/AST/AnyFunctionRef.h

@@ -14,6 +14,7 @@
 #define SWIFT_AST_CAPTURE_INFO_H
 
 #include "swift/Basic/LLVM.h"
+#include "swift/Basic/SourceLoc.h"
 #include "swift/AST/TypeAlignments.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerIntPair.h"
@@ -44,8 +45,9 @@ class CapturedValue {
 
 private:
   Storage Value;
+  SourceLoc Loc;
 
-  explicit CapturedValue(Storage V) : Value(V) {}
+  explicit CapturedValue(Storage V, SourceLoc Loc) : Value(V), Loc(Loc) {}
 
 public:
   friend struct llvm::DenseMapInfo<CapturedValue>;
@@ -61,12 +63,14 @@ class CapturedValue {
     IsNoEscape = 1 << 1
   };
 
-  CapturedValue(llvm::PointerUnion<ValueDecl*, OpaqueValueExpr*> Ptr,
-                unsigned Flags)
-      : Value(Ptr, Flags) {}
+  CapturedValue(ValueDecl *Val, unsigned Flags, SourceLoc Loc)
+      : Value(Val, Flags), Loc(Loc) {}
+
+  CapturedValue(OpaqueValueExpr *Val, unsigned Flags)
+      : Value(Val, Flags), Loc(SourceLoc()) {}
 
   static CapturedValue getDynamicSelfMetadata() {
-    return CapturedValue((ValueDecl *)nullptr, 0);
+    return CapturedValue((ValueDecl *)nullptr, 0, SourceLoc());
   }
 
   bool isDirect() const { return Value.getInt() & IsDirect; }
@@ -80,7 +84,9 @@ class CapturedValue {
   CapturedValue mergeFlags(CapturedValue cv) {
     assert(Value.getPointer() == cv.Value.getPointer() &&
            "merging flags on two different value decls");
-    return CapturedValue(Value.getPointer(), getFlags() & cv.getFlags());
+    return CapturedValue(
+        Storage(Value.getPointer(), getFlags() & cv.getFlags()),
+        Loc);
   }
 
   ValueDecl *getDecl() const {
@@ -95,49 +101,13 @@ class CapturedValue {
     return Value.getPointer().dyn_cast<OpaqueValueExpr *>();
   }
 
-  unsigned getFlags() const { return Value.getInt(); }
-
-  bool operator==(CapturedValue RHS) const {
-    return Value == RHS.Value;
-  }
-
-  bool operator!=(CapturedValue RHS) const {
-    return Value != RHS.Value;
-  }
+  SourceLoc getLoc() const { return Loc; }
 
-  bool operator<(CapturedValue RHS) const {
-    return Value < RHS.Value;
-  }
+  unsigned getFlags() const { return Value.getInt(); }
 };
 
 } // end swift namespace
 
-namespace llvm {
-
-template <> struct DenseMapInfo<swift::CapturedValue> {
-  using CapturedValue = swift::CapturedValue;
-
-  using PtrIntPairDenseMapInfo = DenseMapInfo<CapturedValue::Storage>;
-
-  static inline swift::CapturedValue getEmptyKey() {
-    return CapturedValue{PtrIntPairDenseMapInfo::getEmptyKey()};
-  }
-
-  static inline CapturedValue getTombstoneKey() {
-    return CapturedValue{PtrIntPairDenseMapInfo::getTombstoneKey()};
-  }
-
-  static unsigned getHashValue(const CapturedValue &Val) {
-    return PtrIntPairDenseMapInfo::getHashValue(Val.Value);
-  }
-
-  static bool isEqual(const CapturedValue &LHS, const CapturedValue &RHS) {
-    return PtrIntPairDenseMapInfo::isEqual(LHS.Value, RHS.Value);
-  }
-};
-
-} // end llvm namespace
-
 namespace swift {
 
 class DynamicSelfType;

branches/rxwei-patch-1/include/swift/AST/CaptureInfo.h

@@ -116,6 +116,14 @@ ERROR(unsupported_c_function_pointer_conversion,none,
 ERROR(objc_selector_malformed,none,"the type ObjectiveC.Selector is malformed",
       ())
 
+// Capture before declaration diagnostics.
+ERROR(capture_before_declaration,none,
+      "closure captures %0 before it is declared", (Identifier))
+ERROR(capture_before_declaration_defer,none,
+      "'defer' block captures %0 before it is declared", (Identifier))
+NOTE(captured_value_declared_here,none,
+     "captured value declared here", ())
+
 // Invalid escaping capture diagnostics.
 ERROR(escaping_inout_capture,none,
       "escaping closure captures 'inout' parameter %0", (Identifier))

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSIL.def

@@ -3016,14 +3016,6 @@ ERROR(method_call_in_closure_without_explicit_self,none,
 ERROR(implicit_use_of_self_in_closure,none,
       "implicit use of 'self' in closure; use 'self.' to make"
       " capture semantics explicit", ())
-ERROR(capture_before_declaration,none,
-      "cannot capture %0 before it is declared", (Identifier))
-ERROR(transitive_capture_before_declaration,none,
-      "cannot capture %0, which would use %1 before it is declared",
-      (Identifier, Identifier))
-NOTE(transitive_capture_through_here,none,
-     "%0, declared here, captures %1",
-     (Identifier, Identifier))
 
 WARNING(recursive_accessor_reference,none,
         "attempting to %select{access|modify}1 %0 within its own "

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSema.def

@@ -592,17 +592,18 @@ class AbstractASTScopeDeclConsumer {
   /// 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;
+  virtual bool
+  lookInMembers(NullablePtr<DeclContext> selfDC, DeclContext *const scopeDC,
+                NominalTypeDecl *const nominal,
+                function_ref<bool(Optional<bool>)> calculateIsCascadingUse) = 0;
 
 #ifndef NDEBUG
-  virtual void stopForDebuggingIfTargetLookup() = 0;
+  virtual void startingNextLookupStep() = 0;
+  virtual void finishingLookup(std::string) const = 0;
+  virtual bool isTargetLookup() const = 0;
 #endif
 };
 
@@ -615,19 +616,19 @@ class ASTScopeDeclGatherer : public AbstractASTScopeDeclConsumer {
   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);
+  bool lookInMembers(NullablePtr<DeclContext>, DeclContext *const,
+                     NominalTypeDecl *const,
+                     function_ref<bool(Optional<bool>)>) override {
+    return false;
   }
 
 #ifndef NDEBUG
-  void stopForDebuggingIfTargetLookup() override {}
+  void startingNextLookupStep() override {}
+  void finishingLookup(std::string) const override {}
+  bool isTargetLookup() const override { return false; }
 #endif
 
   ArrayRef<ValueDecl *> getDecls() { return values; }
@@ -641,12 +642,17 @@ class ASTScope {
 
 public:
   ASTScope(SourceFile *);
-  static Optional<bool>
+
+  /// \return the scopes traversed
+  static llvm::SmallVector<const ast_scope::ASTScopeImpl *, 0>
   unqualifiedLookup(SourceFile *, DeclName, SourceLoc,
                     const DeclContext *startingContext,
-                    Optional<bool> isCascadingUse,
                     namelookup::AbstractASTScopeDeclConsumer &);
 
+  static Optional<bool>
+  computeIsCascadingUse(ArrayRef<const ast_scope::ASTScopeImpl *> history,
+                        Optional<bool> initialIsCascadingUse);
+
   LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
                             "only for use within the debugger");
   void print(llvm::raw_ostream &) const;

branches/rxwei-patch-1/include/swift/AST/NameLookup.h

@@ -585,10 +585,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// existential type throughout the given type.
   Type eraseOpenedExistential(OpenedArchetypeType *opened);
 
-  /// Erase DynamicSelfType from the given type by replacing it with its
-  /// underlying type.
-  Type eraseDynamicSelfType();
-
   /// Given a declaration context, returns a function type with the 'self'
   /// type curried as the input if the declaration context describes a type.
   /// Otherwise, returns the type itself.

branches/rxwei-patch-1/include/swift/AST/Types.h

@@ -247,8 +247,11 @@ namespace swift {
     bool EnableDeserializationRecovery = true;
 
     /// Should we use \c ASTScope-based resolution for unqualified name lookup?
+    /// Default is in \c ParseLangArgs
+    ///
+    /// This is a staging flag; eventually it will be removed.
     bool EnableASTScopeLookup = false;
-    
+
     /// Someday, ASTScopeLookup will supplant lookup in the parser
     bool DisableParserLookup = false;
 

branches/rxwei-patch-1/include/swift/Basic/LangOptions.h

@@ -869,7 +869,12 @@ 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">,
+def disable_astscope_lookup : Flag<["-"], "disable-astscope-lookup">,
+  Flags<[FrontendOption]>,
+  HelpText<"Disable ASTScope-based unqualified name lookup">;
+
+def disable_parser_lookup : Flag<["-"], "disable-parser-lookup">,
+  Flags<[FrontendOption]>,
   HelpText<"Disable parser lookup & use ast scope lookup only (experimental)">;
 
 def index_file : Flag<["-"], "index-file">,

branches/rxwei-patch-1/include/swift/Option/Options.td

@@ -568,8 +568,6 @@ struct SILConstantInfo {
 
 /// Different ways in which a function can capture context.
 enum class CaptureKind {
-  /// No context arguments are necessary.
-  None,
   /// A local value captured as a mutable box.
   Box,
   /// A local value captured as a single pointer to storage (formed with

branches/rxwei-patch-1/include/swift/SIL/TypeLowering.h

@@ -37,13 +37,18 @@ using namespace ast_scope;
 
 #pragma mark ASTScope
 
-
-Optional<bool> ASTScope::unqualifiedLookup(
+llvm::SmallVector<const ASTScopeImpl *, 0> ASTScope::unqualifiedLookup(
     SourceFile *SF, DeclName name, SourceLoc loc,
-    const DeclContext *startingContext, Optional<bool> isCascadingUse,
+    const DeclContext *startingContext,
     namelookup::AbstractASTScopeDeclConsumer &consumer) {
   return ASTScopeImpl::unqualifiedLookup(SF, name, loc, startingContext,
-                                         isCascadingUse, consumer);
+                                         consumer);
+}
+
+Optional<bool> ASTScope::computeIsCascadingUse(
+    ArrayRef<const ast_scope::ASTScopeImpl *> history,
+    Optional<bool> initialIsCascadingUse) {
+  return ASTScopeImpl::computeIsCascadingUse(history, initialIsCascadingUse);
 }
 
 void ASTScope::dump() const { impl->dump(); }
@@ -108,6 +113,20 @@ Stmt *LabeledConditionalStmtScope::getStmt() const {
   return getLabeledConditionalStmt();
 }
 
+bool AbstractFunctionBodyScope::isAMethod(
+    const AbstractFunctionDecl *const afd) {
+  // What makes this interesting is that a method named "init" which is not
+  // in a nominal type or extension decl body still gets an implicit self
+  // parameter (even though the program is illegal).
+  // So when choosing between creating a MethodBodyScope and a
+  // PureFunctionBodyScope do we go by the enclosing Decl (i.e.
+  // "afd->getDeclContext()->isTypeContext()") or by
+  // "bool(afd->getImplicitSelfDecl())"?
+  //
+  // Since the code uses \c getImplicitSelfDecl, use that.
+  return afd->getImplicitSelfDecl();
+}
+
 #pragma mark getLabeledConditionalStmt
 LabeledConditionalStmt *IfStmtScope::getLabeledConditionalStmt() const {
   return stmt;
@@ -132,6 +151,14 @@ ASTContext &ASTScopeImpl::getASTContext() const {
 
 #pragma mark getDeclContext
 
+NullablePtr<DeclContext> ASTScopeImpl::getDeclContext() const {
+  return nullptr;
+}
+
+NullablePtr<DeclContext> ASTSourceFileScope::getDeclContext() const {
+  return NullablePtr<DeclContext>(SF);
+}
+
 NullablePtr<DeclContext> GenericTypeOrExtensionScope::getDeclContext() const {
   return getGenericContext();
 }
@@ -168,6 +195,10 @@ NullablePtr<DeclContext> AttachedPropertyWrapperScope::getDeclContext() const {
       .getInitContext();
 }
 
+NullablePtr<DeclContext> AbstractFunctionDeclScope::getDeclContext() const {
+  return decl;
+}
+
 NullablePtr<DeclContext> AbstractFunctionParamsScope::getDeclContext() const {
   return matchingContext;
 }