---

yaml
---
r: 294591
b: refs/heads/tensorflow
c: eeeb469
h: refs/heads/master
i:
  294589: 1200c2b
  294587: 2a6ef93
  294583: bdbfc42
  294575: 3d2bd53
  294559: 61919ad
  294527: 5e63973

Author: jckarter

[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: 8e5c027a776a5b9f3b69226f6580752b7171bf1d
+refs/heads/tensorflow: eeeb46956f52d2000e4a5cfbc98d5f7a31e5edef
 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/CMakeLists.txt

@@ -117,6 +117,8 @@ endif()
 
 set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
     "Build Swift with code coverage instrumenting enabled [FALSE, NOT-MERGED, MERGED]")
+set_property(CACHE SWIFT_ANALYZE_CODE_COVERAGE PROPERTY
+    STRINGS FALSE "NOT-MERGED" "MERGED")
 
 # SWIFT_VERSION is deliberately /not/ cached so that an existing build directory
 # can be reused when a new version of Swift comes out (assuming the user hasn't
@@ -169,6 +171,8 @@ endif()
 
 set(SWIFT_STDLIB_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
     "Build type for the Swift standard library and SDK overlays [Debug, RelWithDebInfo, Release, MinSizeRel]")
+set_property(CACHE SWIFT_STDLIB_BUILD_TYPE PROPERTY
+    STRINGS "Debug" "RelWithDebInfo" "Release" "MinSizeRel")
 # Allow the user to specify the standard library CMAKE_MSVC_RUNTIME_LIBRARY
 # value.  The following values are valid:
 #   - MultiThreaded (/MT)

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/cmake/modules/StandaloneOverlay.cmake

