Merge pull request #17227 from slavapestov/init-declname-hack

Sema: Fudge backward compatibility for `init` special declname

Author: slavapestov

lib/FrontendTool/ReferenceDependencies.cpp

@@ -354,11 +354,16 @@ bool swift::emitReferenceDependencies(DiagnosticEngine &diags, SourceFile *SF,
   llvm::array_pod_sort(sortedMembers.begin(), sortedMembers.end(),
                        [](const TableEntryTy *lhs,
                           const TableEntryTy *rhs) -> int {
-    if (lhs->first.first == rhs->first.first)
-      return lhs->first.second.compare(rhs->first.second);
+    if (auto cmp = lhs->first.first->getName().compare(rhs->first.first->getName()))
+      return cmp;
 
-    if (lhs->first.first->getName() != rhs->first.first->getName())
-      return lhs->first.first->getName().compare(rhs->first.first->getName());
+    if (auto cmp = lhs->first.second.compare(rhs->first.second))
+      return cmp;
+
+    // We can have two entries with the same member name if one of them
+    // was the special 'init' name and the other is the plain 'init' token.
+    if (lhs->second != rhs->second)
+      return lhs->second ? -1 : 1;
 
     // Break type name ties by mangled name.
     auto lhsMangledName = mangleTypeAsContext(lhs->first.first);

lib/Sema/CSSimplify.cpp

@@ -3123,9 +3123,18 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
   // Look for members within the base.
   LookupResult &lookup = lookupMember(instanceTy, memberName);
 
+  // If this is true, we're using type construction syntax (Foo()) rather
+  // than an explicit call to `init` (Foo.init()).
+  bool isImplicitInit = false;
   TypeBase *favoredType = nullptr;
   if (memberName.isSimpleName(DeclBaseName::createConstructor())) {
-    if (auto anchor = memberLocator->getAnchor()) {
+    SmallVector<LocatorPathElt, 2> parts;
+    if (auto *anchor = memberLocator->getAnchor()) {
+      auto path = memberLocator->getPath();
+      if (!path.empty())
+        if (path.back().getKind() == ConstraintLocator::ConstructorMember)
+          isImplicitInit = true;
+
       if (auto applyExpr = dyn_cast<ApplyExpr>(anchor)) {
         auto argExpr = applyExpr->getArg();
         favoredType = getFavoredType(argExpr);
@@ -3340,6 +3349,20 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
                                 /*isBridged=*/false,
                                 /*isUnwrappedOptional=*/false));
 
+  // Backward compatibility hack. In Swift 4, `init` and init were
+  // the same name, so you could write "foo.init" to look up a
+  // method or property named `init`.
+  if (!TC.Context.isSwiftVersionAtLeast(5) &&
+      memberName.getBaseName() == DeclBaseName::createConstructor() &&
+      !isImplicitInit) {
+    auto &compatLookup = lookupMember(instanceTy,
+                                      TC.Context.getIdentifier("init"));
+    for (auto result : compatLookup)
+      addChoice(getOverloadChoice(result.getValueDecl(),
+                                  /*isBridged=*/false,
+                                  /*isUnwrappedOptional=*/false));
+  }
+
   // If the instance type is a bridged to an Objective-C type, perform
   // a lookup into that Objective-C type.
   if (bridgedType) {

test/Compatibility/special_case_name.swift

@@ -0,0 +1,45 @@
+// RUN: %target-typecheck-verify-swift -swift-version 4
+
+// https://bugs.swift.org/browse/SR-1660
+
+enum DayOfTheWeek : Int {
+  case monday = 0
+  case `inout` = 1
+  case `init` = 2
+  case friday = 3
+  case tuesday = 4
+}
+
+let _: DayOfTheWeek = DayOfTheWeek.init
+
+let _: DayOfTheWeek = DayOfTheWeek.`init`
+
+func match(_ d: DayOfTheWeek) {
+  switch d {
+  case .monday: break
+  case .`inout`: break
+  case .`init`: break
+  case .friday: break
+  case .tuesday: break
+  }
+}
+
+enum Fox {
+  case `init`(Int)
+  
+  init() {
+    self = .`init`(10)
+  }
+}
+
+let _: Fox = Fox(10)
+// expected-error@-1 {{argument passed to call that takes no arguments}}
+
+let _: () -> Fox = Fox.init
+let _: (Int) -> Fox = Fox.`init`
+
+func match(_ f: Fox) {
+  switch f {
+  case .`init`(let n): _ = n
+  }
+}

test/Compatibility/special_func_name.swift

@@ -0,0 +1,43 @@
+// RUN: %target-typecheck-verify-swift -swift-version 4
+
+protocol P1 {
+  static func `init`(_: Int) // expected-note {{protocol requires function 'init' with type '(Int) -> ()'; do you want to add a stub?}}
+  // expected-note@-1 {{did you mean 'init'?}}
+}
+
+struct S11 : P1 {
+  static func `init`(_: Int) {}
+}
+
+struct S12 : P1 { // expected-error {{type 'S12' does not conform to protocol 'P1'}}
+  init(_: Int) {}
+}
+
+protocol P2 {
+  init(_: Int) // expected-note {{protocol requires initializer 'init' with type 'Int'; do you want to add a stub?}}
+}
+
+struct S21 : P2 { // expected-error {{type 'S21' does not conform to protocol 'P2'}}
+  // expected-note@-1 {{candidate has non-matching type '()'}}
+  static func `init`(_: Int) {}
+}
+
+struct S22 : P2 {
+  init(_: Int) {}
+}
+
+_ = S11(0) // expected-error {{argument passed to call that takes no arguments}}
+_ = S11.init(0)
+_ = S11.`init`(0)
+
+_ = S12(0)
+_ = S12.init(0)
+_ = S12.`init`(0) // expected-error {{type 'S12' has no member 'init'}}
+
+_ = S21(0) // expected-error {{argument passed to call that takes no arguments}}
+_ = S21.init(0)
+_ = S21.`init`(0)
+
+_ = S22(0)
+_ = S22.init(0)
+_ = S22.`init`(0) // expected-error {{type 'S22' has no member 'init'}}

test/decl/enum/special_case_name.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -swift-version 5
 
 // https://bugs.swift.org/browse/SR-1660
 

test/decl/func/special_func_name.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -swift-version 5
 
 protocol P1 {
   static func `init`(_: Int) // expected-note {{protocol requires function 'init' with type '(Int) -> ()'; do you want to add a stub?}}