[concurrency] Add a new type Builtin.ImplicitIsolationActor.

gottesmm · gottesmm · commit d7197fc09e73 · 2025-08-25T16:21:04.000-07:00
This is currently not wired up to anything. I am going to wire it up in
subsequent commits.

The reason why we are introducing this new Builtin type is to represent that we
are going to start stealing bits from the protocol witness table pointer of the
Optional&lt;any Actor&gt; that this type is bitwise compatible with. The type will
ensure that this value is only used in places where we know that it will be
properly masked out giving us certainty that this value will not be used in any
manner without it first being bit cleared and transformed back to Optional&lt;any
Actor&gt;.
diff --git a/include/swift/AST/TypeNodes.def b/include/swift/AST/TypeNodes.def
@@ -144,7 +144,8 @@ ABSTRACT_TYPE(Builtin, Type)
   BUILTIN_CONCRETE_TYPE(BuiltinVector, BuiltinType)
   BUILTIN_GENERIC_TYPE(BuiltinFixedArray, BuiltinType)
   BUILTIN_CONCRETE_TYPE(BuiltinUnboundGeneric, BuiltinType)
-  TYPE_RANGE(Builtin, BuiltinInteger, BuiltinUnboundGeneric)
+  BUILTIN_CONCRETE_TYPE(BuiltinImplicitIsolationActor, BuiltinType)
+  TYPE_RANGE(Builtin, BuiltinInteger, BuiltinImplicitIsolationActor)
 TYPE(Tuple, Type)
 ABSTRACT_TYPE(ReferenceStorage, Type)
 #define REF_STORAGE(Name, ...) \
@@ -234,6 +235,7 @@ SINGLETON_TYPE(RawPointer, BuiltinRawPointer)
 SINGLETON_TYPE(RawUnsafeContinuation, BuiltinRawUnsafeContinuation)
 SINGLETON_TYPE(NativeObject, BuiltinNativeObject)
 SINGLETON_TYPE(BridgeObject, BuiltinBridgeObject)
+SINGLETON_TYPE(ImplicitIsolationActor, BuiltinImplicitIsolationActor)
 SINGLETON_TYPE(UnsafeValueBuffer, BuiltinUnsafeValueBuffer)
 SINGLETON_TYPE(DefaultActorStorage, BuiltinDefaultActorStorage)
 SINGLETON_TYPE(NonDefaultDistributedActorStorage, BuiltinNonDefaultDistributedActorStorage)
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -2012,6 +2012,19 @@ BEGIN_CAN_TYPE_WRAPPER(BuiltinVectorType, BuiltinType)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getElementType)
 END_CAN_TYPE_WRAPPER(BuiltinVectorType, BuiltinType)
 
