Merge pull request #2995 from slavapestov/function-interface-type-fixes

Author: swift-ci

include/swift/AST/ASTContext.h

@@ -755,7 +755,7 @@ class ASTContext {
 
   /// \brief Retrieve the substitutions for a bound generic type, if known.
   Optional<ArrayRef<Substitution>>
-  getSubstitutions(BoundGenericType *Bound, DeclContext *gpContext) const;
+  getSubstitutions(TypeBase *type, DeclContext *gpContext) const;
 
   /// Record a conformance loader and its context data for the given
   /// declaration.
@@ -856,10 +856,10 @@ class ASTContext {
   Optional<StringRef> getBriefComment(const Decl *D);
   void setBriefComment(const Decl *D, StringRef Comment);
 
-  friend class BoundGenericType;
+  friend class TypeBase;
 
   /// \brief Set the substitutions for the given bound generic type.
-  void setSubstitutions(BoundGenericType *Bound,
+  void setSubstitutions(TypeBase *type,
                         DeclContext *gpContext,
                         ArrayRef<Substitution> Subs) const;
 

include/swift/AST/DeclContext.h

@@ -367,10 +367,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
 
   /// Determine whether the innermost context is generic.
   bool isInnermostContextGeneric() const;
-  
-  /// Determine whether the innermost context is either a generic type context,
-  /// or a concrete type nested inside a generic type context.
-  bool isGenericTypeContext() const;
 
   /// Determine the maximum depth of the current generic type context's generic
   /// parameters. If the current context is not a generic type context, returns

include/swift/AST/Types.h

@@ -1541,26 +1541,6 @@ class BoundGenericType : public TypeBase, public llvm::FoldingSetNode {
   /// Retrieve the set of generic arguments provided at this level.
   ArrayRef<Type> getGenericArgs() const { return GenericArgs; }
 
-  /// \brief Retrieve the set of substitutions used to produce this bound
-  /// generic type from the underlying generic type.
-  ///
-  /// \param module The module in which we should compute the substitutions.
-  /// FIXME: We currently don't account for this properly, so it can be null.
-  ///
-  /// \param resolver The resolver that handles lazy type checking, where
-  /// required. This can be null for a fully-type-checked AST.
-  ///
-  /// \param gpContext The context from which the generic parameters will be
-  /// extracted, which will be either the nominal type declaration or an
-  /// extension thereof. If null, will be set to the nominal type declaration.
-  ArrayRef<Substitution> getSubstitutions(ModuleDecl *module,
-                                          LazyResolver *resolver,
-                                          DeclContext *gpContext = nullptr);
-
-  /// Retrieves the generic parameter context to use with substitutions for
-  /// this bound generic type, using the given context if possible.
-  DeclContext *getGenericParamContext(DeclContext *gpContext) const;
-
   void Profile(llvm::FoldingSetNodeID &ID) {
     RecursiveTypeProperties properties;
     Profile(ID, TheDecl, Parent, GenericArgs, properties);

lib/AST/ASTContext.cpp

@@ -277,7 +277,7 @@ struct ASTContext::Implementation {
     llvm::FoldingSet<UnboundGenericType> UnboundGenericTypes;
     llvm::FoldingSet<BoundGenericType> BoundGenericTypes;
 
-    llvm::DenseMap<std::pair<BoundGenericType *, DeclContext *>,
+    llvm::DenseMap<std::pair<TypeBase *, DeclContext *>,
                    ArrayRef<Substitution>>
       BoundGenericSubstitutions;
 
@@ -1130,35 +1130,36 @@ ASTContext::createTrivialSubstitutions(BoundGenericType *BGT,
 }
 
 Optional<ArrayRef<Substitution>>
-ASTContext::getSubstitutions(BoundGenericType* bound,
+ASTContext::getSubstitutions(TypeBase *type,
                              DeclContext *gpContext) const {
   assert(gpContext && "Missing generic parameter context");
-  auto arena = getArena(bound->getRecursiveProperties());
-  assert(bound->isCanonical() && "Requesting non-canonical substitutions");
+  auto arena = getArena(type->getRecursiveProperties());
+  assert(type->isCanonical() && "Requesting non-canonical substitutions");
   auto &boundGenericSubstitutions
     = Impl.getArena(arena).BoundGenericSubstitutions;
-  auto known = boundGenericSubstitutions.find({bound, gpContext});
+  auto known = boundGenericSubstitutions.find({type, gpContext});
   if (known != boundGenericSubstitutions.end())
     return known->second;
 
   // We can trivially create substitutions for Array and Optional.
-  if (bound->getDecl() == getArrayDecl() ||
-      bound->getDecl() == getOptionalDecl())
-    return createTrivialSubstitutions(bound, gpContext);
+  if (auto bound = dyn_cast<BoundGenericType>(type))
+    if (bound->getDecl() == getArrayDecl() ||
+        bound->getDecl() == getOptionalDecl())
+      return createTrivialSubstitutions(bound, gpContext);
 
   return None;
 }
 
-void ASTContext::setSubstitutions(BoundGenericType* Bound,
+void ASTContext::setSubstitutions(TypeBase* type,
                                   DeclContext *gpContext,
                                   ArrayRef<Substitution> Subs) const {
-  auto arena = getArena(Bound->getRecursiveProperties());
+  auto arena = getArena(type->getRecursiveProperties());
   auto &boundGenericSubstitutions
     = Impl.getArena(arena).BoundGenericSubstitutions;
-  assert(Bound->isCanonical() && "Requesting non-canonical substitutions");
-  assert(boundGenericSubstitutions.count({Bound, gpContext}) == 0 &&
+  assert(type->isCanonical() && "Requesting non-canonical substitutions");
+  assert(boundGenericSubstitutions.count({type, gpContext}) == 0 &&
          "Already have substitutions?");
-  boundGenericSubstitutions[{Bound, gpContext}] = Subs;
+  boundGenericSubstitutions[{type, gpContext}] = Subs;
 }
 
 Type ASTContext::getTypeVariableMemberType(TypeVariableType *baseTypeVar,

lib/AST/Decl.cpp

@@ -4472,7 +4472,7 @@ bool EnumElementDecl::computeType() {
   if (getArgumentType())
     resultTy = FunctionType::get(getArgumentType(), resultTy);
 
-  if (ED->isGenericTypeContext())
+  if (ED->isGenericContext())
     resultTy = PolymorphicFunctionType::get(argTy, resultTy,
                                             ED->getGenericParamsOfContext());
   else

lib/AST/DeclContext.cpp

@@ -431,17 +431,6 @@ bool DeclContext::isGenericContext() const {
   llvm_unreachable("illegal declcontext hierarchy");
 }
 
-/// Determine whether the given context nested inside a generic type context
-/// with no local contexts in between.
-bool DeclContext::isGenericTypeContext() const {
-  for (const auto *dc = this; dc->isTypeContext(); dc = dc->getParent()) {
-    if (dc->isInnermostContextGeneric())
-      return true;
-  }
-  
-  return false;
-}
-
 /// Determine the maximum depth of the current generic type context's generic
 /// parameters. If the current context is not a generic type context, returns
 /// the maximum depth of any generic parameter in this context.

lib/AST/Module.cpp

@@ -662,41 +662,40 @@ void Module::getDisplayDecls(SmallVectorImpl<Decl*> &Results) const {
   FORWARD(getDisplayDecls, (Results));
 }
 
-DeclContext *BoundGenericType::getGenericParamContext(
-               DeclContext *gpContext) const {
-  // If no context was provided, use the declaration itself.
-  if (!gpContext)
-    return getDecl();
-
-  assert(gpContext->getAsNominalTypeOrNominalTypeExtensionContext() == getDecl() &&
-         "not a valid context");
-  return gpContext;
-}
-
-ArrayRef<Substitution> BoundGenericType::getSubstitutions(
-                                           Module *module,
-                                           LazyResolver *resolver,
-                                           DeclContext *gpContext) {
+ArrayRef<Substitution>
+TypeBase::gatherAllSubstitutions(Module *module,
+                                 LazyResolver *resolver,
+                                 DeclContext *gpContext) {
   // FIXME: If there is no module, infer one. This is a hack for callers that
   // don't have access to the module. It will have to go away once we're
   // properly differentiating bound generic types based on the protocol
   // conformances visible from a given module.
   if (!module) {
-    module = getDecl()->getParentModule();
+    module = getAnyNominal()->getParentModule();
   }
 
   // Check the context, introducing the default if needed.
-  gpContext = getGenericParamContext(gpContext);
+  if (!gpContext)
+    gpContext = getAnyNominal();
+
+  assert(gpContext->getAsNominalTypeOrNominalTypeExtensionContext()
+         == getAnyNominal() && "not a valid context");
+
+  auto *genericParams = gpContext->getGenericParamsOfContext();
+  if (!genericParams)
+    return { };
 
   // If we already have a cached copy of the substitutions, return them.
-  auto *canon = getCanonicalType()->castTo<BoundGenericType>();
+  auto *canon = getCanonicalType().getPointer();
   const ASTContext &ctx = canon->getASTContext();
   if (auto known = ctx.getSubstitutions(canon, gpContext))
     return *known;
 
   // Compute the set of substitutions.
   TypeSubstitutionMap substitutions;
 
+  // The type itself contains substitutions up to the innermost
+  // non-type context.
   CanType parent(canon);
   auto *parentDC = gpContext;
   while (parent) {
@@ -727,9 +726,14 @@ ArrayRef<Substitution> BoundGenericType::getSubstitutions(
     llvm_unreachable("Not a nominal or bound generic type");
   }
 
-  // Collect all of the archetypes.
-  auto *genericParams = gpContext->getGenericParamsOfContext();
+  // Add forwarding substitutions from the outer context if we have
+  // a type nested inside a generic function.
+  if (auto *outerGenericParams = parentDC->getGenericParamsOfContext()) {
+    for (auto archetype : outerGenericParams->getAllNestedArchetypes())
+      substitutions[archetype] = archetype;
+  }
 
+  // Collect all of the archetypes.
   SmallVector<ArchetypeType *, 2> allArchetypesList;
   ArrayRef<ArchetypeType *> allArchetypes = genericParams->getAllArchetypes();
   if (genericParams->getOuterParameters()) {

lib/AST/Type.cpp

@@ -329,32 +329,6 @@ ArrayRef<Type> TypeBase::getAllGenericArgs(SmallVectorImpl<Type> &scratch) {
   return scratch;
 }
 
-ArrayRef<Substitution>
-TypeBase::gatherAllSubstitutions(Module *module,
-                                 LazyResolver *resolver,
-                                 DeclContext *gpContext) {
-  Type type(this);
-  while (type) {
-    // Skip to the parent of a nominal type.
-    if (auto nominal = type->getAs<NominalType>()) {
-      type = nominal->getParent();
-      if (gpContext)
-        gpContext = gpContext->getParent();
-      continue;
-    }
-
-    // Return the substitutions in a bound generic type.
-    // This walks any further parent types.
-    if (auto boundGeneric = type->getAs<BoundGenericType>())
-      return boundGeneric->getSubstitutions(module, resolver, gpContext);
-
-    llvm_unreachable("Not a nominal or bound generic type");
-  }
-
-  // Not a generic type.
-  return { };
-}
-
 bool TypeBase::isUnspecializedGeneric() {
   CanType CT = getCanonicalType();
   if (CT.getPointer() != this)
@@ -1814,11 +1788,10 @@ bool TypeBase::isBindableTo(Type b, LazyResolver *resolver) {
         if (bgt->getDecl()->isInvalid())
           return false;
 
-        auto origSubs = bgt->getSubstitutions(bgt->getDecl()->getParentModule(),
-                                              Resolver);
-        auto substSubs = substBGT->getSubstitutions(
-                                              bgt->getDecl()->getParentModule(),
-                                              Resolver);
+        auto origSubs = bgt->gatherAllSubstitutions(
+            bgt->getDecl()->getParentModule(), Resolver);
+        auto substSubs = substBGT->gatherAllSubstitutions(
+            bgt->getDecl()->getParentModule(), Resolver);
         assert(origSubs.size() == substSubs.size());
         for (unsigned subi : indices(origSubs)) {
           if (!visit(origSubs[subi].getReplacement()->getCanonicalType(),

lib/IDE/ReconstructType.cpp

@@ -77,7 +77,7 @@ static TypeBase *GetTemplateArgument(TypeBase *type, size_t arg_idx) {
       if (!bound_generic_type)
         break;
       const ArrayRef<Substitution> &substitutions =
-          bound_generic_type->getSubstitutions(nullptr, nullptr);
+          bound_generic_type->gatherAllSubstitutions(nullptr, nullptr);
       if (arg_idx >= substitutions.size())
         break;
       const Substitution &substitution = substitutions[arg_idx];

lib/IRGen/Fulfillment.cpp

@@ -245,10 +245,10 @@ bool FulfillmentMap::searchBoundGenericTypeMetadata(IRGenModule &IGM,
   bool hadFulfillment = false;
 
   GenericTypeRequirements requirements(IGM, type->getDecl());
-  requirements.enumerateFulfillments(IGM,
-                  type->getSubstitutions(IGM.getSwiftModule(), nullptr),
-                                [&](unsigned reqtIndex, CanType arg,
-                                    Optional<ProtocolConformanceRef> conf) {
+  requirements.enumerateFulfillments(
+      IGM, type->gatherAllSubstitutions(IGM.getSwiftModule(), nullptr),
+      [&](unsigned reqtIndex, CanType arg,
+          Optional<ProtocolConformanceRef> conf) {
     // Skip uninteresting type arguments.
     if (!keys.hasInterestingType(arg))
       return;