[+0-all-args] Update plus zero tests.

test/ClangImporter/plus_zero_optional.swift

@@ -0,0 +1,83 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -I %S/Inputs/custom-modules -enable-sil-ownership -emit-silgen -o - %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import ObjectiveC
+import Foundation
+import objc_ext
+import TestProtocols
+
+class A {
+  @objc func foo() -> String? {
+    return ""
+  }
+// CHECK-LABEL:    sil hidden [thunk] @$S8optional1AC3fooSSSgyFTo : $@convention(objc_method) (A) -> @autoreleased Optional<NSString>
+// CHECK:    bb0([[SELF:%.*]] : @unowned $A):
+// CHECK:      [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK:      [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+// CHECK:      [[T0:%.*]] = function_ref @$S8optional1AC3fooSSSgyF
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[BORROWED_SELF_COPY]])
+// CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+// CHECK-NEXT: destroy_value [[SELF_COPY]]
+// CHECK-NEXT: switch_enum [[T1]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+//   Something branch: project value, translate, inject into result.
+// CHECK:    [[SOME_BB]]([[STR:%.*]] : @owned $String):
+// CHECK:      [[T0:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+// CHECK-NEXT: [[BORROWED_STR:%.*]] = begin_borrow [[STR]]
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[BORROWED_STR]])
+// CHECK-NEXT: enum $Optional<NSString>, #Optional.some!enumelt.1, [[T1]]
+// CHECK-NEXT: end_borrow [[BORROWED_STR:%.*]] from [[STR]]
+// CHECK-NEXT: destroy_value [[STR]]
+// CHECK-NEXT: br
+//   Nothing branch: inject nothing into result.
+//
+// CHECK: [[NONE_BB]]:
+// CHECK-NEXT: enum $Optional<NSString>, #Optional.none!enumelt
+// CHECK-NEXT: br
+//   Continuation.
+// CHECK: bb3([[T0:%.*]] : @owned $Optional<NSString>):
+// CHECK-NEXT: return [[T0]]
+
+  @objc func bar(x x : String?) {}
+// CHECK-LABEL:    sil hidden [thunk] @$S8optional1AC3bar1xySSSg_tFTo : $@convention(objc_method) (Optional<NSString>, A) -> ()
+// CHECK:    bb0([[ARG:%.*]] : @unowned $Optional<NSString>, [[SELF:%.*]] : @unowned $A):
+// CHECK:      [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK:      [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK:      switch_enum [[ARG_COPY]] : $Optional<NSString>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+//   Something branch: project value, translate, inject into result.
+// CHECK:    [[SOME_BB]]([[NSSTR:%.*]] : @owned $NSString):
+// CHECK:      [[T0:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+//   Make a temporary initialized string that we're going to clobber as part of the conversion process (?).
+// CHECK-NEXT: [[NSSTR_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[NSSTR]] : $NSString
+// CHECK-NEXT: [[STRING_META:%.*]] = metatype $@thin String.Type
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[NSSTR_BOX]], [[STRING_META]])
+// CHECK-NEXT: enum $Optional<String>, #Optional.some!enumelt.1, [[T1]]
+// CHECK-NEXT: destroy_value [[NSSTR_BOX]]
+// CHECK-NEXT: br
+//
+//   Nothing branch: inject nothing into result.
+// CHECK:   [[NONE_BB]]:
+// CHECK:      enum $Optional<String>, #Optional.none!enumelt
+// CHECK-NEXT: br
+//   Continuation.
+// CHECK:      bb3([[T0:%.*]] : @owned $Optional<String>):
+// CHECK:      [[BORROWED_T0:%.*]] = begin_borrow [[T0]]
+// CHECK:      [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+// CHECK:      [[T1:%.*]] = function_ref @$S8optional1AC3bar1xySSSg_tF
+// CHECK-NEXT: [[T2:%.*]] = apply [[T1]]([[BORROWED_T0]], [[BORROWED_SELF_COPY]])
+// CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+// CHECK-NEXT: end_borrow [[BORROWED_T0]] from [[T0]]
+// CHECK-NEXT: destroy_value [[T0]]
+// CHECK-NEXT: destroy_value [[SELF_COPY]]
+// CHECK-NEXT: return [[T2]] : $()
+}
+
+
+// rdar://15144951
+class TestWeak : NSObject {
+  weak var b : WeakObject? = nil
+}
+class WeakObject : NSObject {}

