---

yaml
---
r: 275453
b: refs/heads/master-next
c: 68cb52a
h: refs/heads/master
i:
  275451: 08468a6

Author: compnerd

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 65b3164726f2e62dff31e90a5cb5e3fb67cc82bf
-refs/heads/master-next: 52054d2443f844cdbe99799b9353b9afd45ec873
+refs/heads/master-next: 68cb52a35161f97604577d39f6f2dc2b190c38cd
 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,6 +6,7 @@ CHANGELOG
 
 | Contents               |
 | :--------------------- |
+| [Swift 5.1](#swift-51) |
 | [Swift 5.0](#swift-50) |
 | [Swift 4.2](#swift-42) |
 | [Swift 4.1](#swift-41) |
@@ -29,11 +30,13 @@ 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
-```
+  ```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 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"
-    FALSE)
+    "Enable the Swift stable ABI's class marker bit for new deployment targets"
+    TRUE)
 
 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,6 +1209,15 @@ 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,6 +1192,31 @@ 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,6 +78,14 @@ 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.
-///
-/// 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);
+std::string mangleNode(NodePointer root);
 
 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.
 ///
-/// 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);
+/// 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);
 
 /// Remangle in the old mangling scheme.
 ///

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

@@ -279,7 +279,11 @@ template<typename T> class Vector {
     Capacity = 0;
     Elems = 0;
   }
-  
+
+  void clear() {
+    NumElems = 0;
+  }
+
   iterator begin() { return Elems; }
   iterator end() { return Elems + NumElems; }
 
@@ -299,6 +303,11 @@ 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);
@@ -327,6 +336,9 @@ 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.SubstWordsInIdent.push_back({wordStartPos, WordIdx});
+        M.addSubstWordsInIdent({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.Words.push_back({wordStartPos, wordLen});
+        M.addWord({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.SubstWordsInIdent.push_back({ident.size(), -1});
+  M.addSubstWordsInIdent({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();
 
-      std::vector<BuiltType> args;
+      SmallVector<BuiltType, 8> args;
 
       const auto &genericArgs = Node->getChild(1);
       assert(genericArgs->getKind() == NodeKind::TypeList);
@@ -427,7 +427,7 @@ class TypeDecoder {
         return BuiltType();
 
       // Find the protocol list.
-      std::vector<BuiltProtocolDecl> Protocols;
+      SmallVector<BuiltProtocolDecl, 8> 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;
-      std::vector<FunctionParam<BuiltType>> parameters;
+      SmallVector<FunctionParam<BuiltType>, 8> 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;
-      std::vector<ImplFunctionParam<BuiltType>> parameters;
-      std::vector<ImplFunctionResult<BuiltType>> results;
-      std::vector<ImplFunctionResult<BuiltType>> errorResults;
+      SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
+      SmallVector<ImplFunctionResult<BuiltType>, 8> results;
+      SmallVector<ImplFunctionResult<BuiltType>, 8> 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: {
-      std::vector<BuiltType> elements;
+      SmallVector<BuiltType, 8> 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,
-                              std::vector<T> &results) {
+                              SmallVectorImpl<T> &results) {
     if (node->getNumChildren() != 2)
       return true;
 
@@ -871,7 +871,7 @@ class TypeDecoder {
 
   bool decodeMangledFunctionInputType(
       Demangle::NodePointer node,
-      std::vector<FunctionParam<BuiltType>> &params,
+      SmallVectorImpl<FunctionParam<BuiltType>> &params,
       bool &hasParamFlags) {
     // Look through a couple of sugar nodes.
     if (node->getKind() == NodeKind::Type ||

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, &Dem);
+    return Demangle::mangleNode(node);
   }
 
   BuiltProtocolDecl
   createProtocolDecl(Node *node) {
-    return std::make_pair(Demangle::mangleNode(node, &Dem), false);
+    return std::make_pair(Demangle::mangleNode(node), false);
   }
 
   BuiltProtocolDecl
@@ -274,21 +274,21 @@ class TypeRefBuilder {
 
   const BoundGenericTypeRef *
   createBoundGenericType(const Optional<std::string> &mangledName,
-                         const std::vector<const TypeRef *> &args,
+                         ArrayRef<const TypeRef *> args,
                          const TypeRef *parent) {
     return BoundGenericTypeRef::create(*this, *mangledName, args, parent);
   }
 
   const TupleTypeRef *
-  createTupleType(const std::vector<const TypeRef *> &elements,
+  createTupleType(ArrayRef<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(
-      const std::vector<remote::FunctionParam<const TypeRef *>> &params,
+      ArrayRef<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,
-                                  std::vector<const TypeRef *> &args) {
+                                  ArrayRef<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

@@ -0,0 +1,45 @@
+//===--- BackDeployment.h - Support for running on older OS versions. -----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_BACKDEPLOYMENT_H
+#define SWIFT_STDLIB_BACKDEPLOYMENT_H
+
+#if defined(__APPLE__) && defined(__MACH__)
+
+#include "swift/Runtime/Config.h"
+#include "../../../stdlib/public/SwiftShims/Visibility.h"
+
+#ifdef __cplusplus
+namespace swift { extern "C" {
+#endif
+
+#if SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE
+# ifndef __cplusplus
+// This file gets included from some C/ObjC files and
+// SWIFT_RUNTIME_STDLIB_SPI doesn't imply extern in C.
+extern
+# endif
+SWIFT_RUNTIME_STDLIB_SPI unsigned long long _swift_classIsSwiftMask;
+#endif
+
+/// Returns true if the current OS version, at runtime, is a back-deployment
+/// version.
+SWIFT_RUNTIME_STDLIB_INTERNAL
+int _swift_isBackDeploying();
+
+#ifdef __cplusplus
+}} // extern "C", namespace swift
+#endif
+
+#endif // defined(__APPLE__) && defined(__MACH__)
+
+#endif // SWIFT_STDLIB_BACKDEPLOYMENT_H

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

@@ -5,5 +5,7 @@
 #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/CMakeLists.txt

@@ -1,2 +1,13 @@
+# 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)