Merge pull request #6136 from DougGregor/minor-cleanups

Author: swift-ci

include/swift/AST/ASTContext.h

@@ -203,10 +203,6 @@ class ASTContext {
   /// The name of the SwiftShims module "SwiftShims".
   Identifier SwiftShimsModuleName;
 
-  /// Note: in non-NDEBUG builds, tracks the context of each primary
-  /// archetype type, which can be very useful for debugging.
-  llvm::DenseMap<ArchetypeType *, DeclContext *> ArchetypeContexts;
-
   // Define the set of known identifiers.
 #define IDENTIFIER_WITH_NAME(Name, IdStr) Identifier Id_##Name;
 #include "swift/AST/KnownIdentifiers.def"

include/swift/AST/Decl.h

@@ -1466,6 +1466,9 @@ class ExtensionDecl final : public Decl, public DeclContext,
   void setGenericEnvironment(GenericEnvironment *env) {
     assert(!GenericEnv && "Already have generic context");
     GenericEnv = env;
+
+    if (GenericEnv)
+      GenericEnv->setOwningDeclContext(this);
   }
 
   /// Retrieve the generic requirements.
@@ -2275,6 +2278,9 @@ class GenericTypeDecl : public TypeDecl, public DeclContext {
   void setGenericEnvironment(GenericEnvironment *env) {
     assert(!this->GenericEnv && "already have generic context?");
     this->GenericEnv = env;
+
+    if (GenericEnv)
+      GenericEnv->setOwningDeclContext(this);
   }
 
   // Resolve ambiguity due to multiple base classes.
@@ -4558,6 +4564,9 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
   void setGenericEnvironment(GenericEnvironment *GenericEnv) {
     assert(!this->GenericEnv && "already have generic context?");
     this->GenericEnv = GenericEnv;
+
+    if (GenericEnv)
+      GenericEnv->setOwningDeclContext(this);
   }
 
   // Expose our import as member status

include/swift/AST/GenericEnvironment.h

@@ -38,8 +38,9 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
         : private llvm::TrailingObjects<GenericEnvironment, Type,
                                         std::pair<ArchetypeType *,
                                                   GenericTypeParamType *>> {
-  GenericSignature *Signature;
-  ArchetypeBuilder *Builder;
+  GenericSignature *Signature = nullptr;
+  ArchetypeBuilder *Builder = nullptr;
+  DeclContext *OwningDC = nullptr;
 
   // The number of generic type parameter -> context type mappings we have
   // recorded so far. This saturates at the number of generic type parameters,
@@ -164,6 +165,18 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   GenericEnvironment *getIncomplete(GenericSignature *signature,
                                     ArchetypeBuilder *builder);
 
+  /// Set the owning declaration context for this generic environment.
+  void setOwningDeclContext(DeclContext *owningDC);
+
+  /// Retrieve the declaration context that owns this generic environment, if
+  /// there is one.
+  ///
+  /// Note that several generic environments may refer to the same declaration
+  /// context, because non-generic declarations nested within generic ones
+  /// inherit the enclosing generic environment. In such cases, the owning
+  /// context is the outermost context.
+  DeclContext *getOwningDeclContext() const { return OwningDC; }
+
   /// Add a mapping of a generic parameter to a specific type (which may be
   /// an archetype)
   void addMapping(GenericParamKey key, Type contextType);

lib/AST/ASTContext.cpp

@@ -2386,13 +2386,9 @@ void ASTContext::dumpArchetypeContext(ArchetypeType *archetype,
   if (archetype->isOpenedExistential())
     return;
 
-  archetype = archetype->getPrimary();
-  if (!archetype)
-    return;
-
-  auto knownDC = ArchetypeContexts.find(archetype);
-  if (knownDC != ArchetypeContexts.end())
-    knownDC->second->printContext(os, indent);
+  if (auto env = archetype->getGenericEnvironment())
+    if (auto owningDC = env->getOwningDeclContext())
+      owningDC->printContext(os, indent);
 }
 
 //===----------------------------------------------------------------------===//

lib/AST/ASTVerifier.cpp

@@ -451,11 +451,12 @@ struct ASTNodeBase {};
             Out << "AST verification error: archetype "
                 << archetype->getString() << " not allowed in this context\n";
 
-            auto knownDC = Ctx.ArchetypeContexts.find(parent);
-            if (knownDC != Ctx.ArchetypeContexts.end()) {
-              llvm::errs() << "archetype came from:\n";
-              knownDC->second->dumpContext();
-              llvm::errs() << "\n";
+            if (auto env = parent->getGenericEnvironment()) {
+              if (auto owningDC = env->getOwningDeclContext()) {
+                llvm::errs() << "archetype came from:\n";
+                owningDC->dumpContext();
+                llvm::errs() << "\n";
+              }
             }
 
             return true;

lib/AST/ArchetypeBuilder.cpp

@@ -546,11 +546,11 @@ Type ArchetypeBuilder::PotentialArchetype::getTypeInContext(
 
   // Local function to check whether we have a generic parameter that has
   // already been recorded
-  auto getAlreadyRecoveredGenericParam = [&]() -> Optional<Type> {
-    if (!isGenericParam()) return None;
+  auto getAlreadyRecoveredGenericParam = [&]() -> Type {
+    if (!isGenericParam()) return Type();
 
     auto type = genericEnv->getMappingIfPresent(getGenericParamKey());
-    if (!type) return None;
+    if (!type) return Type();
 
     // We already have a mapping for this generic parameter in the generic
     // environment. Return it.
@@ -610,7 +610,7 @@ Type ArchetypeBuilder::PotentialArchetype::getTypeInContext(
     // We will build the archetype below.
     assocType = getResolvedAssociatedType();
   } else if (auto result = getAlreadyRecoveredGenericParam()) {
-    return *result;
+    return result;
   }
 
   // Determine the superclass for the archetype. If it exists and involves
@@ -627,7 +627,7 @@ Type ArchetypeBuilder::PotentialArchetype::getTypeInContext(
     // We might have recursively recorded the archetype; if so, return early.
     // FIXME: This should be detectable before we end up building archetypes.
     if (auto result = getAlreadyRecoveredGenericParam())
-      return *result;
+      return result;
   }
 
   // Build a new archetype.

lib/AST/GenericEnvironment.cpp

@@ -40,6 +40,26 @@ GenericEnvironment::GenericEnvironment(
     addMapping(entry.first->castTo<GenericTypeParamType>(), entry.second);
 }
 
+void GenericEnvironment::setOwningDeclContext(DeclContext *newNowningDC) {
+  if (!OwningDC) {
+    OwningDC = newNowningDC;
+    return;
+  }
+
+  if (!newNowningDC || OwningDC == newNowningDC)
+    return;
+
+  // If we have found a outer context sharing the same generic environment,
+  // use that.
+  if (OwningDC->isChildContextOf(newNowningDC)) {
+    OwningDC = newNowningDC;
+    return;
+  }
+
+  // Otherwise, we have an inner context sharing the envirtonment.
+  assert(newNowningDC->isChildContextOf(OwningDC) && "Not an inner context");
+}
+
 void GenericEnvironment::addMapping(GenericParamKey key,
                                     Type contextType) {
   // Find the index into the parallel arrays of generic parameters and

lib/IRGen/GenMeta.cpp

@@ -4707,7 +4707,7 @@ namespace {
     CanType getParentType() const {
       Type type = Target->getDeclaredTypeInContext();
       Type parentType = type->getNominalParent();
-      return parentType ? parentType->getCanonicalType() : CanType();
+      return parentType.getCanonicalTypeOrNull();
     }
 
   public:

lib/Sema/TypeCheckDecl.cpp

@@ -728,7 +728,6 @@ TypeChecker::handleSILGenericParams(GenericParamList *genericParams,
     parentEnv = checkGenericEnvironment(genericParams, DC, parentSig,
                                         /*allowConcreteGenericParams=*/true);
     parentSig = parentEnv->getGenericSignature();
-    recordArchetypeContexts(parentEnv, DC);
 
     // Compute the final set of archetypes.
     revertGenericParamList(genericParams);
@@ -4782,8 +4781,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       // Assign archetypes.
       auto *env = builder.getGenericEnvironment(sig);
       FD->setGenericEnvironment(env);
-
-      TC.recordArchetypeContexts(env, FD);
     } else if (FD->getDeclContext()->getGenericSignatureOfContext()) {
       (void)TC.validateGenericFuncSignature(FD);
       if (FD->getGenericEnvironment() == nullptr) {
@@ -6409,8 +6406,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       // Assign archetypes.
       auto *env = builder.getGenericEnvironment(sig);
       CD->setGenericEnvironment(env);
-
-      TC.recordArchetypeContexts(env, CD);
     } else if (CD->getDeclContext()->getGenericSignatureOfContext()) {
       (void)TC.validateGenericFuncSignature(CD);
 
@@ -7409,7 +7404,6 @@ checkExtensionGenericParams(TypeChecker &tc, ExtensionDecl *ext, Type type,
                                          ext->getDeclContext(), nullptr,
                                          /*allowConcreteGenericParams=*/true,
                                          inferExtendedTypeReqs);
-  tc.recordArchetypeContexts(env, ext);
 
   // Validate the generic parameters for the last time, to splat down
   // actual archetypes.

lib/Sema/TypeCheckGeneric.cpp

@@ -790,23 +790,6 @@ static void revertDependentTypeLoc(TypeLoc &tl) {
   tl.setType(Type(), /*validated=*/false);
 }
 
-/// Store a mapping from archetypes to DeclContexts for debugging.
-void
-TypeChecker::recordArchetypeContexts(GenericEnvironment *genericEnv,
-                                     DeclContext *dc) {
-#ifndef NDEBUG
-  // Record archetype contexts.
-  auto genericSig = genericEnv->getGenericSignature();
-  for (auto *paramTy : genericSig->getGenericParams()) {
-    auto contextTy = genericEnv->mapTypeIntoContext(
-        paramTy->castTo<GenericTypeParamType>());
-    if (auto *archetype = contextTy->getAs<ArchetypeType>())
-      if (Context.ArchetypeContexts.count(archetype) == 0)
-        Context.ArchetypeContexts[archetype] = dc;
-  }
-#endif
-}
-
 /// Revert the dependent types within the given generic parameter list.
 void TypeChecker::revertGenericParamList(GenericParamList *genericParams) {
   // Revert the inherited clause of the generic parameter list.
@@ -858,7 +841,6 @@ void TypeChecker::validateGenericTypeSignature(GenericTypeDecl *typeDecl) {
   auto *env = checkGenericEnvironment(gp, dc, dc->getGenericSignatureOfContext(),
                                       /*allowConcreteGenericParams=*/false);
   typeDecl->setGenericEnvironment(env);
-  recordArchetypeContexts(env, typeDecl);
 }
 
 void TypeChecker::revertGenericFuncSignature(AbstractFunctionDecl *func) {

lib/Sema/TypeChecker.h

@@ -1071,10 +1071,6 @@ class TypeChecker final : public LazyResolver {
                                    [&](ArchetypeBuilder &) { });
   }
 
-  /// Store a mapping from archetypes to DeclContexts for debugging.
-  void recordArchetypeContexts(GenericEnvironment *genericEnv,
-                               DeclContext *dc);
-
   /// Validate the signature of a generic type.
   ///
   /// \param nominal The generic type.