---

yaml
---
r: 275452
b: refs/heads/master-next
c: 52054d2
h: refs/heads/master

Author: compnerd

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 65b3164726f2e62dff31e90a5cb5e3fb67cc82bf
-refs/heads/master-next: 3ec4b4e0f9ee04ea597afa0e46565c3ba91ba3d4
+refs/heads/master-next: 52054d2443f844cdbe99799b9353b9afd45ec873
 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/CHANGELOG.md

@@ -6,7 +6,6 @@ CHANGELOG
 
 | Contents               |
 | :--------------------- |
-| [Swift 5.1](#swift-51) |
 | [Swift 5.0](#swift-50) |
 | [Swift 4.2](#swift-42) |
 | [Swift 4.1](#swift-41) |
@@ -30,13 +29,11 @@ Swift 5.1
 * Single-parameter functions accepting values of type `Any` are no
   longer preferred over other functions.
 
-  ```swift
-  func foo(_: Any) { print("Any") }
-  func foo<T>(_: T) { print("T") }
-  foo(0) // prints "Any" in Swift < 5.1, "T" in Swift 5.1
-  ```
-
-**Add new entries to the top of this section, not here!**
+```swift
+func foo(_: Any) { print("Any") }
+func foo<T>(_: T) { print("T") }
+foo(0) // prints "Any" in Swift < 5.1, "T" in Swift 5.1
+```
 
 Swift 5.0
 ---------

branches/master-next/CMakeLists.txt

@@ -235,8 +235,8 @@ option(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT
     FALSE)
 
 option(SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT
-    "Enable the Swift stable ABI's class marker bit for new deployment targets"
-    TRUE)
+    "Enable the Swift stable ABI's class marker bit"
+    FALSE)
 
 set(SWIFT_DARWIN_XCRUN_TOOLCHAIN "XcodeDefault" CACHE STRING
     "The name of the toolchain to pass to 'xcrun'")

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

@@ -1209,15 +1209,6 @@ function(_add_swift_library_single target name)
     "${SWIFTLIB_SINGLE_FORCE_BUILD_OPTIMIZED_keyword}"
     RESULT_VAR_NAME c_compile_flags
     )
-
-  if(SWIFTLIB_IS_STDLIB)
-    # We don't ever want to link against the ABI-breakage checking symbols
-    # in the standard library, runtime, or overlays because they only rely
-    # on the header parts of LLVM's ADT.
-    list(APPEND c_compile_flags
-      "-DLLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1")
-  endif()
-
   if(SWIFTLIB_SINGLE_SDK STREQUAL WINDOWS)
     if(libkind STREQUAL SHARED)
       list(APPEND c_compile_flags -D_WINDLL)

branches/master-next/include/swift/ABI/Metadata.h

@@ -1192,31 +1192,6 @@ struct TargetClassMetadata : public TargetAnyClassMetadata<Runtime> {
     return bounds;
   }
 
-  /// Given a statically-emitted metadata template, this sets the correct
-  /// "is Swift" bit for the current runtime. Depending on the deployment
-  /// target a binary was compiled for, statically emitted metadata templates
-  /// may have a different bit set from the one that this runtime canonically
-  /// considers the "is Swift" bit.
-  void setAsTypeMetadata() {
-    // If the wrong "is Swift" bit is set, set the correct one.
-    //
-    // Note that the only time we should see the "new" bit set while
-    // expecting the "old" one is when running a binary built for a
-    // new OS on an old OS, which is not supported, however we do
-    // have tests that exercise this scenario.
-    auto otherSwiftBit = (3ULL - SWIFT_CLASS_IS_SWIFT_MASK);
-    assert(otherSwiftBit == 1ULL || otherSwiftBit == 2ULL);
-
-    if ((this->Data & 3) == otherSwiftBit) {
-      this->Data ^= 3;
-    }
-
-    // Otherwise there should be nothing to do, since only the old "is
-    // Swift" bit is used for backward-deployed runtimes.
-    
-    assert(isTypeMetadata());
-  }
-
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Class;
   }

branches/master-next/include/swift/Basic/Mangler.h

@@ -78,14 +78,6 @@ class Mangler {
     }
   };
 
