---

yaml
---
r: 293853
b: refs/heads/tensorflow
c: 768d1c5
h: refs/heads/master
i:
  293851: 82cf6ab

Author: aschwaighofer

[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: ef7884434910e092c61df33cd58a36fa8036e76c
+refs/heads/tensorflow: 768d1c51a197b0c82a27df45e6e6a01fcfb945ee
 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/ProtocolConformanceRef.h

@@ -109,11 +109,6 @@ class ProtocolConformanceRef {
                                LookupConformanceFn conformances,
                                SubstOptions options = None) const;
 
-  /// Replace opaque types in the conforming type with their underlying types,
-  /// and resolve opaque conformances to their underlying conformances.
-  ProtocolConformanceRef substOpaqueTypesWithUnderlyingTypes(
-      Type origType, ModuleDecl *modulePerformingSubstitution) const;
-
   /// Given a dependent type (expressed in terms of this conformance's
   /// protocol), follow it from the conforming type.
   Type getAssociatedType(Type origType, Type dependentType,

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

@@ -175,11 +175,6 @@ class SubstitutionMap {
                         LookupConformanceFn conformances,
                         SubstOptions options = None) const;
 
-  /// Replace opaque types in the replacement types in the map with their
-  /// underlying types. Does not change keys.
-  SubstitutionMap substOpaqueTypesWithUnderlyingTypes(
-      ModuleDecl *modulePerformingSubstitution) const;
-
   /// Create a substitution map for a protocol conformance.
   static SubstitutionMap
   getProtocolSubstitutions(ProtocolDecl *protocol,

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

@@ -316,11 +316,6 @@ class Type {
   /// Replace references to substitutable types with error types.
   Type substDependentTypesWithErrorTypes() const;
 
-  /// Replace opaque types with their underlying types when visible at the given
-  /// resilience expansion.
-  Type substOpaqueTypesWithUnderlyingTypes(
-      ModuleDecl *modulePerformingSubstitution) const;
-
   bool isPrivateStdlibType(bool treatNonBuiltinProtocolsAsPublic = true) const;
 
   void dump() const;

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

@@ -4821,26 +4821,6 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
 BEGIN_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)
 END_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)
 
-/// A function object that can be used as a \c TypeSubstitutionFn and
-/// \c LookupConformanceFn for \c Type::subst style APIs to map opaque
-/// archetypes with underlying types visible at a given resilience expansion
-/// to their underlying types.
-class ReplaceOpaqueTypesWithUnderlyingTypes {
-public:
-  ModuleDecl *modulePerformingSubstitution;
-  ReplaceOpaqueTypesWithUnderlyingTypes(
-      ModuleDecl *modulePerformingSubstitution)
-      : modulePerformingSubstitution(modulePerformingSubstitution) {}
-
-  /// TypeSubstitutionFn
-  Type operator()(SubstitutableType *maybeOpaqueType) const;
-  
-  /// LookupConformanceFn
-  Optional<ProtocolConformanceRef> operator()(CanType maybeOpaqueType,
-                                              Type replacementType,
-                                              ProtocolDecl *protocol) const;
-};
-  
 /// An archetype that represents the dynamic type of an opened existential.
 class OpenedArchetypeType final : public ArchetypeType,
     private ArchetypeTrailingObjects<OpenedArchetypeType>

branches/tensorflow/include/swift/SIL/TypeSubstCloner.h

@@ -109,11 +109,7 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
 
       assert(Subs.empty() ||
              SubstCalleeSILType ==
-                 Callee->getType().substGenericArgs(AI.getModule(), Subs) ||
-             (Cloner.ReplacingOpaqueArchetypes &&
-              SubstCalleeSILType ==
-                  Cloner.getOpType(Callee->getType().substGenericArgs(
-                      AI.getModule(), Subs))));
+                 Callee->getType().substGenericArgs(AI.getModule(), Subs));
     }
 
     ArrayRef<SILValue> getArguments() const {
@@ -159,14 +155,12 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
   TypeSubstCloner(SILFunction &To,
                   SILFunction &From,
                   SubstitutionMap ApplySubs,
-                  bool Inlining = false,
-                  bool ReplacingOpaqueArchetypes = false)
+                  bool Inlining = false)
     : SILClonerWithScopes<ImplClass>(To, Inlining),
       SwiftMod(From.getModule().getSwiftModule()),
       SubsMap(ApplySubs),
       Original(From),