test/ClangImporter/plus_zero_serialization-sil.swift

@@ -0,0 +1,44 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module-path %t/Test.swiftmodule -emit-sil -o /dev/null -module-name Test %s -sdk "" -import-objc-header %S/Inputs/serialization-sil.h -enable-sil-ownership
+// RUN: %target-sil-func-extractor %t/Test.swiftmodule -sil-print-debuginfo  -func='$S4Test16testPartialApplyyySoAA_pF' -o - | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+// @_transparent to force serialization.
+@_transparent
+public func testPartialApply(_ obj: Test) {
+  // CHECK-LABEL: @$S4Test16testPartialApplyyySoAA_pF : $@convention(thin) (@guaranteed Test) -> () {
+  if let curried1 = obj.normalObject {
+    // CHECK: dynamic_method_br [[CURRIED1_OBJ:%.+]] : $@opened([[CURRIED1_EXISTENTIAL:.+]]) Test, #Test.normalObject!1.foreign, [[CURRIED1_TRUE:[^,]+]], [[CURRIED1_FALSE:[^,]+]]
+    // CHECK: [[CURRIED1_FALSE]]:
+    // CHECK: [[CURRIED1_TRUE]]([[CURRIED1_METHOD:%.+]] : $@convention(objc_method) (@opened([[CURRIED1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject):
+    // CHECK: [[CURRIED1_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[CURRIED1_METHOD]]([[CURRIED1_OBJ]]) : $@convention(objc_method) (@opened([[CURRIED1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject
+    // CHECK: [[CURRIED1_THUNK:%.+]] = function_ref @$SyXlIego_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @owned AnyObject) -> @out Any
+    // CHECK: = partial_apply [callee_guaranteed] [[CURRIED1_THUNK]]([[CURRIED1_PARTIAL]])
+    curried1()
+  }
+  if let curried2 = obj.innerPointer {
+    // CHECK: dynamic_method_br [[CURRIED2_OBJ:%.+]] : $@opened([[CURRIED2_EXISTENTIAL:.+]]) Test, #Test.innerPointer!1.foreign, [[CURRIED2_TRUE:[^,]+]], [[CURRIED2_FALSE:[^,]+]]
+    // CHECK: [[CURRIED2_FALSE]]:
+    // CHECK: [[CURRIED2_TRUE]]([[CURRIED2_METHOD:%.+]] : $@convention(objc_method) (@opened([[CURRIED2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer):
+    // CHECK: [[CURRIED2_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[CURRIED2_METHOD]]([[CURRIED2_OBJ]]) : $@convention(objc_method) (@opened([[CURRIED2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer
+    curried2()
+  }
+  if let prop1 = obj.normalObjectProp {
+    // CHECK: dynamic_method_br [[PROP1_OBJ:%.+]] : $@opened([[PROP1_EXISTENTIAL:.+]]) Test, #Test.normalObjectProp!getter.1.foreign, [[PROP1_TRUE:[^,]+]], [[PROP1_FALSE:[^,]+]]
+    // CHECK: [[PROP1_FALSE]]:
+    // CHECK: [[PROP1_TRUE]]([[PROP1_METHOD:%.+]] : $@convention(objc_method) (@opened([[PROP1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject):
+    // CHECK: [[PROP1_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[PROP1_METHOD]]([[PROP1_OBJ]]) : $@convention(objc_method) (@opened([[PROP1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject
+    // CHECK: = apply [[PROP1_PARTIAL]]() : $@callee_guaranteed () -> @owned AnyObject
+    _ = prop1
+  }
+  if let prop2 = obj.innerPointerProp {
+    // CHECK: dynamic_method_br [[PROP2_OBJ:%.+]] : $@opened([[PROP2_EXISTENTIAL:.+]]) Test, #Test.innerPointerProp!getter.1.foreign, [[PROP2_TRUE:[^,]+]], [[PROP2_FALSE:[^,]+]]
+    // CHECK: [[PROP2_FALSE]]:
+    // CHECK: [[PROP2_TRUE]]([[PROP2_METHOD:%.+]] : $@convention(objc_method) (@opened([[PROP2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer):
+    // CHECK: [[PROP2_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[PROP2_METHOD]]([[PROP2_OBJ]]) : $@convention(objc_method) (@opened([[PROP2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer
+    // CHECK: = apply [[PROP2_PARTIAL]]() : $@callee_guaranteed () -> UnsafeMutableRawPointer
+    _ = prop2
+  }
+} // CHECK: // end sil function '$S4Test16testPartialApplyyySoAA_pF'

