---

yaml
---
r: 294367
b: refs/heads/tensorflow
c: d332d21
h: refs/heads/master
i:
  294365: e7d5f75
  294363: a25e2a6
  294359: 6ef7dad
  294351: 2fb189a
  294335: f716bd5

Author: Rostepher

[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: e43a9f5475fc7ed3efbcf552e66b7f4c3a6c38d3
+refs/heads/tensorflow: d332d21056b1cb95e1b5f5cfe7df6dbaa455f540
 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/cmake/modules/StandaloneOverlay.cmake

@@ -84,7 +84,6 @@ set(SWIFT_APPLE_PLATFORMS
 set(BUILD_STANDALONE TRUE)
 set(SWIFT_BUILD_STANDALONE_OVERLAY TRUE)
 
-set(SWIFT_STDLIB_LIBRARY_BUILD_TYPES "SHARED")
 set(SWIFT_SDK_OVERLAY_LIBRARY_BUILD_TYPES "SHARED")
 
 

branches/tensorflow/lib/AST/Decl.cpp

@@ -6856,13 +6856,7 @@ Type ConstructorDecl::getInitializerInterfaceType() {
     return InitializerInterfaceType;
 
   // Lazily calculate initializer type.
-  auto allocatorTy = getInterfaceType();
-  if (!allocatorTy->is<AnyFunctionType>()) {
-    InitializerInterfaceType = ErrorType::get(getASTContext());
-    return InitializerInterfaceType;
-  }
-
-  auto funcTy = allocatorTy->castTo<AnyFunctionType>()->getResult();
+  auto funcTy = getInterfaceType()->castTo<AnyFunctionType>()->getResult();
   assert(funcTy->is<FunctionType>());
 
   // Constructors have an initializer type that takes an instance

branches/tensorflow/lib/Frontend/ParseableInterfaceSupport.cpp

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsFrontend.h"
 #include "swift/AST/DiagnosticsSema.h"
@@ -164,69 +163,47 @@ namespace {
 class InheritedProtocolCollector {
   static const StringLiteral DummyProtocolName;
 
-  using AvailableAttrList = TinyPtrVector<const AvailableAttr *>;
-  using ProtocolAndAvailability =
-    std::pair<ProtocolDecl *, AvailableAttrList>;
-
   /// Protocols that will be included by the ASTPrinter without any extra work.
   SmallVector<ProtocolDecl *, 8> IncludedProtocols;
-  /// Protocols that will not be printed by the ASTPrinter, along with the
-  /// availability they were declared with.
-  SmallVector<ProtocolAndAvailability, 8> ExtraProtocols;
+  /// Protocols that will not be printed by the ASTPrinter.
+  SmallVector<ProtocolDecl *, 8> ExtraProtocols;
   /// Protocols that can be printed, but whose conformances are constrained with
   /// something that \e can't be printed.
   SmallVector<const ProtocolType *, 8> ConditionalConformanceProtocols;
 
-  /// Helper to extract the `@available` attributes on a decl.
-  AvailableAttrList getAvailabilityAttrs(const Decl *D) {
-    AvailableAttrList result;
-    auto attrRange = D->getAttrs().getAttributes<AvailableAttr>();
-    result.insert(result.begin(), attrRange.begin(), attrRange.end());
-    return result;
-  }
-
   /// For each type in \p directlyInherited, classify the protocols it refers to
   /// as included for printing or not, and record them in the appropriate
   /// vectors.
-  void recordProtocols(ArrayRef<TypeLoc> directlyInherited, const Decl *D) {
-    Optional<AvailableAttrList> availableAttrs;
-
+  void recordProtocols(ArrayRef<TypeLoc> directlyInherited) {
     for (TypeLoc inherited : directlyInherited) {
       Type inheritedTy = inherited.getType();
       if (!inheritedTy || !inheritedTy->isExistentialType())
         continue;
 
       bool canPrintNormally = isPublicOrUsableFromInline(inheritedTy);
-      if (!canPrintNormally && !availableAttrs.hasValue())
-        availableAttrs = getAvailabilityAttrs(D);
+      SmallVectorImpl<ProtocolDecl *> &whichProtocols =
+          canPrintNormally ? IncludedProtocols : ExtraProtocols;
 
       ExistentialLayout layout = inheritedTy->getExistentialLayout();
-      for (ProtocolType *protoTy : layout.getProtocols()) {
-        if (canPrintNormally)
-          IncludedProtocols.push_back(protoTy->getDecl());
-        else
-          ExtraProtocols.push_back({protoTy->getDecl(),
-                                    availableAttrs.getValue()});
-      }
+      for (ProtocolType *protoTy : layout.getProtocols())
+        whichProtocols.push_back(protoTy->getDecl());
       // FIXME: This ignores layout constraints, but currently we don't support
       // any of those besides 'AnyObject'.
     }
   }
 
-  /// For each type directly inherited by \p extension, record any protocols
-  /// that we would have printed in ConditionalConformanceProtocols.
-  void recordConditionalConformances(const ExtensionDecl *extension) {
-    for (TypeLoc inherited : extension->getInherited()) {
+  /// For each type in \p directlyInherited, record any protocols that we would
+  /// have printed in ConditionalConformanceProtocols.
+  void recordConditionalConformances(ArrayRef<TypeLoc> directlyInherited) {
+    for (TypeLoc inherited : directlyInherited) {
       Type inheritedTy = inherited.getType();
       if (!inheritedTy || !inheritedTy->isExistentialType())
         continue;
 
       ExistentialLayout layout = inheritedTy->getExistentialLayout();
-      for (ProtocolType *protoTy : layout.getProtocols()) {
-        if (!isPublicOrUsableFromInline(protoTy))
-          continue;
-        ConditionalConformanceProtocols.push_back(protoTy);
-      }
+      for (ProtocolType *protoTy : layout.getProtocols())
+        if (isPublicOrUsableFromInline(protoTy))
+          ConditionalConformanceProtocols.push_back(protoTy);
       // FIXME: This ignores layout constraints, but currently we don't support
       // any of those besides 'AnyObject'.
     }
@@ -266,7 +243,7 @@ class InheritedProtocolCollector {
     if (!isPublicOrUsableFromInline(nominal))
       return;
 
-    map[nominal].recordProtocols(directlyInherited, D);
+    map[nominal].recordProtocols(directlyInherited);
 
     // Recurse to find any nested types.
     for (const Decl *member : memberContext->getMembers())
@@ -287,7 +264,7 @@ class InheritedProtocolCollector {
     if (!isPublicOrUsableFromInline(nominal))
       return;
 
-    map[nominal].recordConditionalConformances(extension);
+    map[nominal].recordConditionalConformances(extension->getInherited());
     // No recursion here because extensions are never nested.
   }
 
@@ -330,19 +307,16 @@ class InheritedProtocolCollector {
     // Note: We could do this in one pass, but the logic is easier to
     // understand if we build up the list and then print it, even if it takes
     // a bit more memory.
-    // FIXME: This will pick the availability attributes from the first sight
-    // of a protocol rather than the maximally available case.
-    SmallVector<std::pair<ProtocolDecl *, AvailableAttrList>, 16>
-        protocolsToPrint;
-    for (const auto &protoAndAvailability : ExtraProtocols) {
-      protoAndAvailability.first->walkInheritedProtocols(
+    SmallVector<ProtocolDecl *, 16> protocolsToPrint;
+    for (ProtocolDecl *proto : ExtraProtocols) {
+      proto->walkInheritedProtocols(
           [&](ProtocolDecl *inherited) -> TypeWalker::Action {
         if (!handledProtocols.insert(inherited).second)
           return TypeWalker::Action::SkipChildren;
 
         if (isPublicOrUsableFromInline(inherited) &&
             conformanceDeclaredInModule(M, nominal, inherited)) {
-          protocolsToPrint.push_back({inherited, protoAndAvailability.second});
+          protocolsToPrint.push_back(inherited);
           return TypeWalker::Action::SkipChildren;
         }
 
@@ -352,20 +326,14 @@ class InheritedProtocolCollector {
     if (protocolsToPrint.empty())
       return;
 
-    for (const auto &protoAndAvailability : protocolsToPrint) {
-      StreamPrinter printer(out);
-      for (const AvailableAttr *attr : protoAndAvailability.second)
-        attr->print(printer, printOptions);
-
-      printer << "extension ";
-      nominal->getDeclaredType().print(printer, printOptions);
-      printer << " : ";
-
-      ProtocolDecl *proto = protoAndAvailability.first;
-      proto->getDeclaredType()->print(printer, printOptions);
-
-      printer << " {}\n";
-    }
+    out << "extension ";
+    nominal->getDeclaredType().print(out, printOptions);
+    out << " : ";
+    swift::interleave(protocolsToPrint,
+                      [&out, &printOptions](ProtocolDecl *proto) {
+                        proto->getDeclaredType()->print(out, printOptions);
+                      }, [&out] { out << ", "; });
+    out << " {}\n";
   }
 
   /// If there were any conditional conformances that couldn't be printed,
@@ -378,7 +346,7 @@ class InheritedProtocolCollector {
       return false;
     assert(nominal->isGenericContext());
 
-    out << "@available(*, unavailable)\nextension ";
+    out << "extension ";
     nominal->getDeclaredType().print(out, printOptions);
     out << " : ";
     swift::interleave(ConditionalConformanceProtocols,

branches/tensorflow/lib/SILGen/SILGenExpr.cpp

@@ -931,25 +931,6 @@ RValue RValueEmitter::visitOtherConstructorDeclRefExpr(
 }
 
 RValue RValueEmitter::visitNilLiteralExpr(NilLiteralExpr *E, SGFContext C) {
-  // Peephole away the call to Optional<T>(nilLiteral: ()).
-  if (E->getType()->getOptionalObjectType()) {
-    auto *noneDecl = SGF.getASTContext().getOptionalNoneDecl();
-    auto enumTy = SGF.getLoweredType(E->getType());
-
-    ManagedValue noneValue;
-    if (enumTy.isLoadable(SGF.F) || !SGF.silConv.useLoweredAddresses()) {
-      noneValue = ManagedValue::forUnmanaged(
-        SGF.B.createEnum(E, SILValue(), noneDecl, enumTy));
-    } else {
-      noneValue =
-          SGF.B.bufferForExpr(E, enumTy, SGF.getTypeLowering(enumTy), C,
-                              [&](SILValue newAddr) {
-                                SGF.B.createInjectEnumAddr(E, newAddr, noneDecl);
-                              });
-    }
-    return RValue(SGF, E, noneValue);
-  }
-
   return SGF.emitLiteral(E, C);
 }
 

branches/tensorflow/lib/Sema/CSApply.cpp

@@ -1912,27 +1912,57 @@ namespace {
     }
 
     Expr *visitNilLiteralExpr(NilLiteralExpr *expr) {
-      auto type = simplifyType(cs.getType(expr));
-
-      // By far the most common 'nil' literal is for Optional<T>.none.
-      // We don't have to look up the witness in this case since SILGen
-      // knows how to lower it directly.
-      if (auto objectType = type->getOptionalObjectType()) {
-        cs.setType(expr, type);
-        return expr;
-      }
-
       auto &tc = cs.getTypeChecker();
       auto *protocol = tc.getProtocol(expr->getLoc(),
                                       KnownProtocolKind::ExpressibleByNilLiteral);
 
       // For type-sugar reasons, prefer the spelling of the default literal
       // type.
+      auto type = simplifyType(cs.getType(expr));
       if (auto defaultType = tc.getDefaultType(protocol, dc)) {
         if (defaultType->isEqual(type))
           type = defaultType;
       }
 
+      // By far the most common 'nil' literal is for Optional<T>.none.
+      //
+      // Emit this case directly instead of calling Optional.init(nilLiteral:),
+      // since this generates more efficient SIL.
+      if (auto objectType = type->getOptionalObjectType()) {
+        auto *nilDecl = tc.Context.getOptionalNoneDecl();
+        tc.validateDecl(nilDecl);
+        if (!nilDecl->hasInterfaceType())
+          return nullptr;
+
+        auto genericSig =
+          nilDecl->getDeclContext()->getGenericSignatureOfContext();
+        SubstitutionMap subs =
+          SubstitutionMap::get(genericSig, llvm::makeArrayRef(objectType),
+                               { });
+        ConcreteDeclRef concreteDeclRef(nilDecl, subs);
+
+        auto nilType = FunctionType::get(
+            {FunctionType::Param(MetatypeType::get(type))}, type);
+        auto *nilRefExpr = new (tc.Context) DeclRefExpr(
+            concreteDeclRef, DeclNameLoc(expr->getLoc()),
+              /*implicit=*/true, AccessSemantics::Ordinary,
+            nilType);
+        cs.cacheType(nilRefExpr);
+
+        auto *typeExpr = TypeExpr::createImplicitHack(
+            expr->getLoc(),
+            type,
+            tc.Context);
+        cs.cacheType(typeExpr);
+
+        auto *callExpr = new (tc.Context) DotSyntaxCallExpr(
+            nilRefExpr, expr->getLoc(), typeExpr, type);
+        callExpr->setImplicit(true);
+        cs.cacheType(callExpr);
+
+        return callExpr;
+      }
+
       DeclName initName(tc.Context, DeclBaseName::createConstructor(),
                         { tc.Context.Id_nilLiteral });
       return convertLiteralInPlace(expr, type, protocol,