---

yaml
---
r: 326318
b: refs/heads/master-next
c: a42bdf4
h: refs/heads/master

Author: rintaro

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: e052da7d8886fa0439677852e8f7830b20c2e1da
-refs/heads/master-next: a7b4da64479e2653c10918120a239e80433fd471
+refs/heads/master-next: a42bdf4c20eafaaceb65206b984f3497edac7ef5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/cmake/modules/SwiftXcodeSupport.cmake

@@ -100,8 +100,8 @@ macro(swift_common_xcode_cxx_config)
   # Force usage of Clang.
   set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvm.clang.1_0"
       CACHE STRING "Xcode Compiler")
-  # Use C++'14.
-  set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++14"
+  # Use C++'11.
+  set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "c++11"
       CACHE STRING "Xcode C++ Language Standard")
   # Use libc++.
   set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++"

branches/master-next/include/swift/AST/ASTNode.h

@@ -36,10 +36,10 @@ namespace swift {
   enum class DeclKind : uint8_t;
   enum class StmtKind;
 
-  struct ASTNode : public llvm::PointerUnion<Expr*, Stmt*, Decl*> {
+  struct ASTNode : public llvm::PointerUnion3<Expr*, Stmt*, Decl*> {
     // Inherit the constructors from PointerUnion.
-    using PointerUnion::PointerUnion;
-
+    using PointerUnion3::PointerUnion3;
+    
     SourceRange getSourceRange() const;
 
     /// Return the location of the start of the statement.

branches/master-next/include/swift/AST/ASTScope.h

@@ -38,16 +38,6 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 
-/// In case there's a bug in the ASTScope lookup system, suggest that the user
-/// try disabling it.
-/// \p message must be a string literal
-#define ASTScopeAssert(predicate, message)                                     \
-  assert((predicate) && message                                                \
-         " Try compiling with '-disable-astscope-lookup'.")
-
-#define ASTScope_unreachable(message)                                          \
-  llvm_unreachable(message " Try compiling with '-disable-astscope-lookup'.")
-
 namespace swift {
 
 #pragma mark Forward-references
@@ -135,10 +125,10 @@ class ASTScopeImpl {
   /// Must clear source range change whenever this changes
   Children storedChildren;
 
-  bool wasExpanded = false;
-
-  /// For use-before-def, ASTAncestor scopes may be added to a BraceStmt.
-  unsigned astAncestorScopeCount = 0;
+  /// Because expansion returns an insertion point,
+  /// if a scope is reexpanded, the children added NOT by expansion must be
+  /// rescued and reused.
+  unsigned childrenCountWhenLastExpanded = 0;
 
   /// Can clear storedChildren, so must remember this
   bool haveAddedCleanup = false;
@@ -172,7 +162,7 @@ class ASTScopeImpl {
   void *operator new(size_t bytes, const ASTContext &ctx,
                      unsigned alignment = alignof(ASTScopeImpl));
   void *operator new(size_t Bytes, void *Mem) {
-    ASTScopeAssert(Mem, "Allocation failed");
+    assert(Mem);
     return Mem;
   }
 
@@ -190,13 +180,12 @@ class ASTScopeImpl {
 
 public: // for addReusedBodyScopes
   void addChild(ASTScopeImpl *child, ASTContext &);
-  std::vector<ASTScopeImpl *> rescueASTAncestorScopesForReuseFromMe();
+  std::vector<ASTScopeImpl *> rescueYoungestChildren(unsigned count);
 
   /// When reexpanding, do we always create a new body?
-  virtual NullablePtr<ASTScopeImpl> getParentOfASTAncestorScopesToBeRescued();
-  std::vector<ASTScopeImpl *>
-  rescueASTAncestorScopesForReuseFromMeOrDescendants();
-  void replaceASTAncestorScopes(ArrayRef<ASTScopeImpl *>);
+  virtual NullablePtr<ASTScopeImpl> getParentOfRescuedScopes();
+  std::vector<ASTScopeImpl *> rescueScopesToReuse();
+  void addReusedScopes(ArrayRef<ASTScopeImpl *>);
 
 private:
   void removeChildren();
@@ -207,8 +196,6 @@ class ASTScopeImpl {
 
 public:
   void preOrderDo(function_ref<void(ASTScopeImpl *)>);
-  /// Like preorderDo but without myself.
-  void preOrderChildrenDo(function_ref<void(ASTScopeImpl *)>);
   void postOrderDo(function_ref<void(ASTScopeImpl *)>);
 
 #pragma mark - source ranges
@@ -232,12 +219,6 @@ class ASTScopeImpl {
   bool doesRangeMatch(unsigned start, unsigned end, StringRef file = "",
                       StringRef className = "");
 
-  unsigned countDescendants() const;
-
-  /// Make sure that when the argument is executed, there are as many
-  /// descendants after as before.
-  void assertThatTreeDoesNotShrink(function_ref<void()>);
-
 private:
   SourceRange computeSourceRangeOfScope(bool omitAssertions = false) const;
   SourceRange
@@ -272,8 +253,6 @@ class ASTScopeImpl {
   void ensureSourceRangesAreCorrectWhenAddingDescendants(function_ref<void()>);
 
 public: // public for debugging
-  /// Returns source range of this node alone, without factoring in any
-  /// children.
   virtual SourceRange
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const = 0;
 
@@ -335,17 +314,10 @@ class ASTScopeImpl {
   /// Return the scope into which to place subsequent decls
   ASTScopeImpl *expandAndBeCurrent(ScopeCreator &);
 
-  unsigned getASTAncestorScopeCount() const { return astAncestorScopeCount; }
-  bool getWasExpanded() const { return wasExpanded; }
-
 protected:
-  void resetASTAncestorScopeCount() { astAncestorScopeCount = 0; }
-  void increaseASTAncestorScopeCount(unsigned c) { astAncestorScopeCount += c; }
-  void setWasExpanded() { wasExpanded = true; }
   virtual ASTScopeImpl *expandSpecifically(ScopeCreator &) = 0;
   virtual void beCurrent();
-  bool isCurrent() const;
-  virtual bool isCurrentIfWasExpanded() const;
+  virtual bool isCurrent() const;
 
 private:
   /// Compare the pre-expasion range with the post-expansion range and return
@@ -356,8 +328,6 @@ class ASTScopeImpl {
   /// 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.
-  /// After a node is expanded, its source range (getSourceRangeofThisASTNode
-  /// union children's ranges) must be same as this.
   virtual NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion();
   virtual SourceRange sourceRangeForDeferredExpansion() const;
 
@@ -386,6 +356,9 @@ class ASTScopeImpl {
 
   virtual ScopeCreator &getScopeCreator();
 
+protected:
+  void setChildrenCountWhenLastExpanded();
+
 #pragma mark - - creation queries
 public:
   virtual bool isThisAnAbstractStorageDecl() const { return false; }
@@ -533,7 +506,6 @@ class ASTSourceFileScope final : public ASTScopeImpl {
   /// The number of \c Decls in the \c SourceFile that were already seen.
   /// Since parsing can be interleaved with type-checking, on every
   /// lookup, look at creating scopes for any \c Decls beyond this number.
-  /// rdar://55562483 Unify with numberOfChildrenWhenLastExpanded
   int numberOfDeclsAlreadySeen = 0;
 
   ASTSourceFileScope(SourceFile *SF, ScopeCreator *scopeCreator);
@@ -549,9 +521,7 @@ class ASTSourceFileScope final : public ASTScopeImpl {
   NullablePtr<DeclContext> getDeclContext() const override;
 
   void addNewDeclsToScopeTree();
-  void buildFullyExpandedTree();
-  void
-  buildEnoughOfTreeForTopLevelExpressionsButDontRequestGenericsOrExtendedNominals();
+  void buildScopeTreeEagerly();
 
   const SourceFile *getSourceFile() const override;
   NullablePtr<const void> addressForPrinting() const override { return SF; }
@@ -582,7 +552,7 @@ class Portion {
   void *operator new(size_t bytes, const ASTContext &ctx,
                      unsigned alignment = alignof(ASTScopeImpl));
   void *operator new(size_t Bytes, void *Mem) {
-    ASTScopeAssert(Mem, "Allocation failed");
+    assert(Mem);
     return Mem;
   }
 
@@ -605,12 +575,12 @@ class Portion {
   virtual const Decl *
   getReferrentOfScope(const GenericTypeOrExtensionScope *s) const;
 
-  virtual void beCurrent(IterableTypeScope *) const = 0;
-  virtual bool isCurrentIfWasExpanded(const IterableTypeScope *) const = 0;
+  virtual void beCurrent(IterableTypeScope *) const;
+  virtual bool isCurrent(const IterableTypeScope *) const;
   virtual NullablePtr<ASTScopeImpl>
-  insertionPointForDeferredExpansion(IterableTypeScope *) const = 0;
+  insertionPointForDeferredExpansion(IterableTypeScope *) const;
   virtual SourceRange
-  sourceRangeForDeferredExpansion(const IterableTypeScope *) const = 0;
+  sourceRangeForDeferredExpansion(const IterableTypeScope *) const;
   };
 
   // For the whole Decl scope of a GenericType or an Extension
@@ -631,24 +601,6 @@ class Portion {
 
     const Decl *
     getReferrentOfScope(const GenericTypeOrExtensionScope *s) const override;
-
-    /// Make whole portion lazy to avoid circularity in lookup of generic
-    /// parameters of extensions. When \c bindExtension is called, it needs to
-    /// unqualifed-lookup the type being extended. That causes an \c
-    /// ExtensionScope
-    /// (\c GenericTypeOrExtensionWholePortion) to be built.
-    /// The building process needs the generic parameters, but that results in a
-    /// request for the extended nominal type of the \c ExtensionDecl, which is
-    /// an endless recursion. Although we only need to make \c ExtensionScope
-    /// lazy, might as well do it for all \c IterableTypeScopes.
-
-    void beCurrent(IterableTypeScope *) const override;
-    bool isCurrentIfWasExpanded(const IterableTypeScope *) const override;
-
-    NullablePtr<ASTScopeImpl>
-    insertionPointForDeferredExpansion(IterableTypeScope *) const override;
-    SourceRange
-    sourceRangeForDeferredExpansion(const IterableTypeScope *) const override;
   };
 
   /// GenericTypeOrExtension = GenericType or Extension
@@ -687,14 +639,6 @@ class GenericTypeOrExtensionWherePortion final
 
   SourceRange getChildlessSourceRangeOf(const GenericTypeOrExtensionScope *,
                                         bool omitAssertions) const override;
-
-  void beCurrent(IterableTypeScope *) const override;
-  bool isCurrentIfWasExpanded(const IterableTypeScope *) const override;
-
-  NullablePtr<ASTScopeImpl>
-  insertionPointForDeferredExpansion(IterableTypeScope *) const override;
-  SourceRange
-  sourceRangeForDeferredExpansion(const IterableTypeScope *) const override;
 };
 
 /// Behavior specific to representing the Body of a NominalTypeDecl or
@@ -711,7 +655,7 @@ class IterableTypeBodyPortion final
                                         bool omitAssertions) const override;
 
   void beCurrent(IterableTypeScope *) const override;
-  bool isCurrentIfWasExpanded(const IterableTypeScope *) const override;
+  bool isCurrent(const IterableTypeScope *) const override;
   NullablePtr<ASTScopeImpl>
   insertionPointForDeferredExpansion(IterableTypeScope *) const override;
   SourceRange
@@ -750,17 +694,6 @@ class GenericTypeOrExtensionScope : public ASTScopeImpl {
   SourceRange
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
 
-  /// \c tryBindExtension needs to get the extended nominal, and the DeclContext
-  /// is the parent of the \c ExtensionDecl. If the \c SourceRange of an \c
-  /// ExtensionScope were to start where the \c ExtensionDecl says, the lookup
-  /// source locaiton would fall within the \c ExtensionScope. This inclusion
-  /// would cause the lazy \c ExtensionScope to be expanded which would ask for
-  /// its generic parameters in order to create those sub-scopes. That request
-  /// would cause a cycle because it would ask for the extended nominal. So,
-  /// move the source range of an \c ExtensionScope *past* the extended nominal
-  /// type, which is not in-scope there anyway.
-  virtual SourceRange moveStartPastExtendedNominal(SourceRange) const = 0;
-
   virtual GenericContext *getGenericContext() const = 0;
   std::string getClassName() const override;
   virtual std::string declKindName() const = 0;
@@ -799,8 +732,6 @@ class GenericTypeScope : public GenericTypeOrExtensionScope {
 public:
   GenericTypeScope(const Portion *p) : GenericTypeOrExtensionScope(p) {}
   virtual ~GenericTypeScope() {}
-  SourceRange moveStartPastExtendedNominal(SourceRange) const override;
-
 protected:
   NullablePtr<const GenericParamList> genericParams() const override;
 };
@@ -822,11 +753,9 @@ class IterableTypeScope : public GenericTypeScope {
 
 protected:
   void beCurrent() override;
-  bool isCurrentIfWasExpanded() const override;
+  bool isCurrent() const override;
 
 public:
-  void makeWholeCurrent();
-  bool isWholeCurrent() const;
   void makeBodyCurrent();
   bool isBodyCurrent() const;
   NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion() override;
@@ -875,7 +804,6 @@ class ExtensionScope final : public IterableTypeScope {
   NullablePtr<NominalTypeDecl> getCorrespondingNominalTypeDecl() const override;
   std::string declKindName() const override { return "Extension"; }
   SourceRange getBraces() const override;
-  SourceRange moveStartPastExtendedNominal(SourceRange) const override;
   ASTScopeImpl *createTrailingWhereClauseScope(ASTScopeImpl *parent,
                                                ScopeCreator &) override;
   void createBodyScope(ASTScopeImpl *leaf, ScopeCreator &) override;
@@ -1056,7 +984,7 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
   void beCurrent() override;
-  bool isCurrentIfWasExpanded() const override;
+  bool isCurrent() const override;
 
 private:
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
@@ -1072,7 +1000,7 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   static bool isAMethod(const AbstractFunctionDecl *);
 
-  NullablePtr<ASTScopeImpl> getParentOfASTAncestorScopesToBeRescued() override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
@@ -1148,14 +1076,11 @@ class AttachedPropertyWrapperScope final : public ASTScopeImpl {
   /// false positives, that that doesn't hurt anything. However, the result of
   /// the conservative source range computation doesn't seem to be stable. So
   /// keep the original here, and use it for source range queries.
-  /// rdar://55263708
-
   const SourceRange sourceRangeWhenCreated;
 
   AttachedPropertyWrapperScope(VarDecl *e)
       : decl(e), sourceRangeWhenCreated(getSourceRangeOfVarDecl(e)) {
-    ASTScopeAssert(sourceRangeWhenCreated.isValid(),
-                   "VarDecls must have ranges to be looked-up");
+    assert(sourceRangeWhenCreated.isValid());
   }
   virtual ~AttachedPropertyWrapperScope() {}
 
@@ -1232,7 +1157,7 @@ class PatternEntryDeclScope final : public AbstractPatternEntryScope {
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
   void beCurrent() override;
-  bool isCurrentIfWasExpanded() const override;
+  bool isCurrent() const override;
 
 private:
   AnnotatedInsertionPoint
@@ -1406,7 +1331,7 @@ class WholeClosureScope final : public AbstractClosureScope {
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
   void beCurrent() override;
-  bool isCurrentIfWasExpanded() const override;
+  bool isCurrent() const override;
 
 private:
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);
@@ -1477,7 +1402,7 @@ class TopLevelCodeScope final : public ASTScopeImpl {
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
   void beCurrent() override;
-  bool isCurrentIfWasExpanded() const override;
+  bool isCurrent() const override;
 
 private:
   AnnotatedInsertionPoint
@@ -1495,7 +1420,7 @@ class TopLevelCodeScope final : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   NullablePtr<const void> getReferrent() const override;
 
-  NullablePtr<ASTScopeImpl> getParentOfASTAncestorScopesToBeRescued() override;
+  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
 };
 
 /// The \c _@specialize attribute.

branches/master-next/include/swift/AST/Builtins.h

@@ -131,10 +131,7 @@ class IntrinsicInfo {
 
 /// Turn a string like "release" into the LLVM enum.
 llvm::AtomicOrdering decodeLLVMAtomicOrdering(StringRef O);
-
-/// Returns true if the builtin with ID \p ID has a defined static overload for
-/// the type \p Ty.
-bool canBuiltinBeOverloadedForType(BuiltinValueKind ID, Type Ty);
+  
 }
 
 #endif