Merge pull request #68716 from kavon/inverse-parsing

permit parsing of `~` in general type syntaxes

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -2347,8 +2347,8 @@ ERROR(inferred_opaque_type,none,
       "return type of another declaration", (Type))
 
 // Inverse Constraints
-ERROR(inverse_type_not_invertable,none,
-      "type %0 is not invertable", (Type))
+ERROR(inverse_type_not_invertible,none,
+      "type %0 is not invertible", (Type))
 
 // Extensions
 ERROR(non_nominal_extension,none,

include/swift/AST/KnownProtocols.h

@@ -46,7 +46,7 @@ using KnownProtocolSet = FixedBitSet<NumKnownProtocols, KnownProtocolKind>;
 
 /// Produces a set of all protocols that have an inverse, i.e., for every
 /// known protocol KP in the set, ~KP exists.
-KnownProtocolSet getInvertableProtocols();
+KnownProtocolSet getInvertibleProtocols();
 
 /// Retrieve the name of the given known protocol.
 llvm::StringRef getProtocolName(KnownProtocolKind kind);

lib/AST/ASTContext.cpp

@@ -102,7 +102,7 @@ llvm::StringRef swift::getProtocolName(KnownProtocolKind kind) {
   llvm_unreachable("bad KnownProtocolKind");
 }
 
-KnownProtocolSet swift::getInvertableProtocols() {
+KnownProtocolSet swift::getInvertibleProtocols() {
   return { KnownProtocolKind::Copyable };
 }
 

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -732,7 +732,7 @@ void swift::rewriting::realizeInheritedRequirements(
   auto inheritedTypes = decl->getInherited();
   auto *dc = decl->getInnermostDeclContext();
   auto *moduleForInference = dc->getParentModule();
-  auto defaults = getInvertableProtocols();
+  auto defaults = getInvertibleProtocols();
 
   for (auto index : inheritedTypes.getIndices()) {
     Type inheritedType =

lib/Parse/ParseType.cpp

@@ -147,6 +147,7 @@ LayoutConstraint Parser::parseLayoutConstraint(Identifier LayoutConstraintID) {
 ///     type-simple '.Protocol'
 ///     type-simple '?'
 ///     type-simple '!'
+///     '~' type-simple
 ///     type-collection
 ///     type-array
 ///     '_'
@@ -155,15 +156,6 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
     Diag<> MessageID, ParseTypeReason reason) {
   ParserResult<TypeRepr> ty;
 
-
-  // Prevent the use of ~ as prefix for a type. We specially parse them
-  // in inheritance clauses elsewhere.
-  if (!EnabledNoncopyableGenerics && Tok.isTilde()) {
-    auto tildeLoc = consumeToken();
-    diagnose(tildeLoc, diag::cannot_suppress_here)
-        .fixItRemoveChars(tildeLoc, tildeLoc);
-  }
-
   if (Tok.is(tok::kw_inout)
       || (canHaveParameterSpecifierContextualKeyword()
           && (Tok.getRawText().equals("__shared")
@@ -176,6 +168,15 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
     consumeToken();
   }
 
+  // Eat any '~' preceding the type.
+  SourceLoc tildeLoc;
+  if (Tok.isTilde() && !isInSILMode()) {
+    tildeLoc = consumeToken();
+    if (!EnabledNoncopyableGenerics)
+      diagnose(tildeLoc, diag::cannot_suppress_here)
+          .fixItRemoveChars(tildeLoc, tildeLoc);
+  }
+
   switch (Tok.getKind()) {
   case tok::kw_Self:
   case tok::identifier:
@@ -308,6 +309,12 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
     break;
   }
 
+  // Wrap in an InverseTypeRepr if needed.
+  if (EnabledNoncopyableGenerics && tildeLoc) {
+    ty = makeParserResult(ty,
+                          new(Context) InverseTypeRepr(tildeLoc, ty.get()));
+  }
+
   return ty;
 }
 
@@ -639,19 +646,10 @@ ParserResult<TypeRepr> Parser::parseType(
         new (Context) PackExpansionTypeRepr(repeatLoc, ty.get()));
   }
 
-  // Parse inverse '~'
-  SourceLoc tildeLoc;
-  if (EnabledNoncopyableGenerics && Tok.isTilde())
-    tildeLoc = consumeToken();
-
   auto ty = parseTypeScalar(MessageID, reason);
   if (ty.isNull())
     return ty;
 
-  // Attach `~` tightly to the parsed type.
-  if (tildeLoc)
-    ty = makeParserResult(ty, new(Context) InverseTypeRepr(tildeLoc, ty.get()));
-
   // Parse vararg type 'T...'.
   if (Tok.isEllipsis()) {
     Tok.setKind(tok::ellipsis);

lib/Sema/TypeCheckType.cpp

@@ -5040,10 +5040,10 @@ NeverNullType TypeResolver::resolveInverseType(InverseTypeRepr *repr,
   if (auto protoTy = ty->getAs<ProtocolType>())
     if (auto protoDecl = protoTy->getDecl())
       if (auto kp = protoDecl->getKnownProtocolKind())
-        if (getInvertableProtocols().contains(*kp))
+        if (getInvertibleProtocols().contains(*kp))
           return ty;
 
-  diagnoseInvalid(repr, repr->getLoc(), diag::inverse_type_not_invertable, ty);
+  diagnoseInvalid(repr, repr->getLoc(), diag::inverse_type_not_invertible, ty);
   return ErrorType::get(getASTContext());
 }
 

test/Interop/Cxx/class/protocol-conformance-typechecker.swift

@@ -28,11 +28,11 @@ protocol HasReturnNonNull {
 extension ReturnsNonNullValue: HasReturnNonNull {}
 
 
-protocol Invertable {
+protocol Invertible {
   static prefix func !(obj: Self) -> Self
 }
 
-extension HasOperatorExclaim: Invertable {}
+extension HasOperatorExclaim: Invertible {}
 
 extension HasOperatorEqualEqual: Equatable {}
 

test/Parse/inverses.swift

@@ -0,0 +1,84 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature NoncopyableGenerics
+
+// REQUIRES: asserts
+
+protocol U {}
+
+enum Maybe<Thing: ~Copyable> : ~Copyable {}
+
+func more() {
+  let _: any ~Copyable = 19
+
+  let _: any ~Equatable = 19  // expected-error@:14 {{type 'Equatable' is not invertible}}
+
+  let _: any (~Copyable & ~Equatable) // expected-error{{type 'Equatable' is not invertible}}
+
+  let _: ~Any // expected-error {{type 'Any' is not invertible}}
+  let _: ~AnyObject // expected-error {{type 'AnyObject' is not invertible}}
+}
+
+struct S4: ~(Copyable & Equatable) {} // expected-error {{type 'Copyable & Equatable' is not invertible}}
+
+func blah<T>(_ t: T) where T: ~Copyable,
+                           T: ~Hashable {}  // expected-error@:31 {{type 'Hashable' is not invertible}}
+
+func foo<T: ~Copyable>(x: T) {}
+
+struct Buurap<T: ~Copyable> {}
+
+protocol Foo where Self: ~Copyable {
+    func test<T>(_ t: T) where T: ~Self  // expected-error {{type 'Self' is not invertible}}
+}
+
+protocol Sando { func make() }
+
+class C: ~Copyable,
+         ~Sando // expected-error {{type 'Sando' is not invertible}}
+         {}
+
+public struct MoveOnlyS1<T> : ~Copyable { /*deinit {}*/ }
+public struct MoveOnlyS2<T: Equatable> : ~Copyable { /*deinit {}*/ }
+public struct MoveOnlyS3<T: ~Copyable> : ~Copyable { /*deinit {}*/ }
+
+protocol Rope<Element>: Hashable, ~ Copyable {
+
+  associatedtype Element: ~Copyable
+}
+
+extension S: ~Copyable {}
+
+struct S: ~U, // expected-error {{type 'U' is not invertible}}
+          ~Copyable {}
+
+func greenBay<each T: ~Copyable>(_ r: repeat each T) {}
+
+typealias Clone = Copyable
+func dup<D: ~Clone>(_ d: D) {}
+
+func superb(_ thing: some ~Copyable, thing2: some ~Clone) {}
+
+func ownership1(_ t: borrowing any ~Equatable) {} // expected-error {{type 'Equatable' is not invertible}}
+
+func ownership2(_ t: ~ borrowing Int) {} // expected-error {{cannot find type 'borrowing' in scope}}
+                                         // expected-error@-1 {{unnamed parameters must be written with the empty name '_'}}
+                                         // expected-error@-2 {{expected ',' separator}}
+
+func ownership3(_ t: consuming some ~Clone) {}
+
+func what(one: ~Copyable..., // expected-error {{type 'any Copyable' is not invertible}}
+          two: ~(Copyable...) // expected-error {{variadic parameter cannot appear outside of a function parameter list}}
+                              // expected-error@-1 {{type 'any Copyable' is not invertible}}
+          ) {}
+
+struct A { struct B { struct C {} } }
+
+typealias Z1 = (~Copyable).Type // FIXME: should be an error
+typealias Z1 = ~Copyable.Type // expected-error {{type 'any Copyable.Type' is not invertible}}
+typealias Z2 = ~A.B.C // expected-error {{type 'A.B.C' is not invertible}}
+typealias Z3 = ~A? // expected-error {{type 'A?' is not invertible}}
+typealias Z4 = ~Rope<Int> // expected-error {{type 'Rope<Int>' is not invertible}}
+typealias Z5 = (~Int) -> Void // expected-error {{type 'Int' is not invertible}}
+typealias Z6 = ~() -> () // expected-error {{single argument function types require parentheses}}
+                         // expected-error@-1 {{type '()' is not invertible}}
+typealias Z7 = ~(Copyable & Hashable) // expected-error {{type 'Copyable & Hashable' is not invertible}}
+typealias Z8 = ~Copyable & Hashable