---

yaml
---
r: 292863
b: refs/heads/tensorflow
c: 5b2e95d
h: refs/heads/master
i:
  292861: 5f876b8
  292859: 7d48efd
  292855: 77ae05c
  292847: 5a5e603
  292831: 3c8a001
  292799: 9d3c53a
  292735: e05bb7d
  292607: dc9395b
  292351: 37f91d4
  291839: 6a55e34
  290815: 153f385

Author: compnerd

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 5a2e73f7c8896dd1981375bb29df6416fc147b84
+refs/heads/tensorflow: 5b2e95d01f2c1b8603f2ee130f4f851b0fa9b7f3
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/include/swift/AST/Pattern.h

@@ -221,9 +221,7 @@ class alignas(8) Pattern {
 
   void print(llvm::raw_ostream &OS,
              const PrintOptions &Options = PrintOptions()) const;
-  LLVM_ATTRIBUTE_DEPRECATED(
-      void dump() const LLVM_ATTRIBUTE_USED,
-      "only for use within the debugger");
+  void dump() const;
 
   /// walk - This recursively walks the AST rooted at this pattern.
   Pattern *walk(ASTWalker &walker);

branches/tensorflow/include/swift/AST/TypeRepr.h

@@ -160,9 +160,7 @@ class alignas(8) TypeRepr {
 
   void print(raw_ostream &OS, const PrintOptions &Opts = PrintOptions()) const;
   void print(ASTPrinter &Printer, const PrintOptions &Opts) const;
-  LLVM_ATTRIBUTE_DEPRECATED(
-      void dump() const LLVM_ATTRIBUTE_USED,
-      "only for use within the debugger");
+  void dump() const;
 
   /// Clone the given type representation.
   TypeRepr *clone(const ASTContext &ctx) const;

branches/tensorflow/include/swift/Reflection/ReflectionContext.h

@@ -310,7 +310,7 @@ class ReflectionContext
         sizeof(llvm::object::coff_section) * COFFFileHdr->NumberOfSections);
 
     auto findCOFFSectionByName = [&](llvm::StringRef Name)
-        -> std::pair<std::pair<const char *, const char *>, uint32_t> {
+        -> std::pair<const char *, const char *> {
       for (size_t i = 0; i < COFFFileHdr->NumberOfSections; ++i) {
         const llvm::object::coff_section *COFFSec =
             reinterpret_cast<const llvm::object::coff_section *>(
@@ -336,45 +336,43 @@ class ReflectionContext
           End -= 8;
         }
 
-        return {{Begin, End}, 0};
+        return {Begin, End};
       }
-      return {{nullptr, nullptr}, 0};
+      return {nullptr, nullptr};
     };
 
-    std::pair<std::pair<const char *, const char *>, uint32_t> CaptureSec =
+    std::pair<const char *, const char *> CaptureSec =
         findCOFFSectionByName(".sw5cptr");
-    std::pair<std::pair<const char *, const char *>, uint32_t> TypeRefMdSec =
+    std::pair<const char *, const char *> TypeRefMdSec =
         findCOFFSectionByName(".sw5tyrf");
-    std::pair<std::pair<const char *, const char *>, uint32_t> FieldMdSec =
+    std::pair<const char *, const char *> FieldMdSec =
         findCOFFSectionByName(".sw5flmd");
-    std::pair<std::pair<const char *, const char *>, uint32_t> AssocTySec =
+    std::pair<const char *, const char *> AssocTySec =
         findCOFFSectionByName(".sw5asty");
-    std::pair<std::pair<const char *, const char *>, uint32_t> BuiltinTySec =
+    std::pair<const char *, const char *> BuiltinTySec =
         findCOFFSectionByName(".sw5bltn");
-    std::pair<std::pair<const char *, const char *>, uint32_t> ReflStrMdSec =
+    std::pair<const char *, const char *> ReflStrMdSec =
         findCOFFSectionByName(".sw5rfst");
 
-    if (FieldMdSec.first.first == nullptr &&
-        AssocTySec.first.first == nullptr &&
-        BuiltinTySec.first.first == nullptr &&
-        CaptureSec.first.first == nullptr &&
-        TypeRefMdSec.first.first == nullptr &&
-        ReflStrMdSec.first.first == nullptr)
+    if (FieldMdSec.first == nullptr &&
+        AssocTySec.first == nullptr &&
+        BuiltinTySec.first == nullptr &&
+        CaptureSec.first == nullptr &&
+        TypeRefMdSec.first == nullptr &&
+        ReflStrMdSec.first == nullptr)
       return false;
+
     auto LocalStartAddress = reinterpret_cast<uintptr_t>(DOSHdrBuf.get());
     auto RemoteStartAddress =
         static_cast<uintptr_t>(ImageStart.getAddressData());
 
     ReflectionInfo Info = {
-        {{FieldMdSec.first.first, FieldMdSec.first.second}, FieldMdSec.second},
-        {{AssocTySec.first.first, AssocTySec.first.second}, AssocTySec.second},
-        {{BuiltinTySec.first.first, BuiltinTySec.first.second},
-         BuiltinTySec.second},
-        {{CaptureSec.first.first, CaptureSec.first.second}, CaptureSec.second},
-        {{TypeRefMdSec.first.first, TypeRefMdSec.first.second},
-         TypeRefMdSec.second},
-        {{ReflStrMdSec.first.first, ReflStrMdSec.first.second},
-         ReflStrMdSec.second},
+        {{FieldMdSec.first, FieldMdSec.second}, 0},
+        {{AssocTySec.first, AssocTySec.second}, 0},
+        {{BuiltinTySec.first, BuiltinTySec.second}, 0},
+        {{CaptureSec.first, CaptureSec.second}, 0},
+        {{TypeRefMdSec.first, TypeRefMdSec.second}, 0},
+        {{ReflStrMdSec.first, ReflStrMdSec.second}, 0},
         LocalStartAddress,
         RemoteStartAddress};
     this->addReflectionInfo(Info);

branches/tensorflow/lib/AST/ASTPrinter.cpp

@@ -985,33 +985,6 @@ void PrintAST::printTypedPattern(const TypedPattern *TP) {
   printTypeLoc(TP->getTypeLoc());
 }
 
-/// Determines if we are required to print the name of a property declaration,
-/// or if we can elide it by printing a '_' instead.
-static bool mustPrintPropertyName(VarDecl *decl, PrintOptions opts) {
-  // If we're not allowed to omit the name, we must print it.
-  if (!opts.OmitNameOfInaccessibleProperties) return true;
-
-  // If it contributes to the parent's storage, we must print it because clients
-  // need to be able to directly access the storage.
-  // FIXME: We might be able to avoid printing names for some of these
-  //        if we serialized references to them using field indices.
-  if (contributesToParentTypeStorage(decl)) return true;
-
-  // If it's public or @usableFromInline, we must print the name because it's a
-  // visible entry-point.
-  if (isPublicOrUsableFromInline(decl)) return true;
-
-  // If it has an initial value, we must print the name because it's used in
-  // the mangled name of the initializer expression generator function.
-  // FIXME: We _could_ figure out a way to generate an entry point
-  //        for the initializer expression without revealing the name. We just
-  //        don't have a mangling for it.
-  if (decl->hasInitialValue()) return true;
-
-  // If none of those are true, we can elide the name of the variable.
-  return false;
-}
-
 void PrintAST::printPattern(const Pattern *pattern) {
   switch (pattern->getKind()) {
   case PatternKind::Any:
@@ -1022,13 +995,16 @@ void PrintAST::printPattern(const Pattern *pattern) {
     auto named = cast<NamedPattern>(pattern);
     auto decl = named->getDecl();
     recordDeclLoc(decl, [&]{
-      // FIXME: This always returns true now, because of the FIXMEs listed in
-      //        mustPrintPropertyName.
-      if (mustPrintPropertyName(decl, Options))
-        Printer.printName(named->getBoundName());
-      else
+      if (Options.OmitNameOfInaccessibleProperties &&
+          contributesToParentTypeStorage(decl) &&
+          !isPublicOrUsableFromInline(decl) &&
+          // FIXME: We need to figure out a way to generate an entry point
+          //        for the initializer expression without revealing the name.
+          !decl->hasInitialValue())
         Printer << "_";
-    });
+      else
+        Printer.printName(named->getBoundName());
+      });
     break;
   }
 

branches/tensorflow/lib/ClangImporter/ImportType.cpp

@@ -515,7 +515,6 @@ namespace {
         type->getElementType(), ImportTypeKind::Abstract,
         false /* No NSUIntegerAsInt */, Bridgeability::None,
         OptionalTypeKind::OTK_None);
-      if (!element) { return Type(); }
       unsigned count = type->getNumElements();
       // Import vector-of-one as the element type.
       if (count == 1) { return element; }

branches/tensorflow/lib/Sema/MiscDiagnostics.cpp

@@ -2276,8 +2276,7 @@ class VarDeclUsageChecker : public ASTWalker {
       vdi->second |= Flag;
   }
 
-  void markBaseOfStorageUse(Expr *E, ConcreteDeclRef decl, unsigned flags);
-  void markBaseOfStorageUse(Expr *E, bool isMutating);
+  void markBaseOfAbstractStorageDeclStore(Expr *E, ConcreteDeclRef decl);
 
   void markStoredOrInOutExpr(Expr *E, unsigned Flags);
 
@@ -2656,57 +2655,29 @@ VarDeclUsageChecker::~VarDeclUsageChecker() {
   }
 }
 
-/// Handle a use of "x.y" or "x[0]" where 'base' is the expression for x and
-/// 'decl' is the property or subscript.
-///
-/// TODO: Rip this out and just rely on LValueAccessKind.
-void VarDeclUsageChecker::markBaseOfStorageUse(Expr *base, ConcreteDeclRef decl,
-                                               unsigned flags) {
-  // If the base is an rvalue, then we know that this is a non-mutating access.
-  // Note that we can have mutating accesses even when the base has class or
-  // metatype type due to protocols and protocol extensions.
-  if (!base->getType()->hasLValueType() &&
-      !base->isSemanticallyInOutExpr()) {
+/// Handle a store to "x.y" where 'base' is the expression for x and 'decl' is
+/// the decl for 'y'.
+void VarDeclUsageChecker::
+markBaseOfAbstractStorageDeclStore(Expr *base, ConcreteDeclRef decl) {
+  // If the base is a class or an rvalue, then this store just loads the base.
+  if (base->getType()->isAnyClassReferenceType() ||
+      !(base->getType()->hasLValueType() || base->isSemanticallyInOutExpr())) {
     base->walk(*this);
     return;
   }
 
-  // Compute whether this access is to a mutating member.
-  auto *ASD = dyn_cast_or_null<AbstractStorageDecl>(decl.getDecl());
-  bool isMutating = false;
-  if (!ASD) {
-    // If there's no abstract storage declaration (which should hopefully
-    // only happen with invalid code), treat the base access as mutating if
-    // the subobject is being mutated and the base type is not a class
-    // or metatype.
-    if (flags & RK_Written) {
-      Type type = base->getType()->getRValueType()->getInOutObjectType();
-      if (!type->isAnyClassReferenceType() && !type->is<AnyMetatypeType>())
-        isMutating = true;
-    }
-  } else {
-    // Otherwise, consider whether the accessors are mutating.
-    if (flags & RK_Read)
-      isMutating |= ASD->isGetterMutating();
-    if (flags & RK_Written)
-      isMutating |= ASD->isSettable(nullptr) && ASD->isSetterMutating();
-  }
-
-  markBaseOfStorageUse(base, isMutating);
-}
-
-void VarDeclUsageChecker::markBaseOfStorageUse(Expr *base, bool isMutating) {
-  // CSApply sometimes wraps the base in an InOutExpr just because the
-  // base is an l-value; look through that so we can get more precise
-  // checking.
-  if (auto *ioe = dyn_cast<InOutExpr>(base))
-    base = ioe->getSubExpr();
-
-  if (!isMutating) {
+  // If the store is to a non-mutating member, then this is just a load, even
+  // if the base is an inout expr.
+  auto *ASD = cast<AbstractStorageDecl>(decl.getDecl());
+  if (ASD->isSettable(nullptr) && !ASD->isSetterMutating()) {
+    // Sema conservatively converts the base to inout expr when it is an lvalue.
+    // Look through it because we know it isn't actually doing a load/store.
+    if (auto *ioe = dyn_cast<InOutExpr>(base))
+      base = ioe->getSubExpr();
     base->walk(*this);
     return;
   }
-
+  
   // Otherwise this is a read and write of the base.
   return markStoredOrInOutExpr(base, RK_Written|RK_Read);
 }
@@ -2741,33 +2712,36 @@ void VarDeclUsageChecker::markStoredOrInOutExpr(Expr *E, unsigned Flags) {
   if (auto *SE = dyn_cast<SubscriptExpr>(E)) {
     // The index of the subscript is evaluated as an rvalue.
     SE->getIndex()->walk(*this);
-    markBaseOfStorageUse(SE->getBase(), SE->getDecl(), Flags);
+    if (SE->hasDecl())
+      markBaseOfAbstractStorageDeclStore(SE->getBase(), SE->getDecl());
+    else  // FIXME: Should not be needed!
+      markStoredOrInOutExpr(SE->getBase(), RK_Written|RK_Read);
+    
     return;
   }
 
   // Likewise for key path applications. An application of a WritableKeyPath
-  // reads and writes its base; an application of a ReferenceWritableKeyPath
-  // only reads its base; the other KeyPath types cannot be written at all.
+  // reads and writes its base.
   if (auto *KPA = dyn_cast<KeyPathApplicationExpr>(E)) {
     auto &C = KPA->getType()->getASTContext();
     KPA->getKeyPath()->walk(*this);
-
-    bool isMutating =
-      (Flags & RK_Written) &&
-      KPA->getKeyPath()->getType()->getAnyNominal()
-        == C.getWritableKeyPathDecl();
-    markBaseOfStorageUse(KPA->getBase(), isMutating);
+    if (KPA->getKeyPath()->getType()->getAnyNominal()
+          == C.getWritableKeyPathDecl())
+      markStoredOrInOutExpr(KPA->getBase(), RK_Written|RK_Read);
+    if (KPA->getKeyPath()->getType()->getAnyNominal()
+          == C.getReferenceWritableKeyPathDecl())
+      markStoredOrInOutExpr(KPA->getBase(), RK_Read);
     return;
   }
 
   if (auto *ioe = dyn_cast<InOutExpr>(E))
     return markStoredOrInOutExpr(ioe->getSubExpr(), RK_Written|RK_Read);
 
   if (auto *MRE = dyn_cast<MemberRefExpr>(E)) {
-    markBaseOfStorageUse(MRE->getBase(), MRE->getMember(), Flags);
+    markBaseOfAbstractStorageDeclStore(MRE->getBase(), MRE->getMember());
     return;
   }
-
+  
   if (auto *TEE = dyn_cast<TupleElementExpr>(E))
     return markStoredOrInOutExpr(TEE->getBase(), Flags);
 
@@ -2776,12 +2750,6 @@ void VarDeclUsageChecker::markStoredOrInOutExpr(Expr *E, unsigned Flags) {
 
   if (auto *BOE = dyn_cast<BindOptionalExpr>(E))
     return markStoredOrInOutExpr(BOE->getSubExpr(), Flags);
-
-  // Bind existential expressions.
-  if (auto *OEE = dyn_cast<OpenExistentialExpr>(E)) {
-    OpaqueValueMap[OEE->getOpaqueValue()] = OEE->getExistentialValue();
-    return markStoredOrInOutExpr(OEE->getSubExpr(), Flags);
-  }
 
   // If this is an OpaqueValueExpr that we've seen a mapping for, jump to the
   // mapped value.
@@ -2820,16 +2788,8 @@ std::pair<bool, Expr *> VarDeclUsageChecker::walkToExprPre(Expr *E) {
     if (auto VD = dyn_cast<VarDecl>(MRE->getMember().getDecl())) {
       if (AssociatedGetter == VD && AssociatedGetterRefExpr == nullptr)
         AssociatedGetterRefExpr = MRE;
-      markBaseOfStorageUse(MRE->getBase(), MRE->getMember(), RK_Read);
-      return { false, E };
     }
   }
-  if (auto SE = dyn_cast<SubscriptExpr>(E)) {
-    SE->getIndex()->walk(*this);
-    markBaseOfStorageUse(SE->getBase(), SE->getDecl(), RK_Read);
-    return { false, E };
-  }
-
   // If this is an AssignExpr, see if we're mutating something that we know
   // about.
   if (auto *assign = dyn_cast<AssignExpr>(E)) {
@@ -2850,13 +2810,6 @@ std::pair<bool, Expr *> VarDeclUsageChecker::walkToExprPre(Expr *E) {
   // If we see an OpenExistentialExpr, remember the mapping for its OpaqueValue.
   if (auto *oee = dyn_cast<OpenExistentialExpr>(E))
     OpaqueValueMap[oee->getOpaqueValue()] = oee->getExistentialValue();
-
-  // Visit bindings.
-  if (auto ove = dyn_cast<OpaqueValueExpr>(E)) {
-    if (auto mapping = OpaqueValueMap.lookup(ove))
-      mapping->walk(*this);
-    return { false, E };
-  }
 
   // If we saw an ErrorExpr, take note of this.
   if (isa<ErrorExpr>(E))

branches/tensorflow/lib/Sema/TypeCheckAccess.cpp

@@ -1494,11 +1494,11 @@ class ImplementationOnlyImportChecker
                               offendingType->getFullName(), M->getName());
       highlightOffendingType(TC, diag, complainRepr);
     }
-  };
 
-  static_assert(std::is_convertible<DiagnoseGenerically,
-                                    CheckImplementationOnlyCallback>::value,
-                "DiagnoseGenerically has wrong call signature");
+    static_assert(std::is_convertible<DiagnoseGenerically,
+                                      CheckImplementationOnlyCallback>::value,
+                  "DiagnoseGenerically has wrong call signature");
+  };
 
   DiagnoseGenerically getDiagnoseCallback(const Decl *D) {
     return DiagnoseGenerically(TC, D);

branches/tensorflow/stdlib/private/StdlibUnittest/StdlibUnittest.swift

@@ -1777,7 +1777,7 @@ func _parseDottedVersion(_ s: String) -> [Int] {
 }
 
 public func _parseDottedVersionTriple(_ s: String) -> (Int, Int, Int) {
-  let array = _parseDottedVersion(s)
+  var array = _parseDottedVersion(s)
   if array.count >= 4 {
     fatalError("unexpected version")
   }