+class BuiltinImplicitIsolationActorType : public BuiltinType {
+  friend class ASTContext;
+
+  BuiltinImplicitIsolationActorType(const ASTContext &context)
+      : BuiltinType(TypeKind::BuiltinImplicitIsolationActor, context) {}
+
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinImplicitIsolationActor;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinImplicitIsolationActorType, BuiltinType)
+
 /// Size descriptor for a builtin integer type. This is either a fixed bit
 /// width or an abstract target-dependent value such as "size of a pointer".
 class BuiltinIntegerWidth {
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
@@ -266,6 +266,10 @@ class SILType {
 
   bool isBuiltinBridgeObject() const { return is<BuiltinBridgeObjectType>(); }
 
+  bool isBuiltinImplicitIsolationActor() const {
+    return is<BuiltinImplicitIsolationActorType>();
+  }
+
   SILType getBuiltinVectorElementType() const {
     auto vector = castTo<BuiltinVectorType>();
     return getPrimitiveObjectType(vector.getElementType());
@@ -1032,6 +1036,9 @@ class SILType {
   /// Get the type for opaque actor isolation values.
   static SILType getOpaqueIsolationType(const ASTContext &C);
 
+  /// Return Builtin.ImplicitIsolationActor.
+  static SILType getBuiltinImplicitIsolationActorType(const ASTContext &ctx);
+
   //
   // Utilities for treating SILType as a pointer-like type.
   //
diff --git a/include/swift/Strings.h b/include/swift/Strings.h
@@ -144,6 +144,9 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_NATIVEOBJECT = {
 /// The name of the Builtin type for BridgeObject
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_BRIDGEOBJECT = {
     "Builtin.BridgeObject"};
+constexpr static BuiltinNameStringLiteral
+    BUILTIN_TYPE_NAME_IMPLICITISOLATIONACTOR = {
+        "Builtin.ImplicitIsolationActor"};
 /// The name of the Builtin type for RawPointer
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_RAWPOINTER = {
     "Builtin.RawPointer"};
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -6110,6 +6110,8 @@ namespace {
     TRIVIAL_TYPE_PRINTER(BuiltinRawUnsafeContinuation, builtin_raw_unsafe_continuation)
     TRIVIAL_TYPE_PRINTER(BuiltinNativeObject, builtin_native_object)
     TRIVIAL_TYPE_PRINTER(BuiltinBridgeObject, builtin_bridge_object)
+    TRIVIAL_TYPE_PRINTER(BuiltinImplicitIsolationActor,
+                         builtin_implicit_isolated_actor)
     TRIVIAL_TYPE_PRINTER(BuiltinUnsafeValueBuffer, builtin_unsafe_value_buffer)
     TRIVIAL_TYPE_PRINTER(SILToken, sil_token)
 
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -1458,6 +1458,8 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
       auto loc = cast<LocatableType>(tybase);
       return appendType(loc->getSinglyDesugaredType(), sig, forDecl);
     }
+    case TypeKind::BuiltinImplicitIsolationActor:
+      return appendOperator("BA");
     case TypeKind::BuiltinFixedArray: {
       auto bfa = cast<BuiltinFixedArrayType>(tybase);
       appendType(bfa->getSize(), sig, forDecl);
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -6171,6 +6171,7 @@ class TypePrinter : public TypeVisitor<TypePrinter, void, NonRecursivePrintOptio
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinIntegerType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinFloatType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinUnboundGenericType)
+  ASTPRINTER_PRINT_BUILTINTYPE(BuiltinImplicitIsolationActorType)
 #undef ASTPRINTER_PRINT_BUILTINTYPE
 
   void visitBuiltinFixedArrayType(BuiltinFixedArrayType *T,
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -82,6 +82,8 @@ Type swift::getBuiltinType(ASTContext &Context, StringRef Name) {
           .Case("Word", BuiltinTypeKind::BuiltinInteger)
           .Case("IntLiteral", BuiltinTypeKind::BuiltinIntegerLiteral)
           .StartsWith("Int", BuiltinTypeKind::BuiltinInteger)
+          .Case("ImplicitIsolationActor",
+                BuiltinTypeKind::BuiltinImplicitIsolationActor)
           .Default({});
 
   // Handle types that are not BuiltinTypeKinds.
@@ -174,6 +176,8 @@ Type swift::getBuiltinType(ASTContext &Context, StringRef Name) {
     return Context.TheIntegerLiteralType;
   case BuiltinTypeKind::BuiltinUnboundGeneric:
     return Type();
+  case BuiltinTypeKind::BuiltinImplicitIsolationActor:
+    return Context.TheImplicitIsolationActorType;
   }
 
   return Type();
@@ -3504,6 +3508,7 @@ bool BuiltinType::isBitwiseCopyable() const {
     return true;
   case BuiltinTypeKind::BuiltinNativeObject:
   case BuiltinTypeKind::BuiltinBridgeObject:
+  case BuiltinTypeKind::BuiltinImplicitIsolationActor:
   case BuiltinTypeKind::BuiltinUnsafeValueBuffer:
   case BuiltinTypeKind::BuiltinDefaultActorStorage:
   case BuiltinTypeKind::BuiltinNonDefaultDistributedActorStorage:
@@ -3559,6 +3564,10 @@ StringRef BuiltinType::getTypeName(SmallVectorImpl<char> &result,
   case BuiltinTypeKind::BuiltinBridgeObject:
     printer << MAYBE_GET_NAMESPACED_BUILTIN(BUILTIN_TYPE_NAME_BRIDGEOBJECT);
     break;
+  case BuiltinTypeKind::BuiltinImplicitIsolationActor:
+    printer << MAYBE_GET_NAMESPACED_BUILTIN(
+        BUILTIN_TYPE_NAME_IMPLICITISOLATIONACTOR);
+    break;
   case BuiltinTypeKind::BuiltinUnsafeValueBuffer:
     printer << MAYBE_GET_NAMESPACED_BUILTIN(
         BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER);
diff --git a/lib/AST/ConformanceLookup.cpp b/lib/AST/ConformanceLookup.cpp
@@ -480,6 +480,14 @@ getBuiltinBuiltinTypeConformance(Type type, const BuiltinType *builtinType,
                                  ProtocolDecl *protocol) {
   if (auto kp = protocol->getKnownProtocolKind()) {
     switch (*kp) {
+    case KnownProtocolKind::Actor: {
+      if (builtinType->getBuiltinTypeKind() !=
+          BuiltinTypeKind::BuiltinImplicitIsolationActor)
+        break;
+      return ProtocolConformanceRef(type->getASTContext().getBuiltinConformance(
+          type, protocol, BuiltinConformanceKind::Synthesized));
+    }
+
     case KnownProtocolKind::Sendable:
     case KnownProtocolKind::SendableMetatype:
     case KnownProtocolKind::Copyable:
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -194,6 +194,7 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   // These types are always class references.
   case TypeKind::BuiltinNativeObject:
   case TypeKind::BuiltinBridgeObject:
+  case TypeKind::BuiltinImplicitIsolationActor:
   case TypeKind::Class:
   case TypeKind::BoundGenericClass:
   case TypeKind::SILBox:
@@ -514,6 +515,8 @@ bool TypeBase::isActorType() {
 }
 
 bool TypeBase::isAnyActorType() {
+  if (getCanonicalType() == getASTContext().TheImplicitIsolationActorType)
+    return true;
   if (auto actor = getAnyActor())
     return actor->isAnyActor();
   return false;
@@ -4472,6 +4475,7 @@ ReferenceCounting TypeBase::getReferenceCounting() {
     llvm_unreachable("sugared canonical type?");
 
   case TypeKind::BuiltinNativeObject:
+  case TypeKind::BuiltinImplicitIsolationActor:
   case TypeKind::SILBox:
     return ReferenceCounting::Native;
 
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -1440,6 +1440,10 @@ NodePointer Demangler::demangleBuiltinType() {
   NodePointer Ty = nullptr;
   const int maxTypeSize = 4096; // a very conservative upper bound
   switch (nextChar()) {
+    case 'A':
+      Ty = createNode(Node::Kind::BuiltinTypeName,
+                               BUILTIN_TYPE_NAME_IMPLICITISOLATIONACTOR);
+      break;
     case 'b':
       Ty = createNode(Node::Kind::BuiltinTypeName,
                                BUILTIN_TYPE_NAME_BRIDGEOBJECT);
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -909,7 +909,9 @@ ManglingError Remangler::mangleBuiltinTypeName(Node *node, unsigned depth) {
   Buffer << 'B';
   StringRef text = node->getText();
 
-  if (text == BUILTIN_TYPE_NAME_BRIDGEOBJECT) {
+  if (text == BUILTIN_TYPE_NAME_IMPLICITISOLATIONACTOR) {
+    Buffer << 'A';
+  } else if (text == BUILTIN_TYPE_NAME_BRIDGEOBJECT) {
     Buffer << 'b';
   } else if (text == BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER) {
     Buffer << 'B';
diff --git a/lib/IRGen/GenConcurrency.cpp b/lib/IRGen/GenConcurrency.cpp
@@ -879,3 +879,131 @@ irgen::emitTaskCreate(IRGenFunction &IGF, llvm::Value *flags,
   newContext = IGF.Builder.CreateBitCast(newContext, IGF.IGM.Int8PtrTy);
   return { newTask, newContext };
 }
+
+namespace {
+
+/// A TypeInfo implementation for Builtin.Executor.
+class ImplicitIsolationActorTypeInfo final
+    : public ScalarPairTypeInfo<ImplicitIsolationActorTypeInfo,
+                                LoadableTypeInfo> {
+
+public:
+  ImplicitIsolationActorTypeInfo(llvm::StructType *storageType, Size size,
+                                 Alignment align, SpareBitVector &&spareBits)
+      : ScalarPairTypeInfo(storageType, size, std::move(spareBits), align,
+                           IsNotTriviallyDestroyable, IsCopyable, IsFixedSize,
+                           IsABIAccessible) {}
+
+  TypeLayoutEntry *buildTypeLayoutEntry(IRGenModule &IGM, SILType T,
+                                        bool useStructLayouts) const override {
+    if (!useStructLayouts) {
+      return IGM.typeLayoutCache.getOrCreateTypeInfoBasedEntry(*this, T);
+    }
+    return IGM.typeLayoutCache.getOrCreateScalarEntry(
+        *this, T, ScalarKind::NativeStrongReference);
+  }
+
+  static Size getFirstElementSize(IRGenModule &IGM) {
+    return IGM.getPointerSize();
+  }
+
+  static StringRef getFirstElementLabel() { return ".actor"; }
+
+  static bool isFirstElementTrivial() { return false; }
+
+  void emitRetainFirstElement(
+      IRGenFunction &IGF, llvm::Value *data,
+      std::optional<Atomicity> atomicity = std::nullopt) const {
+    if (!atomicity)
+      atomicity = IGF.getDefaultAtomicity();
+    IGF.emitNativeStrongRetain(data, *atomicity);
+  }
+
+  void emitReleaseFirstElement(
+      IRGenFunction &IGF, llvm::Value *data,
+      std::optional<Atomicity> atomicity = std::nullopt) const {
+    if (!atomicity)
+      atomicity = IGF.getDefaultAtomicity();
+    IGF.emitNativeStrongRelease(data, *atomicity);
+  }
+
+  void emitAssignFirstElement(IRGenFunction &IGF, llvm::Value *data,
+                              Address address) const {
+    IGF.emitNativeStrongAssign(data, address);
+  }
+
+  static Size getSecondElementOffset(IRGenModule &IGM) {
+    return IGM.getPointerSize();
+  }
+  static Size getSecondElementSize(IRGenModule &IGM) {
+    return IGM.getPointerSize();
+  }
+  static StringRef getSecondElementLabel() { return ".witness_table_pointer"; }
+  bool isSecondElementTrivial() const { return true; }
+
+  void emitRetainSecondElement(
+      IRGenFunction &IGF, llvm::Value *data,
+      std::optional<Atomicity> atomicity = std::nullopt) const {}
+  void emitReleaseSecondElement(
+      IRGenFunction &IGF, llvm::Value *data,
+      std::optional<Atomicity> atomicity = std::nullopt) const {}
+  void emitAssignSecondElement(IRGenFunction &IGF, llvm::Value *context,
+                               Address dataAddr) const {
+    IGF.Builder.CreateStore(context, dataAddr);
+  }
+
+  // Both pointers may have extra info.
+  bool mayHaveExtraInhabitants(IRGenModule &IGM) const override { return true; }
+  PointerInfo getPointerInfo(IRGenModule &IGM) const {
+    return PointerInfo::forHeapObject(IGM);
+  }
+  unsigned getFixedExtraInhabitantCount(IRGenModule &IGM) const override {
+    return getPointerInfo(IGM).getExtraInhabitantCount(IGM);
+  }
+  APInt getFixedExtraInhabitantValue(IRGenModule &IGM, unsigned bits,
+                                     unsigned index) const override {
+    return getPointerInfo(IGM).getFixedExtraInhabitantValue(IGM, bits, index,
+                                                            0);
+  }
+  llvm::Value *getExtraInhabitantIndex(IRGenFunction &IGF, Address src,
+                                       SILType T,
+                                       bool isOutlined) const override {
+    src = projectFirstElement(IGF, src);
+    return getPointerInfo(IGF.IGM).getExtraInhabitantIndex(IGF, src);
+  }
+  void storeExtraInhabitant(IRGenFunction &IGF, llvm::Value *index,
+                            Address dest, SILType T,
+                            bool isOutlined) const override {
+    // Store the extra-inhabitant value in the first (identity) word.
+    auto first = projectFirstElement(IGF, dest);
+    getPointerInfo(IGF.IGM).storeExtraInhabitant(IGF, index, first);
+
+    // Zero the second word.
+    auto second = projectSecondElement(IGF, dest);
+    IGF.Builder.CreateStore(llvm::ConstantInt::get(IGF.IGM.ExecutorSecondTy, 0),
+                            second);
+  }
+};
+
+} // end anonymous namespace
+
+const LoadableTypeInfo &IRGenModule::getImplicitIsolationActorTypeInfo() {
+  return Types.getImplicitIsolationActorTypeInfo();
+}
+
+const LoadableTypeInfo &TypeConverter::getImplicitIsolationActorTypeInfo() {
+  if (ImplicitIsolationActorTI)
+    return *ImplicitIsolationActorTI;
+
+  auto ty = IGM.SwiftImplicitIsolationActorType;
+  SpareBitVector spareBits;
+  spareBits.append(IGM.getHeapObjectSpareBits());
+  spareBits.append(IGM.getWitnessTablePtrSpareBits());
+
+  ImplicitIsolationActorTI = new ImplicitIsolationActorTypeInfo(
+      ty, IGM.getPointerSize() * 2, IGM.getPointerAlignment(),
+      std::move(spareBits));
+  ImplicitIsolationActorTI->NextConverted = FirstType;
+  FirstType = ImplicitIsolationActorTI;
+  return *ImplicitIsolationActorTI;
+}
diff --git a/lib/IRGen/GenType.cpp b/lib/IRGen/GenType.cpp
@@ -2255,6 +2255,8 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
   }
   case TypeKind::BuiltinNativeObject:
     return &getNativeObjectTypeInfo();
+  case TypeKind::BuiltinImplicitIsolationActor:
+    return &getImplicitIsolationActorTypeInfo();
   case TypeKind::BuiltinBridgeObject:
     return &getBridgeObjectTypeInfo();
   case TypeKind::BuiltinUnsafeValueBuffer:
diff --git a/lib/IRGen/GenType.h b/lib/IRGen/GenType.h
@@ -112,6 +112,7 @@ class TypeConverter {
   const LoadableTypeInfo *JobTI = nullptr;
   const LoadableTypeInfo *ExecutorTI = nullptr;
   const LoadableTypeInfo *WitnessTablePtrTI = nullptr;
+  const LoadableTypeInfo *ImplicitIsolationActorTI = nullptr;
   const TypeInfo *TypeMetadataPtrTI = nullptr;
   const TypeInfo *SwiftContextPtrTI = nullptr;
   const TypeInfo *TaskContinuationFunctionPtrTI = nullptr;
@@ -202,6 +203,7 @@ class TypeConverter {
   const LoadableTypeInfo &getNativeObjectTypeInfo();
   const LoadableTypeInfo &getUnknownObjectTypeInfo();
   const LoadableTypeInfo &getBridgeObjectTypeInfo();
+  const LoadableTypeInfo &getImplicitIsolationActorTypeInfo();
   const LoadableTypeInfo &getRawPointerTypeInfo();
   const LoadableTypeInfo &getRawUnsafeContinuationTypeInfo();
   const LoadableTypeInfo &getJobTypeInfo();
diff --git a/lib/IRGen/IRGenDebugInfo.cpp b/lib/IRGen/IRGenDebugInfo.cpp
@@ -1953,6 +1953,12 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
           llvm::DINode::FlagArtificial, MangledName);
     }
 
+    case TypeKind::BuiltinImplicitIsolationActor: {
+      return createDoublePointerSizedStruct(
+          Scope, "Builtin.ImplicitIsolationActor", nullptr, MainFile, 0,
+          llvm::DINode::FlagArtificial, MangledName);
+    }
+
     case TypeKind::DynamicSelf: {
       // Self. We don't have a way to represent instancetype in DWARF,
       // so we emit the static type instead. This is similar to what we
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
@@ -784,6 +784,12 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
                                          PtrTy,
                                          PtrTy,
                                      });
+  SwiftImplicitIsolationActorType =
+      createStructType(*this, "swift.implicit_isolated_actor_type",
+                       {
+                           RefCountedPtrTy, // ref counted pointer
+                           Int8PtrTy,       // witness table pointer
+                       });
 }
 
 IRGenModule::~IRGenModule() {
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -857,6 +857,9 @@ class IRGenModule {
   llvm::IntegerType *CoroAllocatorFlagsTy;
   llvm::StructType *CoroAllocatorTy;
 
+  llvm::StructType
+      *SwiftImplicitIsolationActorType; // { %swift.refcounted, i8* }
+
   llvm::GlobalVariable *TheTrivialPropertyDescriptor = nullptr;
 
   llvm::Constant *swiftImmortalRefCount = nullptr;
@@ -1100,6 +1103,7 @@ class IRGenModule {
   const LoadableTypeInfo &
   getReferenceObjectTypeInfo(ReferenceCounting refcounting);
   const LoadableTypeInfo &getNativeObjectTypeInfo();
+  const LoadableTypeInfo &getImplicitIsolationActorTypeInfo();
   const LoadableTypeInfo &getUnknownObjectTypeInfo();
   const LoadableTypeInfo &getBridgeObjectTypeInfo();
   const LoadableTypeInfo &getRawPointerTypeInfo();
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
diff --git a/lib/IRGen/MetadataRequest.cpp b/lib/IRGen/MetadataRequest.cpp
diff --git a/lib/SIL/IR/SILType.cpp b/lib/SIL/IR/SILType.cpp
diff --git a/lib/SIL/IR/TypeLowering.cpp b/lib/SIL/IR/TypeLowering.cpp
diff --git a/test/Demangle/Inputs/manglings.txt b/test/Demangle/Inputs/manglings.txt
diff --git a/test/Demangle/Inputs/simplified-manglings.txt b/test/Demangle/Inputs/simplified-manglings.txt

Original file line number	Diff line number	Diff line change
`@@ -1458,6 +1458,8 @@ void ASTMangler::appendType(Type type, GenericSignature sig,`
`1458`	`1458`	`auto loc = cast<LocatableType>(tybase);`
`1459`	`1459`	`return appendType(loc->getSinglyDesugaredType(), sig, forDecl);`
`1460`	`1460`	`}`
	`1461`	`+ case TypeKind::BuiltinImplicitIsolationActor:`
	`1462`	`+ return appendOperator("BA");`
`1461`	`1463`	`case TypeKind::BuiltinFixedArray: {`
`1462`	`1464`	`auto bfa = cast<BuiltinFixedArrayType>(tybase);`
`1463`	`1465`	`appendType(bfa->getSize(), sig, forDecl);`