@@ -65,6 +65,10 @@ option(SWIFT_ENABLE_PARSEABLE_MODULE_INTERFACES
 set(SWIFT_STDLIB_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
   "Build type for the Swift standard library and SDK overlays.")
 
+set_property(CACHE SWIFT_STDLIB_BUILD_TYPE PROPERTY
+  STRINGS
+    "Debug" "RelWithDebInfo" "Release" "MinSizeRel")
+
 # -----------------------------------------------------------------------------
 # Constants
 

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

@@ -452,7 +452,7 @@ ERROR(cannot_convert_sequence_element_value,none,
       "cannot convert sequence element type %0 to expected type %1",
       (Type, Type))
 ERROR(cannot_convert_sequence_element_protocol,none,
-      "sequence element type %0 does not conform to expected protocol %1",
+      "sequence element type %0 does not conform to expected type %1",
       (Type, Type))
 
 ERROR(throws_functiontype_mismatch,none,

branches/tensorflow/lib/AST/ASTContext.cpp

@@ -3440,50 +3440,13 @@ 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);
 
@@ -3517,7 +3480,34 @@ 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()) {
@@ -3529,7 +3519,24 @@ 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/Type.cpp

@@ -2932,11 +2932,8 @@ static Type getMemberForBaseType(LookupConformanceFn lookupConformances,
   }
 
   // If the parent is a type variable or a member rooted in a type variable,
-  // or if the parent is a type parameter, we're done. Also handle
-  // UnresolvedType here, which can come up in diagnostics.
-  if (substBase->isTypeVariableOrMember() ||
-      substBase->isTypeParameter() ||
-      substBase->is<UnresolvedType>())
+  // we're done.
+  if (substBase->isTypeVariableOrMember())
     return getDependentMemberType(substBase);
 
   // Retrieve the member type with the given name.
@@ -2945,6 +2942,10 @@ static Type getMemberForBaseType(LookupConformanceFn lookupConformances,
   if (substBase->is<TupleType>())
     return failed();
 
+  // If the parent is dependent, create a dependent member type.
+  if (substBase->isTypeParameter())
+    return getDependentMemberType(substBase);
+
   // If we know the associated type, look in the witness table.
   LazyResolver *resolver = substBase->getASTContext().getLazyResolver();
   if (assocType) {

branches/tensorflow/lib/IDE/CodeCompletion.cpp

@@ -2286,14 +2286,15 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     Builder.addRightParen();
   }
 
-  SemanticContextKind getSemanticContextKind(const ValueDecl *VD) {
+  SemanticContextKind getSemanticContextKind(const AbstractFunctionDecl *AFD) {
     // FIXME: to get the corect semantic context we need to know how lookup
-    // would have found the VD. For now, just infer a reasonable semantics.
+    // would have found the declaration AFD. For now, just infer a reasonable
+    // semantics.
 
-    if (!VD)
+    if (!AFD)
       return SemanticContextKind::CurrentModule;
 
-    DeclContext *calleeDC = VD->getDeclContext();
+    DeclContext *calleeDC = AFD->getDeclContext();
 
     if (calleeDC->isTypeContext())
       // FIXME: We should distinguish CurrentNominal and Super. We need to
@@ -2308,37 +2309,6 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     return SemanticContextKind::OtherModule;
   }
 
-  void addSubscriptCallPattern(const AnyFunctionType *AFT,
-                               const SubscriptDecl *SD) {
-    foundFunction(AFT);
-    auto genericSig =
-        SD->getInnermostDeclContext()->getGenericSignatureOfContext();
-    AFT = eraseArchetypes(CurrDeclContext->getParentModule(),
-                          const_cast<AnyFunctionType *>(AFT), genericSig)
-              ->castTo<AnyFunctionType>();
-
-    CommandWordsPairs Pairs;
-    CodeCompletionResultBuilder Builder(
-        Sink, CodeCompletionResult::ResultKind::Declaration,
-        getSemanticContextKind(SD), expectedTypeContext);
-    Builder.setAssociatedDecl(SD);
-    setClangDeclKeywords(SD, Pairs, Builder);
-    if (!HaveLParen)
-      Builder.addLeftBracket();
-    else
-      Builder.addAnnotatedLeftBracket();
-    addCallArgumentPatterns(Builder, AFT, SD->getIndices());
-    if (!HaveLParen)
-      Builder.addRightBracket();
-    else
-      Builder.addAnnotatedRightBracket();
-    if (SD && SD->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>())
-      addTypeAnnotationForImplicitlyUnwrappedOptional(Builder,
-                                                      AFT->getResult());
-    else
-      addTypeAnnotation(Builder, AFT->getResult());
-  }
-
   void addFunctionCallPattern(const AnyFunctionType *AFT,
                               const AbstractFunctionDecl *AFD = nullptr) {
     if (AFD) {
@@ -2358,15 +2328,14 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
           AFD ? CodeCompletionResult::ResultKind::Declaration
               : CodeCompletionResult::ResultKind::Pattern,
           getSemanticContextKind(AFD), expectedTypeContext);
-      if (AFD) {
-        Builder.setAssociatedDecl(AFD);
-        setClangDeclKeywords(AFD, Pairs, Builder);
-      }
-
       if (!HaveLParen)
         Builder.addLeftParen();
       else
         Builder.addAnnotatedLeftParen();
+      if (AFD) {
+        Builder.setAssociatedDecl(AFD);
+        setClangDeclKeywords(AFD, Pairs, Builder);
+      }
 
       addCallArgumentPatterns(Builder, AFT->getParams(), declParams,
                               includeDefaultArgs);
@@ -5394,15 +5363,9 @@ void CodeCompletionCallbacksImpl::doneParsing() {
     if (ShouldCompleteCallPatternAfterParen &&
         !ContextInfo.getPossibleCallees().empty()) {
       Lookup.setHaveLParen(true);
-      for (auto &typeAndDecl : ContextInfo.getPossibleCallees()) {
-        if (auto SD = dyn_cast_or_null<SubscriptDecl>(typeAndDecl.second)) {
-          Lookup.addSubscriptCallPattern(typeAndDecl.first, SD);
-        } else {
-          Lookup.addFunctionCallPattern(
-              typeAndDecl.first,
-              dyn_cast_or_null<AbstractFunctionDecl>(typeAndDecl.second));
-        }
-      }
+      for (auto &typeAndDecl : ContextInfo.getPossibleCallees())
+        Lookup.tryFunctionCallCompletions(typeAndDecl.first,
+                                          typeAndDecl.second);
       Lookup.setHaveLParen(false);
 
       shouldPerformGlobalCompletion =

branches/tensorflow/lib/IDE/CodeCompletionResultBuilder.h

@@ -217,21 +217,11 @@ class CodeCompletionResultBuilder {
         CodeCompletionString::Chunk::ChunkKind::RightParen, ")");
   }
 
-  void addAnnotatedLeftBracket() {
-    addLeftBracket();
-    getLastChunk().setIsAnnotation();
-  }
-
   void addLeftBracket() {
     addChunkWithTextNoCopy(
         CodeCompletionString::Chunk::ChunkKind::LeftBracket, "[");
   }
 
-  void addAnnotatedRightBracket() {
-    addRightBracket();
-    getLastChunk().setIsAnnotation();
-  }
-
   void addRightBracket() {
     addChunkWithTextNoCopy(
         CodeCompletionString::Chunk::ChunkKind::RightBracket, "]");

branches/tensorflow/lib/IDE/ExprContextAnalysis.cpp

@@ -404,7 +404,6 @@ static bool collectPossibleCalleesForSubscript(
   if (subscriptExpr->hasDecl()) {
     if (auto SD = dyn_cast<SubscriptDecl>(subscriptExpr->getDecl().getDecl())) {
       auto declType = SD->getInterfaceType();
-      declType = declType.subst(subscriptExpr->getDecl().getSubstitutions());
       if (auto *funcType = declType->getAs<AnyFunctionType>())
         candidates.emplace_back(funcType, SD);
     }

branches/tensorflow/lib/Parse/ParseExpr.cpp

@@ -925,9 +925,12 @@ ParserResult<Expr> Parser::parseExprSuper(bool isExprBasic) {
                                         rSquareLoc,
                                         trailingClosure,
                                         SyntaxKind::FunctionCallArgumentList);
+    if (status.hasCodeCompletion())
+      return makeParserCodeCompletionResult<Expr>();
+    if (status.isError())
+      return nullptr;
     SyntaxContext->createNodeInPlace(SyntaxKind::SubscriptExpr);
     return makeParserResult(
-      status,
       SubscriptExpr::create(Context, superRef, lSquareLoc, indexArgs,
                             indexArgLabels, indexArgLabelLocs, rSquareLoc,
                             trailingClosure, ConcreteDeclRef(),

branches/tensorflow/lib/SIL/TypeLowering.cpp

@@ -19,7 +19,6 @@
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/GenericEnvironment.h"
-#include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/Pattern.h"
@@ -1901,10 +1900,6 @@ TypeConverter::getFunctionInterfaceTypeWithCaptures(CanAnyFunctionType funcType,
 CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
   auto *vd = c.loc.dyn_cast<ValueDecl *>();
 
-  if (vd && !vd->hasInterfaceType()) {
-    Context.getLazyResolver()->resolveDeclSignature(vd);
-  }
-
   switch (c.kind) {
   case SILDeclRef::Kind::Func: {
     if (auto *ACE = c.loc.dyn_cast<AbstractClosureExpr *>()) {

branches/tensorflow/lib/SILGen/ManagedValue.cpp

@@ -69,12 +69,6 @@ void ManagedValue::copyInto(SILGenFunction &SGF, SILLocation loc,
   lowering.emitStoreOfCopy(SGF.B, loc, copy, dest, IsInitialization);
 }
 
-void ManagedValue::copyInto(SILGenFunction &SGF, SILLocation loc,
-                            Initialization *dest) {
-  dest->copyOrInitValueInto(SGF, loc, *this, /*isInit*/ false);
-  dest->finishInitialization(SGF);
-}
-
 /// This is the same operation as 'copy', but works on +0 values that don't
 /// have cleanups.  It returns a +1 value with one.
 ManagedValue ManagedValue::copyUnmanaged(SILGenFunction &SGF, SILLocation loc) {

branches/tensorflow/lib/SILGen/ManagedValue.h

@@ -334,10 +334,6 @@ class ManagedValue {
   /// uninitialized address.
   void copyInto(SILGenFunction &SGF, SILLocation loc, SILValue dest);
 
-  /// Store a copy of this value with independent ownership into the given
-  /// initialization \p dest.
-  void copyInto(SILGenFunction &SGF, SILLocation loc, Initialization *dest);
-
   explicit operator bool() const {
     // "InContext" is not considered false.
     return bool(getValue()) || valueAndFlag.getInt();