-      Inlining(Inlining),
-      ReplacingOpaqueArchetypes(ReplacingOpaqueArchetypes) {
+      Inlining(Inlining) {
   }
 
 protected:
@@ -387,8 +381,6 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
   SILFunction &Original;
   /// True, if used for inlining.
   bool Inlining;
-  /// True if replacing opaque result archetypes.
-  bool ReplacingOpaqueArchetypes;
 };
 
 } // end namespace swift

branches/tensorflow/lib/AST/ProtocolConformance.cpp

@@ -141,14 +141,6 @@ ProtocolConformanceRef::subst(Type origType,
   llvm_unreachable("Invalid conformance substitution");
 }
 
-ProtocolConformanceRef
-ProtocolConformanceRef::substOpaqueTypesWithUnderlyingTypes(
-    Type origType, ModuleDecl *modulePerformingSubstitution) const {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(modulePerformingSubstitution);
-  return subst(origType, replacer, replacer,
-               SubstFlags::SubstituteOpaqueArchetypes);
-}
-
 Type
 ProtocolConformanceRef::getTypeWitnessByName(Type type,
                                              ProtocolConformanceRef conformance,

branches/tensorflow/lib/AST/SubstitutionMap.cpp

@@ -492,12 +492,6 @@ SubstitutionMap SubstitutionMap::subst(TypeSubstitutionFn subs,
   return SubstitutionMap(genericSig, newSubs, newConformances);
 }
 
-SubstitutionMap SubstitutionMap::substOpaqueTypesWithUnderlyingTypes(
-    ModuleDecl *modulePerformingSubstitution) const {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(modulePerformingSubstitution);
-  return subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes);
-}
-
 SubstitutionMap
 SubstitutionMap::getProtocolSubstitutions(ProtocolDecl *protocol,
                                           Type selfType,

branches/tensorflow/lib/AST/Type.cpp

@@ -2460,117 +2460,6 @@ GenericSignature *OpaqueTypeArchetypeType::getBoundSignature() const {
   return Environment->getGenericSignature();
 }
 
-static Optional<std::pair<ArchetypeType *, OpaqueTypeArchetypeType*>>
-getArchetypeAndRootOpaqueArchetype(Type maybeOpaqueType) {
-  auto archetype = dyn_cast<ArchetypeType>(maybeOpaqueType.getPointer());
-  if (!archetype)
-    return None;
-  auto opaqueRoot = dyn_cast<OpaqueTypeArchetypeType>(archetype->getRoot());
-  if (!opaqueRoot)
-    return None;
-
-  return std::make_pair(archetype, opaqueRoot);
-}
-
-Type ReplaceOpaqueTypesWithUnderlyingTypes::operator()(
-                                     SubstitutableType *maybeOpaqueType) const {
-  auto archetypeAndRoot = getArchetypeAndRootOpaqueArchetype(maybeOpaqueType);
-  if (!archetypeAndRoot)
-    return maybeOpaqueType;
-
-  auto archetype = archetypeAndRoot->first;
-  auto opaqueRoot = archetypeAndRoot->second;
-
-  // Don't replace opaque types from resilient modules.
-  auto namingDecl = opaqueRoot->getDecl()->getNamingDecl();
-  auto module = namingDecl->getModuleContext();
-  if (module->isResilient() && module != modulePerformingSubstitution &&
-      !namingDecl->getAttrs().hasAttribute<InlinableAttr>()) {
-    return maybeOpaqueType;
-  }
-
-  auto subs = opaqueRoot->getDecl()->getUnderlyingTypeSubstitutions();
-  // TODO: Check the resilience expansion, and handle opaque types with
-  // unknown underlying types. For now, all opaque types are always
-  // fragile.
-  assert(subs.hasValue() && "resilient opaque types not yet supported");
-  
-  // Apply the underlying type substitutions to the interface type of the
-  // archetype in question. This will map the inner generic signature of the
-  // opaque type to its outer signature.
-  auto partialSubstTy = archetype->getInterfaceType().subst(*subs);
-  // Then apply the substitutions from the root opaque archetype, to specialize
-  // for its type arguments.
-  auto substTy = partialSubstTy.subst(opaqueRoot->getSubstitutions());
-  
-  // If the type still contains opaque types, recur.
-  if (substTy->hasOpaqueArchetype()) {
-    return substTy.substOpaqueTypesWithUnderlyingTypes(
-        modulePerformingSubstitution);
-  }
-  return substTy;
-}
-
-Optional<ProtocolConformanceRef>
-ReplaceOpaqueTypesWithUnderlyingTypes::operator()(CanType maybeOpaqueType,
-                                                 Type replacementType,
-                                                 ProtocolDecl *protocol) const {
-  auto abstractRef = ProtocolConformanceRef(protocol);
-
-  auto archetypeAndRoot = getArchetypeAndRootOpaqueArchetype(maybeOpaqueType);
-  if (!archetypeAndRoot) {
-    assert(maybeOpaqueType->isTypeParameter()
-           || maybeOpaqueType->is<ArchetypeType>());
-    return abstractRef;
-  }
-  
-  auto archetype = archetypeAndRoot->first;
-  auto opaqueRoot = archetypeAndRoot->second;
-
-  // Don't replace opaque types from resilient modules.
-  auto namingDecl = opaqueRoot->getDecl()->getNamingDecl();
-  auto module = namingDecl->getModuleContext();
-  if (module->isResilient() && module != modulePerformingSubstitution &&
-      !namingDecl->getAttrs().hasAttribute<InlinableAttr>()) {
-    return abstractRef;
-  }
-
-  auto subs = opaqueRoot->getDecl()->getUnderlyingTypeSubstitutions();
-  assert(subs.hasValue());
-
-  // Apply the underlying type substitutions to the interface type of the
-  // archetype in question. This will map the inner generic signature of the
-  // opaque type to its outer signature.
-  auto partialSubstTy = archetype->getInterfaceType().subst(*subs);
-  auto partialSubstRef = abstractRef.subst(archetype->getInterfaceType(),
-                                           *subs);
-  
-  // Then apply the substitutions from the root opaque archetype, to specialize
-  // for its type arguments.
-  auto substTy = partialSubstTy.subst(opaqueRoot->getSubstitutions());
-  auto substRef = partialSubstRef.subst(partialSubstTy,
-                                        opaqueRoot->getSubstitutions());
-  
-  // If the type still contains opaque types, recur.
-  if (substTy->hasOpaqueArchetype()) {
-    return substRef.substOpaqueTypesWithUnderlyingTypes(
-        substTy, modulePerformingSubstitution);
-  }
-  return substRef;
-}
-
-Type Type::substOpaqueTypesWithUnderlyingTypes(
-    ModuleDecl *modulePerformingSubstitution) const {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(modulePerformingSubstitution);
-  return subst(replacer, replacer,
-               SubstFlags::SubstituteOpaqueArchetypes
-               // TODO(opaque): Currently lowered types always get opaque types
-               // substituted out of them. When we support opaque type resilience
-               // this won't be true anymore and we'll need to handle
-               // opaque type substitution in SILType::subst.
-               | SubstFlags::AllowLoweredTypes);
-}
-
 CanNestedArchetypeType NestedArchetypeType::getNew(
                                    const ASTContext &Ctx,
                                    ArchetypeType *Parent,

branches/tensorflow/lib/SIL/SILFunctionType.cpp

@@ -2498,7 +2498,8 @@ SILFunctionType::substGenericArgs(SILModule &silModule,
                                   LookupConformanceFn conformances) {
   if (!isPolymorphic()) return CanSILFunctionType(this);
   SILTypeSubstituter substituter(silModule, subs, conformances,
-                                 getGenericSignature(), false);
+                                 getGenericSignature(),
+                                 /*shouldSubstituteOpaqueTypes*/ false);
   return substituter.substSILFunctionType(CanSILFunctionType(this));
 }