struct Point {    let x: Double    let y: Double    let isFilled: Bool}

func getSize() -> Int {    return MemoryLayout<Int16>.size}

xcrun swiftc -dump-ast file.swift  

(source_file "file.swift"  (func_decl range=[file.swift:7:1 - line:9:1] "getSize()" interface type='() -> Int' access=internal    (parameter_list range=[file.swift:7:13 - line:7:14])    (result      (type_ident        (component id='Int' bind=Swift.(file).Int)))    (brace_stmt range=[file.swift:7:23 - line:9:1]      (return_stmt range=[file.swift:8:5 - line:8:32]        (member_ref_expr type='Int' location=file.swift:8:32 range=[file.swift:8:12 - line:8:32] decl=Swift.(file).MemoryLayout.size [with (substitution_map generic_signature=<T> (substitution T -> Int16))]          (type_expr type='MemoryLayout<Int16>.Type' location=file.swift:8:12 range=[file.swift:8:12 - line:8:30] typerepr='MemoryLayout<Int16>'))))))

xcrun swiftc -emit-silgen -O file.swift | swift demangle

sil_stage raw
import Builtinimport Swiftimport SwiftShims
func getSize() -> Int
// mainsil [ossa] @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):  %2 = integer_literal $Builtin.Int32, 0          // user: %3  %3 = struct $Int32 (%2 : $Builtin.Int32)        // user: %4  return %3 : $Int32                              // id: %4} // end sil function 'main'
// getSize()sil hidden [ossa] @file.getSize() -> Swift.Int : $@convention(thin) () -> Int {bb0:  // 获得 MemoryLayout<Int16>.Type 类型  %0 = metatype $@thin MemoryLayout<Int16>.Type   // user: %2
  // 获得 静态属性 size 的 get 方法  // function_ref static MemoryLayout.size.getter  %1 = function_ref @static Swift.MemoryLayout.size.getter : Swift.Int : $@convention(method) <τ_0_0> (@thin MemoryLayout<τ_0_0>.Type) -> Int // user: %2
  // 调用 静态属性 size 的 get 方法，参数是 MemoryLayout<Int16>.Type，并返回一个 Int 类型的值  %2 = apply %1<Int16>(%0) : $@convention(method) <τ_0_0> (@thin MemoryLayout<τ_0_0>.Type) -> Int // user: %3  // 返回结果  return %2 : $Int                                // id: %3} // end sil function 'file.getSize() -> Swift.Int'
//  静态属性 size 的 get 方法// static MemoryLayout.size.gettersil [transparent] [serialized] @static Swift.MemoryLayout.size.getter : Swift.Int : $@convention(method) <τ_0_0> (@thin MemoryLayout<τ_0_0>.Type) -> Int

@frozen public enum MemoryLayout<T> {  @_transparent public static var size: Swift.Int {    @_transparent get {    return Int(Builtin.sizeof(T.self))  }  }  @_transparent public static var stride: Swift.Int {    @_transparent get {    return Int(Builtin.strideof(T.self))  }  }  @_transparent public static var alignment: Swift.Int {    @_transparent get {    return Int(Builtin.alignof(T.self))  }  }}

xcrun swiftc -emit-sil -Onone file.swift | swift demangle

//  静态属性 size 的 get 方法实现，对应的 Swift 版本就是  Int(Builtin.sizeof(T.self))// static MemoryLayout.size.gettersil public_external [transparent] [serialized] @static Swift.MemoryLayout.size.getter : Swift.Int : $@convention(method) <T> (@thin MemoryLayout<T>.Type) -> Int {bb0(%0 : $@thin MemoryLayout<T>.Type):  // 获得 T.Type 类型。  %1 = metatype $@thick T.Type                    // user: %2  // 调用内置函数 sizeof 获取 T.Type 类型的 size 信息，返回结果是 Builtin.Word 类型  %2 = builtin "sizeof"<T>(%1 : $@thick T.Type) : $Builtin.Word // user: %3  // 调用 sextOrBitCast_Word_Int64 将 Builtin.Word 类型的结果转为 Builtin.Int64 类型  %3 = builtin "sextOrBitCast_Word_Int64"(%2 : $Builtin.Word) : $Builtin.Int64 // user: %4  // 将 Builtin.Int64 类型转为 Int 类型  %4 = struct $Int (%3 : $Builtin.Int64)          // user: %5  return %4 : $Int                                // id: %5} // end sil function 'static Swift.MemoryLayout.size.getter : Swift.Int'

sil_stage canonical
// getSize()sil hidden @file.getSize() -> Swift.Int : $@convention(thin) () -> Int {bb0:  %0 = metatype $@thick Int16.Type                // user: %1  %1 = builtin "sizeof"<Int16>(%0 : $@thick Int16.Type) : $Builtin.Word // user: %2  %2 = builtin "sextOrBitCast_Word_Int64"(%1 : $Builtin.Word) : $Builtin.Int64 // user: %3  %3 = struct $Int (%2 : $Builtin.Int64)          // user: %4  return %3 : $Int                                // id: %4} // end sil function 'file.getSize() -> Swift.Int'

@frozen public struct Int16 : Swift.FixedWidthInteger, Swift.SignedInteger, Swift._ExpressibleByBuiltinIntegerLiteral {     public var _value: Builtin.Int16 }

