pub fn is_adt_dtorck(self, adt: &ty::AdtDef) -> bool {
        let dtor_method = match adt.destructor() {
            Some(dtor) => dtor,
            None => return false
        };

        // RFC 1238: if the destructor method is tagged with the
        // attribute `unsafe_destructor_blind_to_params`, then the
        // compiler is being instructed to *assume* that the
        // destructor will not access borrowed data,
        // even if such data is otherwise reachable.
        //
        // Such access can be in plain sight (e.g. dereferencing
        // `*foo.0` of `Foo<'a>(&'a u32)`) or indirectly hidden
        // (e.g. calling `foo.0.clone()` of `Foo<T:Clone>`).
        return !self.has_attr(dtor_method, "unsafe_destructor_blind_to_params");
    }
/// Returns true if this ADT is a dtorck type.
///
/// Invoking the destructor of a dtorck type during usual cleanup
/// (e.g. the glue emitted for stack unwinding) requires all
/// lifetimes in the type-structure of `adt` to strictly outlive
/// the adt value itself.
///
/// If `adt` is not dtorck, then the adt's destructor can be
/// invoked even when there are lifetimes in the type-structure of
/// `adt` that do not strictly outlive the adt value itself.
/// (This allows programs to make cyclic structures without
/// resorting to unasfe means; see RFCs 769 and 1238).
Returns true if this ADT is a dtorck type.
Invoking the destructor of a dtorck type during usual cleanup
requires all
lifetimes in the type-structure of `adt` to strictly outlive
the adt value itself.

If `adt` is not dtorck, then the adt's destructor can be
invoked even when there are lifetimes in the type-structure of
`adt` that do not strictly outlive the adt value itself.
(This allows programs to make cyclic structures without
resorting to unasfe means; see RFCs 769 and 1238).
Returns true if this ADT is a dtorck type . Invoking the destructor of a dtorck type during usual cleanup requires all lifetimes in the type - structure of ` adt ` to strictly outlive the adt value itself . If ` adt ` is not dtorck then the adt ' s destructor can be invoked even when there are lifetimes in the type - structure of ` adt ` that do not strictly outlive the adt value itself . ( This allows programs to make cyclic structures without resorting to unasfe means ; see RFCs 769 and 1238 ) .
pub fn is_adt_dtorck(self, adt: &ty::AdtDef) -> bool {
        let dtor_method = match adt.destructor() {
            Some(dtor) => dtor,
            None => return false
        };
        // RFC 1238: if the destructor method is tagged with the
        // attribute `unsafe_destructor_blind_to_params`, then the
        // compiler is being instructed to *assume* that the
        // destructor will not access borrowed data,
        // even if such data is otherwise reachable.
        //
        // Such access can be in plain sight (e.g. dereferencing
        // `*foo.0` of `Foo<'a>(&'a u32)`) or indirectly hidden
        // (e.g. calling `foo.0.clone()` of `Foo<T:Clone>`).
        return !self.has_attr(dtor_method, "unsafe_destructor_blind_to_params");
    }
pub fn is_adt_dtorck ( self , adt : & ty :: AdtDef ) -> bool { let dtor_method = match adt . destructor ( ) { Some ( dtor ) => dtor , None => return false } ; // RFC 1238: if the destructor method is tagged with the // attribute `unsafe_destructor_blind_to_params`, then the // compiler is being instructed to *assume* that the // destructor will not access borrowed data, // even if such data is otherwise reachable. // // Such access can be in plain sight (e.g. dereferencing // `*foo.0` of `Foo<'a>(&'a u32)`) or indirectly hidden // (e.g. calling `foo.0.clone()` of `Foo<T:Clone>`). return ! self . has_attr ( dtor_method , " " ) ; }
Returns true if this ADT is a dtorck type.
Returns true if this ADT is a dtorck type .
self
adt
&ty::AdtDef