---

yaml
---
r: 322558
b: refs/heads/tensorflow-next
c: 1332310
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1461,4 +1461,4 @@ refs/heads/master-rebranch: 86e95c23aa0d37f24ec138b7853146c1cead2e40
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec
-refs/heads/tensorflow-next: 116df1cb5fcb51d818edf6fc12eaf111d93e4fa0
+refs/heads/tensorflow-next: 13323102ebd342a71552ec921604e9c35002579e

branches/tensorflow-next/lib/Sema/TypeCheckAccess.cpp

@@ -162,29 +162,30 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
     llvm::function_ref<CheckTypeAccessCallback> diagnose) {
   if (TC.Context.isAccessControlDisabled())
     return;
-  if (!type)
-    return;
   // Don't spend time checking local declarations; this is always valid by the
   // time we get to this point.
   if (!contextAccessScope.isPublic() &&
       contextAccessScope.getDeclContext()->isLocalContext())
     return;
 
-  Optional<AccessScope> typeAccessScope =
-      TypeAccessScopeChecker::getAccessScope(type, useDC,
-                                             checkUsableFromInline);
-  auto downgradeToWarning = DowngradeToWarning::No;
+  AccessScope problematicAccessScope = AccessScope::getPublic();
+  if (type) {
+    Optional<AccessScope> typeAccessScope =
+        TypeAccessScopeChecker::getAccessScope(type, useDC,
+                                               checkUsableFromInline);
 
-  // Note: This means that the type itself is invalid for this particular
-  // context, because it references declarations from two incompatible scopes.
-  // In this case we should have diagnosed the bad reference already.
-  if (!typeAccessScope.hasValue())
-    return;
+    // Note: This means that the type itself is invalid for this particular
+    // context, because it references declarations from two incompatible scopes.
+    // In this case we should have diagnosed the bad reference already.
+    if (!typeAccessScope.hasValue())
+      return;
+    problematicAccessScope = *typeAccessScope;
+  }
 
-  AccessScope problematicAccessScope = *typeAccessScope;
+  auto downgradeToWarning = DowngradeToWarning::No;
 
-  if (contextAccessScope.hasEqualDeclContextWith(*typeAccessScope) ||
-      contextAccessScope.isChildOf(*typeAccessScope)) {
+  if (contextAccessScope.hasEqualDeclContextWith(problematicAccessScope) ||
+      contextAccessScope.isChildOf(problematicAccessScope)) {
 
     // /Also/ check the TypeRepr, if present. This can be important when we're
     // unable to preserve typealias sugar that's present in the TypeRepr.
@@ -194,7 +195,9 @@ void AccessControlCheckerBase::checkTypeAccessImpl(
     Optional<AccessScope> typeReprAccessScope =
         TypeReprAccessScopeChecker::getAccessScope(typeRepr, useDC,
                                                    checkUsableFromInline);
-    assert(typeReprAccessScope && "valid Type but not valid TypeRepr?");
+    if (!typeReprAccessScope.hasValue())
+      return;
+
     if (contextAccessScope.hasEqualDeclContextWith(*typeReprAccessScope) ||
         contextAccessScope.isChildOf(*typeReprAccessScope)) {
       // Only if both the Type and the TypeRepr follow the access rules can
@@ -365,9 +368,16 @@ void AccessControlCheckerBase::checkGenericParamAccess(
   if (minAccessScope.isPublic())
     return;
 
+  // FIXME: Promote these to an error in the next -swift-version break.
+  if (isa<SubscriptDecl>(owner) || isa<TypeAliasDecl>(owner))
+    downgradeToWarning = DowngradeToWarning::Yes;
+
   if (checkUsableFromInline) {
-    auto diagID = diag::generic_param_usable_from_inline;
     if (!TC.Context.isSwiftVersionAtLeast(5))
+      downgradeToWarning = DowngradeToWarning::Yes;
+
+    auto diagID = diag::generic_param_usable_from_inline;
+    if (downgradeToWarning == DowngradeToWarning::Yes)
       diagID = diag::generic_param_usable_from_inline_warn;
     auto diag = TC.diagnose(owner,
                             diagID,
@@ -535,6 +545,8 @@ class AccessControlChecker : public AccessControlCheckerBase,
   }
 
   void visitTypeAliasDecl(TypeAliasDecl *TAD) {
+    checkGenericParamAccess(TAD->getGenericParams(), TAD);
+
     checkTypeAccess(TAD->getUnderlyingTypeLoc(), TAD, /*mayBeInferred*/false,
                     [&](AccessScope typeAccessScope,
                         const TypeRepr *complainRepr,
@@ -802,6 +814,8 @@ class AccessControlChecker : public AccessControlCheckerBase,
   }
 
   void visitSubscriptDecl(SubscriptDecl *SD) {
+    checkGenericParamAccess(SD->getGenericParams(), SD);
+
     auto minAccessScope = AccessScope::getPublic();
     const TypeRepr *complainRepr = nullptr;
     auto downgradeToWarning = DowngradeToWarning::No;
@@ -1119,6 +1133,8 @@ class UsableFromInlineChecker : public AccessControlCheckerBase,
   }
 
   void visitTypeAliasDecl(TypeAliasDecl *TAD) {
+    checkGenericParamAccess(TAD->getGenericParams(), TAD);
+
     checkTypeAccess(TAD->getUnderlyingTypeLoc(), TAD, /*mayBeInferred*/false,
                     [&](AccessScope typeAccessScope,
                         const TypeRepr *complainRepr,
@@ -1294,6 +1310,8 @@ class UsableFromInlineChecker : public AccessControlCheckerBase,
   }
 
   void visitSubscriptDecl(SubscriptDecl *SD) {
+    checkGenericParamAccess(SD->getGenericParams(), SD);
+
     for (auto &P : *SD->getIndices()) {
       checkTypeAccess(P->getTypeLoc(), SD, /*mayBeInferred*/false,
                       [&](AccessScope typeAccessScope,

branches/tensorflow-next/stdlib/public/Darwin/Foundation/NSRange.swift

@@ -175,17 +175,33 @@ extension Range where Bound == Int {
 }
 
 extension Range where Bound == String.Index {
-  public init?(_ range: NSRange, in string: __shared String) {
+  private init?<S: StringProtocol>(
+    _ range: NSRange, _genericIn string: __shared S
+  ) {
+    // Corresponding stdlib version
+    guard #available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *) else {
+      fatalError()
+    }
     let u = string.utf16
     guard range.location != NSNotFound,
-      let start = u.index(u.startIndex, offsetBy: range.location, limitedBy: u.endIndex),
-      let end = u.index(u.startIndex, offsetBy: range.location + range.length, limitedBy: u.endIndex),
+      let start = u.index(
+        u.startIndex, offsetBy: range.location, limitedBy: u.endIndex),
+      let end = u.index(
+        start, offsetBy: range.length, limitedBy: u.endIndex),
       let lowerBound = String.Index(start, within: string),
       let upperBound = String.Index(end, within: string)
     else { return nil }
-    
+
     self = lowerBound..<upperBound
   }
+
+  public init?(_ range: NSRange, in string: __shared String) {
+    self.init(range, _genericIn: string)
+  }
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  public init?<S: StringProtocol>(_ range: NSRange, in string: __shared S) {
+    self.init(range, _genericIn: string)
+  }
 }
 
 extension NSRange : CustomReflectable {

branches/tensorflow-next/stdlib/public/core/ASCII.swift

@@ -23,6 +23,10 @@ extension Unicode.ASCII : Unicode.Encoding {
     return EncodedScalar(0x1a) // U+001A SUBSTITUTE; best we can do for ASCII
   }
 
+  /// Returns whether the given code unit represents an ASCII scalar
+  @_alwaysEmitIntoClient
+  public static func isASCII(_ x: CodeUnit) -> Bool { return UTF8.isASCII(x) }
+
   @inline(__always)
   @inlinable
   public static func _isScalar(_ x: CodeUnit) -> Bool {

branches/tensorflow-next/stdlib/public/core/CMakeLists.txt

@@ -83,6 +83,7 @@ set(SWIFTLIB_ESSENTIAL
   KeyValuePairs.swift
   LazyCollection.swift
   LazySequence.swift
+  LegacyABI.swift
   LifetimeManager.swift
   ManagedBuffer.swift
   Map.swift

branches/tensorflow-next/stdlib/public/core/Character.swift

@@ -88,25 +88,26 @@ extension Character {
 }
 
 extension Character {
-  @usableFromInline
-  typealias UTF8View = String.UTF8View
+  /// A view of a character's contents as a collection of UTF-8 code units. See
+  /// String.UTF8View for more information
+  public typealias UTF8View = String.UTF8View
 
+  /// A UTF-8 encoding of `self`.
   @inlinable
-  internal var utf8: UTF8View {
-    return _str.utf8
-  }
-  @usableFromInline
-  typealias UTF16View = String.UTF16View
+  public var utf8: UTF8View { return _str.utf8 }
+
+  /// A view of a character's contents as a collection of UTF-16 code units. See
+  /// String.UTF16View for more information
+  public typealias UTF16View = String.UTF16View
 
+  /// A UTF-16 encoding of `self`.
   @inlinable
-  internal var utf16: UTF16View {
-    return _str.utf16
-  }
+  public var utf16: UTF16View { return _str.utf16 }
+
   public typealias UnicodeScalarView = String.UnicodeScalarView
+
   @inlinable
-  public var unicodeScalars: UnicodeScalarView {
-    return _str.unicodeScalars
-  }
+  public var unicodeScalars: UnicodeScalarView { return _str.unicodeScalars }
 }
 
 extension Character :

branches/tensorflow-next/stdlib/public/core/GroupInfo.json

@@ -223,6 +223,7 @@
     "Equatable.swift",
     "Comparable.swift",
     "Codable.swift",
+    "LegacyABI.swift",
     "MigrationSupport.swift"
   ],
   "Result": [

branches/tensorflow-next/stdlib/public/core/LegacyABI.swift

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// This file contains non-API (or underscored) declarations that are needed to
+// be kept around for ABI compatibility
+
+extension Unicode.UTF16 {
+  @available(*, unavailable, renamed: "Unicode.UTF16.isASCII")
+  @inlinable
+  public static func _isASCII(_ x: CodeUnit) -> Bool  {
+    return Unicode.UTF16.isASCII(x)
+  }
+}
+
+@available(*, unavailable, renamed: "Unicode.UTF8.isASCII")
+@inlinable
+internal func _isASCII(_ x: UInt8) -> Bool {
+  return Unicode.UTF8.isASCII(x)
+}
+
+@available(*, unavailable, renamed: "Unicode.UTF8.isContinuation")
+@inlinable
+internal func _isContinuation(_ x: UInt8) -> Bool {
+  return UTF8.isContinuation(x)
+}
+
+extension Substring {
+@available(*, unavailable, renamed: "Substring.base")
+  @inlinable
+  internal var _wholeString: String { return base }
+}
+

branches/tensorflow-next/stdlib/public/core/StringComparison.swift

@@ -239,7 +239,7 @@ private func _findBoundary(
   }
 
   // Back up to scalar boundary
-  while _isContinuation(utf8[_unchecked: idx]) {
+  while UTF8.isContinuation(utf8[_unchecked: idx]) {
     idx &-= 1
   }
 

branches/tensorflow-next/stdlib/public/core/StringCreate.swift

@@ -193,8 +193,8 @@ extension String {
   internal static func _fromSubstring(
     _ substring: __shared Substring
   ) -> String {
-    if substring._offsetRange == substring._wholeString._offsetRange {
-      return substring._wholeString
+    if substring._offsetRange == substring.base._offsetRange {
+      return substring.base
     }
 
     return String._copying(substring)

branches/tensorflow-next/stdlib/public/core/StringIndexConversions.swift

@@ -11,6 +11,60 @@
 //===----------------------------------------------------------------------===//
 
 extension String.Index {
+  private init?<S: StringProtocol>(
+    _ idx: String.Index, _genericWithin target: S
+  ) {
+    guard target._wholeGuts.isOnGraphemeClusterBoundary(idx),
+          idx >= target.startIndex && idx <= target.endIndex
+    else {
+      return nil
+    }
+
+    self = idx
+  }
+
+  /// Creates an index in the given string that corresponds exactly to the
+  /// specified position.
+  ///
+  /// If the index passed as `sourcePosition` represents the start of an
+  /// extended grapheme cluster---the element type of a string---then the
+  /// initializer succeeds.
+  ///
+  /// The following example converts the position of the Unicode scalar `"e"`
+  /// into its corresponding position in the string. The character at that
+  /// position is the composed `"é"` character.
+  ///
+  ///     let cafe = "Cafe\u{0301}"
+  ///     print(cafe)
+  ///     // Prints "Café"
+  ///
+  ///     let scalarsIndex = cafe.unicodeScalars.firstIndex(of: "e")!
+  ///     let stringIndex = String.Index(scalarsIndex, within: cafe)!
+  ///
+  ///     print(cafe[...stringIndex])
+  ///     // Prints "Café"
+  ///
+  /// If the index passed as `sourcePosition` doesn't have an exact
+  /// corresponding position in `target`, the result of the initializer is
+  /// `nil`. For example, an attempt to convert the position of the combining
+  /// acute accent (`"\u{0301}"`) fails. Combining Unicode scalars do not have
+  /// their own position in a string.
+  ///
+  ///     let nextScalarsIndex = cafe.unicodeScalars.index(after: scalarsIndex)
+  ///     let nextStringIndex = String.Index(nextScalarsIndex, within: cafe)
+  ///
+  ///     print(nextStringIndex)
+  ///     // Prints "nil"
+  ///
+  /// - Parameters:
+  ///   - sourcePosition: A position in a view of the `target` parameter.
+  ///     `sourcePosition` must be a valid index of at least one of the views
+  ///     of `target`.
+  ///   - target: The string referenced by the resulting index.
+  public init?(_ sourcePosition: String.Index, within target: String) {
+    self.init(sourcePosition, _genericWithin: target)
+  }
+
   /// Creates an index in the given string that corresponds exactly to the
   /// specified position.
   ///
@@ -49,14 +103,11 @@ extension String.Index {
   ///     `sourcePosition` must be a valid index of at least one of the views
   ///     of `target`.
   ///   - target: The string referenced by the resulting index.
-  public init?(
-    _ sourcePosition: String.Index,
-    within target: String
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  public init?<S: StringProtocol>(
+    _ sourcePosition: String.Index, within target: S
   ) {
-    guard target._guts.isOnGraphemeClusterBoundary(sourcePosition) else {
-      return nil
-    }
-    self = sourcePosition
+    self.init(sourcePosition, _genericWithin: target)
   }
 
   /// Returns the position in the given UTF-8 view that corresponds exactly to
@@ -81,7 +132,7 @@ extension String.Index {
   ///   position of a UTF-16 trailing surrogate returns `nil`.
   public func samePosition(
     in utf8: String.UTF8View
-    ) -> String.UTF8View.Index? {
+  ) -> String.UTF8View.Index? {
     return String.UTF8View.Index(self, within: utf8)
   }
 

branches/tensorflow-next/stdlib/public/core/StringNormalization.swift

@@ -108,7 +108,7 @@ extension UnsafeBufferPointer where Element == UInt8 {
     if index == 0 || index == count {
       return true
     }
-    assert(!_isContinuation(self[_unchecked: index]))
+    assert(!UTF8.isContinuation(self[_unchecked: index]))
 
     // Sub-300 latiny fast-path
     if self[_unchecked: index] < 0xCC { return true }
@@ -165,7 +165,7 @@ extension UnsafeBufferPointer where Element == UInt8 {
       _internalInvariant(index == count)
       return true
     }
-    return !_isContinuation(self[index])
+    return !UTF8.isContinuation(self[index])
   }
 
 }