void BuiltinUnit::LookupCache::lookupValue(       Identifier Name, NLKind LookupKind, const BuiltinUnit &M,       SmallVectorImpl<ValueDecl*> &Result) {...   if (Type Ty = getBuiltinType(Ctx, Name.str())) {      auto *TAD = new (Ctx) TypeAliasDecl(SourceLoc(), SourceLoc(),                                          Name, SourceLoc(),                                          /*genericparams*/nullptr,                                          const_cast<BuiltinUnit*>(&M));      TAD->setUnderlyingType(Ty);      TAD->setAccess(AccessLevel::Public);      Entry = TAD;...

Type swift::getBuiltinType(ASTContext &Context, StringRef Name) ····  // Handle 'int8' and friends.  if (Name.substr(0, 3) == "Int") {    unsigned BitWidth;    if (!Name.substr(3).getAsInteger(10, BitWidth) &&        BitWidth <= 2048 && BitWidth != 0)  // Cap to prevent insane things.      return BuiltinIntegerType::get(BitWidth, Context);  }····

(lldb) p Name(swift::Identifier) $14 = (Pointer = "Int16")(lldb) p Ty.dump()(builtin_integer_type bit_width=16)(lldb) p TAD->dump()(typealias "Int16" access=public type='Builtin.Int16')

const TypeInfo *TypeConverter::convertStructType(TypeBase *key, CanType type,                                                 StructDecl *D){
...  // Collect all the fields from the type.  SmallVector<VarDecl*, 8> fields;  for (VarDecl *VD : D->getStoredProperties())    fields.push_back(VD);
  // Build the type.  StructTypeBuilder builder(IGM, ty, type);  return builder.layout(fields);}

TypeInfo *layout(ArrayRef<ASTField> astFields) {    SmallVector<FieldImpl, 8> fields;    SmallVector<const TypeInfo *, 8> fieldTypesForLayout;    fields.reserve(astFields.size());    fieldTypesForLayout.reserve(astFields.size());
    bool loadable = true;    auto fieldsABIAccessible = FieldsAreABIAccessible;
    unsigned explosionSize = 0;    for (unsigned i : indices(astFields)) {      auto &astField = astFields[i];      // Compute the field's type info.      // 依次遍历获取 typeInfo 信息      auto &fieldTI = IGM.getTypeInfo(asImpl()->getType(astField));      fieldTypesForLayout.push_back(&fieldTI);
      if (!fieldTI.isABIAccessible())        fieldsABIAccessible = FieldsAreNotABIAccessible;
      fields.push_back(FieldImpl(asImpl()->getFieldInfo(i, astField, fieldTI)));
      auto loadableFieldTI = dyn_cast<LoadableTypeInfo>(&fieldTI);      if (!loadableFieldTI) {        loadable = false;        continue;      }
      auto &fieldInfo = fields.back();      fieldInfo.Begin = explosionSize;      explosionSize += loadableFieldTI->getExplosionSize();      fieldInfo.End = explosionSize;    }
    // Perform layout and fill in the fields.    // 产出 Int16 的 layout 信息    StructLayout layout = asImpl()->performLayout(fieldTypesForLayout);    for (unsigned i = 0, e = fields.size(); i != e; ++i) {      fields[i].completeFrom(layout.getElements()[i]);    }
    // Create the type info.    if (loadable) {      assert(layout.isFixedLayout());      assert(fieldsABIAccessible);      return asImpl()->createLoadable(fields, std::move(layout), explosionSize);    } else if (layout.isFixedLayout()) {      assert(fieldsABIAccessible);      return asImpl()->createFixed(fields, std::move(layout));    } else {      return asImpl()->createNonFixed(fields, fieldsABIAccessible,                                      std::move(layout));    }  }  };

const TypeInfo *TypeConverter::getTypeEntry(CanType canonicalTy) {  ...  // 调用 convertType 函数，将 类型 转为 布局信息  // Convert the type.  auto *convertedTI = convertType(exemplarTy);  ...  return convertedTI;}

(lldb) p exemplarTy.dump()(builtin_integer_type bit_width=16)(lldb) p *convertedTI(const swift::irgen::TypeInfo) $7 = {  Bits = {    OpaqueBits = 8592015620    TypeInfo = {      Kind = 4      AlignmentShift = 1      POD = 1      BitwiseTakable = 1      SubclassKind = 7      AlwaysFixedSize = 1      ABIAccessible = 1    }    FixedTypeInfo = (Size = 2)  }  NextConverted = 0x0000000000000000  StorageType = 0x000000012f009e28  nativeReturnSchema = 0x0000000000000000  nativeParameterSchema = 0x0000000000000000}(lldb) 

/// Convert a primitive builtin type to its LLVM type, size, and/// alignment.static std::tuple<llvm::Type *, Size, Alignment>convertPrimitiveBuiltin(IRGenModule &IGM, CanType canTy) {... case TypeKind::BuiltinInteger: {    auto intTy = cast<BuiltinIntegerType>(ty);    // 获取 bit 宽度    unsigned BitWidth = IGM.getBuiltinIntegerWidth(intTy);    // 转为 Byte     unsigned ByteSize = (BitWidth+7U)/8U;    // Round up the memory size and alignment to a power of 2.    if (!llvm::isPowerOf2_32(ByteSize))      ByteSize = llvm::NextPowerOf2(ByteSize);
    return RetTy{ llvm::IntegerType::get(ctx, BitWidth), Size(ByteSize),             Alignment(ByteSize) };  }...}

unsigned IRGenModule::getBuiltinIntegerWidth(BuiltinIntegerType *t) {  return getBuiltinIntegerWidth(t->getWidth());}

class BuiltinIntegerType {/// Return the bit width of the integer.  Always returns a non-arbitrary  /// width.  BuiltinIntegerWidth getWidth() const {    return Width;  }}

xcrun swiftc -emit-ir -Xfrontend -disable-llvm-optzns -Onone file.swift | swift demangle

define hidden swiftcc i64 @"file.getSize() -> Swift.Int"() #0 {entry:  ret i64 2}