---

yaml
---
r: 294654
b: refs/heads/tensorflow
c: 1499811
h: refs/heads/master

Author: xedin

[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: fe9b48c28d827afa9d6d7dbc39cc3d0b6d1f5004
+refs/heads/tensorflow: 1499811add498d18baf2faba6add19b72de19ca0
 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/CHANGELOG.md

@@ -26,28 +26,6 @@ CHANGELOG
 Swift Next
 ----------
 
-* [SR-8974][]:
-
-  Duplicate tuple element labels are no longer allowed, because it leads
-  to incorrect behavior. For example:
-
-  ```
-  let dupLabels: (foo: Int, foo: Int) = (foo: 1, foo: 2)
-
-  enum Foo { case bar(x: Int, x: Int) }
-  let f: Foo = .bar(x: 0, x: 1)
-  ```
-
-  will now be diagnosed as an error. 
-
-  Note: You can still use duplicate labels when declaring functions and
-  subscripts, as long as the internal labels are different. For example:
-
-  ```
-  func foo(bar x: Int, bar y: Int) {}
-  subscript(a x: Int, a y: Int) -> Int {}
-  ```
-
 * [SR-6118][]:
 
   Subscripts can now declare default arguments:
@@ -7718,6 +7696,5 @@ Swift 1.0
 [SR-7799]: <https://bugs.swift.org/browse/SR-7799>
 [SR-8109]: <https://bugs.swift.org/browse/SR-8109>
 [SR-8546]: <https://bugs.swift.org/browse/SR-8546>
-[SR-8974]: <https://bugs.swift.org/browse/SR-8974>
 [SR-9043]: <https://bugs.swift.org/browse/SR-9043>
 [SR-9827]: <https://bugs.swift.org/browse/SR-9827>

branches/tensorflow/cmake/modules/AddSwift.cmake

@@ -1914,20 +1914,6 @@ function(add_swift_target_library name)
         GYB_SOURCES ${SWIFTLIB_GYB_SOURCES}
       )
 
-      if(sdk STREQUAL WINDOWS)
-        if(SWIFT_COMPILER_IS_MSVC_LIKE)
-          if (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreadedDebugDLL)
-            target_compile_options(${VARIANT_NAME} PRIVATE /MDd /D_DLL /D_DEBUG)
-          elseif (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreadedDebug)
-            target_compile_options(${VARIANT_NAME} PRIVATE /MTd /U_DLL /D_DEBUG)
-          elseif (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreadedDLL)
-            target_compile_options(${VARIANT_NAME} PRIVATE /MD /D_DLL /U_DEBUG)
-          elseif (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreaded)
-            target_compile_options(${VARIANT_NAME} PRIVATE /MT /U_DLL /U_DEBUG)
-          endif()
-        endif()
-      endif()
-
       if(NOT SWIFTLIB_OBJECT_LIBRARY)
         # Add dependencies on the (not-yet-created) custom lipo target.
         foreach(DEP ${SWIFTLIB_LINK_LIBRARIES})

branches/tensorflow/include/swift/AST/DiagnosticsSema.def

@@ -3523,8 +3523,6 @@ ERROR(tuple_single_element,none,
       "cannot create a single-element tuple with an element label", ())
 ERROR(tuple_ellipsis,none,
       "cannot create a variadic tuple", ())
-ERROR(tuple_duplicate_label,none,
-      "cannot create a tuple with a duplicate element label", ())
 ERROR(enum_element_ellipsis,none,
       "variadic enum cases are not supported", ())
 

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

