---

yaml
---
r: 326555
b: refs/heads/tensorflow
c: c08a627
h: refs/heads/master
i:
  326553: 6c909f1
  326551: ec44276

Author: adrian-prantl

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 7697611c1503499646445061faaabc5c2b018ff1
+refs/heads/tensorflow: c08a62764a95844883cd44f7d457d6bd1c253bb4
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/include/swift/AST/ASTScope.h

@@ -177,10 +177,8 @@ class ASTScopeImpl {
   void addChild(ASTScopeImpl *child, ASTContext &);
   std::vector<ASTScopeImpl *> rescueYoungestChildren(unsigned count);
 
-  /// When reexpanding, do we always create a new body?
-  virtual NullablePtr<ASTScopeImpl> getParentOfRescuedScopes();
-  std::vector<ASTScopeImpl *> rescueScopesToReuse();
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>);
+  virtual std::vector<ASTScopeImpl *> rescueScopesToReuse();
+  virtual void addReusedScopes(ArrayRef<ASTScopeImpl *>);
 
 private:
   void removeChildren();
@@ -203,8 +201,7 @@ class ASTScopeImpl {
   /// InterpolatedStringLiteralExprs and EditorPlaceHolders respond to
   /// getSourceRange with the starting point. But we might be asked to lookup an
   /// identifer within one of them. So, find the real source range of them here.
-  ///
-  /// FIXME: Alter how these are parsed so getSourceRange is enough.
+  ///   /// FIXME: Alter how these are parsed so getSourceRange is enough.
   SourceRange getEffectiveSourceRange(ASTNode) const;
 
   void cacheSourceRangeOfMeAndDescendants(bool omitAssertions = false) const;
@@ -306,12 +303,6 @@ class ASTScopeImpl {
   virtual void beCurrent();
   virtual bool isCurrent() const;
 
-  /// Some scopes can be expanded lazily.
-  /// Such scopes must: not change their source ranges after expansion, and
-  /// their expansion must return an insertion point outside themselves.
-  virtual NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion();
-  virtual SourceRange sourceRangeForDeferredExpansion() const;
-
 public:
   // Some nodes (VarDecls and Accessors) are created directly from
   // pattern scope code and should neither be deferred nor should
@@ -557,10 +548,6 @@ class Portion {
 
   virtual void beCurrent(IterableTypeScope *) const;
   virtual bool isCurrent(const IterableTypeScope *) const;
-  virtual NullablePtr<ASTScopeImpl>
-  insertionPointForDeferredExpansion(IterableTypeScope *) const;
-  virtual SourceRange
-  sourceRangeForDeferredExpansion(const IterableTypeScope *) const;
   };
 
   // For the whole Decl scope of a GenericType or an Extension
@@ -636,10 +623,6 @@ class IterableTypeBodyPortion final
 
   void beCurrent(IterableTypeScope *) const override;
   bool isCurrent(const IterableTypeScope *) const override;
-  NullablePtr<ASTScopeImpl>
-  insertionPointForDeferredExpansion(IterableTypeScope *) const override;
-  SourceRange
-  sourceRangeForDeferredExpansion(const IterableTypeScope *) const override;
 };
 
 /// GenericType or Extension scope
@@ -719,6 +702,7 @@ class IterableTypeScope : public GenericTypeScope {
   /// Because of \c parseDelayedDecl members can get added after the tree is
   /// constructed, and they can be out of order. Detect this happening by
   /// remembering the member count.
+  /// TODO: unify with \c numberOfDeclsAlreadySeen
   unsigned memberCount = 0;
 
 public:
@@ -737,8 +721,6 @@ class IterableTypeScope : public GenericTypeScope {
 public:
   void makeBodyCurrent();
   bool isBodyCurrent() const;
-  NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion() override;
-  SourceRange sourceRangeForDeferredExpansion() const override;
 };
 
 class NominalTypeScope final : public IterableTypeScope {
@@ -976,7 +958,8 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   static bool isAMethod(const AbstractFunctionDecl *);
 
-  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
+  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
+  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
 
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
@@ -1139,6 +1122,7 @@ class PatternEntryDeclScope final : public AbstractPatternEntryScope {
   SourceRange
   getChildlessSourceRange(bool omitAssertions = false) const override;
 
+  static bool isHandledSpecially(const ASTNode n);
   NullablePtr<const void> getReferrent() const override;
 
 protected:
@@ -1388,7 +1372,8 @@ class TopLevelCodeScope final : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   NullablePtr<const void> getReferrent() const override;
 
-  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
+  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
+  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
 };
 
 /// The \c _@specialize attribute.

branches/tensorflow/include/swift/AST/ClangModuleLoader.h

@@ -71,32 +71,6 @@ class ClangModuleLoader : public ModuleLoader {
   virtual bool
   isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
                                      const DeclContext *importedDC) = 0;
-
-  /// Look for declarations associated with the given name.
-  ///
-  /// \param name The name we're searching for.
-  virtual void lookupValue(DeclName name, VisibleDeclConsumer &consumer) {}
-
-  /// Look up a type declaration by its Clang name.
-  ///
-  /// Note that this method does no filtering. If it finds the type in a loaded
-  /// module, it returns it. This is intended for use in reflection / debugging
-  /// contexts where access is not a problem.
-  virtual void lookupTypeDecl(StringRef clangName, ClangTypeKind kind,
-                              llvm::function_ref<void(TypeDecl *)> receiver) {}
-
-  /// Look up type a declaration synthesized by the Clang importer itself, using
-  /// a "related entity kind" to determine which type it should be. For example,
-  /// this can be used to find the synthesized error struct for an
-  /// NS_ERROR_ENUM.
-  ///
-  /// Note that this method does no filtering. If it finds the type in a loaded
-  /// module, it returns it. This is intended for use in reflection / debugging
-  /// contexts where access is not a problem.
-  virtual void
-  lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
-                      StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) {}
 };
 
 } // namespace swift

