[Sema] Swift3 compatibility: Fix ambiguous protocol composition production

Fixes: https://bugs.swift.org/browse/SR-2843

'P1 & P2.Type' is mistakingly accepted and parsed as (meatatype (composition P1, P2))
in swift3. Now, we parse it as (composition P1, (metatype P2))

For source compatibility, reconstruct it as Swift3.

Also, this solves inconsistent behavior between type and type-expression in Swift3.

typealias T1 = P1 & P2?  // was accepted as '(P1 & P2)?'
let T2 = (P1 & P2?).self // was silently accepted as 'P1' in Swift3.0

Author: rintaro

include/swift/AST/DiagnosticsSema.def

@@ -1506,6 +1506,9 @@ ERROR(protocol_composition_not_protocol,none,
       "non-protocol type %0 cannot be used within a protocol composition", (Type))
 ERROR(objc_protocol_inherits_non_objc_protocol,none,
       "@objc protocol %0 cannot refine non-@objc protocol %1", (Type, Type))
+WARNING(protocol_composition_with_postfix,none,
+        "protocol composition with postfix '%0' is ambiguous "
+        "and will be rejected in future version of Swift", (StringRef))
 
 ERROR(requires_conformance_nonprotocol,none,
       "type %0 constrained to non-protocol type %1", (TypeLoc, TypeLoc))

lib/Sema/TypeCheckType.cpp

@@ -2614,8 +2614,109 @@ Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
   return TupleType::get(elements, Context);
 }
 
