Sema: Fudge backward compatibility for init special declname

In Swift 4, constructors had the same name as properties,
methods and enum cases named `init`. This meant that you
could use constructor syntax to call such a member, which
caused some confusing behavior.

Recently I added a special declname for `init` so that
constructors have unique names distinct from any name you
can spell, and "foo.init" syntax would look for a member
with the special name rather than one named `init`.

Unfortunately people actually had code where they defined
members named `init` and then use them via normal member
lookup syntax, like this:

enum E {
  case `init`
}

let e: E = E.init

So to maintain backward compatibility, hack member lookup
to also find members named `init` when looking up the special
declname for constructors.

The workaround is only enabled in Swift 4 and 4.2 mode;
in Swift 5 mode you are expected to write "foo.`init`" to access
non-constructor members named `init`.

Fixes <rdar://problem/38682258>.

Author: slavapestov

lib/Sema/CSSimplify.cpp

@@ -3121,9 +3121,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);
@@ -3338,6 +3347,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?}}