branches/tensorflow/include/swift/AST/Decl.h

@@ -1523,17 +1523,6 @@ class GenericContext : private _GenericContext, public DeclContext {
 
   /// Determine whether this context has generic parameters
   /// of its own.
-  ///
-  /// \code
-  /// class C<T> {
-  ///   func f1() {}    // isGeneric == false
-  ///   func f2<T>() {} // isGeneric == true
-  /// }
-  ///
-  /// protocol P { // isGeneric == true due to implicit Self param
-  ///   func p()   // isGeneric == false
-  /// }
-  /// \endcode
   bool isGeneric() const { return GenericParams != nullptr; }
 
   /// Retrieve the trailing where clause for this extension, if any.

branches/tensorflow/include/swift/AST/Expr.h

@@ -5321,33 +5321,6 @@ class KeyPathDotExpr : public Expr {
   }
 };
 
-/// Expression node that effects a "one-way" constraint in
-/// the constraint system, allowing type information to flow from the
-/// subexpression outward but not the other way.
-///
-/// One-way expressions are generally implicit and synthetic, introduced by
-/// the type checker. However, there is a built-in expression of the
-/// form \c Builtin.one_way(x) that forms a one-way constraint coming out
-/// of expression `x` that can be used for testing purposes.
-class OneWayExpr : public Expr {
-  Expr *SubExpr;
-
-public:
-  /// Construct an implicit one-way expression from the given subexpression.
-  OneWayExpr(Expr *subExpr)
-     : Expr(ExprKind::OneWay, /*isImplicit=*/true), SubExpr(subExpr) { }
-
-  SourceLoc getLoc() const { return SubExpr->getLoc(); }
-  SourceRange getSourceRange() const { return SubExpr->getSourceRange(); }
-
-  Expr *getSubExpr() const { return SubExpr; }
-  void setSubExpr(Expr *subExpr) { SubExpr = subExpr; }
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::OneWay;
-  }
-};
-
 inline bool Expr::isInfixOperator() const {
   return isa<BinaryExpr>(this) || isa<IfExpr>(this) ||
          isa<AssignExpr>(this) || isa<ExplicitCastExpr>(this);

branches/tensorflow/include/swift/AST/ExprNodes.def

@@ -191,7 +191,6 @@ EXPR(EditorPlaceholder, Expr)
 EXPR(ObjCSelector, Expr)
 EXPR(KeyPath, Expr)
 UNCHECKED_EXPR(KeyPathDot, Expr)
-UNCHECKED_EXPR(OneWay, Expr)
 EXPR(Tap, Expr)
 LAST_EXPR(Tap)
 

branches/tensorflow/include/swift/Basic/LangOptions.h

@@ -115,9 +115,6 @@ namespace swift {
     /// Only used by lldb-moduleimport-test.
     bool EnableMemoryBufferImporter = false;
 
-    /// Enable the DWARFImporter. Only used by lldb-moduleimport-test.
-    bool EnableDWARFImporter = false;
-    
     /// Allows using identifiers with a leading dollar.
     bool EnableDollarIdentifiers = false;
 
@@ -215,9 +212,6 @@ namespace swift {
     /// before termination of the shrink phrase of the constraint solver.
     unsigned SolverShrinkUnsolvedThreshold = 10;
 
-    /// Enable one-way constraints in function builders.
-    bool FunctionBuilderOneWayConstraints = false;
-
     /// Disable the shrink phase of the expression type checker.
     bool SolverDisableShrink = false;
 
@@ -271,9 +265,6 @@ namespace swift {
     /// whether it is. The warning is useful for testing.
     bool WarnIfASTScopeLookup = false;
 
-    /// Build the ASTScope tree lazily
-    bool LazyASTScopes = false;
-
     /// Whether to use the import as member inference system
     ///
     /// When importing a global, try to infer whether we can import it as a

branches/tensorflow/include/swift/ClangImporter/ClangImporter.h

@@ -60,11 +60,28 @@ class TypeDecl;
 class VisibleDeclConsumer;
 enum class SelectorSplitKind;
 
+/// This interface is implemented by LLDB to serve as a fallback when Clang
+/// modules can't be imported from source in the debugger.
+///
+/// During compile time, ClangImporter-imported Clang modules are compiled with
+/// -gmodules, which emits a DWARF rendition of all types defined in the module
+/// into the .pcm file. On Darwin, these types can be collected by
+/// dsymutil. This delegate allows DWARFImporter to ask LLDB to look up a Clang
+/// type by name, synthesize a Clang AST from it. DWARFImporter then hands this
+/// Clang AST to ClangImporter to import the type into Swift.
+class DWARFImporterDelegate {
+public:
+  virtual ~DWARFImporterDelegate() {}
+  /// Perform a qualified lookup of a Clang type with this name.
+  /// \param kind  Only return results with this type kind.
+  virtual void lookupValue(StringRef name, llvm::Optional<ClangTypeKind> kind,
+                           SmallVectorImpl<clang::Decl *> &results) {}
+};
+
 /// Class that imports Clang modules into Swift, mapping directly
 /// from Clang ASTs over to Swift ASTs.
 class ClangImporter final : public ClangModuleLoader {
   friend class ClangModuleUnit;
-  friend class DWARFImporter;
 
 public:
   class Implementation;
@@ -73,8 +90,11 @@ class ClangImporter final : public ClangModuleLoader {
   Implementation &Impl;
 
   ClangImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
-                DependencyTracker *tracker);
+                DependencyTracker *tracker,
+                std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate);
 
+  ModuleDecl *loadModuleClang(SourceLoc importLoc,
+                              ArrayRef<std::pair<Identifier, SourceLoc>> path);
 public:
   /// Create a new Clang importer that can import a suitable Clang
   /// module into the given ASTContext.
@@ -89,13 +109,15 @@ class ClangImporter final : public ClangModuleLoader {
   ///
   /// \param tracker The object tracking files this compilation depends on.
   ///
+  /// \param dwarfImporterDelegate A helper object that can synthesize
+  /// Clang Decls from debug info. Used by LLDB.
+  ///
   /// \returns a new Clang module importer, or null (with a diagnostic) if
   /// an error occurred.
   static std::unique_ptr<ClangImporter>
-  create(ASTContext &ctx,
-         const ClangImporterOptions &importerOpts,
-         std::string swiftPCHHash = "",
-         DependencyTracker *tracker = nullptr);
+  create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
+         std::string swiftPCHHash = "", DependencyTracker *tracker = nullptr,
+         std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate = {});
 
   ClangImporter(const ClangImporter &) = delete;
   ClangImporter(ClangImporter &&) = delete;
@@ -150,15 +172,15 @@ class ClangImporter final : public ClangModuleLoader {
   /// Look for declarations associated with the given name.
   ///
   /// \param name The name we're searching for.
-  void lookupValue(DeclName name, VisibleDeclConsumer &consumer) override;
+  void lookupValue(DeclName name, VisibleDeclConsumer &consumer);
 
   /// Look up a type declaration by its Clang name.
   ///
   /// Note that this method does no filtering. If it finds the type in a loaded
   /// module, it returns it. This is intended for use in reflection / debugging
   /// contexts where access is not a problem.
   void lookupTypeDecl(StringRef clangName, ClangTypeKind kind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) override;
+                      llvm::function_ref<void(TypeDecl *)> receiver);
 
   /// Look up type a declaration synthesized by the Clang importer itself, using
   /// a "related entity kind" to determine which type it should be. For example,
@@ -171,7 +193,7 @@ class ClangImporter final : public ClangModuleLoader {
   void
   lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
                       StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) override;
+                      llvm::function_ref<void(TypeDecl *)> receiver);
 
   /// Look for textually included declarations from the bridging header.
   ///