キャストをする時、裏側で何が起こっているのか？【Swift】

%4 = init_existential_addr %3 : $*Any, $Int // user: %5

unconditional_checked_cast_addr Any in %6 : $*Any to Int in %8 : $*Int // id: %9

sil-instruction ::= 'init_existential_addr' sil-operand ',' sil-type

%1 = init_existential_addr %0 : $*P, $T
// %0 must be of a $*P address type for non-class protocol or protocol composition type P
// $T must be an AST type that fulfills protocol(s) P
// %1 will be of type $*T', where T' is the maximally abstract lowering of type T

/// The basic layout of an opaque (non-class-bounded) existential type.
template <typename Runtime>
struct TargetOpaqueExistentialContainer {
  TargetValueBuffer<Runtime> Buffer;
  ConstTargetMetadataPointer<Runtime, TargetMetadata> Type;

  const TargetWitnessTable<Runtime> **getWitnessTables() {
    return reinterpret_cast<const TargetWitnessTable<Runtime> **>(this + 1);
  }

  const TargetWitnessTable<Runtime> *const *getWitnessTables() const {
    return reinterpret_cast<const TargetWitnessTable<Runtime> *const *>(this + 1);
  }
...
/// Project out a pointer to the value stored in the container.
///
/// *NOTE* If the container contains the value inline, then this will return a
/// pointer inside the container itself. Otherwise, it will return a pointer
/// to out of line memory.
const OpaqueValue *projectValue() const;
...
};

$ cat dog.swift
class Dog {}
class Doberman: Dog {
    var kawaisa = 3
}

func getKawaisa() -> Int {
    let a = Doberman()
    a.kawaisa = 5
    let b = a as Dog
    let c = b as! Doberman
    return c.kawaisa
}

// getKawaisa()
sil hidden @$s3dog10getKawaisaSiyF : $@convention(thin) () -> Int {
bb0:
 　%0 = metatype $@thick Doberman.Type // user: %2
 　// function_ref Doberman.__allocating_init()
 　%1 = function_ref @$s3dog8DobermanCACycfC : $@convention(method) (@thick Doberman.Type) -> @owned Doberman // user: %2
 　%2 = apply %1(%0) : $@convention(method) (@thick Doberman.Type) -> @owned Doberman // users: %18, %9, %8, %6, %7, %3
 　debug_value %2 : $Doberman, let, name "a" // id: %3
 　%4 = integer_literal $Builtin.Int64, 5 // user: %5
 　%5 = struct $Int (%4 : $Builtin.Int64) // user: %7
 　%6 = class_method %2 : $Doberman, #Doberman.kawaisa!setter.1 : (Doberman) -> (Int) -> (), $@convention(method) (Int, @guaranteed Doberman) -> () // user: %7
 　%7 = apply %6(%5, %2) : $@convention(method) (Int, @guaranteed Doberman) -> ()
 　strong_retain %2 : $Doberman // id: %8
 　%9 = upcast %2 : $Doberman to $Dog // users: %17, %12, %11, %10
 　debug_value %9 : $Dog, let, name "b" // id: %10
 　strong_retain %9 : $Dog // id: %11
 　%12 = unconditional_checked_cast %9 : $Dog to $Doberman // users: %16, %14, %15, %13
 　debug_value %12 : $Doberman, let, name "c" // id: %13
 　%14 = class_method %12 : $Doberman, #Doberman.kawaisa!getter.1 : (Doberman) -> () -> Int, $@convention(method) (@guaranteed Doberman) -> Int // user: %15
 　%15 = apply %14(%12) : $@convention(method) (@guaranteed Doberman) -> Int // user: %19
 　strong_release %12 : $Doberman // id: %16
 　strong_release %9 : $Dog // id: %17
 　strong_release %2 : $Doberman // id: %18
 　return %15 : $Int // id: %19
} // end sil function '$s3dog10getKawaisaSiyF'

// Doberman.__allocating_init()
sil hidden @$s3dog8DobermanCACycfC : $@convention(method) (@thick Doberman.Type) -> @owned Doberman {
bb0(%0 : $@thick Doberman.Type):
  %1 = alloc_ref $Doberman // user: %3
 　// function_ref Doberman.init()
  %2 = function_ref @$s3dog8DobermanCACycfc : $@convention(method) (@owned Doberman) -> @owned Doberman // user: %3
 　%3 = apply %2(%1) : $@convention(method) (@owned Doberman) -> @owned Doberman // user: %4
 　return %3 : $Doberman // id: %4
} // end sil function '$s3dog8DobermanCACycfC'

// Doberman.init()
sil hidden @$s3dog8DobermanCACycfc : $@convention(method) (@owned Doberman) -> @owned Doberman {
// %0 // users: %5, %9, %2
bb0(%0 : $Doberman):
 　%1 = alloc_stack $Doberman, let, name "self" // users: %13, %2, %15, %16
 　store %0 to %1 : $*Doberman // id: %2
 　%3 = integer_literal $Builtin.Int64, 3 // user: %4
 　%4 = struct $Int (%3 : $Builtin.Int64) // user: %7
 　%5 = ref_element_addr %0 : $Doberman, #Doberman.kawaisa // user: %6
 　%6 = begin_access [modify] [dynamic] %5 : $*Int // users: %7, %8
 　store %4 to %6 : $*Int // id: %7
 　end_access %6 : $*Int // id: %8
 　%9 = upcast %0 : $Doberman to $Dog // user: %11
 　// function_ref Dog.init()
 　%10 = function_ref @$s3dog3DogCACycfc : $@convention(method) (@owned Dog) -> @owned Dog // user: %11
 　%11 = apply %10(%9) : $@convention(method) (@owned Dog) -> @owned Dog // user: %12
 　%12 = unchecked_ref_cast %11 : $Dog to $Doberman // users: %14, %17, %13
 　store %12 to %1 : $*Doberman // id: %13
 　strong_retain %12 : $Doberman // id: %14
 　destroy_addr %1 : $*Doberman // id: %15
 　dealloc_stack %1 : $*Doberman // id: %16
 　return %12 : $Doberman // id: %17
} // end sil function '$s3dog8DobermanCACycfc'

1> let a: Int = 28
2> let b = a as Any
3> let c = b as! Int
4> type(of: a)
$R1: Int.Type = Int
5> type(of: b)
$R2: Any.Type = Int
6> type(of: c)
$R3: Int.Type = Int

func type<T, Metatype>(of value: T) -> Metatype

@_transparent
@_semantics("typechecker.type(of:)")
public func type<T, Metatype>(of value: T) -> Metatype { ... }

Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType, ConstraintLocatorBuilder locator, ConstraintLocatorBuilder calleeLocator) { ... }

/// Expr - Base class for all expressions in swift.

/// DynamicTypeExpr - "type(of: base)" - Produces a metatype value.
///
/// The metatype value comes from evaluating an expression then retrieving the
/// metatype of the result.