@@ -953,25 +953,15 @@ class TapExpr : public Expr {
 class InterpolatedStringLiteralExpr : public LiteralExpr {
   /// Points at the beginning quote.
   SourceLoc Loc;
-  /// Points at the ending quote.
-  /// Needed for the upcoming \c ASTScope subsystem because lookups can be
-  /// targeted to inside an \c InterpolatedStringLiteralExpr. It would be nicer
-  /// to use \c EndLoc for this value, but then \c Lexer::getLocForEndOfToken()
-  /// would not work for \c stringLiteral->getEndLoc().
-  SourceLoc TrailingQuoteLoc;
   TapExpr *AppendingExpr;
   Expr *SemanticExpr;
 
 public:
-  InterpolatedStringLiteralExpr(SourceLoc Loc,
-                                SourceLoc TrailingQuoteLoc,
-                                unsigned LiteralCapacity,
+  InterpolatedStringLiteralExpr(SourceLoc Loc, unsigned LiteralCapacity, 
                                 unsigned InterpolationCount,
                                 TapExpr *AppendingExpr)
       : LiteralExpr(ExprKind::InterpolatedStringLiteral, /*Implicit=*/false),
-        Loc(Loc),
-        TrailingQuoteLoc(TrailingQuoteLoc),
-        AppendingExpr(AppendingExpr), SemanticExpr() {
+        Loc(Loc), AppendingExpr(AppendingExpr), SemanticExpr() {
     Bits.InterpolatedStringLiteralExpr.InterpolationCount = InterpolationCount;
     Bits.InterpolatedStringLiteralExpr.LiteralCapacity = LiteralCapacity;
   }
@@ -1008,11 +998,6 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
     // token, so the range should be (Start == End).
     return Loc;
   }
-  SourceLoc getTrailingQuoteLoc() const {
-    // Except when computing a SourceRange for an ASTScope. Then the range
-    // must be (Start - TrainingQuoteLoc).
-    return TrailingQuoteLoc;
-  }
 
   /// Call the \c callback with information about each segment in turn.
   void forEachSegment(ASTContext &Ctx,

branches/tensorflow/include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 493; // dependency types for structs
+const uint16_t SWIFTMODULE_VERSION_MINOR = 491; // mangled class names as vtable keys
 
 using DeclIDField = BCFixed<31>;
 
@@ -948,8 +948,7 @@ namespace decls_block {
     GenericEnvironmentIDField, // generic environment
     AccessLevelField,       // access level
     BCVBR<4>,               // number of conformances
-    BCVBR<4>,               // number of inherited types
-    BCArray<TypeIDField>    // inherited types, followed by dependency types
+    BCArray<TypeIDField>    // inherited types
     // Trailed by the generic parameters (if any), the members record, and
     // finally conformance info (if any).
   >;
@@ -982,8 +981,7 @@ namespace decls_block {
     TypeIDField,            // superclass
     AccessLevelField,       // access level
     BCVBR<4>,               // number of conformances
-    BCVBR<4>,               // number of inherited types
-    BCArray<TypeIDField>    // inherited types, followed by dependency types
+    BCArray<TypeIDField>    // inherited types
     // Trailed by the generic parameters (if any), the members record, and
     // finally conformance info (if any).
   >;

branches/tensorflow/lib/AST/ASTContext.cpp

@@ -3440,13 +3440,50 @@ DependentMemberType *DependentMemberType::get(Type base,
 
 OpaqueTypeArchetypeType *
 OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
-                             SubstitutionMap Substitutions)
-{
+                             SubstitutionMap Substitutions) {
   // TODO: We could attempt to preserve type sugar in the substitution map.
-  // Currently archetypes are assumed to be always canonical in many places,
-  // though, so doing so would require fixing those places.
   Substitutions = Substitutions.getCanonical();
-
+  
+  // TODO: Eventually an opaque archetype ought to be arbitrarily substitutable
+  // into any generic environment. However, there isn't currently a good way to
+  // do this with GenericSignatureBuilder; in a situation like this:
+  //
+  // __opaque_type Foo<t_0_0: P>: Q // internal signature <t_0_0: P, t_1_0: Q>
+  //
+  // func bar<t_0_0, t_0_1, t_0_2: P>() -> Foo<t_0_2>
+  //
+  // we'd want to feed the GSB constraints to form:
+  //
+  // <t_0_0: P, t_1_0: Q where t_0_0 == t_0_2>
+  //
+  // even though t_0_2 isn't *in* this generic signature; it represents a type
+  // bound elsewhere from some other generic context. If we knew the generic
+  // environment `t_0_2` came from, then maybe we could map it into that context,
+  // but currently we have no way to know that with certainty.
+  //
+  // For now, opaque types cannot propagate across decls; every declaration
+  // with an opaque type has a unique opaque decl. Therefore, the only
+  // expressions involving opaque types ought to be contextualized inside
+  // function bodies, and the only time we need an opaque interface type should
+  // be for the opaque decl itself and the originating decl with the opaque
+  // result type, in which case the interface type mapping is identity and
+  // this problem can be temporarily avoided.
+#ifndef NDEBUG
+  for (unsigned i : indices(Substitutions.getReplacementTypes())) {
+    auto replacement = Substitutions.getReplacementTypes()[i];
+    
+    if (!replacement->hasTypeParameter())
+      continue;
+    
+    auto replacementParam = replacement->getAs<GenericTypeParamType>();
+    if (!replacementParam)
+      llvm_unreachable("opaque types cannot currently be parameterized by non-identity type parameter mappings");
+    
+    assert(i == Decl->getGenericSignature()->getGenericParamOrdinal(replacementParam)
+           && "opaque types cannot currently be parameterized by non-identity type parameter mappings");
+  }
+#endif
+  
   llvm::FoldingSetNodeID id;
   Profile(id, Decl, Substitutions);
 
@@ -3480,34 +3517,7 @@ OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
   // decl have all been same-type-bound to the arguments from our substitution
   // map.
   GenericSignatureBuilder builder(ctx);
-
   builder.addGenericSignature(Decl->getOpaqueInterfaceGenericSignature());
-  // TODO: The proper thing to do to build the environment in which the opaque
-  // type's archetype exists would be to take the generic signature of the
-  // decl, feed it into a GenericSignatureBuilder, then add same-type
-  // constraints into the builder to bind the outer generic parameters
-  // to their substituted types provided by \c Substitutions. However,
-  // this is problematic for interface types. In a situation like this:
-  //
-  // __opaque_type Foo<t_0_0: P>: Q // internal signature <t_0_0: P, t_1_0: Q>
-  //
-  // func bar<t_0_0, t_0_1, t_0_2: P>() -> Foo<t_0_2>
-  //
-  // we'd want to feed the GSB constraints to form:
-  //
-  // <t_0_0: P, t_1_0: Q where t_0_0 == t_0_2>
-  //
-  // even though t_0_2 isn't *in* the generic signature being built; it
-  // represents a type
-  // bound elsewhere from some other generic context. If we knew the generic
-  // environment `t_0_2` came from, then maybe we could map it into that context,
-  // but currently we have no way to know that with certainty.
-  //
-  // Because opaque types are currently limited so that they only have immediate
-  // protocol constraints, and therefore don't interact with the outer generic
-  // parameters at all, we can get away without adding these constraints for now.
-  // Adding where clauses would break this hack.
-#if DO_IT_CORRECTLY
   // Same-type-constrain the arguments in the outer signature to their
   // replacements in the substitution map.
   if (auto outerSig = Decl->getGenericSignature()) {
@@ -3519,24 +3529,7 @@ OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
          [](Type, Type) { llvm_unreachable("error?"); });
     }
   }
-#else
-  // Assert that there are no same type constraints on the underlying type.
-  // or its associated types.
-  //
-  // This should not be possible until we add where clause support.
-# ifndef NDEBUG
-  for (auto reqt :
-                Decl->getOpaqueInterfaceGenericSignature()->getRequirements()) {
-    auto reqtBase = reqt.getFirstType()->getRootGenericParam();
-    if (reqtBase->isEqual(Decl->getUnderlyingInterfaceType())) {
-      assert(reqt.getKind() != RequirementKind::SameType
-             && "supporting where clauses on opaque types requires correctly "
-                "setting up the generic environment for "
-                "OpaqueTypeArchetypeTypes; see comment above");
-    }
-  }
-# endif
-#endif
+  
   auto signature = std::move(builder)
     .computeGenericSignature(SourceLoc());
 

branches/tensorflow/lib/AST/ASTDumper.cpp

@@ -1930,19 +1930,7 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
   }
   void visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E) {
     printCommon(E, "interpolated_string_literal_expr");
-    
-    // Print the trailing quote location
-    if (auto Ty = GetTypeOfExpr(E)) {
-      auto &Ctx = Ty->getASTContext();
-      auto TQL = E->getTrailingQuoteLoc();
-      if (TQL.isValid()) {
-        PrintWithColorRAII(OS, LocationColor) << " trailing_quote_loc=";
-        TQL.print(PrintWithColorRAII(OS, LocationColor).getOS(),
-                  Ctx.SourceMgr);
-      }
-    }
-    PrintWithColorRAII(OS, LiteralValueColor)
-      << " literal_capacity="
+    PrintWithColorRAII(OS, LiteralValueColor) << " literal_capacity=" 
       << E->getLiteralCapacity() << " interpolation_count="
       << E->getInterpolationCount() << '\n';
     printRec(E->getAppendingExpr());

branches/tensorflow/lib/AST/Expr.cpp

@@ -813,7 +813,6 @@ static LiteralExpr *
 shallowCloneImpl(const InterpolatedStringLiteralExpr *E, ASTContext &Ctx,
                  llvm::function_ref<Type(const Expr *)> getType) {
   auto res = new (Ctx) InterpolatedStringLiteralExpr(E->getLoc(),
-                                                     E->getTrailingQuoteLoc(),
                                                      E->getLiteralCapacity(),
                                                      E->getInterpolationCount(),
                                                      E->getAppendingExpr());

branches/tensorflow/lib/ClangImporter/ClangImporter.cpp

@@ -636,9 +636,7 @@ getNormalInvocationArguments(std::vector<std::string> &invocationArgStrs,
     invocationArgStrs.back().append(moduleCachePath);
   }
 
-  if (importerOpts.DisableModulesValidateSystemHeaders) {
-    invocationArgStrs.push_back("-fno-modules-validate-system-headers");
-  } else {
+  if (!importerOpts.DisableModulesValidateSystemHeaders) {
     invocationArgStrs.push_back("-fmodules-validate-system-headers");
   }
 

branches/tensorflow/lib/IDE/REPLCodeCompletion.cpp

@@ -16,7 +16,6 @@
 
 #include "swift/IDE/REPLCodeCompletion.h"
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/DiagnosticSuppression.h"
 #include "swift/AST/Module.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceManager.h"
@@ -194,7 +193,7 @@ doCodeCompletion(SourceFile &SF, StringRef EnteredCode, unsigned *BufferID,
                  CodeCompletionCallbacksFactory *CompletionCallbacksFactory) {
   // Temporarily disable printing the diagnostics.
   ASTContext &Ctx = SF.getASTContext();
-  DiagnosticSuppression SuppressedDiags(Ctx.Diags);
+  DiagnosticTransaction DelayedDiags(Ctx.Diags);
 
   std::string AugmentedCode = EnteredCode.str();
   AugmentedCode += '\0';
@@ -223,10 +222,7 @@ doCodeCompletion(SourceFile &SF, StringRef EnteredCode, unsigned *BufferID,
   // Now we are done with code completion.  Remove the declarations we
   // temporarily inserted.
   SF.Decls.resize(OriginalDeclCount);
-
-  // Reset the error state because it's only relevant to the code that we just
-  // processed, which now gets thrown away.
-  Ctx.Diags.resetHadAnyError();
+  DelayedDiags.abort();
 }
 
 void REPLCompletions::populate(SourceFile &SF, StringRef EnteredCode) {

branches/tensorflow/lib/Parse/ParseExpr.cpp

@@ -2039,8 +2039,8 @@ ParserResult<Expr> Parser::parseExprStringLiteral() {
     // Return an error, but include an empty InterpolatedStringLiteralExpr
     // so that parseDeclPoundDiagnostic() can figure out why this string
     // literal was bad.
-    return makeParserErrorResult(new (Context) InterpolatedStringLiteralExpr(
-        Loc, Loc.getAdvancedLoc(CloseQuoteBegin), 0, 0, nullptr));
+    return makeParserErrorResult(
+        new (Context) InterpolatedStringLiteralExpr(Loc, 0, 0, nullptr));
   }
 
   unsigned LiteralCapacity = 0;
@@ -2093,8 +2093,7 @@ ParserResult<Expr> Parser::parseExprStringLiteral() {
   }
 
   return makeParserResult(Status, new (Context) InterpolatedStringLiteralExpr(
-                                      Loc, Loc.getAdvancedLoc(CloseQuoteBegin),
-                                      LiteralCapacity, InterpolationCount,
+                                      Loc, LiteralCapacity, InterpolationCount,
                                       AppendingExpr));
 }
 

branches/tensorflow/lib/Parse/ParseIfConfig.cpp

@@ -17,7 +17,6 @@
 #include "swift/Parse/Parser.h"
 
 #include "swift/AST/ASTVisitor.h"
-#include "swift/AST/DiagnosticSuppression.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Version.h"
@@ -639,12 +638,6 @@ ParserResult<IfConfigDecl> Parser::parseIfConfig(
     SmallVector<ASTNode, 16> Elements;
     if (isActive || !isVersionCondition) {
       parseElements(Elements, isActive);
-    } else if (SyntaxContext->isEnabled()) {
-      // We shouldn't skip code if we are building syntax tree.
-      // The parser will keep running and we just discard the AST part.
-      DiagnosticSuppression suppression(Context.Diags);
-      SmallVector<ASTNode, 16> dropedElements;
-      parseElements(dropedElements, false);
     } else {
       DiagnosticTransaction DT(Diags);
       skipUntilConditionalBlockClose();