• acceptxmr 0.11.1/src/payment_gateway.rs
    590
    		 
    #[cfg(test)]
    591
    		 
    #[allow(clippy::expect_used)]
    592
    		 
    mod tests {
  • apalis-core 0.3.6/src/worker/mod.rs
    128
    		 
        /// If queue is full
    129
    		 
        #[allow(unused_variables, clippy::expect_used, clippy::let_and_return)]
    130
    		 
        pub async fn send<M>(&self, message: M) -> Result<M::Result, RecvError>
    221
    		 
        {
    222
    		 
            #[allow(clippy::expect_used)]
    223
    		 
            self.deref()
    429
    		 
            let actor_future = async move {
    430
    		 
                #[allow(clippy::expect_used)]
    431
    		 
                let join_handle = handle_receiver
  • ark-api-ffi 0.17.0-pre.15/src/ffi/world_v0.rs
    163
    		 
            assert_eq!(self.value_type, ValueType::Bool);
    164
    		 
            #[allow(clippy::expect_used)]
    165
    		 
            self.value_data.as_data_bool().as_bool()
  • async-rdma 0.4.0/src/device.rs
    133
    		 
        pub fn name(&self) -> &str {
    134
    		 
            #[allow(clippy::expect_used)]
    135
    		 
            self.c_name().to_str().expect("non-utf8 device name")
  • async-rdma 0.4.0/src/mr_allocator.rs
    146
    		 
                    debug!("new mr_allocator using jemalloc strategy");
    147
    		 
                    #[allow(clippy::expect_used)]
    148
    		 
                    let arena_ind =
    451
    		 
    /// Custom extent alloc hook enable jemalloc manage rdma memory region
    452
    		 
    #[allow(clippy::expect_used)]
    453
    		 
    #[allow(clippy::unreachable)]
    498
    		 
    #[allow(clippy::as_conversions)]
    499
    		 
    #[allow(clippy::expect_used)]
    500
    		 
    unsafe extern "C" fn extent_dalloc_hook(
    516
    		 
    #[allow(clippy::as_conversions)]
    517
    		 
    #[allow(clippy::expect_used)]
    518
    		 
    unsafe extern "C" fn extent_merge_hook(
  • avml 0.10.0/src/upload/status.rs
    21
    		 
                        .with_style(
    22
    		 
                            #[allow(clippy::expect_used)]
    23
    		 
                            ProgressStyle::default_bar()
  • axum-cometd 0.9.0-alpha.4/src/utils/channel_name_validation.rs
    15
    		 
        fn default() -> Self {
    16
    		 
            #[allow(clippy::expect_used)]
    17
    		 
            Self {
  • babbage 0.1.1/src/opt/operation.rs
    27
    		 
        /// Perform the operation.
    28
    		 
        #[allow(clippy::expect_used)]
    29
    		 
        #[inline]
  • cargo-test-fuzz 3.0.5/src/lib.rs
    500
    		 
    #[allow(clippy::expect_used)]
    501
    		 
    fn executable_target(
    547
    		 
    #[allow(clippy::expect_used)]
    548
    		 
    fn check_test_fuzz_and_afl_versions(
    643
    		 
    #[allow(clippy::expect_used)]
    644
    		 
    fn as_version_req(version: &Version) -> VersionReq {
  • cartograph 0.1.2/src/run/engine.rs
    57
    		 
    /// Determine what a single ray will observe.
    58
    		 
    #[allow(clippy::expect_used)]
    59
    		 
    #[inline]
  • cartograph 0.1.2/src/run/thread.rs
    12
    		 
    #[allow(clippy::module_name_repetitions)]
    13
    		 
    #[allow(clippy::expect_used)]
    14
    		 
    #[inline]
    46
    		 
    #[allow(clippy::module_name_repetitions)]
    47
    		 
    #[allow(clippy::expect_used)]
    48
    		 
    #[inline]
  • cucumber 0.19.1/src/feature.rs
    145
    		 
        /// [`Examples`]: gherkin::Examples
    146
    		 
        #[allow(clippy::expect_used)]
    147
    		 
        static TEMPLATE_REGEX: Lazy<Regex> =
  • diffuse 0.1.1/src/sim/system.rs
    36
    		 
        /// Simulate the change of given initial condition within the system.
    37
    		 
        #[allow(clippy::expect_used)]
    38
    		 
        #[inline]
    76
    		 
        /// if the progress bad can not be locked.
    77
    		 
        #[allow(clippy::expect_used)]
    78
    		 
        #[inline]
    119
    		 
        #[allow(clippy::module_name_repetitions)]
    120
    		 
        #[allow(clippy::expect_used)]
    121
    		 
        #[inline]
  • duration-human 0.1.10/src/lib.rs
    23
    		 
    #[cfg(test)]
    24
    		 
    #[allow(clippy::unwrap_in_result, clippy::unwrap_used, clippy::expect_used)]
    25
    		 
    mod test;
  • dylint 2.1.3/src/error.rs
    49
    		 
    #[allow(clippy::expect_used)]
    50
    		 
    pub fn warn(opts: &crate::Dylint, message: &str) {
  • dylint 2.1.3/src/package_options/backup.rs
    39
    		 
    #[allow(clippy::expect_used)]
    40
    		 
    fn sibling_tempfile(path: &Path) -> Result<NamedTempFile> {
  • elastiql 0.5.0/src/aggregation/serialization_deserialization.rs
    545
    		 
                    #[allow(clippy::expect_used)]
    546
    		 
                    aggs.sort_by(|a, b| a.name.partial_cmp(&b.name).expect("invalid ordering"));
  • ergo-rest 0.7.0/src/wasm_timer/timer/interval.rs
    93
    		 
        } else {
    94
    		 
            #[allow(clippy::expect_used)]
    95
    		 
            let spent_ns =
    96
    		 
                duration_to_nanos(now.duration_since(prev)).expect("interval should be expired");
    97
    		 
            #[allow(clippy::expect_used)]
    98
    		 
            let interval_ns =
  • ergotree-interpreter 0.22.0/src/eval/scontext.rs
    91
    		 
    #[cfg(feature = "arbitrary")]
    92
    		 
    #[allow(clippy::unwrap_used, clippy::expect_used)]
    93
    		 
    mod tests {
  • ergotree-interpreter 0.22.0/src/eval/sheader.rs
    96
    		 
    #[cfg(feature = "arbitrary")]
    97
    		 
    #[allow(clippy::expect_used, clippy::panic, clippy::unwrap_used)]
    98
    		 
    mod tests {
  • ergotree-interpreter 0.22.0/src/eval/spreheader.rs
    42
    		 
    #[cfg(feature = "arbitrary")]
    43
    		 
    #[allow(clippy::expect_used)]
    44
    		 
    mod tests {
  • ergotree-interpreter 0.22.0/src/eval/subst_const.rs
    88
    		 
    #[allow(clippy::panic)]
    89
    		 
    #[allow(clippy::expect_used)]
    90
    		 
    mod tests {
  • ergotree-ir 0.22.0/src/chain/ergo_box/register.rs
    442
    		 
    #[allow(clippy::unwrap_used)]
    443
    		 
    #[allow(clippy::expect_used)]
    444
    		 
    #[cfg(test)]
  • ergotree-ir 0.22.0/src/chain/ergo_box.rs
    321
    		 
                    u32::try_from(
    322
    		 
                        #[allow(clippy::expect_used)]
    323
    		 
                        token_ids
  • ergotree-ir 0.22.0/src/ergo_tree.rs
    602
    		 
    #[allow(clippy::panic)]
    603
    		 
    #[allow(clippy::expect_used)]
    604
    		 
    mod tests {
  • ergotree-ir 0.22.0/src/serialization/constant_placeholder.rs
    28
    		 
    #[cfg(feature = "arbitrary")]
    29
    		 
    #[allow(clippy::expect_used)]
    30
    		 
    #[allow(clippy::unwrap_used)]
  • ergotree-ir 0.22.0/src/serialization/serializable.rs
    213
    		 
    /// serialization roundtrip
    214
    		 
    #[allow(clippy::expect_used)]
    215
    		 
    pub fn sigma_serialize_roundtrip<T: SigmaSerializable>(v: &T) -> T {
  • fabruic 0.0.1-dev-1/src/certificate.rs
    187
    		 
    	fn as_ref(private_key: &Self) -> &[u8] {
    188
    		 
    		#[allow(clippy::expect_used)]
    189
    		 
    		private_key.0.as_deref().expect("value already dropped")
    192
    		 
    	fn into(mut private_key: Self) -> Vec<u8> {
    193
    		 
    		#[allow(clippy::expect_used)]
    194
    		 
    		private_key.0.take().expect("value already dropped")
    205
    		 
    pub fn generate_self_signed<S: Into<String>>(domain: S) -> (Certificate, PrivateKey) {
    206
    		 
    	#[allow(clippy::expect_used)]
    207
    		 
    	let key_pair = rcgen::generate_simple_self_signed([domain.into()])
    210
    		 
    	(
    211
    		 
    		#[allow(clippy::expect_used)]
    212
    		 
    		Certificate::unchecked_from_der(
  • fabruic 0.0.1-dev-1/src/quic/connection/incoming.rs
    57
    		 
    			self.r#type = Some(r#type);
    58
    		 
    			#[allow(clippy::expect_used)]
    59
    		 
    			self.r#type
  • fabruic 0.0.1-dev-1/src/quic/connection/receiver_stream.rs
    91
    		 
    			(self.buffer.len() >= size_of::<u64>()).then(|| {
    92
    		 
    				#[allow(clippy::expect_used)]
    93
    		 
    				{
  • fabruic 0.0.1-dev-1/src/quic/connection/sender.rs
    106
    		 
    		// reserve an appropriate amount of space
    107
    		 
    		#[allow(clippy::expect_used)]
    108
    		 
    		bytes.reserve(
    126
    		 
    		// make sure that our length is correct
    127
    		 
    		#[allow(clippy::expect_used)]
    128
    		 
    		{
  • fabruic 0.0.1-dev-1/src/quic/endpoint/builder.rs
    52
    		 
    		let mut client = ClientConfig::default();
    53
    		 
    		#[allow(clippy::expect_used)]
    54
    		 
    		let crypto = Arc::get_mut(&mut client.crypto).expect("failed to build `ClientConfig`");
    162
    		 
    		// set transport defaults
    163
    		 
    		#[allow(clippy::expect_used)]
    164
    		 
    		let _ = transport
  • ferium 4.3.4/src/main.rs
    29
    		 
    pub static THEME: Lazy<ColorfulTheme> = Lazy::new(Default::default);
    30
    		 
    #[allow(clippy::expect_used)]
    31
    		 
    pub static STYLE_NO: Lazy<ProgressStyle> = Lazy::new(|| {
    36
    		 
    });
    37
    		 
    #[allow(clippy::expect_used)]
    38
    		 
    pub static STYLE_BYTE: Lazy<ProgressStyle> = Lazy::new(|| {
    54
    		 
        }
    55
    		 
        #[allow(clippy::expect_used)] // No error handling yet
    56
    		 
        let runtime = builder.build().expect("Could not initialise Tokio runtime");
  • ferium 4.3.4/src/subcommands/add.rs
    15
    		 
    #[allow(clippy::expect_used)]
    16
    		 
    pub async fn github(
  • ferium 4.3.4/src/subcommands/modpack/mod.rs
    20
    		 
    #[allow(clippy::expect_used)]
    21
    		 
    pub fn check_output_directory(output_dir: &Path) -> Result<()> {
  • flacenc 0.1.0/src/main.rs
    81
    		 
    /// Serializes `Stream` to a file.
    82
    		 
    #[allow(clippy::expect_used)]
    83
    		 
    fn write_stream<F: Write>(stream: &Stream, file: &mut F) {
    93
    		 
    #[allow(clippy::expect_used)]
    94
    		 
    #[allow(clippy::exit)]
  • fregate 0.7.0/src/application/app.rs
    193
    		 
    #[allow(clippy::expect_used)]
    194
    		 
    async fn shutdown_signal() {
  • fregate 0.7.0/src/application/configuration.rs
    156
    		 
    impl Default for AppConfig<Empty> {
    157
    		 
        #[allow(clippy::expect_used)]
    158
    		 
        fn default() -> Self {
  • fregate 0.7.0/src/application/proxy_router.rs
    16
    		 
    // TODO: remove allow
    17
    		 
    #[allow(clippy::expect_used)]
    18
    		 
    async fn proxy_handler(
  • gitig 0.3.0/src/main.rs
    59
    		 
    ///           having to put the error message pretty-printing inside main()
    60
    		 
    #[allow(clippy::result_expect_used, clippy::exit, clippy::use_debug)]
    61
    		 
    fn main() {
  • gitig 0.3.0/src/template.rs
    103
    		 
        /// Other reasons for `Err` can be io related errors.
    104
    		 
        #[allow(clippy::option_expect_used)]
    105
    		 
        pub fn write_to(&self, path: &PathBuf, append: bool) -> Result<()> {
  • holodex 0.3.1/src/model/id.rs
    159
    		 
        fn from_str(s: &str) -> Result<Self, Self::Err> {
    160
    		 
            #[allow(clippy::expect_used)]
    161
    		 
            let regex =
    494
    		 
        fn from_str(s: &str) -> Result<Self, Self::Err> {
    495
    		 
            #[allow(clippy::expect_used)]
    496
    		 
            let regex = Regex::new(r"UC[0-9a-zA-Z_-]{21}[AQgw]").expect("Channel ID regex broke.");
  • hyraigne 0.1.4/src/fs.rs
    18
    		 
    /// Clean a name to safely use it as directory name.
    19
    		 
    #[allow(clippy::expect_used)] // Regexp are hardcoded and correct.
    20
    		 
    pub(crate) fn sanitize_name(name: &str) -> PathBuf {
    47
    		 
    // Extract the file extension from the image URL.
    48
    		 
    #[allow(clippy::expect_used)] // Highly unlikely to have bad UTF-8 in file ext.
    49
    		 
    pub(crate) fn extname_from_url(url: &Url) -> &str {
  • hyraigne 0.1.4/src/sites/mangadex/site.rs
    97
    		 
            #[allow(clippy::expect_used)] // Shouldn't have NaN & friends here…
    98
    		 
            chapters
    174
    		 
    // Convert a series URL into the corresponding API endpoint.
    175
    		 
    #[allow(clippy::expect_used)] // Regexp is hardcoded and valid.
    176
    		 
    fn endpoint_from_url(url: &Url) -> Result<Url> {
  • hyraigne 0.1.4/src/sites/mangakakalot/chapter.rs
    35
    		 
    /// Extract chapter ID and volume name (if any) from chapter's title.
    36
    		 
    #[allow(clippy::expect_used)] // Regexp is hardcoded and valid.
    37
    		 
    fn parse_title(
  • hyraigne 0.1.4/src/sites/mangakakalot/selectors.rs
    5
    		 
    /// Select the series title.
    6
    		 
    #[allow(clippy::expect_used)]
    7
    		 
    pub(super) static SERIES_TITLE_SELECTOR: Lazy<kuchiki::Selectors> =
    13
    		 
    /// Select `<meta property="og:url" content="URL" />`
    14
    		 
    #[allow(clippy::expect_used)]
    15
    		 
    pub(super) static SERIES_URL_SELECTOR: Lazy<kuchiki::Selectors> =
    21
    		 
    /// Select chapter links in the chapter list.
    22
    		 
    #[allow(clippy::expect_used)]
    23
    		 
    pub(super) static CHAPTER_SELECTOR: Lazy<kuchiki::Selectors> =
    29
    		 
    /// Select image URLs from the chapter page.
    30
    		 
    #[allow(clippy::expect_used)]
    31
    		 
    pub(super) static PAGE_URL_SELECTOR: Lazy<kuchiki::Selectors> =
  • hyraigne 0.1.4/src/sites/mangakakalot/site.rs
    77
    		 
            #[allow(clippy::expect_used)] // Shouldn't have NaN & friends here…
    78
    		 
            chapters
  • icu_calendar 1.1.0/src/any_calendar.rs
    531
    		 
                Self::JapaneseExtended(_) => AnyCalendarKind::JapaneseExtended,
    532
    		 
                #[allow(clippy::expect_used)] // Invariant known at compile time
    533
    		 
                Self::Ethiopian(ref e) => e
  • icu_calendar 1.1.0/src/japanese.rs
    712
    		 
                    if let Ok(index) = data.binary_search_by(|(d, _)| d.year.cmp(int)) {
    713
    		 
                        #[allow(clippy::expect_used)] // see expect message
    714
    		 
                        let (era_start, code) = data
  • icu_capi 1.1.0/src/properties_maps.rs
    26
    		 
        ) -> Box<ICU4XCodePointMapData8> {
    27
    		 
            #[allow(clippy::expect_used)] // infallible for the chosen properties
    28
    		 
            Box::new(ICU4XCodePointMapData8(
    152
    		 
            ) -> Result<Box<ICU4XCodePointMapData16>, ICU4XError> {
    153
    		 
                #[allow(clippy::expect_used)] // script is a 16-bit property
    154
    		 
                Ok(Box::new(ICU4XCodePointMapData16(
  • icu_codepointtrie 0.4.0/src/planes.rs
    171
    		 
        ];
    172
    		 
        #[allow(clippy::expect_used)] // TODO(#1668) Clippy exceptions need docs or fixing.
    173
    		 
        let index: ZeroVec<u16> = ZeroVec::parse_byte_slice(index_array_as_bytes).expect("infallible");
    174
    		 
        #[allow(clippy::expect_used)] // TODO(#1668) Clippy exceptions need docs or fixing.
    175
    		 
        let data: ZeroVec<u8> = ZeroVec::parse_byte_slice(data_8_array).expect("infallible");
  • icu_collections 1.1.0/src/codepointtrie/cptrie.rs
    429
    		 
            let error_converted = error_vec.try_into_converted::<P>()?;
    430
    		 
            #[allow(clippy::expect_used)] // we know this cannot fail
    431
    		 
            Ok(CodePointTrie {
  • icu_datetime 1.1.0/src/provider/date_time.rs
    283
    		 
            let mut locale = self.locale.clone();
    284
    		 
            #[allow(clippy::expect_used)] // experimental
    285
    		 
            let cal_val = self.cal_val.expect("should be present for components bag");
  • icu_datetime 1.1.0/src/skeleton/helpers.rs
    236
    		 
                    // TODO(#2626) - Since this is fallible, we should make this method fallible.
    237
    		 
                    #[allow(clippy::expect_used)] // Generic pattern combination should never fail.
    238
    		 
                    let dt = dt_pattern
  • icu_provider 1.1.0/src/datagen/heap_measure.rs
    38
    		 
        /// Panics if the buffer is not in postcard-0.7 format.
    39
    		 
        #[allow(clippy::expect_used)] // The function documents when panics may occur.
    40
    		 
        pub fn attempt_zero_copy_heap_size<M>(self) -> HeapStats
  • icu_provider_blob 1.1.0/src/export/blob_exporter.rs
    5
    		 
    // This is "export" feature, and there are many internal invariants
    6
    		 
    #![allow(clippy::expect_used)]
    63
    		 
            };
    64
    		 
            #[allow(clippy::expect_used)]
    65
    		 
            self.resources.lock().expect("poison").push((
  • iir_filters 0.1.2/src/test_util.rs
    1
    		 
    #[allow(clippy::expect_used)]
    2
    		 
    #[allow(clippy::panic)]
  • kanidm_client 1.1.0-alpha.11/src/lib.rs
    407
    		 
            // Now get the origin.
    408
    		 
            #[allow(clippy::expect_used)]
    409
    		 
            let uri = Url::parse(&address).expect("failed to parse address");
    411
    		 
            #[allow(clippy::expect_used)]
    412
    		 
            let origin =
  • kanidm_tools 1.1.0-alpha.11/src/cli/common.rs
    102
    		 
                    if tokens.len() == 1 {
    103
    		 
                        #[allow(clippy::expect_used)]
    104
    		 
                        let (f_uname, f_token) = tokens.iter().next().expect("Memory Corruption");
  • kanidm_tools 1.1.0-alpha.11/src/cli/session.rs
    252
    		 
                {
    253
    		 
                    #[allow(clippy::expect_used)]
    254
    		 
                    mechs
    266
    		 
                    #[allow(clippy::expect_used)]
    267
    		 
                    mechs
    293
    		 
                    {
    294
    		 
                        #[allow(clippy::expect_used)]
    295
    		 
                        allowed
    307
    		 
                        #[allow(clippy::expect_used)]
    308
    		 
                        allowed
  • kbs2 0.6.0/src/kbs2/agent.rs
    383
    		 
            // at the very end of its lifecycle, meaning that an expect here is acceptable.
    384
    		 
            #[allow(clippy::expect_used)]
    385
    		 
            fs::remove_file(Agent::path()).expect("attempted to remove missing agent socket");
  • kbs2 0.6.0/src/kbs2/session.rs
    56
    		 
                // for non-directories.
    57
    		 
                #[allow(clippy::expect_used)]
    58
    		 
                let label = path
  • kbs2 0.6.0/src/kbs2/util.rs
    81
    		 
        // greater than or equal to the epoch.
    82
    		 
        #[allow(clippy::expect_used)]
    83
    		 
        SystemTime::now()
  • lecturn 0.1.9/src/editor.rs
    91
    		 
            #[allow(clippy::expect_used)]
    92
    		 
            Self {
  • litemap 0.6.1/src/testing.rs
    12
    		 
    // Test code
    13
    		 
    #[allow(clippy::expect_used)]
    14
    		 
    fn check_equivalence<'a, K, V, S0, S1>(mut a: S0, mut b: S1)
    49
    		 
    // Test code
    50
    		 
    #[allow(clippy::expect_used)]
    51
    		 
    fn check_into_iter_equivalence<'a, K, V, S0, S1>(a: S0, b: S1)
    89
    		 
    // Test code
    90
    		 
    #[allow(clippy::expect_used)]
    91
    		 
    #[allow(clippy::panic)]
    124
    		 
    // Test code
    125
    		 
    #[allow(clippy::expect_used)]
    126
    		 
    pub fn check_store<'a, S>()
    172
    		 
    // Test code
    173
    		 
    #[allow(clippy::expect_used)]
    174
    		 
    pub fn check_store_full<'a, S>()
  • matrix-oracle 0.1.3/src/server.rs
    183
    		 
    		#[cfg(test)]
    184
    		 
    		#[allow(clippy::expect_used)]
    185
    		 
    		let response = self
    224
    		 
    			Server::Host(ref host) => (host.as_str(), 8448),
    225
    		 
    			#[allow(clippy::expect_used)]
    226
    		 
    			Server::HostPort(ref host) => split_port(host).expect("HostPort was constructed with port"),
    227
    		 
    			#[allow(clippy::expect_used)]
    228
    		 
    			Server::Srv(ref addr, _) => split_port(addr).expect("The SRV record includes the port"),
  • meiosis 0.1.0/examples/helloworld.rs
    114
    		 
                        for evaluated_species in species.iter() {
    115
    		 
                            #[allow(clippy::expect_used)]
    116
    		 
                            let fittest = evaluated_species
    145
    		 
        let species = result.state().species();
    146
    		 
        #[allow(clippy::expect_used)]
    147
    		 
        let fittest = species
  • meiosis 0.1.0/src/algorithm/fitness.rs
    779
    		 
                        // a species always has members in this state
    780
    		 
                        #[allow(clippy::expect_used)]
    781
    		 
                        let representative = species
    852
    		 
                        // we allow `expect` as a missing representative is a irrecoverable error anyway
    853
    		 
                        #[allow(clippy::expect_used)]
    854
    		 
                        let representative = final_selected
    996
    		 
                            // this is always the first parent, which is guaranteed to be `Some`
    997
    		 
                            #[allow(clippy::expect_used)]
    998
    		 
                            return parent_one.take().expect("option can't be None");
    1031
    		 
                            // this is always the first parent, which is guaranteed to be `Some`
    1032
    		 
                            #[allow(clippy::expect_used)]
    1033
    		 
                            return parent_one.take().expect("option can't be None");
    1161
    		 
            #[allow(clippy::shadow_unrelated, clippy::expect_used)]
    1162
    		 
            let mut species = sort_population_to_species(
  • meiosis 0.1.0/src/fitness/floats.rs
    20
    		 
            // This is fine as we're checking the value first anyway.
    21
    		 
            #[allow(clippy::expect_used)]
    22
    		 
            // To make sure that -0.0 and +0.0 are both considered equal, we use `partial_cmp`
    44
    		 
            // This is fine as we're checking the value first anyway.
    45
    		 
            #[allow(clippy::expect_used)]
    46
    		 
            // To make sure that -0.0 and +0.0 are both considered equal, we use `partial_cmp`
  • meiosis 0.1.0/src/operators/mutation/combination.rs
    101
    		 
            // `from_fn` can infer the array length from the return type
    102
    		 
            #[allow(clippy::expect_used)]
    103
    		 
            let strategies = core::array::from_fn(|_| iter.next().expect("constructed iterator has known length"));
  • mure 0.2.1/src/app/list.rs
    16
    		 
                    if full && path {
    17
    		 
                        #[allow(clippy::expect_used)]
    18
    		 
                        let abpath = mure_repo
    25
    		 
                    } else if path {
    26
    		 
                        #[allow(clippy::expect_used)]
    27
    		 
                        let relpath = mure_repo
  • mure 0.2.1/src/app/refresh.rs
    37
    		 
                    let result = refresh(
    38
    		 
                        #[allow(clippy::expect_used)]
    39
    		 
                        mure_repo
  • mure 0.2.1/src/test_fixture.rs
    15
    		 
    #[cfg(test)]
    16
    		 
    #[allow(clippy::expect_used, clippy::unwrap_used)]
    17
    		 
    impl Fixture {
  • necessist-core 0.1.0-beta.6/src/backup.rs
    72
    		 
    #[allow(clippy::expect_used)]
    73
    		 
    fn sibling_tempfile(path: &Path) -> Result<NamedTempFile> {
  • necessist-core 0.1.0-beta.6/src/framework/impls/rust/mod.rs
    132
    		 
        ) -> Result<Option<(Exec, Option<Box<Postprocess>>)>> {
    133
    		 
            #[allow(clippy::expect_used)]
    134
    		 
            let test_path = self
    203
    		 
        fn build_test_command(&self, _context: &LightContext, test_file: &Path) -> Command {
    204
    		 
            #[allow(clippy::expect_used)]
    205
    		 
            let flags = self
    215
    		 
        fn build_test_exec(&self, _context: &LightContext, test_file: &Path) -> Exec {
    216
    		 
            #[allow(clippy::expect_used)]
    217
    		 
            let flags = self
  • necessist-core 0.1.0-beta.6/src/offset_based_rewriter/impls.rs
    63
    		 
        #[allow(clippy::cast_possible_wrap)]
    64
    		 
        #[allow(clippy::expect_used)]
    65
    		 
        #[allow(clippy::unwrap_used)]
  • oxker 0.2.1/src/app_data/mod.rs
    70
    		 
        /// Current time as unix timestamp
    71
    		 
        #[allow(clippy::expect_used)]
    72
    		 
        fn get_systemtime() -> u64 {
  • passport 0.4.0/src/lib.rs
    231
    		 
    	fn set_issuing_time(mut self, expires_in: Option<u64>) -> Self {
    232
    		 
    		#[allow(clippy::expect_used)]
    233
    		 
    		let now = SystemTime::UNIX_EPOCH.elapsed().expect("System time is before unix epoch").as_secs();
  • pix-engine 0.7.0/src/gui/state.rs
    139
    		 
    impl Default for UiState {
    140
    		 
        #[allow(clippy::expect_used)]
    141
    		 
        fn default() -> Self {
  • pix-engine 0.7.0/src/renderer/sdl/texture.rs
    28
    		 
        fn deref(&self) -> &Self::Target {
    29
    		 
            #[allow(clippy::expect_used)]
    30
    		 
            self.inner.as_ref().expect("texture has been dropped")
    35
    		 
        fn deref_mut(&mut self) -> &mut Self::Target {
    36
    		 
            #[allow(clippy::expect_used)]
    37
    		 
            self.inner.as_mut().expect("texture has been dropped")
  • pix-engine 0.7.0/src/renderer/sdl.rs
    30
    		 
    #[allow(clippy::expect_used)]
    31
    		 
    static TTF: Lazy<Sdl2TtfContext> = Lazy::new(|| sdl2::ttf::init().expect("sdl2_ttf initialized"));
    125
    		 
        fn font(&self) -> &SdlFont<'static, 'static> {
    126
    		 
            #[allow(clippy::expect_used)]
    127
    		 
            self.loaded_fonts
    134
    		 
        fn font_mut(&mut self) -> &mut SdlFont<'static, 'static> {
    135
    		 
            #[allow(clippy::expect_used)]
    136
    		 
            self.loaded_fonts
    334
    		 
                    // SAFETY: We just checked or inserted a texture.
    335
    		 
                    #[allow(clippy::expect_used)]
    336
    		 
                    window.text_cache.get_mut(&key).expect("valid text cache")
    744
    		 
                // SAFETY: We just checked or inserted a texture.
    745
    		 
                #[allow(clippy::expect_used)]
    746
    		 
                window.image_cache.get_mut(&key).expect("valid image cache")
  • pix-engine 0.7.0/src/renderer.rs
    68
    		 
    impl Default for RendererSettings {
    69
    		 
        #[allow(clippy::expect_used)]
    70
    		 
        fn default() -> Self {
  • probe-rs 0.16.0/src/debug/mod.rs
    218
    		 
    #[allow(clippy::unwrap_used, clippy::expect_used)]
    219
    		 
    pub(crate) fn _print_all_attributes(
  • ranges 0.3.3/src/ranges/difference.rs
    27
    		 
        /// ```
    28
    		 
        #[allow(clippy::too_many_lines, clippy::expect_used)]
    29
    		 
        #[must_use]
  • ranges 0.3.3/src/ranges/insert.rs
    132
    		 
                    // we can safely unwrap here because we know there are at least two ranges
    133
    		 
                    #[allow(clippy::integer_arithmetic, clippy::expect_used)]
    134
    		 
                    let last = self
  • ranges 0.3.3/src/ranges/intersect.rs
    52
    		 
            #[allow(clippy::expect_used)]
    53
    		 
            loop {
  • ranges 0.3.3/src/ranges/remove.rs
    32
    		 
        /// ```
    33
    		 
        #[allow(clippy::expect_used)]
    34
    		 
        pub fn remove<R>(&mut self, range: R) -> bool
  • ranges 0.3.3/src/ranges/symmetric_difference.rs
    64
    		 
            #[allow(clippy::expect_used)]
    65
    		 
            loop {
  • ranges 0.3.3/src/ranges/union.rs
    64
    		 
            #[allow(clippy::expect_used)]
    65
    		 
            loop {
  • reqwest-cache 0.1.2/src/lib.rs
    124
    		 
    		// constructor
    125
    		 
    		#[allow(clippy::expect_used)]
    126
    		 
    		let (mut parts, _) = http::Request::builder()
  • russh-keys 0.24.0/src/key.rs
    284
    		 
            match self {
    285
    		 
                #[allow(clippy::expect_used)]
    286
    		 
                Self::Ed25519(kp) => Self::Ed25519(
  • rust-query 0.0.0-alpha-1/src/sycamore.rs
    56
    		 
    // For consistent panicing behaviour with other contexts
    57
    		 
    #[allow(clippy::expect_used)]
    58
    		 
    #[must_use = "Function has no other effect than to provide reference to the QueryClient, it should be used"]
  • s3s 0.2.0/src/signature_v4/methods.rs
    38
    		 
    fn hmac_sha256(key: impl AsRef<[u8]>, data: impl AsRef<[u8]>) -> impl AsRef<[u8]> {
    39
    		 
        #[allow(clippy::expect_used)]
    40
    		 
        let mut m = <Hmac<Sha256>>::new_from_slice(key.as_ref()).expect("HMAC can take key of any size");
  • sendstream_parser 0.2.2/src/wire/tlv.rs
    46
    		 
                    input,
    47
    		 
                    #[allow(clippy::expect_used)]
    48
    		 
                    T::parse_exact(data.try_into().expect("length is already checked")),
    223
    		 
    fn parse_time(data: [u8; 12]) -> SystemTime {
    224
    		 
        #[allow(clippy::expect_used)]
    225
    		 
        let secs = u64::from_le_bytes(data[..8].try_into().expect("right size"));
    226
    		 
        #[allow(clippy::expect_used)]
    227
    		 
        let nanos = u32::from_le_bytes(data[8..].try_into().expect("right size"));
  • siderophile 0.2.1/src/trawl_source/mod.rs
    108
    		 
    #[allow(clippy::expect_used)]
    109
    		 
    pub fn find_rs_files_in_dir(dir: &Path) -> impl Iterator<Item = PathBuf> {
    125
    		 
    #[allow(clippy::expect_used, clippy::unwrap_used)]
    126
    		 
    fn find_rs_files_in_package(pack: &Package) -> Vec<RsFile> {
  • siderophile 0.2.1/src/utils.rs
    86
    		 
    #[allow(clippy::missing_panics_doc, clippy::expect_used, clippy::unwrap_used)]
    87
    		 
    pub fn configure_rustup_toolchain() {
  • sigma-ser 0.11.0/src/scorex_serialize.rs
    180
    		 
    /// serialization roundtrip
    181
    		 
    #[allow(clippy::expect_used)]
    182
    		 
    pub fn scorex_serialize_roundtrip<T: ScorexSerializable>(v: &T) -> T {
  • sqlx-database-tester 0.4.2/src/lib.rs
    33
    		 
    ) -> sqlx::postgres::PgConnectOptions {
    34
    		 
    	#[allow(clippy::expect_used)]
    35
    		 
    	let mut options = sqlx::postgres::PgConnectOptions::from_str(&get_database_uri())
  • sxd_html 0.1.1/src/lib.rs
    186
    		 
        ) {
    187
    		 
            #[allow(clippy::expect_used)]
    188
    		 
            let parent = sibling.parent().expect("must have a parent");
    190
    		 
            let children = {
    191
    		 
                #[allow(clippy::expect_used)]
    192
    		 
                let mut v = vec![ChildOfElement::try_from(sibling.clone()).expect("must be element")];
  • sxd_html 0.1.1/src/util.rs
    32
    		 
            {
    33
    		 
                #[allow(clippy::expect_used)]
    34
    		 
                ChildOfRoot::try_from(handle).expect("Cannot convert to ChildOfRoot")
    46
    		 
            {
    47
    		 
                #[allow(clippy::expect_used)]
    48
    		 
                ChildOfElement::try_from(handle).expect("Cannot convert to ChildOfElement")
  • synthez-core 0.2.0/src/field.rs
    250
    		 
        pub fn into_inner(self) -> T {
    251
    		 
            #[allow(clippy::expect_used)]
    252
    		 
            self.0.expect("Uninitialized `Required` value")
    259
    		 
        fn deref(&self) -> &Self::Target {
    260
    		 
            #[allow(clippy::expect_used)]
    261
    		 
            self.0.as_ref().expect("Uninitialized `Required` value")
    266
    		 
        fn deref_mut(&mut self) -> &mut Self::Target {
    267
    		 
            #[allow(clippy::expect_used)]
    268
    		 
            self.0.as_mut().expect("Uninitialized `Required` value")
  • vqueue 2.0.1-rc.4/src/cli/debugger/show.rs
    48
    		 
            for lifetime in Self::lifetimes() {
    49
    		 
                #[allow(clippy::expect_used)]
    50
    		 
                let split_index = itertools::partition(&mut values, |i| {
  • vsmtp-delivery 2.0.1-rc.4/src/lib.rs
    54
    		 
    // at this point there should be no error
    55
    		 
    #[allow(clippy::expect_used)]
    56
    		 
    fn to_lettre_envelope(from: &Option<Address>, rcpt: &[Rcpt]) -> lettre::address::Envelope {
  • vsmtp-delivery 2.0.1-rc.4/src/send.rs
    88
    		 
                resolvers.get_resolver_or_root(
    89
    		 
                    #[allow(clippy::expect_used)]
    90
    		 
                    to.get(0)
  • vsmtp-delivery 2.0.1-rc.4/src/sender.rs
    87
    		 
                alloc::sync::Arc::clone(
    88
    		 
                    #[allow(clippy::expect_used)]
    89
    		 
                    self.senders
  • vsmtp-protocol 2.0.1-rc.4/src/command.rs
    282
    		 
            #[allow(clippy::expect_used)]
    283
    		 
            for args in words {
  • vsmtp-protocol 2.0.1-rc.4/src/receiver.rs
    381
    		 
                        tracing::warn!("Closing after {} without receiving a command", e);
    382
    		 
                        #[allow(clippy::expect_used)]
    383
    		 
                        self.sink
  • vsmtp-protocol 2.0.1-rc.4/src/receiver_handler.rs
    96
    		 
        async fn on_data(&mut self) -> Reply {
    97
    		 
            #[allow(clippy::expect_used)]
    98
    		 
            "354 Start mail input; end with <CRLF>.<CRLF>\r\n"
    105
    		 
        async fn on_quit(&mut self) -> Reply {
    106
    		 
            #[allow(clippy::expect_used)]
    107
    		 
            "221 Service closing transmission channel"
    114
    		 
        async fn on_noop(&mut self) -> Reply {
    115
    		 
            #[allow(clippy::expect_used)]
    116
    		 
            "250 Ok\r\n".parse().expect("valid syntax")
    121
    		 
        async fn on_help(&mut self, _: UnparsedArgs) -> Reply {
    122
    		 
            #[allow(clippy::expect_used)]
    123
    		 
            "214 joining us https://viridit.com/support"
    133
    		 
            #[allow(clippy::expect_used)]
    134
    		 
            if unimplemented_command.iter().any(|c| {
  • vsmtp-protocol 2.0.1-rc.4/src/smtp_sasl.rs
    135
    		 
            let temp = mechanism.to_string();
    136
    		 
            #[allow(clippy::expect_used)]
    137
    		 
            let selected =
  • wapc-pool 1.0.0/src/hostpool.rs
    338
    		 
      pub fn build(mut self) -> HostPool {
    339
    		 
        #[allow(clippy::expect_used)]
    340
    		 
        let factory = self
  • zerovec 0.9.2/src/map2d/cursor.rs
    259
    		 
            let start = range.start;
    260
    		 
            #[allow(clippy::expect_used)] // protected by the debug_assert above
    261
    		 
            let binary_search_result = self
    273
    		 
            let start = range.start;
    274
    		 
            #[allow(clippy::expect_used)] // protected by the debug_assert above
    275
    		 
            let binary_search_result = self
  • zerovec 0.9.2/src/map2d/map.rs
    244
    		 
        fn joiner_expand(&mut self, key0_index: usize) {
    245
    		 
            #[allow(clippy::expect_used)] // slice overflow
    246
    		 
            self.joiner
    426
    		 
            #[allow(clippy::expect_used)] // slice overflow
    427
    		 
            let joiner_value = u32::try_from(self.keys1.zvl_len() + 1)
  • zerovec 0.9.2/src/ule/multi.rs
    25
    		 
        pub fn compute_encoded_len_for(lengths: &[usize]) -> usize {
    26
    		 
            #[allow(clippy::expect_used)] // See #1410
    27
    		 
            unsafe {
  • acceptxmr 0.11.1/src/rpc/authentication.rs
    305
    		 
    mod tests {
    306
    		 
        #![allow(clippy::expect_used)]
  • apalis-core 0.3.6/src/worker/deadlock.rs
    3
    		 
    #![allow(clippy::expect_used, clippy::panic)]
  • arctk 2.0.7/src/lib.rs
    20
    		 
        clippy::exhaustive_structs,
    21
    		 
        clippy::expect_used,
    22
    		 
        clippy::float_arithmetic,
  • arctk-proc 0.4.3/src/lib.rs
    15
    		 
        clippy::panic,
    16
    		 
        clippy::expect_used,
    17
    		 
        clippy::wildcard_enum_match_arm
  • bonsaimq 0.2.0/examples/checkpoints.rs
    1
    		 
    //! Checkpoint example.
    2
    		 
    #![allow(clippy::expect_used, unused_qualifications, clippy::unused_async, clippy::print_stdout)]
  • bonsaimq 0.2.0/examples/context.rs
    1
    		 
    //! Simple example using context.
    2
    		 
    #![allow(clippy::expect_used, unused_qualifications, clippy::unused_async, clippy::print_stdout)]
  • bonsaimq 0.2.0/examples/error_handling.rs
    1
    		 
    //! Example showing the error handling in jobs.
    2
    		 
    #![allow(clippy::expect_used, unused_qualifications, clippy::unused_async, clippy::print_stdout)]
  • bonsaimq 0.2.0/examples/simple.rs
    1
    		 
    //! Simple example.
    2
    		 
    #![allow(clippy::expect_used, unused_qualifications, clippy::unused_async, clippy::print_stdout)]
  • bonsaimq 0.2.0/src/registry.rs
    100
    		 
    mod tests {
    101
    		 
    	#![allow(clippy::expect_used, unused_qualifications, clippy::unused_async)]
  • bonsaimq 0.2.0/tests/general.rs
    1
    		 
    //! General tests and simple cases.
    2
    		 
    #![allow(clippy::expect_used, clippy::unused_async)]
  • bonsaimq 0.2.0/tests/ordering.rs
    1
    		 
    //! Testing that job order works as expected.
    2
    		 
    #![allow(clippy::expect_used)]
  • bonsaimq 0.2.0/tests/stress.rs
    1
    		 
    //! Stress-test, making sure everything still works as expected
    2
    		 
    #![allow(clippy::expect_used)]
  • bve 0.0.1/src/lib.rs
    37
    		 
    #![allow(clippy::non_ascii_literal)]
    38
    		 
    #![allow(clippy::option_expect_used)]
    39
    		 
    #![allow(clippy::panic)]
    40
    		 
    #![allow(clippy::result_expect_used)]
    41
    		 
    #![allow(clippy::shadow_reuse)]
  • bve-derive 0.0.1/src/lib.rs
    39
    		 
    #![allow(clippy::non_ascii_literal)]
    40
    		 
    #![allow(clippy::option_expect_used)]
    41
    		 
    #![allow(clippy::panic)]
    42
    		 
    #![allow(clippy::result_expect_used)]
    43
    		 
    #![allow(clippy::shadow_reuse)]
  • bve-native 0.0.1/src/lib.rs
    79
    		 
    #![allow(clippy::non_ascii_literal)]
    80
    		 
    #![allow(clippy::option_expect_used)]
    81
    		 
    #![allow(clippy::panic)]
    82
    		 
    #![allow(clippy::result_expect_used)]
    83
    		 
    #![allow(clippy::shadow_reuse)]
  • c2pa 1.0.0/examples/custom_assertion.rs
    74
    		 
    pub mod tests {
    75
    		 
        #![allow(clippy::expect_used)]
  • c2pa 1.0.0/src/assertions/actions.rs
    305
    		 
    pub mod tests {
    306
    		 
        #![allow(clippy::expect_used)]
    307
    		 
        #![allow(clippy::panic)]
  • c2pa 1.0.0/src/assertions/creative_work.rs
    105
    		 
    pub mod tests {
    106
    		 
        #![allow(clippy::expect_used)]
    107
    		 
        #![allow(clippy::unwrap_used)]
  • c2pa 1.0.0/src/assertions/ingredient.rs
    141
    		 
    pub mod tests {
    142
    		 
        #![allow(clippy::expect_used)]
    143
    		 
        #![allow(clippy::panic)]
  • c2pa 1.0.0/src/assertions/metadata.rs
    262
    		 
    pub mod tests {
    263
    		 
        #![allow(clippy::expect_used)]
    264
    		 
        #![allow(clippy::unwrap_used)]
  • c2pa 1.0.0/src/assertions/schema_org.rs
    206
    		 
    pub mod tests {
    207
    		 
        #![allow(clippy::expect_used)]
    208
    		 
        #![allow(clippy::unwrap_used)]
  • c2pa 1.0.0/src/assertions/thumbnail.rs
    86
    		 
    pub mod tests {
    87
    		 
        #![allow(clippy::expect_used)]
    88
    		 
        #![allow(clippy::unwrap_used)]
  • c2pa 1.0.0/src/assertions/user.rs
    73
    		 
    pub mod tests {
    74
    		 
        #![allow(clippy::expect_used)]
    75
    		 
        #![allow(clippy::unwrap_used)]
  • c2pa 1.0.0/src/assertions/user_cbor.rs
    73
    		 
    pub mod tests {
    74
    		 
        #![allow(clippy::expect_used)]
    75
    		 
        #![allow(clippy::unwrap_used)]
  • c2pa 1.0.0/src/assertions/uuid_assertion.rs
    71
    		 
    pub mod tests {
    72
    		 
        #![allow(clippy::expect_used)]
    73
    		 
        #![allow(clippy::unwrap_used)]
  • c2patool 0.3.9/src/info.rs
    78
    		 
    pub mod tests {
    79
    		 
        #![allow(clippy::expect_used)]
  • esopt 0.2.0/src/lib.rs
    2
    		 
    #![allow(clippy::assign_op_pattern)]
    3
    		 
    #![allow(clippy::expect_used)] // TODO: get rid of.
  • expecto-patronum 0.1.0/src/lib.rs
    12
    		 
    #![allow(clippy::panic)]
    13
    		 
    #![allow(clippy::expect_used)]
    14
    		 
    #![allow(clippy::arithmetic_side_effects)]
  • girt-config 2.2.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-core 2.2.1/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-display 2.2.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-git 2.2.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-input 2.2.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-runtime 0.1.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-testutils 0.1.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-todo-file 2.2.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • girt-view 2.2.0/src/lib.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • git-interactive-rebase-tool 2.2.1/src/main.rs
    54
    		 
    	clippy::else_if_without_else,
    55
    		 
    	clippy::expect_used,
    56
    		 
    	clippy::implicit_return,
  • graph_safe_compare 0.2.1/src/like_anticipated.rs
    36
    		 
            {
    37
    		 
                #![allow(clippy::expect_used)] // Truly infallible.
    38
    		 
                self.expect("infallible")
  • icu_codepointtrie_builder 0.3.4/src/lib.rs
    59
    		 
    #![allow(clippy::panic)]
    60
    		 
    #![allow(clippy::expect_used)]
  • icu_provider_fs 1.1.0/src/export/mod.rs
    73
    		 
        clippy::unwrap_used,
    74
    		 
        clippy::expect_used,
    75
    		 
        clippy::panic
  • kanidm_tools 1.1.0-alpha.11/src/cli/lib.rs
    11
    		 
    // We allow expect since it forces good error messages at the least.
    12
    		 
    #![allow(clippy::expect_used)]
  • kanidm_tools 1.1.0-alpha.11/src/cli/main.rs
    11
    		 
    // We allow expect since it forces good error messages at the least.
    12
    		 
    #![allow(clippy::expect_used)]
  • ldap3_cli 0.3.1/src/cldap.rs
    11
    		 
    // We allow expect since it forces good error messages at the least.
    12
    		 
    #![allow(clippy::expect_used)]
  • ldap3_cli 0.3.1/src/ldap.rs
    11
    		 
    // We allow expect since it forces good error messages at the least.
    12
    		 
    #![allow(clippy::expect_used)]
  • ldap3_cli 0.3.1/src/ldap_debug.rs
    11
    		 
    // We allow expect since it forces good error messages at the least.
    12
    		 
    #![allow(clippy::expect_used)]
  • ldap3_cli 0.3.1/src/lib.rs
    11
    		 
    // We allow expect since it forces good error messages at the least.
    12
    		 
    #![allow(clippy::expect_used)]
  • ldap3_client 0.3.1/src/lib.rs
    11
    		 
    // We allow expect since it forces good error messages at the least.
    12
    		 
    #![allow(clippy::expect_used)]
  • ldap3_proto 0.3.1/src/lib.rs
    12
    		 
    // We allow expect since it forces good error messages at the least.
    13
    		 
    #![allow(clippy::expect_used)]
  • libpd-rs 0.1.9/src/lib.rs
    28
    		 
        // Expect is fine in relevant cases
    29
    		 
        clippy::expect_used,
  • mecs 0.1.1/src/lib.rs
    25
    		 
    	#![allow(clippy::panic             )] // We use panic when we reach an unstable state
    26
    		 
    	#![allow(clippy::result_expect_used)] // We use expect when making assertions
    27
    		 
    	#![allow(clippy::option_expect_used)] // ...
    28
    		 
    	#![allow(clippy::indexing_slicing  )] // We use [] when we want to panic if the value doesn't exist
  • ofnn 0.1.3/src/lib.rs
    3
    		 
    //! Architecture influenced by Keras: Sequential models
    4
    		 
    #![allow(clippy::expect_used)] // TODO: get rid of it.
  • plow_cli 0.4.8/src/main.rs
    29
    		 
        // We decided that we're ok with expect
    30
    		 
        clippy::expect_used,
    31
    		 
        clippy::wildcard_imports,
  • plow_graphify 0.2.2/src/lib.rs
    26
    		 
        // We decided that we're ok with expect
    27
    		 
        clippy::expect_used,
  • plow_linter 0.2.8/src/lib.rs
    28
    		 
        // We decided that we're ok with expect
    29
    		 
        clippy::expect_used,
  • plow_ontology 0.2.1/src/lib.rs
    26
    		 
        // We decided that we're ok with expect
    27
    		 
        clippy::expect_used,
  • plow_package_management 0.3.1/src/lib.rs
    28
    		 
        // We decided that we're ok with expect
    29
    		 
        clippy::expect_used,
  • rdma 0.3.0/src/lib.rs
    7
    		 
        clippy::panic_in_result_fn,
    8
    		 
        clippy::expect_used,
    9
    		 
        clippy::unwrap_used,
  • requeuest 0.6.0/tests/send.rs
    3
    		 
    #![allow(clippy::unwrap_used, clippy::expect_used)]
  • sample-config 0.2.0/tests/features.rs
    1
    		 
    #![allow(clippy::expect_used)] // Allowed in tests.
    2
    		 
    #![allow(unused_imports)] // Without features this file is empty.
  • sample-config 0.2.0/tests/generation.rs
    1
    		 
    #![allow(clippy::expect_used)] // Allowed in tests.
  • sample-config-macros 0.2.0/src/lib.rs
    1
    		 
    //! Macros for sample configs.
    2
    		 
    #![allow(clippy::expect_used)] // Allowed in procedural macros.
  • stringmetrics 2.2.2/src/lib.rs
    209
    		 
        clippy::missing_docs_in_private_items,
    210
    		 
        clippy::expect_used,
    211
    		 
        clippy::unwrap_used,
  • swarm-bot 0.3.4/src/main.rs
    64
    		 
        clippy::panic,
    65
    		 
        clippy::expect_used,
    66
    		 
        clippy::cast_precision_loss,
  • xmp_toolkit 1.0.1/src/tests/mod.rs
    17
    		 
    #![allow(clippy::expect_used)]
    18
    		 
    #![allow(clippy::panic)]
  • zerovec 0.9.2/src/varzerovec/owned.rs
    6
    		 
    #![allow(clippy::unwrap_used)]
    7
    		 
    #![allow(clippy::expect_used)]
    8
    		 
    #![allow(clippy::indexing_slicing)]