[Test] Add more tests for @_typeEraser

Author: hborla

test/Sema/type_eraser.swift

@@ -7,36 +7,103 @@ class AnyP: P {
 @_typeEraser(AnyP)
 protocol P {}
 
-class ConcreteP: P {}
+struct ConcreteP: P, Hashable {}
 
-dynamic func opaque() -> some P {
+// CHECK-LABEL: testBasic
+dynamic func testBasic() -> some P {
   // CHECK: underlying_to_opaque_expr{{.*}}'some P'
   // CHECK-NEXT: call_expr implicit type='AnyP'{{.*}}arg_labels=erasing:
   // CHECK: call_expr type='ConcreteP'
   ConcreteP()
 }
 
-class AnyQ: Q {
-  init<T: Q>(erasing: T) {}
+// CHECK-LABEL: testTypeAlias
+typealias AliasForP = P
+dynamic func testTypeAlias() -> some AliasForP {
+  // CHECK: underlying_to_opaque_expr{{.*}}'some P'
+  // CHECK-NEXT: call_expr implicit type='AnyP'{{.*}}arg_labels=erasing:
+  // CHECK: call_expr type='ConcreteP'
+  ConcreteP()
+}
+
+// CHECK-LABEL: testNoDynamic
+func testNoDynamic() -> some P {
+  // CHECK: underlying_to_opaque_expr{{.*}}'some P'
+  // CHECK-NEXT: call_expr type='ConcreteP'
+  ConcreteP()
 }
-@_typeEraser(AnyQ)
-protocol Q {}
 
-struct ConcreteQ: Q {}
+// CHECK-LABEL: testNoOpaque
+dynamic func testNoOpaque() -> P {
+  // CHECK: erasure_expr implicit type='P'
+  // CHECK-NEXT: normal_conformance type=ConcreteP protocol=P
+  // CHECK-NEXT: call_expr type='ConcreteP'
+  ConcreteP()
+}
 
+// CHECK-LABEL: testComposition
+typealias Composition = P & Hashable
+dynamic func testComposition() -> some Composition {
+  // CHECK: underlying_to_opaque_expr{{.*}}'some Hashable & P'
+  // CHECK-NEXT: call_expr type='ConcreteP'
+  ConcreteP()
+}
+
+// CHECK-LABEL: struct_decl{{.*}}Builder
 @_functionBuilder
 struct Builder {
-  static func buildBlock(_ params: Q...) -> ConcreteQ {
-    return ConcreteQ()
+  static func buildBlock(_ params: P...) -> ConcreteP {
+    return ConcreteP()
   }
 }
 
-// CHECK-LABEL: transformFnBody
-@Builder
-dynamic var transformFnBody: some Q {
-  // CHECK: return_stmt
-  // CHECK-NEXT: underlying_to_opaque_expr implicit type='some Q'
-  // CHECK-NEXT: call_expr implicit type='AnyQ'{{.*}}arg_labels=erasing:
-  // CHECK: declref_expr implicit type='@lvalue ConcreteQ'
-  ConcreteQ()
+// CHECK-LABEL: TestFunctionBuilder
+class TestFunctionBuilder {
+  // CHECK-LABEL: testTransformFnBody
+  @Builder dynamic var testTransformFnBody: some P {
+    // CHECK: return_stmt
+    // CHECK-NEXT: underlying_to_opaque_expr implicit type='some P'
+    // CHECK-NEXT: call_expr implicit type='AnyP'{{.*}}arg_labels=erasing:
+    // CHECK: declref_expr implicit type='@lvalue ConcreteP'
+    ConcreteP()
+  }
+
+  // CHECK-LABEL: func_decl{{.*}}takesBuilder
+  func takesBuilder(@Builder closure: () -> ConcreteP) -> ConcreteP { closure() }
+
+  // CHECK-LABEL: testClosureBuilder
+  dynamic var testClosureBuilder: some P {
+    // CHECK: underlying_to_opaque_expr implicit type='some P'
+    // CHECK-NEXT: call_expr implicit type='AnyP'{{.*}}arg_labels=erasing:
+    // CHECK: closure_expr type='() -> ConcreteP'
+    takesBuilder {
+      // CHECK: return_stmt
+      // CHECK-NEXT: load_expr implicit type='ConcreteP'
+      ConcreteP()
+    }
+  }
+}
+
+// CHECK-LABEL: class_decl{{.*}}DynamicReplacement
+class DynamicReplacement {
+  dynamic func testDynamicReplaceable() -> some P {
+    // CHECK: underlying_to_opaque_expr implicit type='some P'
+    // CHECK-NEXT: call_expr implicit type='AnyP'{{.*}}arg_labels=erasing:
+    // CHECK: call_expr type='ConcreteP'
+    ConcreteP()
+  }
+}
+
+// CHECK-LABEL: extension_decl{{.*}}DynamicReplacement
+extension DynamicReplacement {
+  // CHECK-LABEL: testDynamicReplacement
+  @_dynamicReplacement(for: testDynamicReplaceable)
+  func testDynamicReplacement() -> some P {
+    print("not single expr return")
+    // CHECK: return_stmt
+    // CHECK-NEXT: underlying_to_opaque_expr implicit type='some P'
+    // CHECK-NEXT: call_expr implicit type='AnyP'{{.*}}arg_labels=erasing:
+    // CHECK: call_expr type='ConcreteP'
+    return ConcreteP()
+  }
 }

test/Serialization/serialize_attr.swift

@@ -82,3 +82,15 @@ public class CC<T : PP> {
 // CHECK-DAG: sil [serialized] [_specialize exported: false, kind: full, where T == Int, U == Float] [canonical] [ossa] @$s14serialize_attr14specializeThis_1uyx_q_tr0_lF : $@convention(thin) <T, U> (@in_guaranteed T, @in_guaranteed U) -> () {
 
 // CHECK-DAG: sil [serialized] [noinline] [_specialize exported: false, kind: full, where T == RR, U == SS] [canonical] [ossa] @$s14serialize_attr2CCC3foo_1gqd___AA2GGVyxGtqd___AHtAA2QQRd__lF : $@convention(method) <T where T : PP><U where U : QQ> (@in_guaranteed U, GG<T>, @guaranteed CC<T>) -> (@out U, GG<T>) {
+
+
+ // @_typeEraser
+ // -----------------------------------------------------------------------------
+
+public class AnyP: P {
+  public init<T: P>(erasing: T) {}
+}
+
+// CHECK-DAG: @_typeEraser(AnyP) protocol P
+@_typeEraser(AnyP)
+public protocol P {}