Outer generics

Author: David Ungar

include/swift/AST/ASTScope.h

@@ -360,14 +360,13 @@ class ASTScopeImpl {
     return {false, isCascadingUse};
   }
 
-
-  virtual bool lookInGenericParameters(Optional<bool> isCascadingUse,
-                                       DeclConsumer) const;
+  virtual bool lookInMyGenericParameters(Optional<bool> isCascadingUse,
+                                         DeclConsumer) const;
 
   // Consume the generic parameters in the context and its outer contexts
-  static bool lookInMyAndOuterGenericParameters(const GenericContext *,
-                                                Optional<bool> isCascadingUse,
-                                                DeclConsumer);
+  static bool lookInGenericParametersOf(NullablePtr<const GenericParamList>,
+                                        Optional<bool> isCascadingUse,
+                                        DeclConsumer);
 
   NullablePtr<const ASTScopeImpl> parentIfNotChildOfTopScope() const {
     const auto *p = getParent().get();
@@ -579,8 +578,6 @@ class GenericTypeOrExtensionScope : public ASTScopeImpl {
   virtual std::string declKindName() const = 0;
   virtual bool doesDeclHaveABody() const;
   const char *portionName() const { return portion->portionName; }
-  bool lookInGenericParameters(Optional<bool> isCascadingUse,
-                               DeclConsumer) const override;
   NullablePtr<DeclContext>
       computeSelfDCForParent(NullablePtr<DeclContext>) const override;
   Optional<bool> resolveIsCascadingUseForThisScope(
@@ -605,9 +602,18 @@ class GenericTypeOrExtensionScope : public ASTScopeImpl {
   virtual NullablePtr<const ASTScopeImpl> getLookupLimitForDecl() const;
 };
 
-class IterableTypeScope : public GenericTypeOrExtensionScope {
+class GenericTypeScope : public GenericTypeOrExtensionScope {
+public:
+  GenericTypeScope(const Portion *p) : GenericTypeOrExtensionScope(p) {}
+  virtual ~GenericTypeScope() {}
+
+  bool lookInMyGenericParameters(Optional<bool> isCascadingUse,
+                                 DeclConsumer) const override;
+};
+
+class IterableTypeScope : public GenericTypeScope {
 public:
-  IterableTypeScope(const Portion *p) : GenericTypeOrExtensionScope(p) {}
+  IterableTypeScope(const Portion *p) : GenericTypeScope(p) {}
   virtual ~IterableTypeScope() {}
 
   virtual SourceRange getBraces() const = 0;
@@ -659,13 +665,15 @@ class ExtensionScope final : public IterableTypeScope {
                                                ScopeCreator &) override;
   void createBodyScope(ASTScopeImpl *leaf, ScopeCreator &) override;
   NullablePtr<Decl> getDecl() const override { return decl; }
+  bool lookInMyGenericParameters(Optional<bool> isCascadingUse,
+                                 DeclConsumer) const override;
 };
 
-class TypeAliasScope final : public GenericTypeOrExtensionScope {
+class TypeAliasScope final : public GenericTypeScope {
 public:
   TypeAliasDecl *const decl;
   TypeAliasScope(const Portion *p, TypeAliasDecl *e)
-      : GenericTypeOrExtensionScope(p), decl(e) {}
+      : GenericTypeScope(p), decl(e) {}
   virtual ~TypeAliasScope() {}
 
   std::string declKindName() const override { return "TypeAlias"; }
@@ -675,11 +683,11 @@ class TypeAliasScope final : public GenericTypeOrExtensionScope {
   NullablePtr<Decl> getDecl() const override { return decl; }
 };
 
-class OpaqueTypeScope final : public GenericTypeOrExtensionScope {
+class OpaqueTypeScope final : public GenericTypeScope {
 public:
   OpaqueTypeDecl *const decl;
   OpaqueTypeScope(const Portion *p, OpaqueTypeDecl *e)
-      : GenericTypeOrExtensionScope(p), decl(e) {}
+      : GenericTypeScope(p), decl(e) {}
   virtual ~OpaqueTypeScope() {}
 
   std::string declKindName() const override { return "OpaqueType"; }
@@ -764,8 +772,8 @@ class AbstractFunctionDeclScope final : public ASTScopeImpl {
 
 protected:
   Decl *getEnclosingAbstractFunctionOrSubscriptDecl() const override;
-  bool lookInGenericParameters(Optional<bool> isCascadingUse,
-                               DeclConsumer) const override;
+  bool lookInMyGenericParameters(Optional<bool> isCascadingUse,
+                                 DeclConsumer) const override;
   Optional<bool>
   resolveIsCascadingUseForThisScope(Optional<bool>) const override;
 };
@@ -1246,8 +1254,8 @@ class SubscriptDeclScope final : public ASTScopeImpl {
 
 protected:
   Decl *getEnclosingAbstractFunctionOrSubscriptDecl() const override;
-  bool lookInGenericParameters(Optional<bool> isCascadingUse,
-                               DeclConsumer) const override;
+  bool lookInMyGenericParameters(Optional<bool> isCascadingUse,
+                                 DeclConsumer) const override;
   NullablePtr<AbstractStorageDecl>
   getEnclosingAbstractStorageDecl() const override {
     return decl;

lib/AST/ASTScopeLookup.cpp

@@ -202,7 +202,7 @@ Optional<bool> ASTScopeImpl::lookup(
   // you can say "self.name" to get a name shadowed by a generic but you
   // can't do the opposite to get a generic shadowed by a name.
   if (!skipSearchForGenericsAndMembers) {
-    if (lookInGenericParameters(isCascadingUseForThisScope, consumer))
+    if (lookInMyGenericParameters(isCascadingUseForThisScope, consumer))
       return isCascadingUseForThisScope;
   }
   // Dig out the type we're looking into.
@@ -244,23 +244,26 @@ Optional<bool> ASTScopeImpl::lookupInParent(
                               consumer);
 }
 
-#pragma mark lookInGenericParameters
+#pragma mark lookInMyGenericParameters
 
-bool ASTScopeImpl::lookInGenericParameters(Optional<bool> isCascadingUse,
-                                           ASTScopeImpl::DeclConsumer) const {
+bool ASTScopeImpl::lookInMyGenericParameters(Optional<bool> isCascadingUse,
+                                             ASTScopeImpl::DeclConsumer) const {
   return false;
 }
 
-bool AbstractFunctionDeclScope::lookInGenericParameters(
+bool AbstractFunctionDeclScope::lookInMyGenericParameters(
     Optional<bool> isCascadingUse, ASTScopeImpl::DeclConsumer consumer) const {
-  return lookInMyAndOuterGenericParameters(decl, isCascadingUse, consumer);
+  return lookInGenericParametersOf(decl->getGenericParams(), isCascadingUse,
+                                   consumer);
 }
-bool SubscriptDeclScope::lookInGenericParameters(
+
+bool SubscriptDeclScope::lookInMyGenericParameters(
     Optional<bool> isCascadingUse, ASTScopeImpl::DeclConsumer consumer) const {
-  return lookInMyAndOuterGenericParameters(decl, isCascadingUse, consumer);
+  return lookInGenericParametersOf(decl->getGenericParams(), isCascadingUse,
+                                   consumer);
 }
 
-bool GenericTypeOrExtensionScope::lookInGenericParameters(
+bool GenericTypeScope::lookInMyGenericParameters(
     Optional<bool> isCascadingUse, ASTScopeImpl::DeclConsumer consumer) const {
   // For Decls:
   // WAIT, WHAT?! Isn't this covered by the GenericParamScope
@@ -271,25 +274,35 @@ bool GenericTypeOrExtensionScope::lookInGenericParameters(
   // Sigh... These must be here so that from body, we search generics before
   // members. But they also must be on the Decl scope for lookups starting from
   // generic parameters, where clauses, etc.
-  return lookInMyAndOuterGenericParameters(getGenericContext(), isCascadingUse,
-                                           consumer);
+  return lookInGenericParametersOf(getGenericContext()->getGenericParams(),
+                                   isCascadingUse, consumer);
 }
 
-bool ASTScopeImpl::lookInMyAndOuterGenericParameters(
-    const GenericContext *const gc, Optional<bool> isCascadingUse,
-    ASTScopeImpl::DeclConsumer consumer) {
-  for (auto *params = gc->getGenericParams(); params;
+bool ExtensionScope::lookInMyGenericParameters(
+    Optional<bool> isCascadingUse, ASTScopeImpl::DeclConsumer consumer) const {
+  // For extensions of nested types, must check outer parameters
+  for (auto *params = decl->getGenericParams(); params;
        params = params->getOuterParameters()) {
-    SmallVector<ValueDecl *, 32> bindings;
-    for (auto *param : params->getParams())
-      bindings.push_back(param);
-    if (consumer.consume(bindings, DeclVisibilityKind::GenericParameter,
-                         isCascadingUse))
+    if (lookInGenericParametersOf(params, isCascadingUse, consumer))
       return true;
   }
   return false;
 }
 
+bool ASTScopeImpl::lookInGenericParametersOf(
+    const NullablePtr<const GenericParamList> paramList,
+    Optional<bool> isCascadingUse, ASTScopeImpl::DeclConsumer consumer) {
+  if (!paramList)
+    return false;
+  SmallVector<ValueDecl *, 32> bindings;
+  for (auto *param : paramList.get()->getParams())
+    bindings.push_back(param);
+  if (consumer.consume(bindings, DeclVisibilityKind::GenericParameter,
+                       isCascadingUse))
+    return true;
+  return false;
+}
+
 #pragma mark lookupInSelfType
 
 std::pair<bool, Optional<bool>>