test/DebugInfo/plus_zero_closure-multivalue.swift

@@ -0,0 +1,43 @@
+// REQUIRES: plus_zero_runtime
+// rdar://problem/23727705:
+// RUN-DISABLED: %target-swift-frontend -O %s -disable-llvm-optzns -emit-ir -g -o - | %FileCheck %s
+import StdlibUnittest
+
+// CHECK: define {{.*}}i1 {{.*}}4main4sort
+// CHECK: call void @llvm.dbg.value(metadata i8*{{.*}}, metadata ![[A:.*]], metadata ![[P1:.*]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[A]], metadata ![[P2:.*]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[A]], metadata ![[P3:.*]])
+// CHECK: call void @llvm.dbg.value(metadata i8*{{.*}}, metadata ![[B:.*]], metadata ![[P1]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[B]], metadata ![[P2]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[B]], metadata ![[P3]])
+// CHECK-DAG: ![[A]] = !DILocalVariable(name: "a",{{.*}} line: 17
+// CHECK-DAG: ![[B]] = !DILocalVariable(name: "b",{{.*}} line: 17
+// CHECK-DAG: ![[P1]] = !DIExpression(DW_OP_bit_piece, 0, {{(32|64)}})
+// CHECK-DAG: ![[P2]] = !DIExpression(DW_OP_bit_piece, {{(32, 32|64, 64)}})
+// CHECK-DAG: ![[P3]] = !DIExpression(DW_OP_bit_piece, {{(64, 32|128, 64)}})
+public func sort(_ a: String, b: String) -> Bool {
+  _blackHole("Sorting..\(a) & \(b)")
+  return (a < b)
+}
+
+public func demo() {
+    let names = ["Sean", "Barry", "Kate"]
+    let sortedNames = names.sorted(by: sort)
+    var sortedNamesAsString : String = String()
+    for name in sortedNames {
+        sortedNamesAsString += ("\(name), ")
+    }
+    _blackHole(sortedNamesAsString)
+}
+demo()
+
+// At -O0, we should have a single aggregate argument.
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s --check-prefix=CHECK-O0
+// Verify that a reabstraction thunk does not have a line number.
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0: !DILocalVariable(name: "a", arg: 1{{.*}} line: 17,
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0: !DILocalVariable(name: "b", arg: 2{{.*}} line: 17,
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0: !DISubprogram(linkageName: "$SS2SSbs5Error_pIgggdzo_S2SSbsAA_pIegnndzo_TR",

test/DebugInfo/plus_zero_generic_args.swift

@@ -0,0 +1,54 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -primary-file %s -emit-ir -verify -g -o - | %FileCheck %s
+
+func markUsed<T>(_ t: T) {}
+
+protocol AProtocol {
+  func f() -> String
+}
+class AClass : AProtocol {
+  func f() -> String { return "A" }
+}
+class AnotherClass : AProtocol {
+  func f() -> String { return "B" }
+}
+
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9aFunction{{.*}}D",{{.*}} elements: ![[PROTOS:[0-9]+]]
+// CHECK-DAG: ![[PROTOS]] = !{![[INHERIT:.*]]}
+// CHECK-DAG: ![[INHERIT]] = !DIDerivedType(tag: DW_TAG_inheritance,{{.*}} baseType: ![[PROTOCOL:[0-9]+]]
+// CHECK-DAG: ![[PROTOCOL]] = !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9AProtocol_pmD",
+// CHECK-DAG: !DILocalVariable(name: "x", arg: 1,{{.*}} type: ![[T:.*]])
+// CHECK-DAG: ![[T]] = !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9aFunction
+// CHECK-DAG: !DILocalVariable(name: "y", arg: 2,{{.*}} type: ![[Q:.*]])
+// CHECK-DAG: ![[Q]] = !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9aFunction
+func aFunction<T : AProtocol, Q : AProtocol>(_ x: T, _ y: Q, _ z: String) {
+   markUsed("I am in \(z): \(x.f()) \(y.f())")
+}
+
+aFunction(AClass(),AnotherClass(),"aFunction")
+
+struct Wrapper<T: AProtocol> {
+
+  init<U>(from : Wrapper<U>) {
+  // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "Wrapper",{{.*}} identifier: "$S12generic_args7WrapperVyAC4fromACyxGACyqd__G_tcAA9AProtocolRd__lufcQq_GD")
+    var wrapped = from
+    wrapped = from
+    _ = wrapped
+  }
+
+  func passthrough(_ t: T) -> T {
+    // The type of local should have the context Wrapper<T>.
+    // CHECK-DAG: ![[WRAPPER:.*]] = !DICompositeType({{.*}}identifier: "$S12generic_args7WrapperVQq_D")
+    // CHECK-DAG: !DILocalVariable(name: "local",{{.*}} line: [[@LINE+1]],{{.*}} type: ![[WRAPPER]]
+    var local = t
+    local = t
+    return local
+  }
+}
+
+// CHECK-DAG: ![[FNTY:.*]] = !DICompositeType({{.*}}identifier: "$S12generic_args5apply_1fq_x_q_xXEtr0_lFQq_AaB_ACq_x_q_xXEtr0_lFQq0_Ignr_D"
+// CHECK-DAG: !DILocalVariable(name: "f", {{.*}}, line: [[@LINE+1]], type: ![[FNTY]])
+func apply<T, U> (_ x: T, f: (T) -> (U)) -> U {
+  return f(x)
+}
+

test/DebugInfo/plus_zero_resilience.swift

@@ -0,0 +1,39 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+//
+// Compile the external swift module.
+// RUN: %target-swift-frontend -g -emit-module -enable-resilience \
+// RUN:   -emit-module-path=%t/resilient_struct.swiftmodule \
+// RUN:   -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
+//
+// RUN: %target-swift-frontend -g -I %t -emit-ir -enable-resilience %s  -o - \
+// RUN:  | %FileCheck %s
+//
+// RUN: %target-swift-frontend -g -I %t -emit-sil -enable-resilience %s -o - \
+// RUN:    | %FileCheck %s --check-prefix=CHECK-SIL
+// RUN: %target-swift-frontend -g -I %t -emit-sil -enable-resilience %s -o - \
+// RUN:    -debugger-support | %FileCheck %s --check-prefix=CHECK-LLDB
+import resilient_struct
+
+func use<T>(_ t: T) {}
+
+public func f() {
+  let s1 = Size(w: 1, h: 2)
+  use(s1)
+  // CHECK: %[[ADDR:.*]] = alloca i8*
+  // CHECK: call void @llvm.dbg.declare(metadata i8** %[[ADDR]],
+  // CHECK-SAME:                        metadata ![[V1:[0-9]+]],
+  // CHECK-SAME:                        metadata !DIExpression(DW_OP_deref))
+  // CHECK: %[[S1:.*]] = alloca i8,
+  // CHECK: store i8* %[[S1]], i8** %[[ADDR]]
+  // CHECK: ![[V1]] = !DILocalVariable(name: "s1", {{.*}}type: ![[TY:[0-9]+]])
+  // CHECK: ![[TY]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Size",
+  // FIXME-NOT: size:
+  // CHECK: =
+}
+
+// CHECK-SIL: // f()
+// CHECK-LLDB: // f()
+// CHECK-SIL: %0 = alloc_stack $Size, let, name "s1"
+// CHECK-LLDB: %0 = metatype $@thin Size.Type
+// CHECK-LLDB: debug_value %{{.*}} : $Size, let, name "s1"