---

yaml
---
r: 318973
b: refs/heads/master-rebranch
c: a9cae77
h: refs/heads/master
i:
  318971: 9a6c1a4

Author: swift-ci

[refs]

@@ -1457,4 +1457,4 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: ec83122128560f5628d70cf5b183fb1638fe4724
+refs/heads/master-rebranch: a9cae779f444a8ea3156b6562a309af954ed01f4

branches/master-rebranch/include/swift/AST/Stmt.h

@@ -1055,15 +1055,26 @@ class CaseStmt final
     return UnknownAttrLoc.isValid();
   }
 
-  Optional<ArrayRef<VarDecl *>> getCaseBodyVariables() const {
-    if (!CaseBodyVariables)
-      return None;
+  /// Return an ArrayRef containing the case body variables of this CaseStmt.
+  ///
+  /// Asserts if case body variables was not explicitly initialized. In contexts
+  /// where one wants a non-asserting version, \see
+  /// getCaseBodyVariablesOrEmptyArray.
+  ArrayRef<VarDecl *> getCaseBodyVariables() const {
     ArrayRef<VarDecl *> a = *CaseBodyVariables;
     return a;
   }
 
-  Optional<MutableArrayRef<VarDecl *>> getCaseBodyVariables() {
-    return CaseBodyVariables;
+  bool hasCaseBodyVariables() const { return CaseBodyVariables.hasValue(); }
+
+  /// Return an MutableArrayRef containing the case body variables of this
+  /// CaseStmt.
+  ///
+  /// Asserts if case body variables was not explicitly initialized. In contexts
+  /// where one wants a non-asserting version, \see
+  /// getCaseBodyVariablesOrEmptyArray.
+  MutableArrayRef<VarDecl *> getCaseBodyVariables() {
+    return *CaseBodyVariables;
   }
 
   ArrayRef<VarDecl *> getCaseBodyVariablesOrEmptyArray() const {

branches/master-rebranch/lib/AST/ASTDumper.cpp

@@ -1622,13 +1622,13 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
     if (S->hasUnknownAttr())
       OS << " @unknown";
 
-    if (auto caseBodyVars = S->getCaseBodyVariables()) {
+    if (S->hasCaseBodyVariables()) {
       OS << '\n';
       OS.indent(Indent + 2);
       PrintWithColorRAII(OS, ParenthesisColor) << '(';
       PrintWithColorRAII(OS, StmtColor) << "case_body_variables";
       OS << '\n';
-      for (auto *vd : *caseBodyVars) {
+      for (auto *vd : S->getCaseBodyVariables()) {
         OS.indent(2);
         // TODO: Printing a var decl does an Indent ... dump(vd) ... '\n'. We
         // should see if we can factor this dumping so that the caller of

branches/master-rebranch/lib/AST/Decl.cpp

@@ -5094,7 +5094,7 @@ NullablePtr<VarDecl> VarDecl::getCorrespondingCaseBodyVariable() const {
 
   // A var decl associated with a case stmt implies that the case stmt has body
   // var decls. So we can access the optional value here without worry.
-  auto caseBodyVars = *caseStmt->getCaseBodyVariables();
+  auto caseBodyVars = caseStmt->getCaseBodyVariables();
   auto result = llvm::find_if(caseBodyVars, [&](VarDecl *caseBodyVar) {
     return caseBodyVar->getName() == name;
   });

branches/master-rebranch/lib/AST/NameLookup.cpp

@@ -2349,10 +2349,8 @@ void FindLocalVal::visitCaseStmt(CaseStmt *S) {
   }
 
   if (!inPatterns && !items.empty()) {
-    if (auto caseBodyVars = S->getCaseBodyVariables()) {
-      for (auto *vd : *caseBodyVars) {
-        checkValueDecl(vd, DeclVisibilityKind::LocalVariable);
-      }
+    for (auto *vd : S->getCaseBodyVariablesOrEmptyArray()) {
+      checkValueDecl(vd, DeclVisibilityKind::LocalVariable);
     }
   }
   visit(S->getBody());

branches/master-rebranch/lib/SILGen/SILGenPattern.cpp

@@ -2332,12 +2332,8 @@ void PatternMatchEmission::initSharedCaseBlockDest(CaseStmt *caseBlock,
   auto *block = SGF.createBasicBlock();
   result.first->second.first = block;
 
-  // Add args for any pattern variables
-  auto caseBodyVars = caseBlock->getCaseBodyVariables();
-  if (!caseBodyVars)
-    return;
-
-  for (auto *vd : *caseBodyVars) {
+  // Add args for any pattern variables if we have any.
+  for (auto *vd : caseBlock->getCaseBodyVariablesOrEmptyArray()) {
     if (!vd->hasName())
       continue;
 
@@ -2365,14 +2361,10 @@ void PatternMatchEmission::emitAddressOnlyAllocations() {
   for (auto &entry : SharedCases) {
     CaseStmt *caseBlock = entry.first;
 
-    auto caseBodyVars = caseBlock->getCaseBodyVariables();
-    if (!caseBodyVars)
-      continue;
-
     // If we have a shared case with bound decls, setup the arguments for the
     // shared block by emitting the temporary allocation used for the arguments
     // of the shared block.
-    for (auto *vd : *caseBodyVars) {
+    for (auto *vd : caseBlock->getCaseBodyVariablesOrEmptyArray()) {
       if (!vd->hasName())
         continue;
 
@@ -2436,8 +2428,7 @@ void PatternMatchEmission::emitSharedCaseBlocks() {
     assert(SGF.getCleanupsDepth() == PatternMatchStmtDepth);
     SWIFT_DEFER { assert(SGF.getCleanupsDepth() == PatternMatchStmtDepth); };
 
-    auto caseBodyVars = caseBlock->getCaseBodyVariables();
-    if (!caseBodyVars) {
+    if (!caseBlock->hasCaseBodyVariables()) {
       emitCaseBody(caseBlock);
       continue;
     }
@@ -2448,7 +2439,7 @@ void PatternMatchEmission::emitSharedCaseBlocks() {
     // args needing Cleanup will get that as well.
     Scope scope(SGF.Cleanups, CleanupLocation(caseBlock));
     unsigned argIndex = 0;
-    for (auto *vd : *caseBodyVars) {
+    for (auto *vd : caseBlock->getCaseBodyVariables()) {
       if (!vd->hasName())
         continue;
 
@@ -2606,14 +2597,14 @@ static void switchCaseStmtSuccessCallback(SILGenFunction &SGF,
   if (!row.hasFallthroughTo() && caseBlock->getCaseLabelItems().size() == 1) {
     // If we have case body vars, set them up to point at the matching var
     // decls.
-    if (auto caseBodyVars = caseBlock->getCaseBodyVariables()) {
+    if (caseBlock->hasCaseBodyVariables()) {
       // Since we know that we only have one case label item, grab its pattern
       // vars and use that to update expected with the right SILValue.
       //
       // TODO: Do we need a copy here?
       SmallVector<VarDecl *, 4> patternVars;
       row.getCasePattern()->collectVariables(patternVars);
-      for (auto *expected : *caseBodyVars) {
+      for (auto *expected : caseBlock->getCaseBodyVariables()) {
         if (!expected->hasName())
           continue;
         for (auto *vd : patternVars) {
@@ -2622,7 +2613,8 @@ static void switchCaseStmtSuccessCallback(SILGenFunction &SGF,
           }
 
           // Ok, we found a match. Update the VarLocs for the case block.
-          SGF.VarLocs[expected] = SGF.VarLocs[vd];
+          auto v = SGF.VarLocs[vd];
+          SGF.VarLocs[expected] = v;
         }
       }
     }
@@ -2639,8 +2631,7 @@ static void switchCaseStmtSuccessCallback(SILGenFunction &SGF,
 
   // If we do not have any bound decls, we do not need to setup any
   // variables. Just jump to the shared destination.
-  auto caseBodyVars = caseBlock->getCaseBodyVariables();
-  if (!caseBodyVars) {
+  if (!caseBlock->hasCaseBodyVariables()) {
     // Don't emit anything yet, we emit it at the cleanup level of the switch
     // statement.
     JumpDest sharedDest = emission.getSharedCaseBlockDest(caseBlock);
@@ -2657,7 +2648,7 @@ static void switchCaseStmtSuccessCallback(SILGenFunction &SGF,
   SILModule &M = SGF.F.getModule();
   SmallVector<VarDecl *, 4> patternVars;
   row.getCasePattern()->collectVariables(patternVars);
-  for (auto *expected : *caseBodyVars) {
+  for (auto *expected : caseBlock->getCaseBodyVariables()) {
     if (!expected->hasName())
       continue;
     for (auto *var : patternVars) {
@@ -2844,8 +2835,7 @@ void SILGenFunction::emitSwitchFallthrough(FallthroughStmt *S) {
 
   // If our destination case doesn't have any bound decls, there is no rebinding
   // to do. Just jump to the shared dest.
-  auto destCaseBodyVars = destCaseStmt->getCaseBodyVariables();
-  if (!destCaseBodyVars) {
+  if (!destCaseStmt->hasCaseBodyVariables()) {
     Cleanups.emitBranchAndCleanups(sharedDest, S);
     return;
   }
@@ -2855,13 +2845,13 @@ void SILGenFunction::emitSwitchFallthrough(FallthroughStmt *S) {
   SmallVector<SILValue, 4> args;
   CaseStmt *fallthroughSourceStmt = S->getFallthroughSource();
 
-  for (auto *expected : *destCaseBodyVars) {
+  for (auto *expected : destCaseStmt->getCaseBodyVariables()) {
     if (!expected->hasName())
       continue;
 
     // The type checker enforces that if our destination case has variables then
     // our fallthrough source must as well.
-    for (auto *var : *fallthroughSourceStmt->getCaseBodyVariables()) {
+    for (auto *var : fallthroughSourceStmt->getCaseBodyVariables()) {
       if (!var->hasName() || var->getName() != expected->getName()) {
         continue;
       }

branches/master-rebranch/lib/Sema/MiscDiagnostics.cpp

@@ -2414,10 +2414,8 @@ class VarDeclUsageChecker : public ASTWalker {
 
     // Make sure that we setup our case body variables.
     if (auto *caseStmt = dyn_cast<CaseStmt>(S)) {
-      if (auto caseBoundDecls = caseStmt->getCaseBodyVariables()) {
-        for (auto *vd : *caseBoundDecls) {
-          VarDecls[vd] |= 0;
-        }
+      for (auto *vd : caseStmt->getCaseBodyVariablesOrEmptyArray()) {
+        VarDecls[vd] |= 0;
       }
     }
 

branches/master-rebranch/stdlib/public/Darwin/CoreGraphics/CGFloat.swift.gyb

@@ -513,111 +513,18 @@ public func %=(lhs: inout CGFloat, rhs: CGFloat) {
 // tgmath
 //===----------------------------------------------------------------------===//
 
-%from SwiftMathFunctions import *
-extension CGFloat: Real {
-% for func in ElementaryFunctions + RealFunctions:
-
-  @_alwaysEmitIntoClient
-  public static func ${func.decl("CGFloat")} {
-    return CGFloat(NativeType.${func.swiftName}(${func.params("", ".native")}))
-  }
-% end
-
-  @_alwaysEmitIntoClient
-  public static func pow(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-    return CGFloat(NativeType.pow(x.native, y.native))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func pow(_ x: CGFloat, _ n: Int) -> CGFloat {
-    return CGFloat(NativeType.pow(x.native, n))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func root(_ x: CGFloat, _ n: Int) -> CGFloat {
-    return CGFloat(NativeType.root(x.native, n))
-  }
-
-  @_alwaysEmitIntoClient
-  public static func atan2(y: CGFloat, x: CGFloat) -> CGFloat {
-    return CGFloat(NativeType.atan2(y: y.native, x: x.native))
-  }
-
-#if !os(Windows)
-  @_alwaysEmitIntoClient
-  public static func logGamma(_ x: CGFloat) -> CGFloat {
-    return CGFloat(NativeType.logGamma(x.native))
-  }
-#endif
-}
-
-@available(swift, deprecated: 5.1, message: "Use `root(x, 3)`.")
-@_transparent
-public func cbrt(_ x: CGFloat) -> CGFloat {
-  return CGFloat.root(x, 3)
-}
-
-@available(swift, deprecated: 5.1, message: "Use CGFloat.minimum( ) or Swift.min( )")
-@_transparent
-public func fmin(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-  return .minimum(x, y)
-}
-
-@available(swift, deprecated: 5.1, message: "Use CGFloat.maximum( ) or Swift.max( )")
-@_transparent
-public func fmax(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-  return .maximum(x, y)
-}
-
-#if !os(Windows)
-@available(swift, deprecated: 5.1, message: "Use (logGamma(x), signGamma(x)).")
-@_transparent
-public func lgamma(_ x: CGFloat) -> (CGFloat, Int) {
-  return (CGFloat.logGamma(x), CGFloat.signGamma(x) == .plus ? 1 : -1)
-}
-#endif
-
-@available(swift, deprecated: 5.1, message: "Use `x.exponent` or `floor(log2(x))`.")
-@_transparent
-public func logb(_ x: CGFloat) -> CGFloat {
-  return CGFloat.log2(x).rounded(.down)
-}
-
-@available(swift, deprecated: 5.1, message: "Swift does not model dynamic rounding modes, use x.rounded(.toNearestOrEven).")
-@_transparent
-public func nearbyint(_ x: CGFloat) -> CGFloat {
-  return x.rounded(.toNearestOrEven)
-}
-
-@available(swift, deprecated: 5.1, message: "Use the .nextUp or .nextDown property.")
-@_transparent
-public func nextafter(_ x: CGFloat, _ y: CGFloat) -> CGFloat {
-  return y > x ? x.nextUp : (y < x ? x.nextDown : y)
-}
-
-@available(swift, deprecated: 5.1, message: "Swift does not model dynamic rounding modes, use x.rounded(.toNearestOrEven).")
-@_transparent
-public func rint(_ x: CGFloat) -> CGFloat {
-  return x.rounded(.toNearestOrEven)
-}
-
-@available(swift, deprecated: 5.1, message: "Use `gamma(x)`.")
-@_transparent
-public func tgamma(_ x: CGFloat) -> CGFloat {
-  return CGFloat.gamma(x)
-}
-
 %{
 UnaryFunctions = [
   'acos', 'asin', 'atan', 'cos', 'sin', 'tan',
   'acosh', 'asinh', 'atanh', 'cosh', 'sinh', 'tanh',
   'exp', 'exp2', 'expm1',
-  'log', 'log10', 'log1p', 'log2',
-  'erf', 'erfc',
+  'log', 'log10', 'log1p', 'log2', 'logb',
+  'cbrt', 'erf', 'erfc', 'tgamma',
+  'nearbyint', 'rint'
 ]
 
 BinaryFunctions = [
-  'atan2', 'hypot', 'pow', 'copysign', 'fdim'
+  'atan2', 'hypot', 'pow', 'copysign', 'nextafter', 'fdim', 'fmax', 'fmin'
 ]
 }%
 
@@ -664,12 +571,18 @@ public func ldexp(_ x: CGFloat, _ n: Int) -> CGFloat {
   return CGFloat(ldexp(x.native, n))
 }
 
-@available(swift, deprecated: 4.2, obsoleted: 5.1, message: "use the exponent property.")
+@available(swift, deprecated: 4.2, message: "use the exponent property.")
 @_transparent
 public func ilogb(_ x: CGFloat) -> Int {
   return Int(x.exponent)
 }
 
+@_transparent
+public func lgamma(_ x: CGFloat) -> (CGFloat, Int) {
+  let (value, sign) = lgamma(x.native)
+  return (CGFloat(value), sign)
+}
+
 @_transparent
 public func remquo(_ x: CGFloat, _ y: CGFloat) -> (CGFloat, Int) {
   let (rem, quo) = remquo(x.native, y.native)