[ASTGen] Implement PackElementTypeRepr, InverseTypeRepr and class constraint

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -1034,6 +1034,12 @@ BridgedTypeRepr BridgedImplicitlyUnwrappedOptionalTypeRepr_createParsed(
     BridgedASTContext cContext, BridgedTypeRepr base,
     BridgedSourceLoc cExclamationLoc);
 
+SWIFT_NAME("BridgedInverseTypeRepr.createParsed(_:tildeLoc:constraint:)")
+BridgedTypeRepr
+BridgedInverseTypeRepr_createParsed(BridgedASTContext cContext,
+                                    BridgedSourceLoc cTildeLoc,
+                                    BridgedTypeRepr cConstraint);
+
 SWIFT_NAME("BridgedMemberTypeRepr.createParsed(_:base:members:)")
 BridgedTypeRepr
 BridgedMemberTypeRepr_createParsed(BridgedASTContext cContext,
@@ -1051,6 +1057,12 @@ BridgedProtocolTypeRepr_createParsed(BridgedASTContext cContext,
                                      BridgedTypeRepr baseType,
                                      BridgedSourceLoc cProtoLoc);
 
+SWIFT_NAME("BridgedPackElementTypeRepr.createParsed(_:base:eachKeywordLoc:)")
+BridgedTypeRepr
+BridgedPackElementTypeRepr_createParsed(BridgedASTContext cContext,
+                                        BridgedTypeRepr base,
+                                        BridgedSourceLoc cEachLoc);
+
 SWIFT_NAME(
     "BridgedPackExpansionTypeRepr.createParsed(_:base:repeatKeywordLoc:)")
 BridgedTypeRepr

lib/AST/ASTBridging.cpp

@@ -1328,6 +1328,15 @@ BridgedTypeRepr BridgedDictionaryTypeRepr_createParsed(
                          SourceRange{lSquareLoc, rSquareLoc});
 }
 
