// RUN: %target-sil-opt -enable-sil-verify-all %s -specdevirt -code-sinking  | %FileCheck %s

sil_stage canonical

import Builtin
import Swift

// Make sure we convert a class_method into a diamond control flow
// where one of the sides is a direct call to FOO::ping.
class Foo {
  func ping()
}

sil @_TFC8testcase3Foo4pingfS0_FT_T_ : $@convention(method) (@guaranteed Foo) -> ()
sil @_TFC8testcase3FoocfMS0_FT_S0_ : $@convention(method) (@owned Foo) -> @owned Foo

sil @_TF8testcase7my_mainFCS_3FooT_ : $@convention(thin) (@owned Foo) -> () {
bb0(%0 : $Foo):

//CHECK: checked_cast_br [exact] %0 : $Foo to $Foo

//CHECK: function_ref @_TFC8testcase3Foo4pingfS0_FT_T_
//CHECK: apply

//CHECK: class_method
//CHECK-NEXT: apply
  %1 = class_method %0 : $Foo, #Foo.ping!1 : (Foo) -> () -> (), $@convention(method) (@guaranteed Foo) -> () // user: %2
  %2 = apply %1(%0) : $@convention(method) (@guaranteed Foo) -> ()
  %3 = tuple ()                                   // user: %4
  return %3 : $()                                 // id: %4
}

sil_vtable Foo {
  #Foo.ping!1: @_TFC8testcase3Foo4pingfS0_FT_T_	// testcase.Foo.ping (testcase.Foo)() -> ()
  #Foo.init!initializer.1: @_TFC8testcase3FoocfMS0_FT_S0_	// testcase.Foo.init (testcase.Foo.Type)() -> testcase.Foo
}

class C {
  class func foo()
  class func bar()
}

// CHECK-LABEL: sil @_TZFC4spec1C3foofMS0_FT_T_
sil @_TZFC4spec1C3foofMS0_FT_T_ : $@convention(method) (@thick C.Type) -> () {
bb0(%0 : $@thick C.Type):
  %2 = tuple ()
  return %2 : $()
}

// CHECK-LABEL: sil @_TZFC4spec1C3barfMS0_FT_T_
sil @_TZFC4spec1C3barfMS0_FT_T_ : $@convention(method) (@thick C.Type) -> () {
  // CHECK: bb0
bb0(%0 : $@thick C.Type):
  // CHECK-NOT: class_method
  // CHECK: checked_cast_br [exact] %0 : $@thick C.Type to $@thick C.Type, bb2, bb3
  // CHECK: bb1
  // CHECK: return
  // CHECK: bb2
  // CHECK: [[REF:%.*]] = function_ref @_TZFC4spec1C3foofMS0_FT_T_
  // CHECK: apply [[REF]]
  // CHECK: br bb1
  // CHECK: bb3
  // CHECK: [[METHOD:%.*]] = class_method %0 : $@thick C.Type, #C.foo!1 : (C.Type) -> () -> (), $@convention(method) (@thick C.Type) -> ()
  // CHECK: apply [[METHOD]]
  %2 = class_method %0 : $@thick C.Type, #C.foo!1 : (C.Type) -> () -> (), $@convention(method) (@thick C.Type) -> ()
  %3 = apply %2(%0) : $@convention(method) (@thick C.Type) -> ()
  %4 = tuple ()
  return %4 : $()
}

sil_vtable C {
  #C.foo!1: @_TZFC4spec1C3foofMS0_FT_T_
  #C.bar!1: @_TZFC4spec1C3barfMS0_FT_T_
}