• ark-api 0.17.0-pre.15/src/api/ml.rs
    210
    		 
            // We have already verified that the length is OK, so the slicing cannot panic
    211
    		 
            #[allow(clippy::indexing_slicing)]
    212
    		 
            bytes[..str_data.len()].copy_from_slice(str_data);
  • ascii 1.1.0/src/ascii_char.rs
    358
    		 
            // We want to slice here and detect `const_err` from rustc if the slice is invalid
    359
    		 
            #[allow(clippy::indexing_slicing)]
    360
    		 
            ALL[ch as usize]
    702
    		 
        #[must_use]
    703
    		 
        #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1`
    704
    		 
        pub const fn to_ascii_uppercase(&self) -> Self {
    720
    		 
        #[must_use]
    721
    		 
        #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1`
    722
    		 
        pub const fn to_ascii_lowercase(&self) -> Self {
  • ascii 1.1.0/src/ascii_str.rs
    531
    		 
    #[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default
    532
    		 
    impl Index<usize> for AsciiStr {
    541
    		 
    #[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default
    542
    		 
    impl IndexMut<usize> for AsciiStr {
  • ascii 1.1.0/src/ascii_string.rs
    715
    		 
    #[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default
    716
    		 
    impl<T> Index<T> for AsciiString
    728
    		 
    #[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default
    729
    		 
    impl<T> IndexMut<T> for AsciiString
  • avml 0.10.0/src/iomem.rs
    73
    		 
            #[allow(clippy::indexing_slicing)]
    74
    		 
            while !ranges.is_empty() && range.end >= ranges[0].start {
  • binfarce 0.2.1/src/macho.rs
    189
    		 
        #[allow(clippy::indexing_slicing)]
    190
    		 
        pub fn symbols(&self) -> Result<(Vec<SymbolData>, u64), ParseError> {
    229
    		 
    #[allow(clippy::integer_arithmetic)]
    230
    		 
    #[allow(clippy::indexing_slicing)]
    231
    		 
    fn parse_symbols(
  • binfarce 0.2.1/src/pe.rs
    138
    		 
        #[allow(clippy::cast_possible_truncation)]
    139
    		 
        #[allow(clippy::indexing_slicing)]
    140
    		 
        pub fn symbols(&self) -> Result<(Vec<SymbolData>, u64), ParseError> {
  • cap-primitives 1.0.4/src/rustix/fs/dir_utils.rs
    68
    		 
    /// canonicalizing to `foo/.` since these syscalls treat these differently.
    69
    		 
    #[allow(clippy::indexing_slicing)]
    70
    		 
    pub(crate) fn strip_dir_suffix(path: &Path) -> impl Deref<Target = Path> + '_ {
  • cargo-patch 0.3.0/src/main.rs
    432
    		 
        clippy::as_conversions,
    433
    		 
        clippy::indexing_slicing,
    434
    		 
        clippy::cast_possible_truncation
  • cbe-program-runtime 1.15.0/src/executor_cache.rs
    364
    		 
    #[allow(clippy::indexing_slicing)]
    365
    		 
    #[cfg(test)]
  • cbe-program-runtime 1.15.0/src/pre_account.rs
    166
    		 
            #[allow(clippy::indexing_slicing)]
    167
    		 
            {
  • cbe-sdk 1.15.0/src/transaction_context.rs
    1088
    		 
        #[allow(clippy::indexing_slicing)]
    1089
    		 
        {
  • deduplicating_array 0.1.3/src/lib.rs
    64
    		 
        for i in 0..N {
    65
    		 
            #[allow(clippy::indexing_slicing)] // i, j in 0..N
    66
    		 
            match array.iter().take(i).position(|item| item == &array[i]) {
    94
    		 
                    HumanDe::Value(v) => {
    95
    		 
                        #[allow(clippy::indexing_slicing)] // i in 0..N by enumerate
    96
    		 
                        array[i].write(v);
    106
    		 
                        }
    107
    		 
                        #[allow(clippy::indexing_slicing)] // j < i in 0..N by enumerate
    108
    		 
                        array[i].write(array[j].assume_init_ref().clone());
    117
    		 
                    MachineDe::Value(v) => {
    118
    		 
                        #[allow(clippy::indexing_slicing)] // i in 0..N by enumerate
    119
    		 
                        array[i].write(v);
    129
    		 
                        }
    130
    		 
                        #[allow(clippy::indexing_slicing)] // j < i in 0..N by enumerate
    131
    		 
                        array[i].write(array[j].assume_init_ref().clone());
  • display_utils 0.4.0/src/lib.rs
    147
    		 
    	} else {
    148
    		 
    		#[allow(clippy::indexing_slicing)] // index will be in 0..8 always due to modulo
    149
    		 
    		UnicodeBlockBar {
    219
    		 
    						core::cmp::Ordering::Less => &BLOCK_CHARS[0],
    220
    		 
    						#[allow(clippy::indexing_slicing)] // that index will always be in 0..=8
    221
    		 
    						core::cmp::Ordering::Equal => &BLOCK_CHARS[8 - steps % 8],
    485
    		 
    			for (start, part) in self.source.match_indices(self.from) {
    486
    		 
    				#[allow(clippy::indexing_slicing)] // match_indices returns well-aligned indices
    487
    		 
    				f.write_str(&self.source[last_end..start])?;
    491
    		 
    			}
    492
    		 
    			#[allow(clippy::indexing_slicing)] // last_end is well-aligned still
    493
    		 
    			f.write_str(&self.source[last_end..])?;
    529
    		 
    			for (start, part) in self.source.match_indices(self.from).take(self.n) {
    530
    		 
    				#[allow(clippy::indexing_slicing)] // match_indices returns well-aligned indices
    531
    		 
    				f.write_str(&self.source[last_end..start])?;
  • elastiql 0.5.0/src/aggregation/serialization_deserialization.rs
    342
    		 
    #[doc(hidden)]
    343
    		 
    #[allow(clippy::indexing_slicing)]
    344
    		 
    fn split_ty_and_name(ty_and_name: &str) -> (Ty, String) {
  • expecto-patronum 0.1.0/src/lib.rs
    80
    		 
    /// Choose a patronus based on the provided `msg`.
    81
    		 
    #[allow(clippy::indexing_slicing)]
    82
    		 
    fn choose_patronus(msg: &str) -> Patronus {
  • fixed_decimal 0.5.2/src/decimal.rs
    247
    		 
                    match X.checked_sub(i) {
    248
    		 
                        #[allow(clippy::indexing_slicing)] // X - i < X
    249
    		 
                        Some(v) => mem[v] = d,
    263
    		 
                debug_assert!(i <= X);
    264
    		 
                #[allow(clippy::indexing_slicing)] // X - i < X
    265
    		 
                result.digits.extend_from_slice(&mem[(X - i)..]);
    1666
    		 
        #[cfg(debug_assertions)]
    1667
    		 
        #[allow(clippy::indexing_slicing)]
    1668
    		 
        fn check_invariants(&self) {
    1761
    		 
            }
    1762
    		 
            #[allow(clippy::indexing_slicing)] // The string is not empty.
    1763
    		 
            let sign = match input_str[0] {
    1767
    		 
            };
    1768
    		 
            #[allow(clippy::indexing_slicing)] // The string is not empty.
    1769
    		 
            let no_sign_str = if sign == Sign::None {
  • girt-config 2.2.0/src/color.rs
    61
    		 
    	#[allow(clippy::indexing_slicing)]
    62
    		 
    	#[inline]
  • girt-config 2.2.0/src/utils.rs
    12
    		 
    #[allow(clippy::string_slice, clippy::indexing_slicing)]
    13
    		 
    pub(super) fn get_input(config: Option<&Config>, name: &str, default: &str) -> Result<Vec<String>> {
  • girt-core 2.2.1/src/modules/external_editor/argument_tokenizer.rs
    12
    		 
    // as far as I know, this is safe because the slices are always on specific boundaries
    13
    		 
    #[allow(clippy::string_slice, clippy::indexing_slicing)]
    14
    		 
    pub(super) fn tokenize(input: &str) -> Option<Vec<String>> {
  • girt-core 2.2.1/src/modules/list/utils.rs
    204
    		 
    // safe slice, as it is only on the hash, which is hexadecimal
    205
    		 
    #[allow(clippy::string_slice, clippy::indexing_slicing)]
    206
    		 
    pub(super) fn get_todo_line_segments(
  • girt-core 2.2.1/src/modules/show_commit/view_builder.rs
    66
    		 
    	// safe slice, as it is only on the hash, which is hexadecimal
    67
    		 
    	#[allow(clippy::string_slice, clippy::indexing_slicing)]
    68
    		 
    	fn build_leading_summary(commit: &Commit, is_full_width: bool) -> ViewLine {
    158
    		 
    	// safe slice, only slices across graphemes whitespace
    159
    		 
    	#[allow(clippy::string_slice, clippy::indexing_slicing)]
    160
    		 
    	fn get_diff_line_segments(
  • girt-input 2.2.0/src/key_bindings.rs
    35
    		 
    #[inline]
    36
    		 
    #[allow(clippy::string_slice, clippy::indexing_slicing)]
    37
    		 
    pub fn map_keybindings<CustomEvent: crate::CustomEvent>(bindings: &[String]) -> Vec<Event<CustomEvent>> {
  • girt-runtime 0.1.0/src/runtime/mod.rs
    56
    		 
    	/// Returns and error if any of the threads registered to the runtime produce an error.
    57
    		 
    	#[allow(clippy::indexing_slicing)]
    58
    		 
    	#[inline]
  • girt-view 2.2.0/src/testutil.rs
    188
    		 
    #[allow(clippy::indexing_slicing, clippy::string_slice, clippy::panic)]
    189
    		 
    pub(crate) fn _assert_rendered_output(options: AssertRenderOptions, actual: &[String], expected: &[String]) {
  • i3-insert-workspace 1.0.1/src/insert_workspace.rs
    58
    		 
    /// Insert a new workspace at the given location
    59
    		 
    #[allow(clippy::indexing_slicing)]
    60
    		 
    pub fn insert_workspace(
  • icu_calendar 1.1.0/src/iso.rs
    480
    		 
            let month_offset = [0, 1, -1, 0, 0, 1, 1, 2, 3, 3, 4, 4];
    481
    		 
            #[allow(clippy::indexing_slicing)] // date.0.month in 1..=12
    482
    		 
            let mut offset = month_offset[date.0.month as usize - 1];
  • icu_collator 1.1.0/src/comparison.rs
    544
    		 
                            // Index in range by construction
    545
    		 
                            #[allow(clippy::indexing_slicing)]
    546
    		 
                            let left_prefix =
    559
    		 
                            // Index in range by construction
    560
    		 
                            #[allow(clippy::indexing_slicing)]
    561
    		 
                            let right_prefix = &right_remaining
  • icu_collator 1.1.0/src/elements.rs
    892
    		 
            // rewriting with `get()` would result in two checks.
    893
    		 
            #[allow(clippy::indexing_slicing)]
    894
    		 
            if !self.upcoming[0].decomposition_starts_with_non_starter() {
    1180
    		 
            // Indices are in range by construction, so indexing is OK.
    1181
    		 
            #[allow(clippy::indexing_slicing)]
    1182
    		 
            self.upcoming[start_combining..end_combining].sort_by_key(|c| c.ccc());
    1187
    		 
        // increases one by one by construction.
    1188
    		 
        #[allow(clippy::indexing_slicing)]
    1189
    		 
        fn look_ahead(&mut self, pos: usize) -> Option<CharacterAndClassAndTrieValue> {
    1246
    		 
            // Indices in range by construction
    1247
    		 
            #[allow(clippy::indexing_slicing)]
    1248
    		 
            {
    1295
    		 
                        // https://github.com/rust-lang/rust/issues/15701
    1296
    		 
                        #[allow(clippy::indexing_slicing)]
    1297
    		 
                        if jamo_index >= self.jamo.len() {
  • icu_collections 1.1.0/src/codepointinvlist/builder.rs
    49
    		 
            #[allow(clippy::indexing_slicing)] // all indices are binary search results
    50
    		 
            if start_eq_end && start_pos_check && end_res.is_err() {
    179
    		 
        pub fn add_set(&mut self, set: &CodePointInversionList) {
    180
    		 
            #[allow(clippy::indexing_slicing)] // chunks
    181
    		 
            set.as_inversion_list()
    200
    		 
            if let Some(&last) = self.intervals.last() {
    201
    		 
                #[allow(clippy::indexing_slicing)]
    202
    		 
                // by invariant, if we have a last we have a (different) first
    254
    		 
        /// assert_eq!(check.iter_chars().next(), Some('F'));
    255
    		 
        #[allow(clippy::indexing_slicing)] // chunks
    256
    		 
        pub fn remove_set(&mut self, set: &CodePointInversionList) {
    325
    		 
        /// ```
    326
    		 
        #[allow(clippy::indexing_slicing)] // chunks
    327
    		 
        pub fn retain_set(&mut self, set: &CodePointInversionList) {
  • icu_collections 1.1.0/src/codepointinvlist/cpinvlist.rs
    177
    		 
        ) -> Result<Self, CodePointInversionListError> {
    178
    		 
            #[allow(clippy::indexing_slicing)] // chunks
    179
    		 
            if is_valid_zv(&inv_list) {
    360
    		 
        pub fn iter_chars(&self) -> impl Iterator<Item = char> + '_ {
    361
    		 
            #[allow(clippy::indexing_slicing)] // chunks
    362
    		 
            self.inv_list
    389
    		 
        pub fn iter_ranges(&self) -> impl ExactSizeIterator<Item = RangeInclusive<u32>> + '_ {
    390
    		 
            #[allow(clippy::indexing_slicing)] // chunks
    391
    		 
            self.inv_list.as_ule_slice().chunks(2).map(|pair| {
  • icu_collections 1.1.0/src/codepointinvlist/utils.rs
    13
    		 
    /// and within the bounds of `0x0 -> 0x10FFFF + 1` inclusive.
    14
    		 
    #[allow(clippy::indexing_slicing)] // windows
    15
    		 
    #[allow(clippy::unwrap_used)] // by is_empty check
  • icu_datetime 1.1.0/src/pattern/item/ule.rs
    100
    		 
            #[allow(clippy::indexing_slicing)] // chunks
    101
    		 
            if !bytes
    233
    		 
            }
    234
    		 
            #[allow(clippy::indexing_slicing)] // chunks
    235
    		 
            if !bytes
  • icu_datetime 1.1.0/src/pattern/runtime/helpers.rs
    24
    		 
            .find_map(|(i, item)| f(&item).map(|result| (i, result)));
    25
    		 
        #[allow(clippy::indexing_slicing)] // i was produced by enumerate
    26
    		 
        if let Some((i, result)) = result {
    47
    		 
            .find_map(|(i, item)| f(&item).map(|result| (i, result)));
    48
    		 
        #[allow(clippy::indexing_slicing)] // i was produced by enumerate
    49
    		 
        if let Some((i, result)) = result {
  • icu_datetime 1.1.0/tests/mock.rs
    36
    		 
    pub fn parse_gregorian_from_str(input: &str) -> Result<DateTime<Gregorian>, CalendarError> {
    37
    		 
        #![allow(clippy::indexing_slicing)] // all indexing is gated
    38
    		 
        let validate = |c, i| -> Result<(), CalendarError> {
    94
    		 
        match input.rfind(&['+', '-', '\u{2212}', 'Z']) {
    95
    		 
            #[allow(clippy::indexing_slicing)] // valid index
    96
    		 
            Some(index) => Ok((
  • icu_decimal 1.1.0/src/format.rs
    47
    		 
                }
    48
    		 
                #[allow(clippy::indexing_slicing)] // digit_at in 0..=9
    49
    		 
                sink.write_char(self.symbols.digits[self.value.digit_at(m) as usize])?;
  • icu_list 1.1.0/src/patterns.rs
    52
    		 
            for i in 0..12 {
    53
    		 
                #[allow(clippy::indexing_slicing)] // self.0 is &[_; 12]
    54
    		 
                if self.0[i].default == old {
    129
    		 
                    }
    130
    		 
                    #[allow(clippy::indexing_slicing)] // find
    131
    		 
                    Ok(ListJoinerPattern {
    146
    		 
        fn borrow_tuple(&'data self) -> PatternParts<'data> {
    147
    		 
            #![allow(clippy::indexing_slicing)] // by invariant
    148
    		 
            let index_0 = self.index_0 as usize;
  • icu_locid 1.1.0/src/extensions/mod.rs
    95
    		 
            }
    96
    		 
            #[allow(clippy::indexing_slicing)]
    97
    		 
            Self::try_from_byte(bytes[start])
  • icu_locid 1.1.0/src/parser/mod.rs
    21
    		 
    const fn is_separator(slice: &[u8], idx: usize) -> bool {
    22
    		 
        #[allow(clippy::indexing_slicing)]
    23
    		 
        let b = slice[idx];
    104
    		 
        pub fn peek(&self) -> Option<&'a [u8]> {
    105
    		 
            #[allow(clippy::indexing_slicing)] // peek_manual returns valid indices
    106
    		 
            self.peek_manual().map(|(s, e)| &self.slice[s..e])
    115
    		 
            *self = s;
    116
    		 
            #[allow(clippy::indexing_slicing)] // next_manual returns valid indices
    117
    		 
            res.map(|(s, e)| &self.slice[s..e])
  • icu_normalizer 1.1.0/src/lib.rs
    931
    		 
            // is in permissible range.
    932
    		 
            #[allow(clippy::indexing_slicing)]
    933
    		 
            sort_slice_by_ccc(&mut self.buffer[combining_start..], self.trie);
    2458
    		 
            // an input or data issue.
    2459
    		 
            #[allow(clippy::indexing_slicing)]
    2460
    		 
            if s.as_ptr() == self.expect.as_ptr() {
    2497
    		 
            // an input or data issue.
    2498
    		 
            #[allow(clippy::indexing_slicing)]
    2499
    		 
            if s.as_ptr() == self.expect.as_ptr() {
    2536
    		 
            // an input or data issue.
    2537
    		 
            #[allow(clippy::indexing_slicing)]
    2538
    		 
            if s.as_ptr() == self.expect.as_ptr() {
  • icu_pattern 0.1.3/src/parser/mod.rs
    329
    		 
                        let range = self.advance_state(self.idx, ParserState::Default);
    330
    		 
                        #[allow(clippy::indexing_slicing)]
    331
    		 
                        // TODO(#1668) Clippy exceptions need docs or fixing.
    375
    		 
                        self.start_idx = self.len;
    376
    		 
                        #[allow(clippy::indexing_slicing)]
    377
    		 
                        // TODO(#1668) Clippy exceptions need docs or fixing.
  • icu_plurals 1.1.0/src/rules/reference/lexer.rs
    131
    		 
                            let mut value = 0;
    132
    		 
                            #[allow(clippy::indexing_slicing)]
    133
    		 
                            // start..end are calculated to be within bounds.
  • icu_provider 1.1.0/src/hello_world.rs
    108
    		 
        fn load(&self, req: DataRequest) -> Result<DataResponse<HelloWorldV1Marker>, DataError> {
    109
    		 
            #[allow(clippy::indexing_slicing)] // binary_search
    110
    		 
            let data = Self::DATA
  • icu_provider 1.1.0/src/helpers.rs
    95
    		 
    // The indexing operations in this function have been reviewed in detail and won't panic.
    96
    		 
    #[allow(clippy::indexing_slicing)]
    97
    		 
    pub const fn fxhash_32(bytes: &[u8], ignore_leading: usize, ignore_trailing: usize) -> u32 {
  • icu_provider 1.1.0/src/key.rs
    331
    		 
        // The indexing operations in this function have been reviewed in detail and won't panic.
    332
    		 
        #[allow(clippy::indexing_slicing)]
    333
    		 
        pub const fn construct_internal(
    392
    		 
                let byte = if i < end {
    393
    		 
                    #[allow(clippy::indexing_slicing)] // protected by debug assertion
    394
    		 
                    Some(path.as_bytes()[i])
  • icu_uniset 0.5.0/src/builder.rs
    49
    		 
            } else {
    50
    		 
                #[allow(clippy::indexing_slicing)]
    51
    		 
                if start_pos_check {
    56
    		 
                if end_pos_check {
    57
    		 
                    #[allow(clippy::indexing_slicing)]
    58
    		 
                    // TODO(#1668) Clippy exceptions need docs or fixing.
    179
    		 
                    self.add(
    180
    		 
                        #[allow(clippy::indexing_slicing)]
    181
    		 
                        // TODO(#1668) Clippy exceptions need docs or fixing.
    182
    		 
                        AsULE::from_unaligned(pair[0]),
    183
    		 
                        #[allow(clippy::indexing_slicing)]
    184
    		 
                        // TODO(#1668) Clippy exceptions need docs or fixing.
    198
    		 
            if let Some(last) = self.intervals.last() {
    199
    		 
                #[allow(clippy::indexing_slicing)] // TODO(#1668) Clippy exceptions need docs or fixing.
    200
    		 
                if start <= self.intervals[0] && end >= *last {
  • icu_uniset 0.5.0/src/uniset.rs
    103
    		 
        pub fn from_inversion_list(inv_list: ZeroVec<'data, u32>) -> Result<Self, UnicodeSetError> {
    104
    		 
            #[allow(clippy::indexing_slicing)] // TODO(#1668) Clippy exceptions need docs or fixing.
    105
    		 
            if is_valid_zv(&inv_list) {
    269
    		 
        pub fn iter_chars(&self) -> impl Iterator<Item = char> + '_ {
    270
    		 
            #[allow(clippy::indexing_slicing)] // TODO(#1668) Clippy exceptions need docs or fixing.
    271
    		 
            self.inv_list
    296
    		 
        pub fn iter_ranges(&self) -> impl ExactSizeIterator<Item = RangeInclusive<u32>> + '_ {
    297
    		 
            #[allow(clippy::indexing_slicing)] // TODO(#1668) Clippy exceptions need docs or fixing.
    298
    		 
            self.inv_list.as_ule_slice().chunks(2).map(|pair| {
  • icu_uniset 0.5.0/src/utils.rs
    13
    		 
    /// and within the bounds of `0x0 -> 0x10FFFF` inclusive.
    14
    		 
    #[allow(clippy::indexing_slicing)] // TODO(#1668) Clippy exceptions need docs or fixing.
    15
    		 
    pub fn is_valid_zv(inv_list_zv: &ZeroVec<'_, u32>) -> bool {
  • icu4x_ecma402 0.8.0/src/pluralrules.rs
    48
    		 
            } else {
    49
    		 
                #[allow(clippy::indexing_slicing)] // fract output shape
    50
    		 
                &raw_frac_part[2..]
  • io-arrays 0.12.0/src/windows.rs
    234
    		 
        #[allow(clippy::indexing_slicing)]
    235
    		 
        let bufs = &mut bufs[remove..];
    266
    		 
        #[allow(clippy::indexing_slicing)]
    267
    		 
        let bufs = &mut bufs[remove..];
  • kmp 0.1.1/src/find.rs
    60
    		 
    /// [`kmp_find`]: ./fn.kmp_find.html
    61
    		 
    #[allow(clippy::indexing_slicing)]
    62
    		 
    pub fn kmp_find_with_lsp_table<N, H>(needle: &[N], haystack: &[H], lsp: &[usize]) -> Option<usize>
  • kmp 0.1.1/src/match.rs
    79
    		 
        #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    80
    		 
        while let Some(position) = kmp_find_with_lsp_table(needle, &haystack[start..], lsp) {
  • kmp 0.1.1/src/table.rs
    6
    		 
    /// `_with_lsp_table`.
    7
    		 
    #[allow(clippy::indexing_slicing)]
    8
    		 
    pub fn kmp_table<N>(needle: &[N]) -> Vec<usize>
  • layered-io 0.20.0/src/read_layered.rs
    56
    		 
    /// [`ReadLayered::read_with_status`].
    57
    		 
    #[allow(clippy::indexing_slicing)]
    58
    		 
    pub fn default_read_to_end<Inner: ReadLayered + ?Sized>(
    114
    		 
    /// of [`ReadLayered::read_with_status`].
    115
    		 
    #[allow(clippy::indexing_slicing)]
    116
    		 
    pub fn default_read_exact_using_status<Inner: ReadLayered + ?Sized>(
  • layered-io 0.20.0/src/write_layered.rs
    53
    		 
    /// [`Write::write`].
    54
    		 
    #[allow(clippy::indexing_slicing)]
    55
    		 
    pub fn default_write_all<Inner: Write + ?Sized>(
    116
    		 
        #[allow(clippy::indexing_slicing)]
    117
    		 
        let bufs = &mut bufs[remove..];
  • lecturn 0.1.9/src/document.rs
    60
    		 
            }
    61
    		 
            #[allow(clippy::indexing_slicing)]
    62
    		 
            let new_row = self.rows[at.y].split(at.x);
    79
    		 
            } else {
    80
    		 
                #[allow(clippy::indexing_slicing)]
    81
    		 
                let row = &mut self.rows[at.y];
    84
    		 
        }
    85
    		 
        #[allow(clippy::integer_arithmetic, clippy::indexing_slicing)]
    86
    		 
        pub fn delete(&mut self, at: &Position) {
  • lecturn 0.1.9/src/row.rs
    138
    		 
        }
    139
    		 
        #[allow(clippy::indexing_slicing)]
    140
    		 
        pub fn add_highlighting(&mut self, highlight_type: highlighting::Type, index: usize) {
  • meiosis 0.1.0/src/algorithm/fitness.rs
    899
    		 
        // all slicing done in here is only done so if a length check makes a panic impossible
    900
    		 
        #[allow(clippy::indexing_slicing, clippy::too_many_lines)]
    901
    		 
        pub fn recombine(
  • meiosis 0.1.0/src/operators/mutation/random/multi/nudge.rs
    50
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    51
    		 
            #[allow(clippy::indexing_slicing)]
    52
    		 
            for _ in 0..mutations_by_rate(GENES, self.rate) {
    88
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    89
    		 
            #[allow(clippy::indexing_slicing)]
    90
    		 
            for _ in 0..mutations_by_rate(genotype.len(), self.rate) {
    131
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    132
    		 
            #[allow(clippy::indexing_slicing)]
    133
    		 
            for _ in 0..mutations_by_rate(chars.len(), self.rate) {
  • meiosis 0.1.0/src/operators/mutation/random/multi/uniform.rs
    40
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    41
    		 
            #[allow(clippy::indexing_slicing)]
    42
    		 
            for _ in 0..mutations_by_rate(GENES, self.rate) {
    67
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    68
    		 
            #[allow(clippy::indexing_slicing)]
    69
    		 
            for _ in 0..mutations_by_rate(genotype.len(), self.rate) {
    99
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    100
    		 
            #[allow(clippy::indexing_slicing)]
    101
    		 
            for _ in 0..mutations_by_rate(chars.len(), self.rate) {
  • meiosis 0.1.0/src/operators/mutation/random/single/nudge.rs
    38
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    39
    		 
            #[allow(clippy::indexing_slicing)]
    40
    		 
            if rng.gen_bool(self.chance) {
    65
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    66
    		 
            #[allow(clippy::indexing_slicing)]
    67
    		 
            if rng.gen_bool(self.chance) {
    91
    		 
            // this is okay because we're indexing with a value that can't possibly be outside of the slice range
    92
    		 
            #[allow(clippy::indexing_slicing)]
    93
    		 
            if rng.gen_bool(self.chance) {
  • memcached 0.4.4/src/client/mod.rs
    488
    		 
        /// 没有风险
    489
    		 
        #[allow(clippy::indexing_slicing)]
    490
    		 
        fn get_connection(&self, key: &str) -> &Pool<ConnectionManager> {
  • oapth 0.1.0/src/utils.rs
    25
    		 
          // Indexing will not panic in this scenario
    26
    		 
          allow(clippy::indexing_slicing)
    27
    		 
        ]
  • paper 0.4.0/src/app/translate.rs
    114
    		 
                Input::User(user_input) => {
    115
    		 
                    #[allow(clippy::indexing_slicing)] // EnumMap guarantees that index is in bounds.
    116
    		 
                    let mode_interpreter = self.map[self.mode];
  • plow_cli 0.4.8/src/manifest.rs
    229
    		 
                        let literal_name_and_req = literal.split(' ').collect::<Vec<&str>>();
    230
    		 
                        #[allow(clippy::indexing_slicing)]
    231
    		 
                        IndexedPackageDependency {
    325
    		 
                            #[allow(clippy::string_slice)]
    326
    		 
                            #[allow(clippy::indexing_slicing)]
    327
    		 
                            return Some(email.to_owned()[..email.len() - 1].to_owned());
  • plow_cli 0.4.8/src/subcommand/init/field.rs
    18
    		 
    #[allow(clippy::indexing_slicing)]
    19
    		 
    impl FieldName {
    43
    		 
    #[allow(clippy::indexing_slicing)]
    44
    		 
    impl TryFrom<String> for FieldName {
  • plow_cli 0.4.8/src/subcommand/init/workspace/fields.rs
    242
    		 
        #[allow(clippy::unwrap_in_result)]
    243
    		 
        #[allow(clippy::indexing_slicing)]
    244
    		 
        #[allow(clippy::unwrap_used)]
  • plow_cli 0.4.8/src/sync.rs
    286
    		 
    #[allow(clippy::indexing_slicing)]
    287
    		 
    fn split(haystack: &[u8], needle: u8) -> impl Iterator<Item = &[u8]> {
    318
    		 
    #[allow(clippy::indexing_slicing)]
    319
    		 
    pub fn str_from_u8_nul_utf8(utf8_src: &[u8]) -> Result<&str, std::str::Utf8Error> {
    327
    		 
    #[allow(clippy::indexing_slicing)]
    328
    		 
    fn parse(data: &[u8]) -> Result<(String, Vec<PackageVersionWithRegistryMetadata>), CliError> {
  • plow_ontology 0.2.1/src/lib.rs
    75
    		 
    #[allow(clippy::indexing_slicing)]
    76
    		 
    impl PackageName {
    90
    		 
    #[allow(clippy::indexing_slicing)]
    91
    		 
    impl TryFrom<String> for PackageName {
  • plow_package_management 0.3.1/src/resolve/dependency.rs
    44
    		 
        /// will be used later in [`VersionRequestResolver`](crate::resolve::VersionRequestResolver)
    45
    		 
        #[allow(clippy::indexing_slicing)]
    46
    		 
        pub fn derive_range_for_version_request_pair(predicates: &[String]) -> Result<Range<V>>
  • plow_package_management 0.3.1/src/resolve.rs
    475
    		 
                    // We explicitly insert and always know that we'll have the organization package in cache.
    476
    		 
                    #[allow(clippy::indexing_slicing)]
    477
    		 
                    self.available_packages_cache.borrow()[package][0]
  • plow_package_management 0.3.1/src/version.rs
    183
    		 
    #[allow(clippy::indexing_slicing)]
    184
    		 
    impl TryFrom<&str> for SemanticVersion {
    199
    		 
    #[allow(clippy::indexing_slicing)]
    200
    		 
    impl TryFrom<String> for SemanticVersion {
    208
    		 
    #[allow(clippy::indexing_slicing)]
    209
    		 
    impl TryFrom<&String> for SemanticVersion {
    217
    		 
    #[allow(clippy::indexing_slicing)]
    218
    		 
    impl FromStr for SemanticVersion {
  • ranges 0.3.3/src/ranges/contains.rs
    22
    		 
        #[must_use]
    23
    		 
        #[allow(clippy::indexing_slicing, clippy::integer_arithmetic, clippy::integer_division)]
    24
    		 
        pub fn contains(&self, item: &T) -> bool {
  • ranges 0.3.3/src/ranges/insert.rs
    75
    		 
                Some((s, e)) if s == e => {
    76
    		 
                    #[allow(clippy::indexing_slicing)]
    77
    		 
                    match new_range.arrangement(&self.ranges[s]) {
    84
    		 
                            // remove the value at index s and replace it with a temporary full range
    85
    		 
                            #[allow(clippy::indexing_slicing)]
    86
    		 
                            let existing_range = core::mem::replace(&mut self.ranges[s], GenericRange::full());
    128
    		 
                    // replace first element of affected indices by full range
    129
    		 
                    #[allow(clippy::indexing_slicing)]
    130
    		 
                    let first = core::mem::replace(&mut self.ranges[s], GenericRange::full());
    151
    		 
                    // replace temporary value with the newly calculated one
    152
    		 
                    #[allow(clippy::indexing_slicing)]
    153
    		 
                    // using a block to apply the lint allowance, because attributes on expressions are
  • ranges 0.3.3/src/ranges.rs
    72
    		 
        /// Returns true if the whole domain is in this range.
    73
    		 
        #[allow(clippy::indexing_slicing)]
    74
    		 
        #[must_use]
  • rim 0.1.1/src/document.rs
    50
    		 
            }
    51
    		 
            #[allow(clippy::indexing_slicing)]
    52
    		 
            let current_row = &mut self.rows[at.y];
    68
    		 
            } else {
    69
    		 
                #[allow(clippy::indexing_slicing)]
    70
    		 
                let row = &mut self.rows[at.y];
    81
    		 
        }
    82
    		 
        #[allow(clippy::integer_arithmetic, clippy::indexing_slicing)]
    83
    		 
        pub fn delete(&mut self, at: &Position) {
    113
    		 
        }
    114
    		 
        #[allow(clippy::indexing_slicing)]
    115
    		 
        pub fn find(&self, query: &str, at: &Position, direction: SearchDirection) -> Option<Position> {
    160
    		 
            };
    161
    		 
            #[allow(clippy::indexing_slicing)]
    162
    		 
            for row in &mut self.rows[..until] {
  • rim 0.1.1/src/row.rs
    180
    		 
                    {
    181
    		 
                        #[allow(clippy::indexing_slicing)]
    182
    		 
                        for i in index.saturating_add(search_match)..next_index {
    225
    		 
            if *index > 0 {
    226
    		 
                #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    227
    		 
                let prev_char = chars[*index - 1];
    233
    		 
                if *index < chars.len().saturating_sub(word.len()) {
    234
    		 
                    #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    235
    		 
                    let next_char = chars[*index + word.len()];
    322
    		 
        }
    323
    		 
        #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    324
    		 
        fn highlight_multiline_comment(
    384
    		 
                if *index > 0 {
    385
    		 
                    #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    386
    		 
                    let prev_char = chars[*index - 1];
  • routing 0.37.1/src/types.rs
    88
    		 
    #[cfg(test)]
    89
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(indexing_slicing))]
    90
    		 
    mod tests {
  • russh 0.36.0/src/channel_stream/read_buffer.rs
    26
    		 
                if start < bytes.len() {
    27
    		 
                    #[allow(clippy::indexing_slicing)]
    28
    		 
                    target.put_slice(&bytes[start..]);
    33
    		 
                if start < bytes.len() && end <= bytes.len() {
    34
    		 
                    #[allow(clippy::indexing_slicing)]
    35
    		 
                    target.put_slice(&bytes[start..end]);
  • russh 0.36.0/src/cipher/block.rs
    118
    		 
                }
    119
    		 
                #[allow(clippy::indexing_slicing)]
    120
    		 
                self.cipher
    174
    		 
            if self.mac.is_etm() {
    175
    		 
                #[allow(clippy::indexing_slicing)]
    176
    		 
                self.cipher
  • russh 0.36.0/src/cipher/chacha20poly1305.rs
    44
    		 
        #[allow(clippy::indexing_slicing)] // length checked
    45
    		 
        fn make_opening_key(
    59
    		 
        #[allow(clippy::indexing_slicing)] // length checked
    60
    		 
        fn make_sealing_key(
    85
    		 
    #[allow(clippy::indexing_slicing)] // length checked
    86
    		 
    fn make_counter(sequence_number: u32) -> Nonce {
    109
    		 
        #[allow(clippy::indexing_slicing)] // lengths checked
    110
    		 
        fn open<'a>(
    170
    		 
            let mut cipher = ChaCha20Legacy::new(&self.k1, &nonce);
    171
    		 
            #[allow(clippy::indexing_slicing)] // length checked
    172
    		 
            cipher.apply_keystream(&mut plaintext_in_ciphertext_out[..PACKET_LENGTH_LEN]);
  • russh 0.36.0/src/cipher/clear.rs
    65
    		 
            debug_assert_eq!(tag.len(), 0); // self.tag_len());
    66
    		 
            #[allow(clippy::indexing_slicing)] // length known
    67
    		 
            Ok(&ciphertext_in_plaintext_out[4..])
  • russh-keys 0.24.0/src/agent/client.rs
    218
    		 
            let len = self.buf.len() - 4;
    219
    		 
            #[allow(clippy::indexing_slicing)] // static length
    220
    		 
            BigEndian::write_u32(&mut self.buf[..], len as u32);
    238
    		 
            #[allow(clippy::indexing_slicing)] // static length
    239
    		 
            if self.buf[0] == msg::IDENTITIES_ANSWER {
    297
    		 
                #[allow(clippy::indexing_slicing, clippy::unwrap_used)]
    298
    		 
                // length is checked, hash already checked
    367
    		 
                #[allow(clippy::indexing_slicing)] // length is checked
    368
    		 
                if !self.buf.is_empty() && self.buf[0] == msg::SIGN_RESPONSE {
    396
    		 
                #[allow(clippy::indexing_slicing)] // length is checked
    397
    		 
                if !self.buf.is_empty() && self.buf[0] == msg::SIGN_RESPONSE {
  • russh-keys 0.24.0/src/agent/server.rs
    243
    		 
                    let _comment = r.read_string()?;
    244
    		 
                    #[allow(clippy::indexing_slicing)] // length checked before
    245
    		 
                    let public = ed25519_dalek::PublicKey::from_bytes(
    254
    		 
                    #[allow(clippy::indexing_slicing)] // positions checked before
    255
    		 
                    (
    298
    		 
                    #[allow(clippy::indexing_slicing)] // length is known
    299
    		 
                    let blob = writebuf[len0..].to_vec();
  • russh-keys 0.24.0/src/encoding.rs
    46
    		 
    /// Encoding length of the given mpint.
    47
    		 
    #[allow(clippy::indexing_slicing)]
    48
    		 
    pub fn mpint_len(s: &[u8]) -> usize {
    67
    		 
            self.resize(current + len, 0u8);
    68
    		 
            #[allow(clippy::indexing_slicing)] // length is known
    69
    		 
            &mut self[current..]
  • rvim 0.0.8/src/document.rs
    58
    		 
            }
    59
    		 
            #[allow(clippy::indexing_slicing)]
    60
    		 
            let current_row = &mut self.rows[at.y];
    77
    		 
            } else {
    78
    		 
                #[allow(clippy::indexing_slicing)]
    79
    		 
                let row = &mut self.rows[at.y];
    90
    		 
        }
    91
    		 
        #[allow(clippy::integer_arithmetic, clippy::indexing_slicing)]
    92
    		 
        pub fn delete(&mut self, at: &Position) {
    122
    		 
        }
    123
    		 
        #[allow(clippy::indexing_slicing)]
    124
    		 
        pub fn find(&self, query: &str, at: &Position, direction: SearchDirection) -> Option<Position> {
    169
    		 
            };
    170
    		 
            #[allow(clippy::indexing_slicing)]
    171
    		 
            for row in &mut self.rows[..until] {
  • rvim 0.0.8/src/row.rs
    192
    		 
                    {
    193
    		 
                        #[allow(clippy::indexing_slicing)]
    194
    		 
                        for i in index.saturating_add(search_match)..next_index {
    237
    		 
            if *index > 0 {
    238
    		 
                #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    239
    		 
                let prev_char = chars[*index - 1];
    245
    		 
                if *index < chars.len().saturating_sub(word.len()) {
    246
    		 
                    #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    247
    		 
                    let next_char = chars[*index + word.len()];
    334
    		 
        }
    335
    		 
        #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    336
    		 
        fn highlight_multiline_comment(
    396
    		 
                if *index > 0 {
    397
    		 
                    #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    398
    		 
                    let prev_char = chars[*index - 1];
  • s3-server 0.2.0/src/streams/multipart.rs
    126
    		 
    {
    127
    		 
        #[allow(clippy::indexing_slicing)]
    128
    		 
        let pat_without_crlf = &pat[..pat.len().wrapping_sub(2)];
    185
    		 
                        Some(b) => {
    186
    		 
                            #[allow(clippy::indexing_slicing)]
    187
    		 
                            let b = &b[..b.len().saturating_sub(2)];
    293
    		 
                            for idx in memchr_iter(b'\r', bytes.as_ref()) {
    294
    		 
                                #[allow(clippy::indexing_slicing)]
    295
    		 
                                let remaining = &bytes[idx..];
    378
    		 
                #[allow(clippy::indexing_slicing)]
    379
    		 
                let byte = self.slice[idx.wrapping_sub(1)];
    381
    		 
                if byte == b'\r' {
    382
    		 
                    #[allow(clippy::indexing_slicing)]
    383
    		 
                    let left = &self.slice[..idx.wrapping_sub(1)];
  • s3s 0.2.0/src/http/multipart.rs
    121
    		 
    {
    122
    		 
        #[allow(clippy::indexing_slicing)]
    123
    		 
        let pat_without_crlf = &pat[..pat.len().wrapping_sub(2)];
    180
    		 
                        Some(b) => {
    181
    		 
                            #[allow(clippy::indexing_slicing)]
    182
    		 
                            let b = &b[..b.len().saturating_sub(2)];
    285
    		 
                            for idx in memchr_iter(b'\r', bytes.as_ref()) {
    286
    		 
                                #[allow(clippy::indexing_slicing)]
    287
    		 
                                let remaining = &bytes[idx..];
    368
    		 
                #[allow(clippy::indexing_slicing)]
    369
    		 
                let byte = self.slice[idx.wrapping_sub(1)];
    371
    		 
                if byte == b'\r' {
    372
    		 
                    #[allow(clippy::indexing_slicing)]
    373
    		 
                    let left = &self.slice[..idx.wrapping_sub(1)];
  • s3s 0.2.0/src/signature_v4/methods.rs
    54
    		 
        #[inline(always)]
    55
    		 
        #[allow(clippy::indexing_slicing)]
    56
    		 
        fn to_hex(x: u8) -> u8 {
  • safecoin-program-runtime 1.14.3/src/pre_account.rs
    169
    		 
            #[allow(clippy::indexing_slicing)]
    170
    		 
            {
  • safecoin-sdk 1.14.3/src/transaction_context.rs
    973
    		 
        #[allow(clippy::indexing_slicing)]
    974
    		 
        {
  • solana-program-runtime 1.14.13/src/executor_cache.rs
    361
    		 
    #[allow(clippy::indexing_slicing)]
    362
    		 
    #[cfg(test)]
  • solana-program-runtime 1.14.13/src/pre_account.rs
    169
    		 
            #[allow(clippy::indexing_slicing)]
    170
    		 
            {
  • solana-sdk 1.14.13/src/transaction_context.rs
    973
    		 
        #[allow(clippy::indexing_slicing)]
    974
    		 
        {
  • swarm-bot 0.3.4/src/client/physics/mod.rs
    195
    		 
            // we know this is valid because face_idx < 6
    196
    		 
            #[allow(clippy::indexing_slicing)]
    197
    		 
            let place_loc = locations[face_idx];
  • swarm-bot 0.3.4/src/client/state/local/inventory.rs
    70
    		 
            let idx = (36..45).find_map(|idx| {
    71
    		 
                #[allow(clippy::indexing_slicing)]
    72
    		 
                self.slots[idx].take()?;
  • swarm-bot 0.3.4/src/schematic.rs
    78
    		 
        #[allow(unused, clippy::unwrap_used, clippy::indexing_slicing)]
    79
    		 
        pub fn blocks(&self) -> impl Iterator<Item = (BlockLocation, BlockState)> + '_ {
  • swarm-bot 0.3.4/src/storage/chunk.rs
    48
    		 
    impl LowMemoryChunkSection {
    49
    		 
        #[allow(clippy::indexing_slicing)]
    50
    		 
        fn get_simple_type(&self, x: u8, y: u8, z: u8) -> SimpleType {
    65
    		 
        #[allow(unused, clippy::indexing_slicing)]
    66
    		 
        fn set_simple_type(&mut self, x: u8, y: u8, z: u8, input: SimpleType) {
    125
    		 
    impl ChunkData<HighMemoryChunkSection> {
    126
    		 
        #[allow(clippy::indexing_slicing)]
    127
    		 
        pub fn all_at(&self, y: u8) -> [BlockState; 256] {
    239
    		 
        #[allow(unused, clippy::indexing_slicing)]
    240
    		 
        pub fn all_states(&self) -> [BlockState; 4096] {
  • system-interface 0.25.3/src/fs/file_io_ext.rs
    357
    		 
        #[allow(clippy::indexing_slicing)]
    358
    		 
        let bufs = &mut bufs[remove..];
    389
    		 
        #[allow(clippy::indexing_slicing)]
    390
    		 
        let bufs = &mut bufs[remove..];
  • system-interface 0.25.3/src/io/io_ext.rs
    162
    		 
        #[allow(clippy::indexing_slicing)]
    163
    		 
        let bufs = &mut bufs[remove..];
    194
    		 
        #[allow(clippy::indexing_slicing)]
    195
    		 
        let bufs = &mut bufs[remove..];
  • tinystr 0.7.1/src/ascii.rs
    74
    		 
            // Indexing is protected by TinyStrError::TooLarge
    75
    		 
            #[allow(clippy::indexing_slicing)]
    76
    		 
            while i < len {
    123
    		 
                let mut i = 0;
    124
    		 
                #[allow(clippy::indexing_slicing)] // < N is safe
    125
    		 
                while i < N && self.bytes[i] as u8 != AsciiByte::B0 as u8 {
    162
    		 
            // Indexing is protected by the loop guard
    163
    		 
            #[allow(clippy::indexing_slicing)]
    164
    		 
            while i < M && i < N {
  • tinystr 0.7.1/src/int_ops.rs
    19
    		 
            // The function documentation defines when panics may occur
    20
    		 
            #[allow(clippy::indexing_slicing)]
    21
    		 
            while i < N {
    176
    		 
            // The function documentation defines when panics may occur
    177
    		 
            #[allow(clippy::indexing_slicing)]
    178
    		 
            while i < N {
  • trace4rs 0.5.0/src/env/mod.rs
    16
    		 
            // - 1: The first and only group in that match
    17
    		 
            #[allow(clippy::indexing_slicing)]
    18
    		 
            if let Ok(s) = std::env::var(&c[1]) {
  • trace4rs-fmtorp 0.5.0/src/lib.rs
    66
    		 
                        // and no overflow potential
    67
    		 
                        #[allow(clippy::indexing_slicing, clippy::integer_arithmetic)]
    68
    		 
                        let ff = &fmt_str[(strt + 1)..xi];
    122
    		 
                // safe since last range.start is inbounds as invariant of Fmtr.
    123
    		 
                #[allow(clippy::indexing_slicing)]
    124
    		 
                write!(writer.by_ref(), "{}", &self.fmt_str[last..*range.start()])?;
    138
    		 
            // safe since if we're off the end it will just be an empty slice
    139
    		 
            #[allow(clippy::indexing_slicing)]
    140
    		 
            write!(writer, "{}", &self.fmt_str[last..])?;
  • vsmtp-delivery 2.0.1-rc.4/src/transport/maildir.rs
    190
    		 
                #[allow(
    191
    		 
                    clippy::indexing_slicing,
    192
    		 
                    clippy::unreachable,
  • vsmtp-plugin-mysql 1.4.0-rc.10/src/lib.rs
    38
    		 
    #[allow(
    39
    		 
        clippy::indexing_slicing,
    40
    		 
        clippy::unwrap_used,
  • waffles-solana-bpf-loader-program 1.15.0/src/syscalls/cpi.rs
    1074
    		 
    #[allow(clippy::indexing_slicing)]
    1075
    		 
    #[allow(clippy::integer_arithmetic)]
  • waffles-solana-program-runtime 1.15.0/src/executor_cache.rs
    364
    		 
    #[allow(clippy::indexing_slicing)]
    365
    		 
    #[cfg(test)]
  • waffles-solana-program-runtime 1.15.0/src/pre_account.rs
    166
    		 
            #[allow(clippy::indexing_slicing)]
    167
    		 
            {
  • waffles-solana-sdk 1.15.0/src/transaction_context.rs
    1069
    		 
        #[allow(clippy::indexing_slicing)]
    1070
    		 
        {
  • xbe 0.1.1/src/lib.rs
    810
    		 
                    #[cfg_attr(feature = "cargo-clippy", allow(indexing_slicing))]
    811
    		 
                    let bytes = &raw.library_name[..name_end];
  • zerovec 0.9.2/src/flexzerovec/slice.rs
    38
    		 
        let mut bytes = [0; USIZE_WIDTH];
    39
    		 
        #[allow(clippy::indexing_slicing)] // protected by debug_assert above
    40
    		 
        bytes[0..width].copy_from_slice(chunk);
  • zerovec 0.9.2/src/map/vecs.rs
    299
    		 
        fn zvl_replace(&mut self, index: usize, value: &T) -> T {
    300
    		 
            #[allow(clippy::indexing_slicing)]
    301
    		 
            let unaligned = self.with_mut(|vec| {
    335
    		 
        #[allow(clippy::indexing_slicing)] // documented panic
    336
    		 
        fn zvl_permute(&mut self, permutation: &mut [usize]) {
  • zerovec 0.9.2/src/ule/chars.rs
    60
    		 
                // TODO: Use slice::as_chunks() when stabilized
    61
    		 
                #[allow(clippy::indexing_slicing)]
    62
    		 
                // Won't panic because the chunks are always 3 bytes long
  • zerovec 0.9.2/src/ule/encode.rs
    71
    		 
            self.encode_var_ule_as_slices(move |slices| {
    72
    		 
                #[allow(clippy::indexing_slicing)] // by debug_assert
    73
    		 
                for slice in slices {
  • zerovec 0.9.2/src/ule/option.rs
    75
    		 
            for chunk in bytes.chunks(size) {
    76
    		 
                #[allow(clippy::indexing_slicing)] // `chunk` will have enough bytes to fit Self
    77
    		 
                match chunk[0] {
    169
    		 
            }
    170
    		 
            #[allow(clippy::indexing_slicing)] // slice already verified to be nonempty
    171
    		 
            match slice[0] {
    216
    		 
        #[allow(clippy::indexing_slicing)] // This method is allowed to panic when lengths are invalid
    217
    		 
        fn encode_var_ule_write(&self, dst: &mut [u8]) {
  • zerovec 0.9.2/src/varzerovec/components.rs
    514
    		 
        let num_elements_bytes = elements.len().to_le_bytes();
    515
    		 
        #[allow(clippy::indexing_slicing)] // Function contract allows panicky behavior
    516
    		 
        output[0..LENGTH_WIDTH].copy_from_slice(&num_elements_bytes[0..LENGTH_WIDTH]);
    528
    		 
            let idx_limit = idx_offset + F::INDEX_WIDTH;
    529
    		 
            #[allow(clippy::indexing_slicing)] // Function contract allows panicky behavior
    530
    		 
            let idx_slice = &mut output[idx_offset..idx_limit];
  • Aetherus 0.1.1/src/lib.rs
    22
    		 
        clippy::implicit_return,
    23
    		 
        clippy::indexing_slicing,
    24
    		 
        clippy::integer_arithmetic,
  • alt_serde_derive 1.0.119/src/lib.rs
    38
    		 
        clippy::filter_map,
    39
    		 
        clippy::indexing_slicing,
    40
    		 
        clippy::items_after_statements,
  • arctk 2.0.7/src/lib.rs
    23
    		 
        clippy::implicit_return,
    24
    		 
        clippy::indexing_slicing,
    25
    		 
        clippy::integer_arithmetic,
  • async-rdma 0.4.0/src/lib.rs
    116
    		 
        clippy::exhaustive_structs,
    117
    		 
        clippy::indexing_slicing,
    118
    		 
        clippy::separated_literal_suffix, // conflicts with clippy::unseparated_literal_suffix
  • babbage 0.1.1/src/lib.rs
    20
    		 
        clippy::implicit_return,
    21
    		 
        clippy::indexing_slicing,
    22
    		 
        clippy::integer_arithmetic,
  • Boa 0.13.1/src/syntax/lexer/tests.rs
    1
    		 
    //! Tests for the lexer.
    2
    		 
    #![allow(clippy::indexing_slicing)]
  • boa_engine 0.16.0/src/syntax/lexer/tests.rs
    1
    		 
    //! Tests for the lexer.
    2
    		 
    #![allow(clippy::indexing_slicing)]
  • borsholder 0.9.3/src/lib.rs
    14
    		 
    #![cfg_attr(feature = "cargo-clippy", warn(warnings, clippy_pedantic))]
    15
    		 
    #![cfg_attr(feature = "cargo-clippy", allow(indexing_slicing, similar_names))]
  • bve 0.0.1/src/lib.rs
    27
    		 
    #![allow(clippy::implicit_return)]
    28
    		 
    #![allow(clippy::indexing_slicing)]
    29
    		 
    #![allow(clippy::integer_arithmetic)]
  • bve-derive 0.0.1/src/lib.rs
    28
    		 
    #![allow(clippy::implicit_return)]
    29
    		 
    #![allow(clippy::indexing_slicing)]
    30
    		 
    #![allow(clippy::indexing_slicing)] // Proc macros are error prone
    31
    		 
    #![allow(clippy::integer_arithmetic)]
  • bve-native 0.0.1/src/lib.rs
    68
    		 
    #![allow(clippy::implicit_return)]
    69
    		 
    #![allow(clippy::indexing_slicing)]
    70
    		 
    #![allow(clippy::integer_arithmetic)]
  • cartograph 0.1.2/src/lib.rs
    20
    		 
        clippy::implicit_return,
    21
    		 
        clippy::indexing_slicing,
    22
    		 
        clippy::integer_arithmetic,
  • cosmic-text 0.6.0/src/lib.rs
    62
    		 
    // Indexing a slice can cause panics and that is something we always want to avoid
    63
    		 
    #![allow(clippy::indexing_slicing)]
    64
    		 
    // Overflows can produce unpredictable results and are only checked in debug builds
  • diffuse 0.1.1/src/lib.rs
    20
    		 
        clippy::implicit_return,
    21
    		 
        clippy::indexing_slicing,
    22
    		 
        clippy::integer_arithmetic,
  • electrs-rocksdb 0.15.1-rc1/src/lib.rs
    64
    		 
        // '... may panic' lints.
    65
    		 
        clippy::indexing_slicing,
    66
    		 
        // Too much work to fix.
  • exonum 1.0.0/src/lib.rs
    91
    		 
        // '... may panic' lints.
    92
    		 
        clippy::indexing_slicing,
    93
    		 
        // Too much work to fix.
  • exonum-cli 1.0.0/src/lib.rs
    127
    		 
        // '... may panic' lints.
    128
    		 
        clippy::indexing_slicing,
    129
    		 
        // Too much work to fix.
  • exonum-crypto 1.0.0/src/lib.rs
    36
    		 
        // '... may panic' lints.
    37
    		 
        clippy::indexing_slicing,
    38
    		 
        // Too much work to fix.
  • exonum-explorer 1.0.0/src/lib.rs
    45
    		 
        // '... may panic' lints.
    46
    		 
        clippy::indexing_slicing,
    47
    		 
        // Too much work to fix.
  • exonum-explorer-service 1.0.0/src/lib.rs
    75
    		 
        // '... may panic' lints.
    76
    		 
        clippy::indexing_slicing,
    77
    		 
        // Too much work to fix.
  • exonum-keys 1.0.0/src/lib.rs
    51
    		 
        // '... may panic' lints.
    52
    		 
        clippy::indexing_slicing,
    53
    		 
        // Too much work to fix.
  • exonum-merkledb 1.0.0/src/lib.rs
    156
    		 
        // '... may panic' lints.
    157
    		 
        clippy::indexing_slicing,
    158
    		 
        // Too much work to fix.
  • exonum-middleware-service 1.0.0/src/lib.rs
    49
    		 
        // '... may panic' lints.
    50
    		 
        clippy::indexing_slicing,
    51
    		 
        // Too much work to fix.
  • exonum-node 1.0.0/src/lib.rs
    51
    		 
        // '... may panic' lints.
    52
    		 
        clippy::indexing_slicing,
    53
    		 
        // Too much work to fix.
  • exonum-proto 1.0.0/src/lib.rs
    50
    		 
        // '... may panic' lints.
    51
    		 
        clippy::indexing_slicing,
    52
    		 
        // Too much work to fix.
  • exonum-rust-runtime 1.0.0/src/lib.rs
    316
    		 
        // '... may panic' lints.
    317
    		 
        clippy::indexing_slicing,
    318
    		 
        // Too much work to fix.
  • exonum-supervisor 1.0.0/src/lib.rs
    142
    		 
        // '... may panic' lints.
    143
    		 
        clippy::indexing_slicing,
    144
    		 
        // Too much work to fix.
  • exonum-system-api 1.0.0/src/lib.rs
    89
    		 
        // '... may panic' lints.
    90
    		 
        clippy::indexing_slicing,
    91
    		 
        // Too much work to fix.
  • exonum-testkit 1.0.0/src/lib.rs
    108
    		 
        // '... may panic' lints.
    109
    		 
        clippy::indexing_slicing,
    110
    		 
        // Too much work to fix.
  • exonum-time 1.0.0/src/lib.rs
    112
    		 
        // '... may panic' lints.
    113
    		 
        clippy::indexing_slicing,
    114
    		 
        // Too much work to fix.
  • get_env 0.1.0/src/lib.rs
    49
    		 
    	feature = "cargo-clippy",
    50
    		 
    	allow(type_complexity, option_option, indexing_slicing)
    51
    		 
    )]
  • girt-todo-file 2.2.0/src/lib.rs
    74
    		 
    // LINT-REPLACE-END
    75
    		 
    #![allow(clippy::indexing_slicing)]
  • icu_datetime 1.1.0/src/options/components.rs
    355
    		 
            {
    356
    		 
                #![allow(clippy::indexing_slicing)] // debug
    357
    		 
                debug_assert!(
  • icu_list 1.1.0/src/provider/mod.rs
    78
    		 
        pub(crate) fn start(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
    79
    		 
            #![allow(clippy::indexing_slicing)] // style as usize < 3
    80
    		 
            &self.0[4 * (style as usize)]
    83
    		 
        pub(crate) fn middle(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
    84
    		 
            #![allow(clippy::indexing_slicing)] // style as usize < 3
    85
    		 
            &self.0[4 * (style as usize) + 1]
    88
    		 
        pub(crate) fn end(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
    89
    		 
            #![allow(clippy::indexing_slicing)] // style as usize < 3
    90
    		 
            &self.0[4 * (style as usize) + 2]
    93
    		 
        pub(crate) fn pair(&self, style: ListLength) -> &ConditionalListJoinerPattern<'data> {
    94
    		 
            #![allow(clippy::indexing_slicing)] // style as usize < 3
    95
    		 
            &self.0[4 * (style as usize) + 3]
  • icu_provider_fs 1.1.0/src/export/mod.rs
    71
    		 
    #![allow(
    72
    		 
        clippy::indexing_slicing,
    73
    		 
        clippy::unwrap_used,
  • imdl 0.1.12/src/lib.rs
    7
    		 
      clippy::implicit_return,
    8
    		 
      clippy::indexing_slicing,
    9
    		 
      clippy::integer_arithmetic,
  • io-extras 0.17.1/src/os/windows/stdio.rs
    11
    		 
        clippy::integer_arithmetic,
    12
    		 
        clippy::indexing_slicing,
    13
    		 
        clippy::unwrap_used,
  • kukoo 0.1.0/src/map_inner.rs
    1
    		 
    #![allow(clippy::indexing_slicing)] // TODO: use safe method for indexing and remove this line.
  • lockfree-cuckoohash 0.1.0/src/map_inner.rs
    1
    		 
    #![allow(clippy::indexing_slicing)] // TODO: use safe method for indexing and remove this line.
  • lucia 0.5.0/src/network/transport/mock.rs
    2
    		 
      // Intended for testing environments
    3
    		 
      clippy::indexing_slicing
    4
    		 
    )]
  • matterdb 1.2.0/src/lib.rs
    102
    		 
        // '... may panic' lints.
    103
    		 
        clippy::indexing_slicing,
    104
    		 
        // Too much work to fix.
  • mecs 0.1.1/src/lib.rs
    27
    		 
    	#![allow(clippy::option_expect_used)] // ...
    28
    		 
    	#![allow(clippy::indexing_slicing  )] // We use [] when we want to panic if the value doesn't exist
    29
    		 
    	#![allow(clippy::unreachable       )] // We use unreachable when making assertions
  • metaldb 1.0.0/src/lib.rs
    101
    		 
        // '... may panic' lints.
    102
    		 
        clippy::indexing_slicing,
    103
    		 
        // Too much work to fix.
  • neodyn_xc 0.4.0/src/lib.rs
    69
    		 
             clippy::float_arithmetic, clippy::implicit_return,
    70
    		 
             clippy::indexing_slicing, clippy::inline_asm_x86_intel_syntax,
    71
    		 
             clippy::integer_arithmetic, clippy::integer_division,
  • notifier 0.1.3/src/lib.rs
    26
    		 
    	clippy::new_without_default,
    27
    		 
    	clippy::indexing_slicing,
    28
    		 
    	clippy::needless_pass_by_value,
  • rtop_dev 1.1.0/src/lib.rs
    63
    		 
        clippy::else_if_without_else,
    64
    		 
        clippy::indexing_slicing,
    65
    		 
        clippy::cast_possible_truncation,
  • rtop-rs 1.1.1/src/lib.rs
    22
    		 
        clippy::else_if_without_else,
    23
    		 
        clippy::indexing_slicing,
    24
    		 
        clippy::cast_possible_truncation,
  • serde_derive 1.0.152/src/lib.rs
    43
    		 
        clippy::enum_glob_use,
    44
    		 
        clippy::indexing_slicing,
    45
    		 
        clippy::items_after_statements,
  • serde_derive_state 0.4.10/src/lib.rs
    38
    		 
        clippy::filter_map,
    39
    		 
        clippy::indexing_slicing,
    40
    		 
        clippy::items_after_statements,
  • serde_json_experimental 1.0.29-rc1/src/lib.rs
    335
    		 
    // string ser/de uses indexing and slicing
    336
    		 
        indexing_slicing,
    337
    		 
    // things are often more readable this way
  • slice-deque 0.3.0/src/lib.rs
    139
    		 
        clippy::inline_always,
    140
    		 
        clippy::indexing_slicing
    141
    		 
    )]
  • slice-ring-buffer 0.3.2/src/lib.rs
    139
    		 
        clippy::inline_always,
    140
    		 
        clippy::indexing_slicing
    141
    		 
    )]
  • starling 4.0.0/src/lib.rs
    9
    		 
    #![allow(clippy::integer_arithmetic)]
    10
    		 
    #![allow(clippy::indexing_slicing)]
    11
    		 
    #![allow(clippy::cast_possible_truncation)]
  • swarm-bot 0.3.4/src/client/pathfind/incremental/mod.rs
    1
    		 
    #![allow(clippy::indexing_slicing)]
    2
    		 
    #![allow(clippy::unwrap_used)]
  • swarm-bot 0.3.4/src/main.rs
    62
    		 
        clippy::unwrap_used,
    63
    		 
        clippy::indexing_slicing,
    64
    		 
        clippy::panic,
  • tcp_typed 0.1.4/src/lib.rs
    32
    		 
    	clippy::if_not_else,
    33
    		 
    	clippy::indexing_slicing,
    34
    		 
    	clippy::new_ret_no_self,
  • vsmtp-protocol 2.0.1-rc.4/src/lib.rs
    44
    		 
    #![allow(clippy::std_instead_of_core)] // issue with thiserror
    45
    		 
    #![allow(clippy::indexing_slicing)] // issue with async_stream
  • wave-insight-lib 0.1.3/src/lib.rs
    42
    		 
        clippy::integer_arithmetic, // TODO
    43
    		 
        clippy::indexing_slicing, // TODO
    44
    		 
        clippy::unwrap_used, // TODO