+BridgedTypeRepr
+BridgedInverseTypeRepr_createParsed(BridgedASTContext cContext,
+                                    BridgedSourceLoc cTildeLoc,
+                                    BridgedTypeRepr cConstraint) {
+
+  return new (cContext.unbridged())
+      InverseTypeRepr(cTildeLoc.unbridged(), cConstraint.unbridged());
+}
+
 BridgedTypeRepr
 BridgedMetatypeTypeRepr_createParsed(BridgedASTContext cContext,
                                      BridgedTypeRepr baseType,
@@ -1346,6 +1355,15 @@ BridgedProtocolTypeRepr_createParsed(BridgedASTContext cContext,
   return new (context) ProtocolTypeRepr(baseType.unbridged(), protoLoc);
 }
 
+BridgedTypeRepr
+BridgedPackElementTypeRepr_createParsed(BridgedASTContext cContext,
+                                        BridgedTypeRepr base,
+                                        BridgedSourceLoc cEachLoc) {
+  ASTContext &context = cContext.unbridged();
+  return new (context)
+      PackElementTypeRepr(cEachLoc.unbridged(), base.unbridged());
+}
+
 BridgedTypeRepr
 BridgedPackExpansionTypeRepr_createParsed(BridgedASTContext cContext,
                                           BridgedTypeRepr base,

lib/ASTGen/Sources/ASTGen/Bridge.swift

@@ -130,6 +130,12 @@ extension BridgedStringRef {
   }
 }
 
+extension BridgedStringRef: ExpressibleByStringLiteral {
+  public init(stringLiteral str: StaticString) {
+    self.init(data: str.utf8Start, count: str.utf8CodeUnitCount)
+  }
+}
+
 extension SyntaxProtocol {
   /// Obtains the bridged start location of the node excluding leading trivia in the source buffer provided by `astgen`
   ///

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -33,13 +33,14 @@ func isTypeMigrated(_ node: TypeSyntax) -> Bool {
   while true {
     switch current.kind {
     case // Known implemented kinds.
-        .arrayType, .attributedType, .compositionType, .someOrAnyType,
-        .dictionaryType, .functionType, .implicitlyUnwrappedOptionalType,
-        .memberType, .metatypeType, .namedOpaqueReturnType, .optionalType,
-        .packExpansionType, .identifierType, .tupleType:
+        .arrayType, .attributedType, .classRestrictionType, .compositionType,
+        .someOrAnyType, .dictionaryType, .functionType, .identifierType,
+        .implicitlyUnwrappedOptionalType, .memberType, .metatypeType,
+        .namedOpaqueReturnType, .optionalType, .packElementType,
+        .packExpansionType, .suppressedType, .tupleType:
       break
     case // Known unimplemented kinds.
-        .suppressedType, .packElementType, .missingType:
+        .missingType:
       return false;
     case // Unknown type kinds
       _ where current.is(TypeSyntax.self):
@@ -66,8 +67,8 @@ extension ASTGenVisitor {
       return self.generate(arrayType: node)
     case .attributedType(let node):
       return self.generate(attributedType: node)
-    case .classRestrictionType:
-      break
+    case .classRestrictionType(let node):
+      return self.generate(classRestrictionType: node)
     case .compositionType(let node):
       return self.generate(compositionType: node)
     case .dictionaryType(let node):
@@ -88,14 +89,14 @@ extension ASTGenVisitor {
       return self.generate(namedOpaqueReturnType: node)
     case .optionalType(let node):
       return self.generate(optionalType: node)
-    case .packElementType:
-      break
+    case .packElementType(let node):
+      return self.generate(packElementType: node)
     case .packExpansionType(let node):
       return self.generate(packExpansionType: node)
     case .someOrAnyType(let node):
       return self.generate(someOrAnyType: node)
-    case .suppressedType:
-      break
+    case .suppressedType(let node):
+      return self.generate(suppressedType: node)
     case .tupleType(let node):
       return self.generate(tupleType: node)
     }
@@ -239,6 +240,16 @@ extension ASTGenVisitor {
     )
   }
 
+  func generate(packElementType node: PackElementTypeSyntax) -> BridgedTypeRepr {
+    let base = generate(type: node.pack)
+    let eachLoc = self.generateSourceLoc(node.eachKeyword)
+    return BridgedPackElementTypeRepr.createParsed(
+      self.ctx,
+      base: base,
+      eachKeywordLoc: eachLoc
+    )
+  }
+
   func generate(packExpansionType node: PackExpansionTypeSyntax) -> BridgedTypeRepr {
     let base = generate(type: node.repetitionPattern)
     let repeatLoc = self.generateSourceLoc(node.repeatKeyword)
@@ -314,6 +325,24 @@ extension ASTGenVisitor {
     }
   }
 
+  func generate(suppressedType node: SuppressedTypeSyntax) -> BridgedTypeRepr {
+    return BridgedInverseTypeRepr.createParsed(
+      self.ctx,
+      tildeLoc: self.generateSourceLoc(node.withoutTilde),
+      constraint: self.generate(type: node.type)
+    )
+  }
+
+  func generate(classRestrictionType node: ClassRestrictionTypeSyntax) -> BridgedTypeRepr {
+    // TODO: diagnostics.
+    // warning: using 'class' keyword to define a class-constrained protocol is deprecated; use 'AnyObject' instead
+    return BridgedSimpleIdentTypeRepr.createParsed(
+      self.ctx,
+      loc: self.generateSourceLoc(node.classKeyword),
+      name: self.ctx.getIdentifier("AnyObject")
+    )
+  }
+
   // NOTE: When implementing new `generate(type:)`, please update  `isTypeMigrated(_:)`.
 }
 

test/ASTGen/types.swift

@@ -41,3 +41,14 @@ func test13(body: (_ value: Int) -> Void, i: Int) {
 func test14() {
   _ = Array<Array<Array<Int>>>().count
 }
+
+func testRepeatEach<each T>(_ t: repeat each T) -> (repeat each T) {
+  fatalError()
+}
+
+struct FileDescriptor: ~Copyable {
+  var fd = 1
+}
+
+// FIXME: warning for 'class'
+protocol ClassOnly: class {}