Merge pull request #27787 from CodaFi/assordid-order

Member Type Lookups Shouldn't Recurse

Author: CodaFi

lib/Sema/TypeCheckNameLookup.cpp

@@ -430,9 +430,15 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
   for (auto decl : decls) {
     auto *typeDecl = cast<TypeDecl>(decl);
 
-    auto memberType = typeDecl->getDeclaredInterfaceType();
+    // HACK: Lookups rooted at a typealias are trying to look for its underlying
+    // type so they shouldn't also find that same typealias.
+    if (decl == dyn_cast<TypeAliasDecl>(dc)) {
+      continue;
+    }
 
     if (isUnsupportedMemberTypeAccess(type, typeDecl)) {
+      auto memberType = typeDecl->getDeclaredInterfaceType();
+
       // Add the type to the result set, so that we can diagnose the
       // reference instead of just saying the member does not exist.
       if (types.insert(memberType->getCanonicalType()).second)
@@ -477,8 +483,8 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
     }
 
     // Substitute the base into the member's type.
-    memberType = substMemberTypeWithBase(dc->getParentModule(),
-                                         typeDecl, type);
+    auto memberType = substMemberTypeWithBase(dc->getParentModule(),
+                                              typeDecl, type);
 
     // If we haven't seen this type result yet, add it to the result set.
     if (types.insert(memberType->getCanonicalType()).second)

test/decl/circularity.swift

@@ -0,0 +1,45 @@
+// RUN: %target-typecheck-verify-swift
+
+// N.B. Validating the pattern binding initializer for `pickMe` used to cause
+// recursive validation of the VarDecl. Check that we don't regress now that
+// this isn't the case.
+public struct Cyclic {
+  static func pickMe(please: Bool) -> Int { return 42 }
+  public static let pickMe = Cyclic.pickMe(please: true)
+}
+
+struct Node {}
+struct Parameterized<Value, Format> {
+  func please<NewValue>(_ transform: @escaping (_ otherValue: NewValue) -> Value) -> Parameterized<NewValue, Format> {
+    fatalError()
+  }
+}
+
+extension Parameterized where Value == [Node], Format == String {
+  static var pickMe: Parameterized {
+    fatalError()
+  }
+}
+
+extension Parameterized where Value == Node, Format == String {
+  static let pickMe = Parameterized<[Node], String>.pickMe.please { [$0] }
+}
+
+enum Loop: Circle {
+  struct DeLoop { }
+}
+
+protocol Circle {
+  typealias DeLoop = Loop.DeLoop
+}
+
+class Base {
+    static func foo(_ x: Int) {}
+}
+
+class Sub: Base {
+    var foo = { () -> Int in
+        let x = 42
+        return foo(1) // expected-error {{variable used within its own initial value}}
+    }()
+}

test/decl/overload.swift

@@ -609,28 +609,3 @@ enum SR_10084_E_16 {
   typealias Z = Int // expected-note {{'Z' previously declared here}}
   case Z // expected-error {{invalid redeclaration of 'Z'}}
 }
-
-// N.B. Validating the pattern binding initializer for `pickMe` used to cause
-// recursive validation of the VarDecl. Check that we don't regress now that
-// this isn't the case.
-public struct Cyclic {
-  static func pickMe(please: Bool) -> Int { return 42 }
-  public static let pickMe = Cyclic.pickMe(please: true)
-}
-
-struct Node {}
-struct Parameterized<Value, Format> {
-  func please<NewValue>(_ transform: @escaping (_ otherValue: NewValue) -> Value) -> Parameterized<NewValue, Format> {
-    fatalError()
-  }
-}
-
-extension Parameterized where Value == [Node], Format == String {
-  static var pickMe: Parameterized {
-    fatalError()
-  }
-}
-
-extension Parameterized where Value == Node, Format == String {
-  static let pickMe = Parameterized<[Node], String>.pickMe.please { [$0] }
-}