[Sema] refactor TypeDecl::isNoncopyable

kavon · kavon · commit a9c64baaa3a4 · 2023-11-06T15:40:12.000-08:00
In preparation for reporting whether the inverse marking on a TypeDecl
was inferred instead of explicit.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -3118,13 +3118,14 @@ class TypeDecl : public ValueDecl {
   ArrayRef<InheritedEntry> Inherited;
 
   struct {
-    /// Whether the "hasNoncopyableAnnotation" bit has been computed yet.
+    /// Whether the "noncopyableAnnotationKind" field has been computed yet.
     unsigned isNoncopyableAnnotationComputed : 1;
 
-    /// Whether this declaration had a noncopyable inverse written somewhere.
-    unsigned hasNoncopyableAnnotation : 1;
+    unsigned noncopyableAnnotationKind : 2;
+    static_assert((unsigned)InverseMarkingKind::LAST < 4);
+
   } LazySemanticInfo = { };
-  friend class HasNoncopyableAnnotationRequest;
+  friend class NoncopyableAnnotationRequest;
 
 protected:
   TypeDecl(DeclKind K, llvm::PointerUnion<DeclContext *, ASTContext *> context,
@@ -3153,9 +3154,15 @@ class TypeDecl : public ValueDecl {
 
   void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
 
-  /// Is this type _always_ noncopyable? Will answer 'false' if the type is
-  /// conditionally copyable.
-  bool isNoncopyable() const;
+  /// Is it possible for this type to lack a Copyable constraint?
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isNoncopyable` instead of using this.
+  bool canBeNoncopyable() const {
+    return getNoncopyableMarking() != InverseMarkingKind::None;
+  }
+
+  /// Determine how the ~Copyable was applied to this TypeDecl, if at all.
+  InverseMarkingKind getNoncopyableMarking() const;
 
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&
diff --git a/include/swift/AST/KnownProtocols.h b/include/swift/AST/KnownProtocols.h
@@ -73,6 +73,15 @@ llvm::Optional<InvertibleProtocolKind>
 /// Returns the KnownProtocolKind corresponding to an InvertibleProtocolKind.
 KnownProtocolKind getKnownProtocolKind(InvertibleProtocolKind ip);
 
+/// Describes the way an inverse was applied to a TypeDecl.
+enum class InverseMarkingKind: uint8_t {
+  None,            // No inverse marking is present
+  Inferred,        // Inverse is inferred based on generic parameters.
+  Explicit,        // Inverse is explicitly present.
+
+  LAST = Explicit
+};
+
 } // end namespace swift
 
 #endif
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -427,10 +427,10 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
-/// Determine whether the given declaration has any markings that would cause it
-/// to not have an implicit, unconditional conformance to Copyable.
-class HasNoncopyableAnnotationRequest
-    : public SimpleRequest<HasNoncopyableAnnotationRequest, bool(TypeDecl *),
+/// Determine the kind of noncopyable marking present for this declaration.
+class NoncopyableAnnotationRequest
+    : public SimpleRequest<NoncopyableAnnotationRequest,
+                           InverseMarkingKind(TypeDecl *),
                            RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -439,13 +439,13 @@ class HasNoncopyableAnnotationRequest
   friend SimpleRequest;
 
   // Evaluation.
-  bool evaluate(Evaluator &evaluator, TypeDecl *decl) const;
+  InverseMarkingKind evaluate(Evaluator &evaluator, TypeDecl *decl) const;
 
 public:
   // Separate caching.
   bool isCached() const { return true; }
-  llvm::Optional<bool> getCachedResult() const;
-  void cacheResult(bool value) const;
+  llvm::Optional<InverseMarkingKind> getCachedResult() const;
+  void cacheResult(InverseMarkingKind value) const;
 };
 
 /// Determine whether the given declaration is escapable.
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -210,8 +210,9 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, HasNoncopyableAnnotationRequest, bool(TypeDecl *), SeparatelyCached,
-              NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, NoncopyableAnnotationRequest,
+              InverseMarkingKind(TypeDecl *),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsNoncopyableRequest,
               bool (CanType),
               Cached, NoLocationInfo)
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -3324,12 +3324,12 @@ static bool usesFeatureFlowSensitiveConcurrencyCaptures(Decl *decl) {
 static bool usesFeatureMoveOnly(Decl *decl) {
   if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
     if (auto *nominal = extension->getSelfNominalTypeDecl())
-      if (nominal->isNoncopyable())
+      if (nominal->canBeNoncopyable())
         return true;
   }
 
   if (auto typeDecl = dyn_cast<TypeDecl>(decl)) {
-    if (typeDecl->isNoncopyable())
+    if (typeDecl->canBeNoncopyable())
       return true;
   }
 
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
@@ -3238,7 +3238,7 @@ class Verifier : public ASTWalker {
       PrettyStackTraceDecl debugStack("verifying DestructorDecl", DD);
 
       auto *ND = DD->getDeclContext()->getSelfNominalTypeDecl();
-      if (!isa<ClassDecl>(ND) && !ND->isNoncopyable() && !DD->isInvalid()) {
+      if (!isa<ClassDecl>(ND) && !ND->canBeNoncopyable() && !DD->isInvalid()) {
         Out << "DestructorDecls outside classes/move only types should be "
                "marked invalid\n";
         abort();
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -4876,12 +4876,11 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
                                         llvm::None);
 }
 
-bool TypeDecl::isNoncopyable() const {
-  // NOTE: must answer true iff it is unconditionally noncopyable.
+InverseMarkingKind TypeDecl::getNoncopyableMarking() const {
   return evaluateOrDefault(getASTContext().evaluator,
-                           HasNoncopyableAnnotationRequest{
+                           NoncopyableAnnotationRequest{
                                const_cast<TypeDecl *>(this)},
-                           true); // default to true for safety
+                           InverseMarkingKind::Explicit);
 }
 
 Type TypeDecl::getDeclaredInterfaceType() const {
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -2019,7 +2019,7 @@ LookupConformanceInModuleRequest::evaluate(
         // We only need to do this until we are properly dealing with or
         // omitting Copyable conformances in modules/interfaces.
 
-        if (nominal->isNoncopyable())
+        if (nominal->canBeNoncopyable())
           return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
         else
           return ProtocolConformanceRef(protocol);
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
@@ -1047,7 +1047,7 @@ void NominalTypeDecl::prepareConformanceTable() const {
       return;
 
     // No synthesized conformances for move-only nominals.
-    if (isNoncopyable()) {
+    if (canBeNoncopyable()) {
       // assumption is Sendable gets synthesized elsewhere.
       assert(!proto->isSpecificProtocol(KnownProtocolKind::Sendable));
       return;
diff --git a/lib/AST/SwiftNameTranslation.cpp b/lib/AST/SwiftNameTranslation.cpp
@@ -234,7 +234,7 @@ swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
     if (isa<ProtocolDecl>(typeDecl))
       return {Unsupported, UnrepresentableProtocol};
     // Swift's consume semantics are not yet supported in C++.
-    if (typeDecl->isNoncopyable())
+    if (typeDecl->canBeNoncopyable())
       return {Unsupported, UnrepresentableMoveOnly};
     if (typeDecl->isGeneric()) {
       if (isa<ClassDecl>(VD))
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -161,7 +161,7 @@ bool TypeBase::isMarkerExistential() {
 /// that does not rely on conformances.
 static bool alwaysNoncopyable(Type ty) {
   if (auto *nominal = ty->getNominalOrBoundGenericNominal())
-    return nominal->isNoncopyable();
+    return nominal->canBeNoncopyable();
 
   if (auto *expansion = ty->getAs<PackExpansionType>()) {
     return alwaysNoncopyable(expansion->getPatternType());
diff --git a/lib/AST/TypeCheckRequests.cpp b/lib/AST/TypeCheckRequests.cpp
@@ -314,25 +314,29 @@ void IsFinalRequest::cacheResult(bool value) const {
 }
 
 //----------------------------------------------------------------------------//
-// hasNoncopyableAnnotation computation.
+// NoncopyableAnnotationRequest computation.
 //----------------------------------------------------------------------------//
 
-llvm::Optional<bool> HasNoncopyableAnnotationRequest::getCachedResult() const {
+llvm::Optional<InverseMarkingKind>
+NoncopyableAnnotationRequest::getCachedResult() const {
   auto decl = std::get<0>(getStorage());
   if (decl->LazySemanticInfo.isNoncopyableAnnotationComputed)
-    return static_cast<bool>(decl->LazySemanticInfo.hasNoncopyableAnnotation);
+    return static_cast<InverseMarkingKind>(
+              decl->LazySemanticInfo.noncopyableAnnotationKind);
 
   return llvm::None;
 }
 
-void HasNoncopyableAnnotationRequest::cacheResult(bool value) const {
+void NoncopyableAnnotationRequest::cacheResult(InverseMarkingKind value) const {
   auto decl = std::get<0>(getStorage());
   decl->LazySemanticInfo.isNoncopyableAnnotationComputed = true;
-  decl->LazySemanticInfo.hasNoncopyableAnnotation = value;
+  decl->LazySemanticInfo.noncopyableAnnotationKind =
+      static_cast<unsigned>(value);
 
   if (!decl->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
     // Add an attribute for printing
-    if (value && !decl->getAttrs().hasAttribute<MoveOnlyAttr>())
+    if (value == InverseMarkingKind::Explicit
+        && !decl->getAttrs().hasAttribute<MoveOnlyAttr>())
       decl->getAttrs().add(new(decl->getASTContext())
                                MoveOnlyAttr(/*Implicit=*/true));
   }
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -1066,7 +1066,7 @@ void IRGenModule::addObjCClassStub(llvm::Constant *classPtr) {
 
 void IRGenModule::addRuntimeResolvableType(GenericTypeDecl *type) {
   // Collect the nominal type records we emit into a special section.
-  if (type->isNoncopyable()) {
+  if (type->canBeNoncopyable()) {
     // Older runtimes should not be allowed to discover noncopyable types, since
     // they will try to expose them dynamically as copyable types. Record
     // noncopyable type descriptors in a separate vector so that future
diff --git a/lib/IRGen/GenEnum.cpp b/lib/IRGen/GenEnum.cpp
@@ -6597,7 +6597,7 @@ SingletonEnumImplStrategy::completeEnumTypeLayout(TypeConverter &TC,
                                                   llvm::StructType *enumTy) {
   auto deinit = theEnum->getValueTypeDestructor()
     ? IsNotTriviallyDestroyable : IsTriviallyDestroyable;
-  auto copyable = theEnum->isNoncopyable()
+  auto copyable = theEnum->canBeNoncopyable()
     ? IsNotCopyable : IsCopyable;
   if (ElementsWithPayload.empty()) {
     enumTy->setBody(ArrayRef<llvm::Type*>{}, /*isPacked*/ true);
@@ -6673,7 +6673,7 @@ NoPayloadEnumImplStrategy::completeEnumTypeLayout(TypeConverter &TC,
 
   auto deinit = theEnum->getValueTypeDestructor()
     ? IsNotTriviallyDestroyable : IsTriviallyDestroyable;
-  auto copyable = theEnum->isNoncopyable()
+  auto copyable = theEnum->canBeNoncopyable()
     ? IsNotCopyable : IsCopyable;
   return registerEnumTypeInfo(new LoadableEnumTypeInfo(*this,
                               enumTy, tagSize, std::move(spareBits),
@@ -6793,7 +6793,7 @@ TypeInfo *SinglePayloadEnumImplStrategy::completeFixedLayout(
 
   auto deinit = theEnum->getValueTypeDestructor()
     ? IsNotTriviallyDestroyable : IsTriviallyDestroyable;
-  auto copyable = theEnum->isNoncopyable()
+  auto copyable = theEnum->canBeNoncopyable()
     ? IsNotCopyable : IsCopyable;
   getFixedEnumTypeInfo(
       enumTy, Size(sizeWithTag), spareBits.build(), alignment,
@@ -6828,7 +6828,7 @@ TypeInfo *SinglePayloadEnumImplStrategy::completeDynamicLayout(
 
   auto deinit = theEnum->getValueTypeDestructor()
     ? IsNotTriviallyDestroyable : IsTriviallyDestroyable;
-  auto copyable = theEnum->isNoncopyable()
+  auto copyable = theEnum->canBeNoncopyable()
     ? IsNotCopyable : IsCopyable;
   return registerEnumTypeInfo(new NonFixedEnumTypeInfo(*this, enumTy,
          alignment,
@@ -6864,7 +6864,7 @@ MultiPayloadEnumImplStrategy::completeFixedLayout(TypeConverter &TC,
   // of the largest payload.
   CommonSpareBits = {};
   Alignment worstAlignment(1);
-  auto isCopyable = theEnum->isNoncopyable()
+  auto isCopyable = theEnum->canBeNoncopyable()
     ? IsNotCopyable : IsCopyable;
   auto isTriviallyDestroyable = theEnum->getValueTypeDestructor()
     ? IsNotTriviallyDestroyable : IsTriviallyDestroyable;
@@ -7046,7 +7046,7 @@ TypeInfo *MultiPayloadEnumImplStrategy::completeDynamicLayout(
 
   auto enumAccessible = IsABIAccessible_t(TC.IGM.isTypeABIAccessible(Type));
   
-  auto cp = theEnum->isNoncopyable()
+  auto cp = theEnum->canBeNoncopyable()
     ? IsNotCopyable : IsCopyable;
   return registerEnumTypeInfo(new NonFixedEnumTypeInfo(*this, enumTy,
                                                        alignment, td, bt, cp,
@@ -7070,7 +7070,7 @@ ResilientEnumImplStrategy::completeEnumTypeLayout(TypeConverter &TC,
                                                   EnumDecl *theEnum,
                                                   llvm::StructType *enumTy) {
   auto abiAccessible = IsABIAccessible_t(TC.IGM.isTypeABIAccessible(Type));
-  auto copyable = theEnum->isNoncopyable()
+  auto copyable = theEnum->canBeNoncopyable()
     ? IsNotCopyable : IsCopyable;
   return registerEnumTypeInfo(
                        new ResilientEnumTypeInfo(*this, enumTy, copyable,
diff --git a/lib/IRGen/GenStruct.cpp b/lib/IRGen/GenStruct.cpp
@@ -1699,7 +1699,7 @@ const TypeInfo *TypeConverter::convertStructType(TypeBase *key, CanType type,
       || IGM.getSILTypes().getTypeLowering(SILType::getPrimitiveAddressType(type),
                                             TypeExpansionContext::minimal())
             .getRecursiveProperties().isInfinite()) {
-    auto copyable = D->isNoncopyable()
+    auto copyable = D->canBeNoncopyable()
       ? IsNotCopyable : IsCopyable;
     auto structAccessible =
       IsABIAccessible_t(IGM.getSILModule().isTypeMetadataAccessible(type));
diff --git a/lib/IRGen/StructLayout.cpp b/lib/IRGen/StructLayout.cpp
@@ -71,7 +71,7 @@ StructLayout::StructLayout(IRGenModule &IGM,
 
   auto deinit = (decl && decl->getValueTypeDestructor())
     ? IsNotTriviallyDestroyable : IsTriviallyDestroyable;
-  auto copyable = (decl && decl->isNoncopyable())
+  auto copyable = (decl && decl->canBeNoncopyable())
     ? IsNotCopyable : IsCopyable;
 
   // Handle a raw layout specification on a struct.
diff --git a/lib/SIL/IR/SILModule.cpp b/lib/SIL/IR/SILModule.cpp
@@ -680,7 +680,7 @@ lookUpFunctionInVTable(ClassDecl *Class, SILDeclRef Member) {
 
 SILFunction *
 SILModule::lookUpMoveOnlyDeinitFunction(const NominalTypeDecl *nomDecl) {
-  assert(nomDecl->isNoncopyable());
+  assert(nomDecl->canBeNoncopyable());
 
   auto *tbl = lookUpMoveOnlyDeinit(nomDecl);
 
diff --git a/lib/SIL/IR/TypeLowering.cpp b/lib/SIL/IR/TypeLowering.cpp
@@ -2403,7 +2403,7 @@ namespace {
       properties =
           applyLifetimeAnnotation(D->getLifetimeAnnotation(), properties);
 
-      if (D->isNoncopyable()) {
+      if (D->canBeNoncopyable()) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
         if (properties.isAddressOnly())
@@ -2487,7 +2487,7 @@ namespace {
       properties =
           applyLifetimeAnnotation(D->getLifetimeAnnotation(), properties);
 
-      if (D->isNoncopyable()) {
+      if (D->canBeNoncopyable()) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
         if (properties.isAddressOnly())
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -1612,7 +1612,7 @@ void SILGenModule::emitDestructor(ClassDecl *cd, DestructorDecl *dd) {
 
 void SILGenModule::emitMoveOnlyDestructor(NominalTypeDecl *cd,
                                           DestructorDecl *dd) {
-  assert(cd->isNoncopyable());
+  assert(cd->canBeNoncopyable());
 
   emitAbstractFuncDecl(dd);
 
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
@@ -753,7 +753,7 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
                                            {selfDecl->getTypeInContext()},
                                            {}),
                       selfLV.getLValueAddress());
-    } else if (isa<StructDecl>(nominal) && nominal->isNoncopyable()
+    } else if (isa<StructDecl>(nominal) && nominal->canBeNoncopyable()
                && nominal->getStoredProperties().empty()) {
       auto *si = B.createStruct(ctor, lowering.getLoweredType(), {});
       B.emitStoreValueOperation(ctor, si, selfLV.getLValueAddress(),
diff --git a/lib/SILGen/SILGenDestructor.cpp b/lib/SILGen/SILGenDestructor.cpp
@@ -170,7 +170,7 @@ void SILGenFunction::emitDeallocatingDestructor(DestructorDecl *dd) {
   auto *nom = dd->getDeclContext()->getSelfNominalTypeDecl();
   if (isa<ClassDecl>(nom))
     return emitDeallocatingClassDestructor(dd);
-  assert(nom->isNoncopyable());
+  assert(nom->canBeNoncopyable());
   return emitDeallocatingMoveOnlyDestructor(dd);
 }
 
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -1113,7 +1113,7 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
 
     // If this is a nominal type that is move only, emit a deinit table for it.
     if (auto *nom = dyn_cast<NominalTypeDecl>(theType)) {
-      if (nom->isNoncopyable()) {
+      if (nom->canBeNoncopyable()) {
         SGM.emitNonCopyableTypeDeinitTable(nom);
       }
     }
@@ -1178,7 +1178,7 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
     if (auto *cd = dyn_cast<ClassDecl>(theType))
       return SGM.emitDestructor(cast<ClassDecl>(theType), dd);
     if (auto *nom = dyn_cast<NominalTypeDecl>(theType)) {
-      if (nom->isNoncopyable()) {
+      if (nom->canBeNoncopyable()) {
         return SGM.emitMoveOnlyDestructor(nom, dd);
       }
     }
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
@@ -6255,7 +6255,7 @@ void swift::diagnoseCopyableTypeContainingMoveOnlyType(
 
   // If we already have a move only type, just bail, we have no further work to
   // do.
-  if (copyableNominalType->isNoncopyable())
+  if (copyableNominalType->canBeNoncopyable())
     return;
 
   LLVM_DEBUG(llvm::dbgs() << "DiagnoseCopyableType for: "
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -7169,7 +7169,7 @@ void AttributeChecker::visitRawLayoutAttr(RawLayoutAttr *attr) {
     return;
   }
   
-  if (!sd->isNoncopyable()) {
+  if (!sd->canBeNoncopyable()) {
     diagnoseAndRemoveAttr(attr, diag::attr_rawlayout_cannot_be_copyable);
   }
   
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
diff --git a/lib/Sema/TypeCheckDeclPrimary.cpp b/lib/Sema/TypeCheckDeclPrimary.cpp
diff --git a/lib/Sema/TypeCheckInvertible.cpp b/lib/Sema/TypeCheckInvertible.cpp

Original file line number	Diff line number	Diff line change
`@@ -3324,12 +3324,12 @@ static bool usesFeatureFlowSensitiveConcurrencyCaptures(Decl *decl) {`
`3324`	`3324`	`static bool usesFeatureMoveOnly(Decl *decl) {`
`3325`	`3325`	`if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {`
`3326`	`3326`	`if (auto *nominal = extension->getSelfNominalTypeDecl())`
`3327`		`- if (nominal->isNoncopyable())`
	`3327`	`+ if (nominal->canBeNoncopyable())`
`3328`	`3328`	`return true;`
`3329`	`3329`	`}`
`3330`	`3330`
`3331`	`3331`	`if (auto typeDecl = dyn_cast<TypeDecl>(decl)) {`
`3332`		`- if (typeDecl->isNoncopyable())`
	`3332`	`+ if (typeDecl->canBeNoncopyable())`
`3333`	`3333`	`return true;`
`3334`	`3334`	`}`
`3335`	`3335`
Original file line number	Diff line number	Diff line change
`@@ -4876,12 +4876,11 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(`
`4876`	`4876`	`llvm::None);`
`4877`	`4877`	`}`
`4878`	`4878`
`4879`		`-bool TypeDecl::isNoncopyable() const {`
`4880`		`- // NOTE: must answer true iff it is unconditionally noncopyable.`
	`4879`	`+InverseMarkingKind TypeDecl::getNoncopyableMarking() const {`
`4881`	`4880`	`return evaluateOrDefault(getASTContext().evaluator,`
`4882`		`- HasNoncopyableAnnotationRequest{`
	`4881`	`+ NoncopyableAnnotationRequest{`
`4883`	`4882`	`const_cast<TypeDecl *>(this)},`
`4884`		`- true); // default to true for safety`
	`4883`	`+ InverseMarkingKind::Explicit);`
`4885`	`4884`	`}`
`4886`	`4885`
`4887`	`4886`	`Type TypeDecl::getDeclaredInterfaceType() const {`