---

yaml
---
r: 326558
b: refs/heads/tensorflow
c: c3b98ef
h: refs/heads/master

Author: gottesmm

[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: ab3db3e37a4a66759c56548440305d74ee74dc7e
+refs/heads/tensorflow: c3b98ef63ed2ba9de96a3b5631dfbfa06a170689
 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/ASTContext.h

@@ -829,10 +829,6 @@ class ASTContext final {
   /// \param IDC The context whose member decls should be lazily parsed.
   void parseMembers(IterableDeclContext *IDC);
 
-  /// Use the lazy parsers associated with the context to check whether the decl
-  /// context has been parsed.
-  bool hasUnparsedMembers(const IterableDeclContext *IDC) const;
-
   /// Get the lazy function data for the given generic context.
   ///
   /// \param lazyLoader If non-null, the lazy loader to use when creating the

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

@@ -177,8 +177,10 @@ class ASTScopeImpl {
   void addChild(ASTScopeImpl *child, ASTContext &);
   std::vector<ASTScopeImpl *> rescueYoungestChildren(unsigned count);
 
-  virtual std::vector<ASTScopeImpl *> rescueScopesToReuse();
-  virtual void addReusedScopes(ArrayRef<ASTScopeImpl *>);
+  /// When reexpanding, do we always create a new body?
+  virtual NullablePtr<ASTScopeImpl> getParentOfRescuedScopes();
+  std::vector<ASTScopeImpl *> rescueScopesToReuse();
+  void addReusedScopes(ArrayRef<ASTScopeImpl *>);
 
 private:
   void removeChildren();
@@ -201,7 +203,8 @@ 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;
@@ -303,6 +306,12 @@ 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
@@ -548,6 +557,10 @@ 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
@@ -623,6 +636,10 @@ 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
@@ -702,7 +719,6 @@ 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:
@@ -721,6 +737,8 @@ class IterableTypeScope : public GenericTypeScope {
 public:
   void makeBodyCurrent();
   bool isBodyCurrent() const;
+  NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion() override;
+  SourceRange sourceRangeForDeferredExpansion() const override;
 };
 
 class NominalTypeScope final : public IterableTypeScope {
@@ -958,8 +976,7 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   static bool isAMethod(const AbstractFunctionDecl *);
 
-  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
@@ -1122,7 +1139,6 @@ 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:
@@ -1372,8 +1388,7 @@ class TopLevelCodeScope final : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   NullablePtr<const void> getReferrent() const override;
 
-  std::vector<ASTScopeImpl *> rescueScopesToReuse() override;
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>) override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 };
 
 /// The \c _@specialize attribute.

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

@@ -14,7 +14,6 @@
 #define SWIFT_AST_CLANG_MODULE_LOADER_H
 
 #include "swift/AST/ModuleLoader.h"
-#include "swift/Demangling/Demangle.h"
 
 namespace clang {
 class ASTContext;
@@ -28,11 +27,24 @@ namespace swift {
 class DeclContext;
 class VisibleDeclConsumer;
 
+/// Represents the different namespaces for types in C.
+///
+/// A simplified version of clang::Sema::LookupKind.
+enum class ClangTypeKind {
+  Typedef,
+  ObjCClass = Typedef,
+  /// Structs, enums, and unions.
+  Tag,
+  ObjCProtocol,
+};
+
 class ClangModuleLoader : public ModuleLoader {
 private:
   virtual void anchor();
+
 protected:
   using ModuleLoader::ModuleLoader;
+
 public:
   virtual clang::ASTContext &getClangASTContext() const = 0;
   virtual clang::Preprocessor &getClangPreprocessor() const = 0;
@@ -56,37 +68,11 @@ class ClangModuleLoader : public ModuleLoader {
   ///
   /// This routine is used for various hacks that are only permitted within
   /// overlays of imported modules, e.g., Objective-C bridging conformances.
-  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, Demangle::Node::Kind 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, StringRef relatedEntityKind,
-                      llvm::function_ref<void(TypeDecl *)> receiver) {}
+  virtual bool
+  isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
+                                     const DeclContext *importedDC) = 0;
 };
 
 } // namespace swift
 
 #endif // LLVM_SWIFT_AST_CLANG_MODULE_LOADER_H
-

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

@@ -1523,6 +1523,17 @@ 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/DeclContext.h

@@ -459,6 +459,10 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// are used.
   ResilienceExpansion getResilienceExpansion() const;
 
+  /// Returns true if this context may possibly contain members visible to
+  /// AnyObject dynamic lookup.
+  bool mayContainMembersAccessedByDynamicLookup() const;
+
   /// Returns true if lookups within this context could affect downstream files.
   ///
   /// \param functionsAreNonCascading If true, functions are considered non-
@@ -697,7 +701,18 @@ class IterableDeclContext {
   /// detect when a member has been added. A bit would suffice,
   /// but would be more fragile, The scope code could count the members each
   /// time, but I think it's a better trade to just keep a count here.
-  unsigned memberCount = 0;
+  unsigned MemberCount : 29;
+
+  /// Whether parsing the members of this context has been delayed.
+  unsigned HasUnparsedMembers : 1;
+
+  /// Whether delayed parsing detected a possible operator definition
+  /// while skipping the body of this context.
+  unsigned HasOperatorDeclarations : 1;
+
+  /// Whether delayed parsing detect a possible nested class definition
+  /// while skipping the body of this context.
+  unsigned HasNestedClassDeclarations : 1;
 
   template<class A, class B, class C>
   friend struct ::llvm::cast_convert_val;
@@ -709,13 +724,44 @@ class IterableDeclContext {
 
 public:
   IterableDeclContext(IterableDeclContextKind kind)
-    : LastDeclAndKind(nullptr, kind) { }
+    : LastDeclAndKind(nullptr, kind) {
+    MemberCount = 0;
+    HasOperatorDeclarations = 0;
+    HasUnparsedMembers = 0;
+    HasNestedClassDeclarations = 0;
+  }
 
   /// Determine the kind of iterable context we have.
   IterableDeclContextKind getIterableContextKind() const {
     return LastDeclAndKind.getInt();
   }
 
+  bool hasUnparsedMembers() const {
+    return HasUnparsedMembers;
+  }
+
+  void setHasUnparsedMembers() {
+    HasUnparsedMembers = 1;
+  }
+
+  bool maybeHasOperatorDeclarations() const {
+    return HasOperatorDeclarations;
+  }
+
+  void setMaybeHasOperatorDeclarations() {
+    assert(hasUnparsedMembers());
+    HasOperatorDeclarations = 1;
+  }
+
+  bool maybeHasNestedClassDeclarations() const {
+    return HasNestedClassDeclarations;
+  }
+
+  void setMaybeHasNestedClassDeclarations() {
+    assert(hasUnparsedMembers());
+    HasNestedClassDeclarations = 1;
+  }
+
   /// Retrieve the set of members in this context.
   DeclRange getMembers() const;
 
@@ -728,8 +774,8 @@ class IterableDeclContext {
   /// is inserted immediately after the hint.
   void addMember(Decl *member, Decl *hint = nullptr);
 
-  /// See \c memberCount
-  unsigned getMemberCount() const { return memberCount; }
+  /// See \c MemberCount
+  unsigned getMemberCount() const { return MemberCount; }
 
   /// Check whether there are lazily-loaded members.
   bool hasLazyMembers() const {

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

@@ -163,7 +163,7 @@ ERROR(lex_illegal_multiline_string_end,none,
       "multi-line string literal closing delimiter must begin on a new line", ())
 ERROR(lex_multiline_string_indent_inconsistent,none,
       "%select{unexpected space in|unexpected tab in|insufficient}2 indentation of "
-      "%select{line|next %1 lines}0 in multi-line string literal", 
+      "%select{line|next %1 lines}0 in multi-line string literal",
       (bool, unsigned, unsigned))
 NOTE(lex_multiline_string_indent_should_match_here,none,
       "should match %select{space|tab}0 here", (unsigned))
@@ -252,7 +252,7 @@ ERROR(cskeyword_not_attribute,none,
       "'%0' is a declaration modifier, not an attribute", (StringRef))
 
 ERROR(decl_already_static,none,
-      "%0 specified twice", (StaticSpellingKind))
+      "%0 cannot appear after another 'static' or 'class' keyword", (StaticSpellingKind))
 
 ERROR(enum_case_dot_prefix,none,
       "extraneous '.' in enum 'case' declaration", ())
@@ -881,7 +881,7 @@ WARNING(parameter_extraneous_double_up,none,
         "extraneous duplicate parameter name; %0 already has an argument "
         "label", (Identifier))
 ERROR(parameter_operator_keyword_argument,none,
-      "%select{operator|closure|enum case}0 cannot have keyword arguments", 
+      "%select{operator|closure|enum case}0 cannot have keyword arguments",
       (unsigned))
 
 ERROR(parameter_unnamed,none,

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

@@ -5321,6 +5321,33 @@ 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,6 +191,7 @@ EXPR(EditorPlaceholder, Expr)
 EXPR(ObjCSelector, Expr)
 EXPR(KeyPath, Expr)
 UNCHECKED_EXPR(KeyPathDot, Expr)
+UNCHECKED_EXPR(OneWay, Expr)
 EXPR(Tap, Expr)
 LAST_EXPR(Tap)