+/// Restore Swift3 behavior of ambiguous compostion for source compatibility.
+///
+/// Currently, 'P1 & P2.Type' is parsed as (composition P1, (metatype P2))
+/// In Swift3, that was (metatype (composition P1, P2)).
+/// For source compatibility, before resolving Type of that, reconstruct
+/// TypeRepr as so, and emit a warning with fix-it to enclose it with
+/// parenthesis; '(P1 & P2).Type'
+//
+/// \param Comp The type composition to be checked and fixed.
+///
+/// \returns Fixed TypeRepr, or nullptr that indicates no need to fix.
+static TypeRepr *fixCompositionWithPostfix(TypeChecker &TC,
+                                           CompositionTypeRepr *Comp) {
+  // Only for Swift3
+  if (!TC.Context.isSwiftVersion3())
+    return nullptr;
+
+  auto Types = Comp->getTypes();
+  TypeRepr *LastType = nullptr;
+  for (auto i = Types.begin(), e = Types.end(); i != e; ++i) {
+    if (!isa<IdentTypeRepr>(*i)) {
+      // Found non-IdentType not at the last, can't help.
+      if (i + 1 != e)
+        return nullptr;
+      LastType = *i;
+    }
+  }
+  // Only IdentType(s) it's OK.
+  if (!LastType)
+    return nullptr;
+
+  // Strip off the postfix type repr.
+  SmallVector<TypeRepr *, 2> Postfixes;
+  while (true) {
+    if (auto T = dyn_cast<ProtocolTypeRepr>(LastType)) {
+      Postfixes.push_back(LastType);
+      LastType = T->getBase();
+    } else if (auto T = dyn_cast<MetatypeTypeRepr>(LastType)) {
+      Postfixes.push_back(LastType);
+      LastType = T->getBase();
+    } else if (auto T = dyn_cast<OptionalTypeRepr>(LastType)) {
+      Postfixes.push_back(LastType);
+      LastType = T->getBase();
+    } else if (auto T =
+        dyn_cast<ImplicitlyUnwrappedOptionalTypeRepr>(LastType)) {
+      Postfixes.push_back(LastType);
+      LastType = T->getBase();
+    } else if (!isa<IdentTypeRepr>(LastType)) {
+      // Found non-IdentTypeRepr, can't help;
+      return nullptr;
+    } else {
+      break;
+    }
+  }
+  assert(!Postfixes.empty() && isa<IdentTypeRepr>(LastType));
+
+  // Now, we know we can fix-it. do it.
+  SmallVector<TypeRepr *, 4> Protocols(Types.begin(), Types.end() - 1);
+  Protocols.push_back(LastType);
+
+  // Emit fix-it to enclose compostion part into parentheses.
+  TypeRepr *InnerMost = Postfixes.back();
+  TC.diagnose(InnerMost->getLoc(), diag::protocol_composition_with_postfix,
+      isa<ProtocolTypeRepr>(InnerMost) ? ".Protocol" :
+      isa<MetatypeTypeRepr>(InnerMost) ? ".Type" :
+      isa<OptionalTypeRepr>(InnerMost) ? "?" :
+      isa<ImplicitlyUnwrappedOptionalTypeRepr>(InnerMost) ? "!" :
+      /* unreachable */"")
+    .highlight({Comp->getStartLoc(), LastType->getEndLoc()})
+    .fixItInsert(Comp->getStartLoc(), "(")
+    .fixItInsertAfter(LastType->getEndLoc(), ")");
+
+  // Reconstruct postfix type repr with collected protocols.
+  TypeRepr *Fixed = CompositionTypeRepr::create(
+    TC.Context, Protocols, Comp->getStartLoc(),
+    {Comp->getCompositionRange().Start, LastType->getEndLoc()});
+
+  // Add back postix TypeRepr(s) to the composition.
+  while (Postfixes.size()) {
+    auto Postfix = Postfixes.pop_back_val();
+    if (auto T = dyn_cast<ProtocolTypeRepr>(Postfix))
+      Fixed = new (TC.Context) ProtocolTypeRepr(Fixed, T->getProtocolLoc());
+    else if (auto T = dyn_cast<MetatypeTypeRepr>(Postfix))
+      Fixed = new (TC.Context) MetatypeTypeRepr(Fixed, T->getMetaLoc());
+    else if (auto T = dyn_cast<OptionalTypeRepr>(Postfix))
+      Fixed = new (TC.Context) OptionalTypeRepr(Fixed, T->getQuestionLoc());
+    else if (auto T = dyn_cast<ImplicitlyUnwrappedOptionalTypeRepr>(Postfix))
+      Fixed = new (TC.Context)
+        ImplicitlyUnwrappedOptionalTypeRepr(Fixed, T->getExclamationLoc());
+    else
+      llvm_unreachable("unexpected type repr");
+  }
+
+  return Fixed;
+}
+
 Type TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
                                           TypeResolutionOptions options) {
+
+  // Fix 'P1 & P2.Type' to '(P1 & P2).Type' for Swift3
+  if (auto fixed = fixCompositionWithPostfix(TC, repr))
+    return resolveType(fixed, options);
+
   SmallVector<Type, 4> ProtocolTypes;
   for (auto tyR : repr->getTypes()) {
     Type ty = TC.resolveType(tyR, DC, withoutContext(options), Resolver);

test/Compatibility/protocol_composition.swift

@@ -0,0 +1,49 @@
+// RUN: rm -rf %t && mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -parse -primary-file %t/swift3.swift %t/common.swift -verify
+// RUN: %target-swift-frontend -parse -primary-file %t/swift4.swift %t/common.swift -verify -swift-version 4
+
+// BEGIN common.swift
+protocol P1 {
+  static func p1() -> Int
+}
+protocol P2 {
+  static var p2: Int { get }
+}
+
+// BEGIN swift3.swift
+
+// Warning for mitakingly accepted protocol composition production.
+func foo(x: P1 & Any & P2.Type?) {
+  // expected-warning @-1 {{protocol composition with postfix '.Type' is ambiguous and will be rejected in future version of Swift}} {{13-13=(}} {{26-26=)}}
+  let _: (P1 & P2).Type? = x
+  let _: (P1 & P2).Type = x!
+  let _: Int = x!.p1()
+  let _: Int? = x?.p2
+}
+
+// Type expression
+func bar() -> ((P1 & P2)?).Type {
+  let x = (P1 & P2?).self
+  // expected-warning @-1 {{protocol composition with postfix '?' is ambiguous and will be rejected in future version of Swift}} {{12-12=(}} {{19-19=)}}
+  return x
+}
+
+// Non-ident type at non-last position are rejected anyway.
+typealias A1 = P1.Type & P2 // expected-error {{type 'P1.Type' cannot be used within a protocol composition}}
+
+// BEGIN swift4.swift
+
+func foo(x: P1 & Any & P2.Type?) { // expected-error {{non-protocol type 'P2.Type?' cannot be used within a protocol composition}}
+  let _: (P1 & P2).Type? = x // expected-error {{cannot convert value of type 'P1' to specified type '(P1 & P2).Type?'}}
+  let _: (P1 & P2).Type = x! // expected-error {{cannot force unwrap value of non-optional type 'P1'}}
+  let _: Int = x!.p1() // expected-error {{cannot force unwrap value of non-optional type 'P1'}}
+  let _: Int? = x?.p2 // expected-error {{cannot use optional chaining on non-optional value of type 'P1'}}
+}
+
+func bar() -> ((P1 & P2)?).Type {
+  let x = (P1 & P2?).self // expected-error {{non-protocol type 'P2?' cannot be used within a protocol composition}}
+  return x // expected-error {{cannot convert return expression}}
+}
+
+typealias A1 = P1.Type & P2 // expected-error {{type 'P1.Type' cannot be used within a protocol composition}}

test/Parse/type_expr.swift

@@ -1,5 +1,5 @@
-// RUN: %target-parse-verify-swift
-// RUN: %target-parse-verify-swift -enable-astscope-lookup
+// RUN: %target-parse-verify-swift -swift-version 4
+// RUN: %target-parse-verify-swift -enable-astscope-lookup -swift-version 4
 
 // Types in expression contexts must be followed by a member access or
 // constructor call.
@@ -234,7 +234,5 @@ func compositionType() {
   _ = (P1 & Int).self // expected-error {{non-protocol type 'Int' cannot be used within a protocol composition}}
   _ = (P1? & P2).self // expected-error {{non-protocol type 'P1?' cannot be used within a protocol composition}}
 
-  // FIXME: Inconsistency. as per https://bugs.swift.org/browse/SR-2843,
-  // In Swift3 `typealias P = P1 & P2.Type` is parsed as (metatype (type_composite P1, P2))
   _ = (P1 & P2.Type).self // expected-error {{non-protocol type 'P2.Type' cannot be used within a protocol composition}}
 }

test/type/protocol_composition.swift

@@ -1,4 +1,4 @@
-// RUN: %target-parse-verify-swift
+// RUN: %target-parse-verify-swift -swift-version 4
 
 func canonical_empty_protocol() -> Any {
   return 1