-  void addSubstWordsInIdent(const WordReplacement &repl) {
-    SubstWordsInIdent.push_back(repl);
-  }
-
-  void addWord(const SubstitutionWord &word) {
-    Words.push_back(word);
-  }
-
   /// Returns the buffer as a StringRef, needed by mangleIdentifier().
   StringRef getBufferStr() const {
     return StringRef(Storage.data(), Storage.size());

branches/master-next/include/swift/Demangling/Demangle.h

@@ -490,23 +490,23 @@ void mangleIdentifier(const char *data, size_t length,
                       bool usePunycode = true);
 
 /// Remangle a demangled parse tree.
-std::string mangleNode(NodePointer root);
+///
+/// If \p BorrowFrom is specified, the initial bump pointer memory is
+/// borrowed from the free memory of BorrowFrom.
+std::string mangleNode(NodePointer root,
+                       NodeFactory *BorrowFrom = nullptr);
 
 using SymbolicResolver =
   llvm::function_ref<Demangle::NodePointer (SymbolicReferenceKind,
                                             const void *)>;
 
-/// Remangle a demangled parse tree, using a callback to resolve
-/// symbolic references.
-std::string mangleNode(NodePointer root, SymbolicResolver resolver);
-
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
 ///
-/// The returned string is owned by \p Factory. This means \p Factory must stay
-/// alive as long as the returned string is used.
-llvm::StringRef mangleNode(NodePointer root, SymbolicResolver resolver,
-                           NodeFactory &Factory);
+/// If \p BorrowFrom is specified, the initial bump pointer memory is
+/// borrowed from the free memory of BorrowFrom.
+std::string mangleNode(NodePointer root, SymbolicResolver resolver,
+                       NodeFactory *BorrowFrom = nullptr);
 
 /// Remangle in the old mangling scheme.
 ///

branches/master-next/include/swift/Demangling/Demangler.h

@@ -279,11 +279,7 @@ template<typename T> class Vector {
     Capacity = 0;
     Elems = 0;
   }
-
-  void clear() {
-    NumElems = 0;
-  }
-
+  
   iterator begin() { return Elems; }
   iterator end() { return Elems + NumElems; }
 
@@ -303,11 +299,6 @@ template<typename T> class Vector {
 
   T &back() { return (*this)[NumElems - 1]; }
 
-  void resetSize(size_t toPos) {
-    assert(toPos <= NumElems);
-    NumElems = toPos;
-  }
-
   void push_back(const T &NewElem, NodeFactory &Factory) {
     if (NumElems >= Capacity)
       Factory.Reallocate(Elems, Capacity, /*Growth*/ 1);
@@ -336,9 +327,6 @@ class CharVector : public Vector<char> {
   // Append an integer as readable number.
   void append(int Number, NodeFactory &Factory);
 
-  // Append an unsigned 64 bit integer as readable number.
-  void append(unsigned long long Number, NodeFactory &Factory);
-
   StringRef str() const {
     return StringRef(Elems, NumElems);
   }

branches/master-next/include/swift/Demangling/ManglingUtils.h

@@ -160,13 +160,13 @@ void mangleIdentifier(Mangler &M, StringRef ident) {
       if (WordIdx >= 0) {
         // We found a word substitution!
         assert(WordIdx < 26);
-        M.addSubstWordsInIdent({wordStartPos, WordIdx});
+        M.SubstWordsInIdent.push_back({wordStartPos, WordIdx});
       } else if (wordLen >= 2 && M.Words.size() < M.MaxNumWords) {
         // It's a new word: remember it.
         // Note: at this time the word's start position is relative to the
         // begin of the identifier. We must update it afterwards so that it is
         // relative to the begin of the whole mangled Buffer.
-        M.addWord({wordStartPos, wordLen});
+        M.Words.push_back({wordStartPos, wordLen});
       }
       wordStartPos = NotInsideWord;
     }
@@ -181,7 +181,7 @@ void mangleIdentifier(Mangler &M, StringRef ident) {
 
   size_t Pos = 0;
   // Add a dummy-word at the end of the list.
-  M.addSubstWordsInIdent({ident.size(), -1});
+  M.SubstWordsInIdent.push_back({ident.size(), -1});
 
   // Mangle a sequence of word substitutions and sub-strings.
   for (size_t Idx = 0, End = M.SubstWordsInIdent.size(); Idx < End; ++Idx) {

branches/master-next/include/swift/Demangling/TypeDecoder.h

@@ -315,7 +315,7 @@ class TypeDecoder {
       if (Node->getNumChildren() < 2)
         return BuiltType();
 
-      SmallVector<BuiltType, 8> args;
+      std::vector<BuiltType> args;
 
       const auto &genericArgs = Node->getChild(1);
       assert(genericArgs->getKind() == NodeKind::TypeList);
@@ -427,7 +427,7 @@ class TypeDecoder {
         return BuiltType();
 
       // Find the protocol list.
-      SmallVector<BuiltProtocolDecl, 8> Protocols;
+      std::vector<BuiltProtocolDecl> Protocols;
       auto TypeList = Node->getChild(0);
       if (TypeList->getKind() == NodeKind::ProtocolList &&
           TypeList->getNumChildren() >= 1) {
@@ -514,7 +514,7 @@ class TypeDecoder {
         return BuiltType();
 
       bool hasParamFlags = false;
-      SmallVector<FunctionParam<BuiltType>, 8> parameters;
+      std::vector<FunctionParam<BuiltType>> parameters;
       if (!decodeMangledFunctionInputType(Node->getChild(isThrow ? 1 : 0),
                                           parameters, hasParamFlags))
         return BuiltType();
@@ -531,9 +531,9 @@ class TypeDecoder {
     }
     case NodeKind::ImplFunctionType: {
       auto calleeConvention = ImplParameterConvention::Direct_Unowned;
-      SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
-      SmallVector<ImplFunctionResult<BuiltType>, 8> results;
-      SmallVector<ImplFunctionResult<BuiltType>, 8> errorResults;
+      std::vector<ImplFunctionParam<BuiltType>> parameters;
+      std::vector<ImplFunctionResult<BuiltType>> results;
+      std::vector<ImplFunctionResult<BuiltType>> errorResults;
       ImplFunctionTypeFlags flags;
 
       for (unsigned i = 0; i < Node->getNumChildren(); i++) {
@@ -611,7 +611,7 @@ class TypeDecoder {
       return decodeMangledType(Node->getChild(0));
 
     case NodeKind::Tuple: {
-      SmallVector<BuiltType, 8> elements;
+      std::vector<BuiltType> elements;
       std::string labels;
       bool variadic = false;
       for (auto &element : *Node) {
@@ -785,7 +785,7 @@ class TypeDecoder {
 private:
   template <typename T>
   bool decodeImplFunctionPart(Demangle::NodePointer node,
-                              SmallVectorImpl<T> &results) {
+                              std::vector<T> &results) {
     if (node->getNumChildren() != 2)
       return true;
 
@@ -871,7 +871,7 @@ class TypeDecoder {
 
   bool decodeMangledFunctionInputType(
       Demangle::NodePointer node,
-      SmallVectorImpl<FunctionParam<BuiltType>> &params,
+      std::vector<FunctionParam<BuiltType>> &params,
       bool &hasParamFlags) {
     // Look through a couple of sugar nodes.
     if (node->getKind() == NodeKind::Type ||

branches/master-next/include/swift/LLVMPasses/Passes.h

@@ -30,7 +30,7 @@ namespace swift {
                     const llvm::PreservedAnalyses &) { return false; }
 
     using AAResultBase::getModRefInfo;
-    llvm::ModRefInfo getModRefInfo(const llvm::CallBase *Call,
+    llvm::ModRefInfo getModRefInfo(llvm::ImmutableCallSite CS,
                                    const llvm::MemoryLocation &Loc);
   };
 

branches/master-next/include/swift/Reflection/TypeRefBuilder.h

@@ -210,12 +210,12 @@ class TypeRefBuilder {
 
   Optional<std::string>
   createTypeDecl(Node *node, bool &typeAlias) {
-    return Demangle::mangleNode(node);
+    return Demangle::mangleNode(node, &Dem);
   }
 
   BuiltProtocolDecl
   createProtocolDecl(Node *node) {
-    return std::make_pair(Demangle::mangleNode(node), false);
+    return std::make_pair(Demangle::mangleNode(node, &Dem), false);
   }
 
   BuiltProtocolDecl
@@ -274,21 +274,21 @@ class TypeRefBuilder {
 
   const BoundGenericTypeRef *
   createBoundGenericType(const Optional<std::string> &mangledName,
-                         ArrayRef<const TypeRef *> args,
+                         const std::vector<const TypeRef *> &args,
                          const TypeRef *parent) {
     return BoundGenericTypeRef::create(*this, *mangledName, args, parent);
   }
 
   const TupleTypeRef *
-  createTupleType(ArrayRef<const TypeRef *> elements,
+  createTupleType(const std::vector<const TypeRef *> &elements,
                   std::string &&labels, bool isVariadic) {
     // FIXME: Add uniqueness checks in TupleTypeRef::Profile and
     // unittests/Reflection/TypeRef.cpp if using labels for identity.
     return TupleTypeRef::create(*this, elements, isVariadic);
   }
 
   const FunctionTypeRef *createFunctionType(
-      ArrayRef<remote::FunctionParam<const TypeRef *>> params,
+      const std::vector<remote::FunctionParam<const TypeRef *>> &params,
       const TypeRef *result, FunctionTypeFlags flags) {
     return FunctionTypeRef::create(*this, params, result, flags);
   }
@@ -406,7 +406,7 @@ class TypeRefBuilder {
 
   const ObjCClassTypeRef *
   createBoundGenericObjCClassType(const std::string &name,
-                                  ArrayRef<const TypeRef *> args) {
+                                  std::vector<const TypeRef *> &args) {
     // Remote reflection just ignores generic arguments for Objective-C
     // lightweight generic types, since they don't affect layout.
     return createObjCClassType(name);

branches/master-next/include/swift/Runtime/BackDeployment.h

@@ -5,7 +5,5 @@
 #define SWIFT_RUNTIME_CMAKECONFIG_H
 
 #cmakedefine01 SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT
-#cmakedefine01 SWIFT_BNI_OS_BUILD
-#cmakedefine01 SWIFT_BNI_XCODE_BUILD
 
 #endif

branches/master-next/include/swift/Runtime/CMakeConfig.h.in

@@ -1,13 +1,2 @@
-# Detect B&I builds.
-set(SWIFT_BNI_OS_BUILD FALSE)
-set(SWIFT_BNI_XCODE_BUILD FALSE)
-if(DEFINED ENV{RC_XBS})
-  if(NOT DEFINED ENV{RC_XCODE} OR NOT "$ENV{RC_XCODE}")
-    set(SWIFT_BNI_OS_BUILD TRUE)
-  else()
-    set(SWIFT_BNI_XCODE_BUILD TRUE)
-  endif()
-endif()
-
 configure_file(CMakeConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/CMakeConfig.h
                ESCAPE_QUOTES @ONLY)