Update tests for new trivial moves and extend_lifetimes.

Author: atrick

test/AutoDiff/SILGen/autodiff_builtins.swift

@@ -99,7 +99,7 @@ func test_context_builtins_with_type<T>(t: T) {
 // CHECK:   [[CTX:%.*]] = builtin "autoDiffCreateLinearMapContextWithType"<T>({{%.*}} : $@thick T.Type) : $Builtin.NativeObject
 // CHECK:   [[CTX_LIFETIME:%.*]] = move_value [lexical] [var_decl] [[CTX]]
 // CHECK:   [[BORROWED_CTX:%.*]] = begin_borrow [[CTX_LIFETIME]]
-// CHECK:   [[BUF:%.*]] = builtin "autoDiffProjectTopLevelSubcontext"([[BORROWED_CTX]] : $Builtin.NativeObject) : $Builtin.RawPointer // users: {{.*}}
+// CHECK:   [[BUF:%.*]] = builtin "autoDiffProjectTopLevelSubcontext"([[BORROWED_CTX]] : $Builtin.NativeObject) : $Builtin.RawPointer
 // CHECK:   [[BORROWED_CTX:%.*]] = begin_borrow [[CTX_LIFETIME]]
-// CHECK:   [[BUF:%.*]] = builtin "autoDiffAllocateSubcontextWithType"<T>([[BORROWED_CTX]] : $Builtin.NativeObject, {{.*}} : $@thick T.Type) : $Builtin.RawPointer // users: {{.*}}
+// CHECK:   [[BUF:%.*]] = builtin "autoDiffAllocateSubcontextWithType"<T>([[BORROWED_CTX]] : $Builtin.NativeObject, {{.*}} : $@thick T.Type) : $Builtin.RawPointer
 // CHECK:   destroy_value [[CTX_LIFETIME]]

test/AutoDiff/SILOptimizer/activity_analysis.swift

@@ -220,11 +220,11 @@ func checked_cast_addr_active_result<T: Differentiable>(x: T) -> T {
 // CHECK: bb3:
 // CHECK: [ACTIVE] %14 = argument of bb3 : $Optional<Float>
 // CHECK: bb4:
-// CHECK: [ACTIVE] %16 = argument of bb4 : $Float
-// CHECK: [ACTIVE]   %19 = alloc_stack $Float
+// CHECK: [ACTIVE] [[ARG4:%.*]] = argument of bb4 : $Float
+// CHECK: [ACTIVE]   [[ALLOC4:%.*]] = alloc_stack $Float
 // CHECK: bb5:
 // CHECK: bb6:
-// CHECK: [NONE]   %27 = tuple ()
+// CHECK: [NONE]   %{{[0-9]+}} = tuple ()
 
 // CHECK-LABEL: sil hidden [ossa] @${{.*}}checked_cast_addr_active_result{{.*}} : $@convention(thin) <T where T : Differentiable> (@in_guaranteed T) -> @out T {
 // CHECK:   checked_cast_addr_br take_always T in %3 : $*T to Float in %5 : $*Float, bb1, bb2
@@ -832,15 +832,15 @@ func testActiveEnumValue(_ e: DirectEnum, _ x: Float) -> Float {
 // CHECK: bb2:
 // CHECK: [ACTIVE] %6 = argument of bb2 : $Float
 // CHECK: bb3:
-// CHECK: [ACTIVE] %9 = argument of bb3 : $(Float, Float)
-// CHECK: [ACTIVE] (**%10**, %11) = destructure_tuple %9 : $(Float, Float)
-// CHECK: [ACTIVE] (%10, **%11**) = destructure_tuple %9 : $(Float, Float)
-// CHECK: [USEFUL]   %14 = metatype $@thin Float.Type
+// CHECK: [ACTIVE] [[ARG3:%.*]] = argument of bb3 : $(Float, Float)
+// CHECK: [ACTIVE] (**[[D1:%.*]]**, [[D2:%.*]]) = destructure_tuple [[ARG3]] : $(Float, Float)
+// CHECK: [ACTIVE] ([[D1]], **[[D2]]**) = destructure_tuple [[ARG3]] : $(Float, Float)
+// CHECK: [USEFUL]   %{{.*}} = metatype $@thin Float.Type
 // CHECK: [NONE]   // function_ref static Float.+ infix(_:_:)
-// CHECK:   %15 = function_ref @$sSf1poiyS2f_SftFZ : $@convention(method) (Float, Float, @thin Float.Type) -> Float
-// CHECK: [ACTIVE]   %16 = apply %15(%10, %11, %14) : $@convention(method) (Float, Float, @thin Float.Type) -> Float
+// CHECK:   %{{.*}} = function_ref @$sSf1poiyS2f_SftFZ : $@convention(method) (Float, Float, @thin Float.Type) -> Float
+// CHECK: [ACTIVE]   %{{.*}} = apply %{{[0-9]+}}(%{{[0-9]+}}, %{{[0-9]+}}, %{{[0-9]+}}) : $@convention(method) (Float, Float, @thin Float.Type) -> Float
 // CHECK: bb4:
-// CHECK: [ACTIVE] %18 = argument of bb4 : $Float
+// CHECK: [ACTIVE] %{{[0-9]+}} = argument of bb4 : $Float
 
 enum IndirectEnum<T: Differentiable>: Differentiable & AdditiveArithmetic {
   case case1(T)

test/AutoDiff/SILOptimizer/derivative_sil.swift

@@ -41,10 +41,11 @@ func foo(_ x: Float) -> Float {
 // CHECK-SIL:   [[ADD_JVP_FN:%.*]] = differentiable_function_extract [jvp] [[ADD_DIFF_FN]]
 // CHECK-SIL:   [[ADD_RESULT:%.*]] = apply [[ADD_JVP_FN]]([[X]], [[X]], {{.*}})
 // CHECK-SIL:   ([[ORIG_RES:%.*]], [[ADD_DF:%.*]]) = destructure_tuple [[ADD_RESULT]]
+// CHECK-SIL:   [[MV_RES:%.*]] = move_value [var_decl] [[ORIG_RES]] : $Float
 // CHECK-SIL:   [[DF_STRUCT:%.*]] = tuple ([[ADD_DF]] : $@callee_guaranteed (Float, Float) -> Float)
 // CHECK-SIL:   [[DF_REF:%.*]] = function_ref @fooTJdSpSr : $@convention(thin) (Float, @owned (_: @callee_guaranteed (Float, Float) -> Float)) -> Float
 // CHECK-SIL:   [[DF_FN:%.*]] = partial_apply [callee_guaranteed] [[DF_REF]]([[DF_STRUCT]])
-// CHECK-SIL:   [[VJP_RESULT:%.*]] = tuple ([[ORIG_RES]] : $Float, [[DF_FN]] : $@callee_guaranteed (Float) -> Float)
+// CHECK-SIL:   [[VJP_RESULT:%.*]] = tuple ([[MV_RES]] : $Float, [[DF_FN]] : $@callee_guaranteed (Float) -> Float)
 // CHECK-SIL:   return [[VJP_RESULT]] : $(Float, @callee_guaranteed (Float) -> Float)
 // CHECK-SIL: }
 
@@ -67,7 +68,7 @@ func foo(_ x: Float) -> Float {
 // CHECK-SIL:   ([[ORIG_RES:%.*]], [[ADD_PB:%.*]]) = destructure_tuple [[ADD_RESULT]]
 // CHECK-SIL:   [[PB_REF:%.*]] = function_ref @fooTJpSpSr : $@convention(thin) (Float, @owned @callee_guaranteed (Float) -> (Float, Float)) -> Float
 // CHECK-SIL:   [[PB_FN:%.*]] = partial_apply [callee_guaranteed] [[PB_REF]]([[ADD_PB]])
-// CHECK-SIL:   [[VJP_RESULT:%.*]] = tuple ([[ORIG_RES]] : $Float, [[PB_FN]] : $@callee_guaranteed (Float) -> Float)
+// CHECK-SIL:   [[VJP_RESULT:%.*]] = tuple ([[MV_RES]] : $Float, [[PB_FN]] : $@callee_guaranteed (Float) -> Float)
 // CHECK-SIL:   return [[VJP_RESULT]] : $(Float, @callee_guaranteed (Float) -> Float)
 // CHECK-SIL: }
 

test/Interop/Cxx/class/function-call-macosx.swift

@@ -20,11 +20,13 @@ public func testARCWeak() {
 // CHECK: sil [ossa] @$s4main26testARCWeakFunctionPointeryyF : $@convention(thin) () -> () {
 // CHECK: %[[V0:.*]] = function_ref @_Z9getFnPtr2v : $@convention(c) () -> @convention(c) (@in ARCWeak) -> ()
 // CHECK: %[[V1:.*]] = apply %[[V0]]() : $@convention(c) () -> @convention(c) (@in ARCWeak) -> ()
+// CHECK: %[[MV1:.*]] = move_value [var_decl] %[[V1]] : $@convention(c) (@in ARCWeak) -> ()
 // CHECK: %[[V3:.*]] = alloc_stack $ARCWeak
 // CHECK: %[[V6:.*]] = function_ref @_ZN7ARCWeakC1Ev : $@convention(c) () -> @out ARCWeak
 // CHECK: apply %[[V6]](%[[V3]]) : $@convention(c) () -> @out ARCWeak
-// CHECK: apply %[[V1]](%[[V3]]) : $@convention(c) (@in ARCWeak) -> ()
+// CHECK: apply %[[MV1]](%[[V3]]) : $@convention(c) (@in ARCWeak) -> ()
 // CHECK-NEXT: dealloc_stack %[[V3]] : $*ARCWeak
+// CHECK-NEXT: extend_lifetime %[[MV1]] : $@convention(c) (@in ARCWeak) -> ()
 // CHECK-NEXT: %[[V9:.*]] = tuple ()
 // CHECK-NEXT: return %[[V9]] : $()
 

test/Interop/Cxx/foreign-reference/reference-counted-silgen.swift

@@ -9,7 +9,6 @@ import ReferenceCounted
 // CHECK-NOT: retain
 // CHECK-NOT: release
 // CHECK-NOT: copy_value
-// CHECK-NOT: destroy_value
 // CHECK-NOT: begin_borrow
 // CHECK-NOT: end_borrow
 // CHECK: return

test/SILGen/access_marker_gen.swift

@@ -111,8 +111,9 @@ func testClassInstanceProperties(c: C) {
 // CHECK-NEXT:  debug_value
 // CHECK-NEXT:  [[CX:%.*]] = ref_element_addr [[C]] : $C, #C.x
 // CHECK-NEXT:  [[ACCESS:%.*]] = begin_access [read] [dynamic] [[CX]] : $*Int
-// CHECK-NEXT:  [[Y:%.*]] = load [trivial] [[ACCESS]]
+// CHECK-NEXT:  [[L:%.*]] = load [trivial] [[ACCESS]]
 // CHECK-NEXT:  end_access [[ACCESS]]
+// CHECK-NEXT:  [[Y:%.*]] = move_value [var_decl] [[L]]
 // CHECK-NEXT:  debug_value
 // CHECK-NEXT:  [[CX:%.*]] = ref_element_addr [[C]] : $C, #C.x
 // CHECK-NEXT:  [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[CX]] : $*Int

test/SILGen/async_conversion.swift

@@ -47,7 +47,7 @@ actor A: P2 {
   // CHECK: hop_to_executor {{.*}} : $MainActor
   // CHECK: [[F:%.*]] = function_ref @$s4test11mainActorFnyyF : $@convention(thin) () -> ()
   // CHECK: [[THICK_F:%.*]] = thin_to_thick_function [[F]] : $@convention(thin) () -> () to $@callee_guaranteed () -> ()
-  // CHECK: [[THICK_F_VAR:%.*]] = move_value [var_decl] [[THICK_F]]
+  // CHECK: [[THICK_F_VAR:%.*]] = move_value [lexical] [var_decl] [[THICK_F]]
   // CHECK: [[THICK_F_BORROW:%.*]] = begin_borrow [[THICK_F_VAR]]
   // CHECK: [[THICK_F_COPY:%.*]] = copy_value [[THICK_F_BORROW]]
   // CHECK: [[THUNK:%.*]] = function_ref @$sIeg_IegH_TR : $@convention(thin) @async (@guaranteed @callee_guaranteed () -> ()) -> ()

test/SILGen/builtins.swift

@@ -782,8 +782,10 @@ func bindMemory<T>(ptr: Builtin.RawPointer, idx: Builtin.Word, _: T.Type) {
 // CHECK-LABEL: sil hidden [ossa] @$s8builtins12rebindMemory{{[_0-9a-zA-Z]*}}F
 // CHECK: bb0([[P:%.*]] : $Builtin.RawPointer, [[I:%.*]] : $Builtin.Word, [[T:%.*]] : $@thick T.Type):
 // CHECK: [[BIND:%.*]] = bind_memory [[P]] : $Builtin.RawPointer, [[I]] : $Builtin.Word to $*T
-// CHECK: [[REBIND:%.*]] = rebind_memory [[P]] : $Builtin.RawPointer to [[BIND]] : $Builtin.Word
-// CHECK: %{{.*}} = rebind_memory [[P]] : $Builtin.RawPointer to [[REBIND]] : $Builtin.Word
+// CHECK: [[MV1:%.*]] = move_value [var_decl] [[BIND]] : $Builtin.Word
+// CHECK: [[REBIND:%.*]] = rebind_memory [[P]] : $Builtin.RawPointer to [[MV1]] : $Builtin.Word
+// CHECK: [[MV2:%.*]] = move_value [var_decl] [[REBIND]] : $Builtin.Word
+// CHECK: %{{.*}} = rebind_memory [[P]] : $Builtin.RawPointer to [[MV2]] : $Builtin.Word
 // CHECK:   return {{%.*}} : $()
 // CHECK: }
 func rebindMemory<T>(ptr: Builtin.RawPointer, idx: Builtin.Word, _: T.Type) {

test/SILGen/cf_members.swift

@@ -19,9 +19,10 @@ public func foo(_ x: Double) {
   // CHECK: [[GLOBALVAR:%.*]] = global_addr @IAMStruct1GlobalVar
   // CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOBALVAR]] : $*Double
   // CHECK: [[ZZ:%.*]] = load [trivial] [[READ]]
+  // CHECK: [[MV:%.*]] = move_value [var_decl] [[ZZ]] : $Double
   let zz = Struct1.globalVar
   // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[GLOBALVAR]] : $*Double
-  // CHECK: assign [[ZZ]] to [[WRITE]]
+  // CHECK: assign [[MV]] to [[WRITE]]
   Struct1.globalVar = zz
 
   // CHECK: [[Z:%.*]] = project_box
@@ -39,7 +40,7 @@ public func foo(_ x: Double) {
 
   // CHECK: [[FN:%.*]] = function_ref @$s10cf_members3fooyySdFSo10IAMStruct1VSdcfu_ : $@convention(thin) (Double) -> Struct1
   // CHECK: [[A:%.*]] = thin_to_thick_function [[FN]]
-  // CHECK: [[MOVED_A:%.*]] = move_value [var_decl] [[A]]
+  // CHECK: [[MOVED_A:%.*]] = move_value [lexical] [var_decl] [[A]]
   // CHECK: [[BORROWED_A:%.*]] = begin_borrow [[MOVED_A]]
   // CHECK: [[COPIED_A:%.*]] = copy_value [[BORROWED_A]]
   // CHECK: [[BORROWED_A:%.*]] = begin_borrow [[COPIED_A]]
@@ -81,7 +82,7 @@ public func foo(_ x: Double) {
   z = c(x)
   // CHECK: [[THUNK:%.*]] = function_ref @$s10cf_members3fooyySdFSo10IAMStruct1VSdcADcfu2_ : $@convention(thin) (Struct1) -> @owned @callee_guaranteed (Double) -> Struct1
   // CHECK: [[THICK:%.*]] = thin_to_thick_function [[THUNK]]
-  // CHECK: [[MOVED_THICK:%.*]] = move_value [var_decl] [[THICK]]
+  // CHECK: [[MOVED_THICK:%.*]] = move_value [lexical] [var_decl] [[THICK]]
   // CHECK: [[BORROWED_THICK:%.*]] = begin_borrow [[MOVED_THICK]]
   // CHECK: [[COPIED_THICK:%.*]] = copy_value [[BORROWED_THICK]]
   let d: (Struct1) -> (Double) -> Struct1 = Struct1.translate(radians:)
@@ -162,7 +163,7 @@ public func foo(_ x: Double) {
   var y = Struct1.staticMethod()
   // CHECK: [[THUNK:%.*]] = function_ref @$s10cf_members3fooyySdFs5Int32Vycfu8_ : $@convention(thin) () -> Int32 
   // CHECK: [[I2:%.*]] = thin_to_thick_function [[THUNK]]
-  // CHECK: [[MOVED_I2:%.*]] = move_value [var_decl] [[I2]]
+  // CHECK: [[MOVED_I2:%.*]] = move_value [lexical] [var_decl] [[I2]]
   // CHECK: [[BORROWED_I2:%.*]] = begin_borrow [[MOVED_I2]]
   // CHECK: [[COPIED_I2:%.*]] = copy_value [[BORROWED_I2]]
   let i = Struct1.staticMethod

test/SILGen/closure_literal_reabstraction.swift

@@ -132,35 +132,41 @@ func reabstractDynamicGenericStaticMemberRef<T: Buttable>(t: T.Type) {
 }
 
 // CHECK-LABEL: sil {{.*}} @{{.*}}reabstractExistentialInitializerRef
+// CHECK:         [[MV:%.*]] = move_value [var_decl] %0 : $@thick any Buttable.Type
 // CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}u_
-// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]](%0)
+// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]([[MV]])
 // CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape [not_guaranteed] [[CLOSURE]]
 // CHECK:         apply {{.*}}<Int, any Buttable>([[CLOSURE_NE]])
 func reabstractExistentialInitializerRef(butt: any Buttable.Type) {
     gen(f: butt.init)
 }
 
 // CHECK-LABEL: sil {{.*}} @{{.*}}reabstractExistentialStaticMemberRef
+// CHECK:         [[MV:%.*]] = move_value [var_decl] %0 : $@thick any Buttable.Type
 // CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}u_
-// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]](%0)
+// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]([[MV]])
 // CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape [not_guaranteed] [[CLOSURE]]
 // CHECK:         apply {{.*}}<Int, any Buttable>([[CLOSURE_NE]])
 func reabstractExistentialStaticMemberRef(butt: any Buttable.Type) {
     gen(f: butt.create)
 }
 
+// TODO: The move_value [var_decl]'s here are an unexpected consequence of how SILGen generates reabstractions.
+//
 // CHECK-LABEL: sil {{.*}} @{{.*}}reabstractClassCompInitializerRefs
 func reabstractClassCompInitializerRefs<T>(
     butt: any (AbstractGenericButt<T> & Buttable).Type
 ) {
+// CHECK:         [[MV1:%.*]] = move_value [var_decl] %0
 // CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}u_
-// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>(%0)
+// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>([[MV1]])
 // CHECK:         [[CLOSURE_C:%.*]] = convert_function [[CLOSURE]]
 // CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape [not_guaranteed] [[CLOSURE_C]]
 // CHECK:         apply {{.*}}<Int, any (AbstractGenericButt<T> & Buttable)>([[CLOSURE_NE]])
     gen(f: butt.init(c:))
+// CHECK:         [[MV2:%.*]] = move_value [var_decl] %0
 // CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}u0_
-// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>(%0)
+// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>([[MV2]])
 // CHECK:         [[CLOSURE_C:%.*]] = convert_function [[CLOSURE]]
 // CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape [not_guaranteed] [[CLOSURE_C]]
 // CHECK:         apply {{.*}}<Int, any (AbstractGenericButt<T> & Buttable)>([[CLOSURE_NE]])
@@ -171,14 +177,16 @@ func reabstractClassCompInitializerRefs<T>(
 func reabstractClassCompStaticMemberRefs<T>(
     butt: any (AbstractGenericButt<T> & Buttable).Type
 ) {
+// CHECK:         [[MV1:%.*]] = move_value [var_decl] %0
 // CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}u_
-// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>(%0)
+// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>([[MV1]])
 // CHECK:         [[CLOSURE_C:%.*]] = convert_function [[CLOSURE]]
 // CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape [not_guaranteed] [[CLOSURE_C]]
 // CHECK:         apply {{.*}}<Int, any (AbstractGenericButt<T> & Buttable)>([[CLOSURE_NE]])
     gen(f: butt.create(c:))
+// CHECK:         [[MV2:%.*]] = move_value [var_decl] %0
 // CHECK:         [[CLOSURE_FN:%.*]] = function_ref {{.*}}u0_
-// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>(%0)
+// CHECK:         [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE_FN]]<T>([[MV2]])
 // CHECK:         [[CLOSURE_C:%.*]] = convert_function [[CLOSURE]]
 // CHECK:         [[CLOSURE_NE:%.*]] = convert_escape_to_noescape [not_guaranteed] [[CLOSURE_C]]
 // CHECK:         apply {{.*}}<Int, any (AbstractGenericButt<T> & Buttable)>([[CLOSURE_NE]])