160 |
impl Ord for AcceptEncoding {
|
161 |
#[allow(clippy::comparison_chain)]
|
162 |
fn cmp(&self, other: &AcceptEncoding) -> cmp::Ordering {
|
92 |
#[allow(clippy::comparison_chain)] // We're only matching 2/3 arms.
|
93 |
/// # Encode!
|
302 |
#[allow(clippy::comparison_chain)]
|
303 |
pub fn unblock(&self) -> bool {
|
353 |
let priority = record.transaction_priority();
|
354 |
#[allow(clippy::comparison_chain)]
|
355 |
if priority > running_priority {
|
60 |
#[allow(clippy::comparison_chain)]
|
61 |
fn build_evaluation(
|
60 |
#[allow(clippy::comparison_chain)]
|
61 |
fn build_evaluation(&self, previous_round: u64, latest_round: u64) -> EvaluationResult {
|
70 |
#[allow(clippy::comparison_chain)]
|
71 |
fn build_evaluation(
|
148 |
#[allow(clippy::comparison_chain)]
|
149 |
fn build_evaluation(
|
264 |
#[allow(clippy::comparison_chain)]
|
265 |
fn build_evaluation(
|
103 |
#[allow(clippy::comparison_chain)]
|
104 |
if self.count == self.limit {
|
20 |
// get file extension from filepath, return filename if not has exit
|
21 |
#[allow(clippy::comparison_chain)]
|
22 |
pub fn get_file_extension(filename: &str) -> String {
|
32 |
#[allow(clippy::comparison_chain)]
|
33 |
if state_types_from_args.len() == 1 {
|
11 |
/// Panics if the two Values do not overlap.
|
12 |
#[allow(clippy::comparison_chain)]
|
13 |
pub fn merge_into(one: Value, two: Value) -> (Value, Option<Value>, Option<Value>, Option<Value>) {
|
405 |
#[allow(clippy::comparison_chain)]
|
406 |
pub fn from_int(int: Integer, n_bytes: Integer) -> Result<Self, ByteArrayError> {
|
301 |
impl Ord for Fp {
|
302 |
#[allow(clippy::comparison_chain)]
|
303 |
fn cmp(&self, other: &Fp) -> cmp::Ordering {
|
473 |
// Returns `true` if `le_bytes` is less than the modulus (both are in non-Montgomery form).
|
474 |
#[allow(clippy::comparison_chain)]
|
475 |
fn is_valid(le_bytes: &[u8; 48]) -> bool {
|
487 |
// Returns `true` if `le_bytes` is less than the modulus (both are in non-Montgomery form).
|
488 |
#[allow(clippy::comparison_chain)]
|
489 |
fn is_valid_u64(le_bytes: &[u64; 6]) -> bool {
|
125 |
impl Ord for Scalar {
|
126 |
#[allow(clippy::comparison_chain)]
|
127 |
fn cmp(&self, other: &Scalar) -> cmp::Ordering {
|
440 |
/// Assumes that `a` is exactly 4 elements long.
|
441 |
#[allow(clippy::comparison_chain)]
|
442 |
fn is_valid(a: &[u64]) -> bool {
|
30 |
let suffix_len = suffix[4];
|
31 |
#[allow(clippy::comparison_chain)]
|
32 |
if suffix_len < MIN_SUFFIX_LEN {
|
120 |
/// Updates the scroll position to a selected index.
|
121 |
#[allow(clippy::comparison_chain)]
|
122 |
pub fn set_position(&mut self, new_index: usize) {
|
1702 |
impl PartialOrd for Decimal {
|
1703 |
#[allow(clippy::comparison_chain)]
|
1704 |
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
|
1724 |
impl Ord for Decimal {
|
1725 |
#[allow(clippy::comparison_chain)]
|
1726 |
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
79 |
let w = unicode_width::UnicodeWidthStr::width(s);
|
80 |
#[allow(clippy::comparison_chain)]
|
81 |
if w > dw {
|
355 |
#[allow(clippy::comparison_chain)]
|
356 |
pub fn stake_activating_and_deactivating(
|
796 |
#[inline]
|
797 |
#[allow(clippy::comparison_chain)]
|
798 |
fn try_push_impl<const HAE: bool>(&mut self, e: T) -> Result<(), ReservationError> {
|
847 |
#[inline]
|
848 |
#[allow(clippy::comparison_chain)]
|
849 |
pub fn pop(&mut self) -> Option<T> {
|
1081 |
#[inline]
|
1082 |
#[allow(clippy::comparison_chain)]
|
1083 |
fn try_insert_impl<const HAE: bool>(
|
1502 |
#[inline]
|
1503 |
#[allow(clippy::comparison_chain)]
|
1504 |
fn try_resize_with_impl<F, const HAE: bool>(
|
1728 |
#[inline]
|
1729 |
#[allow(clippy::comparison_chain)]
|
1730 |
fn try_resize_impl<const HAE: bool>(
|
11 |
// Clippy comparison_chain doesn't make any sense. It make the code _worse_
|
12 |
#[allow(clippy::comparison_chain)]
|
13 |
pub fn test_config(matches: &clap::ArgMatches) {
|
99 |
let mut new_tip = new_tip.clone();
|
100 |
#[allow(clippy::comparison_chain)]
|
101 |
if old_tip.number() > new_tip.number() {
|
83 |
#[must_use]
|
84 |
#[allow(clippy::comparison_chain)]
|
85 |
pub fn find_in_products(key: usize) -> usize {
|
384 |
#[allow(non_snake_case)]
|
385 |
#[allow(clippy::comparison_chain)]
|
386 |
fn _csc_quad_form<T: FloatT>(M: &CscMatrix<T>, y: &[T], x: &[T]) -> T {
|
103 |
#[allow(clippy::comparison_chain)]
|
104 |
if self.count == self.limit {
|
90 |
#[allow(clippy::comparison_chain)]
|
91 |
if new_limit > old_limit {
|
138 |
#[allow(clippy::comparison_chain)] // not feasible in const context
|
139 |
const fn update(mut self, byte: u8) -> (Self, Option<u8>) {
|
901 |
#[allow(clippy::comparison_chain)]
|
902 |
if symbol < self.last_symbol {
|
1174 |
#[test]
|
1175 |
#[allow(clippy::comparison_chain)]
|
1176 |
fn test_dblist() {
|
1982 |
#[allow(clippy::comparison_chain)]
|
1983 |
if ptr_offset > 0 {
|
2014 |
#[allow(clippy::comparison_chain)]
|
2015 |
if ptr_offset > 0 {
|
221 |
/// piece indices are valid.
|
222 |
#[allow(clippy::comparison_chain)]
|
223 |
pub fn piece_len(&self, index: PieceIndex) -> u32 {
|
1053 |
#[test]
|
1054 |
#[allow(clippy::comparison_chain)]
|
1055 |
fn test_dblist() {
|
104 |
debug_assert!(msg.contains("open_interest"));
|
105 |
#[allow(clippy::comparison_chain)]
|
106 |
if arr.len() > 1 {
|
81 |
} else if let Some(result) = rest_msg.result.as_array() {
|
82 |
#[allow(clippy::comparison_chain)]
|
83 |
if result.len() > 1 {
|
45 |
}
|
46 |
#[allow(clippy::comparison_chain)]
|
47 |
if rest_msg.data.len() > 1 {
|
99 |
}
|
100 |
#[allow(clippy::comparison_chain)]
|
101 |
if rest_msg.data.len() > 1 {
|
12 |
impl Ord for AcceptEncoding {
|
13 |
#[allow(clippy::comparison_chain)]
|
14 |
fn cmp(&self, other: &AcceptEncoding) -> cmp::Ordering {
|
360 |
impl From<&Decimal> for f64 {
|
361 |
#[allow(clippy::comparison_chain)]
|
362 |
#[inline]
|
109 |
for &p in &entry.parents {
|
110 |
#[allow(clippy::comparison_chain)]
|
111 |
if p == target { return true; }
|
32 |
impl std::cmp::Ord for TreeNode {
|
33 |
#[allow(clippy::comparison_chain)]
|
34 |
fn cmp(&self, other: &Self) -> Ordering {
|
352 |
#[allow(clippy::comparison_chain)]
|
353 |
pub fn stake_activating_and_deactivating(
|
352 |
#[allow(clippy::comparison_chain)]
|
353 |
pub fn stake_activating_and_deactivating(
|
429 |
#[allow(clippy::comparison_chain)]
|
430 |
unsafe fn insert_raw(&mut self, index: usize, f: impl FnOnce(*mut u8)) {
|
65 |
impl PartialEq for SourceAmount {
|
66 |
#[allow(clippy::comparison_chain)]
|
67 |
fn eq(&self, other: &Self) -> bool {
|
79 |
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
80 |
#[allow(clippy::comparison_chain)]
|
81 |
if self.base() == other.base() {
|
92 |
fn cmp(&self, other: &Self) -> Ordering {
|
93 |
#[allow(clippy::comparison_chain)]
|
94 |
if self.base() == other.base() {
|
107 |
#[allow(clippy::comparison_chain)]
|
108 |
fn add(self, a: SourceAmount) -> Self::Output {
|
121 |
#[allow(clippy::comparison_chain)]
|
122 |
fn sub(self, a: SourceAmount) -> Self::Output {
|
144 |
#[allow(clippy::comparison_chain)]
|
145 |
pub fn double_scalarmult_vartime(a_scalar: &[u8], a_point: GeP3, b_scalar: &[u8]) -> GeP2 {
|
160 |
impl Ord for AcceptEncoding {
|
161 |
#[allow(clippy::comparison_chain)]
|
162 |
fn cmp(&self, other: &AcceptEncoding) -> cmp::Ordering {
|
199 |
let total_output_value = sum_value(output_candidates.as_slice());
|
200 |
#[allow(clippy::comparison_chain)]
|
201 |
if total_output_value > total_input_value {
|
511 |
// Each parent or ancestor forks towards the node column.
|
512 |
#[allow(clippy::comparison_chain)]
|
513 |
for (&i, p) in parent_columns.iter() {
|
160 |
impl Ord for AcceptEncoding {
|
161 |
#[allow(clippy::comparison_chain)]
|
162 |
fn cmp(&self, other: &AcceptEncoding) -> cmp::Ordering {
|
34 |
// Otherwise, selects the nearest global index greater than global_index, that is stored on local_rank node, and returns that local index
|
35 |
#[allow(clippy::comparison_chain)]
|
36 |
fn to_local_index_ceiling(global_index: u64, local_rank: u64, total_nodes: u64) -> u64 {
|
287 |
let od = other.digit(i);
|
288 |
#[allow(clippy::comparison_chain)]
|
289 |
if sd < od {
|
109 |
#[allow(unused_must_use, clippy::comparison_chain)]
|
110 |
#[must_use]
|
25 |
/// Throws a `HandError::DuplicateCard` error if the two cards are identical.
|
26 |
#[allow(clippy::comparison_chain)]
|
27 |
pub fn new(first: U32Card, second: U32Card) -> Result<TwoCard, HandError> {
|
320 |
#[allow(clippy::comparison_chain)] // We're only matching 2/3.
|
321 |
#[allow(unsafe_code)]
|
348 |
// returned tuple is (effective, activating, deactivating) stake
|
349 |
#[allow(clippy::comparison_chain)]
|
350 |
pub fn stake_activating_and_deactivating(
|
469 |
/// instructing the terminal emulator to fill the background color rightwards.
|
470 |
#[allow(clippy::too_many_arguments, clippy::comparison_chain)]
|
471 |
fn pad_panel_line_to_width<'a>(
|
220 |
#[allow(clippy::comparison_chain)]
|
221 |
let must_split = if new_len < line_width {
|
380 |
/// with regard to the added wrapped lines.
|
381 |
#[allow(clippy::comparison_chain, clippy::type_complexity)]
|
382 |
pub fn wrap_minusplus_block<'c: 'a, 'a>(
|
580 |
#[allow(clippy::comparison_chain, clippy::type_complexity)]
|
581 |
pub fn wrap_zero_block<'c: 'a, 'a>(
|
471 |
/// instructing the terminal emulator to fill the background color rightwards.
|
472 |
#[allow(clippy::too_many_arguments, clippy::comparison_chain)]
|
473 |
fn pad_panel_line_to_width<'a>(
|
274 |
/// with regard to the added wrapped lines.
|
275 |
#[allow(clippy::comparison_chain, clippy::type_complexity)]
|
276 |
pub fn wrap_minusplus_block<'c: 'a, 'a>(
|
474 |
#[allow(clippy::comparison_chain, clippy::type_complexity)]
|
475 |
pub fn wrap_zero_block<'c: 'a, 'a>(
|
343 |
#[allow(clippy::comparison_chain)]
|
344 |
if bytes.len() < expected_buffer_size {
|
826 |
#[allow(clippy::comparison_chain)]
|
827 |
if bytes.len() < expected_buffer_size {
|
196 |
#[allow(clippy::comparison_chain)]
|
197 |
fn _create_comment_tree(q: &mut VecDeque<Comment>, parent: &mut Comment) {
|
129 |
pub fn resize_with_width(&mut self, new_size: usize, width: usize) {
|
130 |
#[allow(clippy::comparison_chain)]
|
131 |
if new_size < self.num_entries {
|
148 |
pub fn resize(&mut self, new_size: usize) {
|
149 |
#[allow(clippy::comparison_chain)]
|
150 |
if new_size < self.num_entries {
|
88 |
#[allow(clippy::comparison_chain)]
|
89 |
impl DspNode for MidiP {
|
1217 |
impl PartialOrd<Unit> for Duration {
|
1218 |
#[allow(clippy::identity_op, clippy::comparison_chain)]
|
1219 |
fn partial_cmp(&self, unit: &Unit) -> Option<Ordering> {
|
471 |
/// instructing the terminal emulator to fill the background color rightwards.
|
472 |
#[allow(clippy::too_many_arguments, clippy::comparison_chain)]
|
473 |
fn pad_panel_line_to_width<'a>(
|
363 |
/// with regard to the added wrapped lines.
|
364 |
#[allow(clippy::comparison_chain, clippy::type_complexity)]
|
365 |
pub fn wrap_minusplus_block<'c: 'a, 'a>(
|
563 |
#[allow(clippy::comparison_chain, clippy::type_complexity)]
|
564 |
pub fn wrap_zero_block<'c: 'a, 'a>(
|
26 |
fn add_whitespace(&mut self, span: Span, loc: LineColumn) -> Result<(), TokenStream> {
|
27 |
#[allow(clippy::comparison_chain)]
|
28 |
if loc.line > self.loc.line {
|
122 |
fn add_whitespace(&mut self, span: Span, loc: LineColumn) -> Result<(), TokenStream> {
|
123 |
#[allow(clippy::comparison_chain)]
|
124 |
if loc.line > self.loc.line {
|
419 |
#[allow(clippy::comparison_chain)]
|
420 |
let bits = if skip > 0 {
|
491 |
#[allow(clippy::comparison_chain)]
|
492 |
let mut bits = if offset > skip {
|
87 |
#[allow(clippy::comparison_chain)]
|
88 |
if new_start_bytes < current_start {
|
260 |
// Clippy complains about this but if I swap to a match expression, performance drops by 1%.
|
261 |
#[allow(clippy::comparison_chain)]
|
262 |
if char_pos == gap_chars {
|
369 |
#[allow(
|
370 |
clippy::comparison_chain,
|
371 |
clippy::needless_range_loop,
|
187 |
/// Get the sign of the given [`i8`]
|
188 |
#[allow(clippy::comparison_chain)] // Cannot use cmp in const function
|
189 |
pub const fn sign_i8(n: i8) -> Self {
|
201 |
/// Returns the sign of `a - b`, where `a` and `b` are usize
|
202 |
#[allow(clippy::comparison_chain)]
|
203 |
pub const fn sign_from_diff(a: usize, b: usize) -> Self {
|
376 |
/// This function does *NOT* set the `CommandBuffer::custom_capacity` override.
|
377 |
#[allow(clippy::comparison_chain)]
|
378 |
fn resize(&mut self) {
|
164 |
/// without any loss of precision.
|
165 |
#[allow(clippy::comparison_chain)]
|
166 |
pub fn negative_digit_comp<F: RawFloat, const FORMAT: u128>(
|
539 |
#[cfg(feature = "radix")]
|
540 |
#[allow(clippy::comparison_chain)]
|
541 |
pub fn byte_comp<F: RawFloat, const FORMAT: u128>(
|
485 |
/// This is the normal case for a finite number with non-zero significant digits.
|
486 |
#[allow(clippy::comparison_chain)]
|
487 |
pub fn compute_nearest_normal<F: RawFloat>(float: F) -> ExtendedFloat80 {
|
616 |
/// Compute the interval I = [w,w+).
|
617 |
#[allow(clippy::comparison_chain)]
|
618 |
pub fn compute_left_closed_directed<F: RawFloat>(float: F) -> ExtendedFloat80 {
|
702 |
/// Compute the interval I = (w−,w]..
|
703 |
#[allow(clippy::comparison_chain, clippy::if_same_then_else)]
|
704 |
pub fn compute_right_closed_directed<F: RawFloat>(float: F, shorter: bool) -> ExtendedFloat80 {
|
101 |
/// and the scientific notation's exponent digits.
|
102 |
#[allow(clippy::comparison_chain)]
|
103 |
pub unsafe fn write_float_scientific<const FORMAT: u128>(
|
169 |
/// significant digits and the leading zeros.
|
170 |
#[allow(clippy::comparison_chain)]
|
171 |
pub unsafe fn write_float_negative_exponent<const FORMAT: u128>(
|
431 |
#[inline]
|
432 |
#[allow(clippy::comparison_chain)]
|
433 |
pub unsafe fn truncate_and_round(
|
63 |
/// Safe as long as `digit_count <= digits.len()`.
|
64 |
#[allow(clippy::comparison_chain)]
|
65 |
#[cfg_attr(not(feature = "compact"), inline)]
|
2620 |
#[allow(clippy::comparison_chain)]
|
2621 |
if displacement < 0 {
|
54 |
#[allow(clippy::comparison_chain)]
|
55 |
if subdim > 2 {
|
54 |
#[allow(clippy::comparison_chain)]
|
55 |
while end != start {
|
40 |
#[ allow(clippy::comparison_chain) ]
|
41 |
if self.next_index > entries.len() {
|
64 |
fn step(&mut self) {
|
65 |
#[ allow(clippy::comparison_chain) ]
|
66 |
if self.block_pos == self.table.index.num_data_blocks() {
|
684 |
#[allow(clippy::comparison_chain)]
|
685 |
if platform_tags.len() > 2 {
|
429 |
#[allow(clippy::comparison_chain)]
|
430 |
pub(super) fn tokenize<'a>(source: &'a str) -> Result<Tokens<'a>, &'static str> {
|
114 |
/// without any loss of precision.
|
115 |
#[allow(clippy::comparison_chain)]
|
116 |
pub fn negative_digit_comp<F: Float>(
|
743 |
#[allow(clippy::comparison_chain)]
|
744 |
pub fn double_scalarmult_vartime(a_scalar: &[u8], a_point: GeP3, b_scalar: &[u8]) -> GeP2 {
|
238 |
impl<'a, W: InnerWriterTrait> Write for EncryptionLayerWriter<'a, W> {
|
239 |
#[allow(clippy::comparison_chain)]
|
240 |
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
79 |
#[allow(clippy::comparison_chain)]
|
80 |
if line > prev_line {
|
2650 |
if let Some(previous_association) = entries.last() {
|
2651 |
#[allow(clippy::comparison_chain)]
|
2652 |
if previous_association.item_id > item_id {
|
179 |
// Solve the subproblem.
|
180 |
#[allow(clippy::comparison_chain)]
|
181 |
if subdim > 2 {
|
136 |
#[allow(clippy::comparison_chain)]
|
137 |
if subdim > 2 {
|
119 |
// TODO: rewrite using ioctl!
|
120 |
#[allow(clippy::comparison_chain)]
|
121 |
{
|
140 |
impl Ord for AcceptEncoding {
|
141 |
#[allow(clippy::comparison_chain)]
|
142 |
fn cmp(&self, other: &AcceptEncoding) -> cmp::Ordering {
|
558 |
#[allow(clippy::comparison_chain)]
|
559 |
if count > 2 {
|
302 |
let size = unsafe { winnls::GetLocaleInfoEx(lpLocaleName, LCType, buf_ptr, size) };
|
303 |
#[allow(clippy::comparison_chain)]
|
304 |
if size == 0 {
|
627 |
/// Returns the celestial state as computed from a de4xx.{FXB,XB} file in the original frame
|
628 |
#[allow(clippy::comparison_chain)]
|
629 |
pub fn raw_celestial_state(&self, path: &[usize], epoch: Epoch) -> Result<Orbit, NyxError> {
|
454 |
/// Differential correction using finite differencing
|
455 |
#[allow(clippy::comparison_chain)]
|
456 |
pub fn minimize(
|
35 |
/// Differential correction using finite differencing
|
36 |
#[allow(clippy::comparison_chain)]
|
37 |
pub fn try_achieve_fd(
|
31 |
/// Differential correction using hyperdual numbers for the objectives
|
32 |
#[allow(clippy::comparison_chain)]
|
33 |
pub fn try_achieve_dual(
|
665 |
// match, use them.
|
666 |
#[allow(clippy::comparison_chain)]
|
667 |
if fnd_buf.len() == needed {
|
399 |
/// Write blocks to bucket with ID `bucket_id`
|
400 |
#[allow(clippy::comparison_chain)]
|
401 |
fn write_bucket(&mut self, bucket_id: i64, mut blocks: Vec<Block>) {
|
67 |
// https://github.com/rust-lang/rust-clippy/issues/5354
|
68 |
#[allow(clippy::comparison_chain)]
|
69 |
while x >= y {
|
31 |
sorted_imports.sort_by(|a, b| {
|
32 |
#[allow(clippy::comparison_chain)]
|
33 |
if a.0.len() > b.0.len() {
|
26 |
impl<T: PartialEq, G: Genotype<T>> Crossover<T, G> for CrossoverFunctions {
|
27 |
#[allow(clippy::comparison_chain)]
|
28 |
fn cross(&self, ind1: &G, ind2: &G) -> (G, G) {
|
833 |
#[allow(clippy::comparison_chain)]
|
834 |
slide_bp
|
718 |
#[allow(clippy::comparison_chain)]
|
719 |
fn quarter(s: &str, count: usize) -> IResult<&str, String, DateTimeError<&str>> {
|
7 |
#[allow(
|
8 |
clippy::comparison_chain,
|
9 |
clippy::cast_possible_wrap,
|
171 |
#[allow(clippy::comparison_chain)]
|
172 |
pub fn get_applicable_rules(&self, args: &[Term], i: usize) -> RuleSet {
|
405 |
{
|
406 |
#[allow(clippy::comparison_chain)]
|
407 |
pub fn try_read(&self, index: usize, readers: &AtomicUsize, cx: &Context<'_>) -> TryRead<T> {
|
257 |
#[allow(clippy::comparison_chain)]
|
258 |
if next_count > mode_count {
|
188 |
for (naf, lookup_table) in nafs.iter().zip(lookup_tables.iter()) {
|
189 |
#[allow(clippy::comparison_chain)]
|
190 |
if naf[i] > 0 {
|
199 |
for (naf, lookup_table) in nafs.iter().zip(lookup_tables.iter()) {
|
200 |
#[allow(clippy::comparison_chain)]
|
201 |
if naf[i] > 0 {
|
210 |
let mb = mirror.borrow_and_update().await.unwrap();
|
211 |
#[allow(clippy::comparison_chain)]
|
212 |
if mb.len() < len {
|
210 |
let mb = mirror.borrow_and_update().await.unwrap();
|
211 |
#[allow(clippy::comparison_chain)]
|
212 |
if mb.len() < len {
|
215 |
let mb = mirror.borrow_and_update().await.unwrap();
|
216 |
#[allow(clippy::comparison_chain)]
|
217 |
if mb.len() < len {
|
210 |
let mb = mirror.borrow_and_update().await.unwrap();
|
211 |
#[allow(clippy::comparison_chain)]
|
212 |
if mb.len() < len {
|
210 |
let mb = mirror.borrow_and_update().await.unwrap();
|
211 |
#[allow(clippy::comparison_chain)]
|
212 |
if mb.len() < len {
|
215 |
let mb = mirror.borrow_and_update().await.unwrap();
|
216 |
#[allow(clippy::comparison_chain)]
|
217 |
if mb.len() < len {
|
160 |
impl Ord for AcceptEncoding {
|
161 |
#[allow(clippy::comparison_chain)]
|
162 |
fn cmp(&self, other: &AcceptEncoding) -> cmp::Ordering {
|
194 |
}
|
195 |
#[allow(clippy::comparison_chain)]
|
196 |
unsafe impl VTabCursor for SeriesTabCursor<'_> {
|
194 |
}
|
195 |
#[allow(clippy::comparison_chain)]
|
196 |
unsafe impl VTabCursor for SeriesTabCursor<'_> {
|
259 |
/// Read some bytes from `rd`, and add them to our internal buffer.
|
260 |
#[allow(clippy::comparison_chain)]
|
261 |
pub fn read(&mut self, rd: &mut dyn io::Read) -> io::Result<usize> {
|
317 |
fn discard(&mut self, taken: usize) {
|
318 |
#[allow(clippy::comparison_chain)]
|
319 |
if taken < self.used {
|
38 |
#[allow(clippy::comparison_chain)]
|
39 |
if cmp == 0 {
|
45 |
let w = unicode_width::UnicodeWidthStr::width(s);
|
46 |
#[allow(clippy::comparison_chain)]
|
47 |
if w > dw {
|
355 |
#[allow(clippy::comparison_chain)]
|
356 |
pub fn stake_activating_and_deactivating(
|
160 |
impl Ord for AcceptEncoding {
|
161 |
#[allow(clippy::comparison_chain)]
|
162 |
fn cmp(&self, other: &AcceptEncoding) -> cmp::Ordering {
|
10 |
#[allow(clippy::comparison_chain)]
|
11 |
unsafe extern "C" fn read<T: Read + Seek>(
|
514 |
#[cfg(test)]
|
515 |
#[allow(clippy::comparison_chain)]
|
516 |
mod tests {
|
559 |
#[cfg(test)]
|
560 |
#[allow(clippy::comparison_chain)]
|
561 |
mod tests {
|
297 |
#[inline]
|
298 |
#[allow(clippy::comparison_chain)]
|
299 |
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
297 |
#[inline]
|
298 |
#[allow(clippy::comparison_chain)]
|
299 |
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
355 |
#[allow(clippy::comparison_chain)]
|
356 |
pub fn stake_activating_and_deactivating(
|
736 |
#[allow(clippy::comparison_chain)]
|
737 |
match (&from, to) {
|
411 |
#[allow(clippy::comparison_chain)]
|
412 |
match (&from, &to) {
|
5144 |
#[allow(clippy::comparison_chain)]
|
5145 |
return if name_matches == 0 {
|
27 |
// comparison chain is actually cleaner here IMO
|
28 |
#[allow(clippy::comparison_chain)]
|
29 |
if count == 1 {
|
347 |
#[allow(clippy::comparison_chain)]
|
348 |
if context_changes.len() == 1 {
|
383 |
#[allow(clippy::comparison_chain)]
|
384 |
if context_changes.len() == 1 {
|
157 |
if let Some(content_length) = content_length {
|
158 |
#[allow(clippy::comparison_chain)]
|
159 |
if request_buffer[offset..].len() == content_length {
|
131 |
#[inline]
|
132 |
#[allow(clippy::comparison_chain)]
|
133 |
// Looks for the element in the block. Returns the positions if found.
|
931 |
#[allow(clippy::cognitive_complexity, clippy::comparison_chain)]
|
932 |
fn emit_message_default(
|
471 |
// Else, check if we need to jump ahead
|
472 |
#[allow(clippy::comparison_chain)]
|
473 |
if msg.round.0 < self.block.round().number.0 {
|
658 |
#[allow(clippy::comparison_chain)] // I think this is easier to understand this way
|
659 |
let new_row = if dir < 0 {
|
186 |
/// Ensures that this pool key is canonical. If the two denoms are the same, returns None.
|
187 |
#[allow(clippy::comparison_chain)]
|
188 |
fn to_canonical(self) -> Option<Self> {
|
64 |
// TODO(tarcieri): rewrite this logic to follow Tendermint spec and be clippy-friendly
|
65 |
#[allow(clippy::comparison_chain)]
|
66 |
pub fn update_consensus_state(
|
268 |
{
|
269 |
#[allow(clippy::comparison_chain)]
|
270 |
#[must_use]
|
169 |
{
|
170 |
#[allow(clippy::comparison_chain)]
|
171 |
fn rotate(&self, amount: i8) -> Self {
|
32 |
/// directly and has better runtime and memory performance.
|
33 |
#[allow(clippy::comparison_chain)]
|
34 |
#[must_use]
|
61 |
/// directly and has better runtime and memory performance.
|
62 |
#[allow(clippy::comparison_chain)]
|
63 |
fn rotate_mut(&mut self, amount: i8) {
|
130 |
let succ = &mut self.nodes[inlet.node];
|
131 |
#[allow(clippy::comparison_chain)]
|
132 |
if inlet.slot == succ.inputs.len() {
|
329 |
let bias = &inputs[2];
|
330 |
#[allow(clippy::comparison_chain)]
|
331 |
if bias.rank() > 1 {
|
100 |
#[allow(clippy::comparison_chain)]
|
101 |
if let Some(bias) = &self.bias {
|
202 |
// https://github.com/google/gemmlowp/blob/13d57703abca3005d97b19df1f2db731607a7dc2/fixedpoint/fixedpoint.h#L385
|
203 |
#[allow(clippy::comparison_chain)] // nah
|
204 |
pub fn saturating_rounding_multiply_by_pot(x: i32, exponent: i32) -> i32 {
|
166 |
for axis in 0..data.ndim() {
|
167 |
#[allow(clippy::comparison_chain)]
|
168 |
if output_shape[axis] == data.shape()[axis] {
|
511 |
#[allow(clippy::comparison_chain)]
|
512 |
#[inline]
|
1763 |
#[allow(clippy::comparison_chain)]
|
1764 |
fn outline_var_impl(
|
155 |
// write partial len
|
156 |
#[allow(clippy::comparison_chain)]
|
157 |
if total < 2 {
|
71 |
// TODO: Use exclusive range pattern when it will be possible.
|
72 |
#[allow(clippy::comparison_chain)]
|
73 |
if pos > N {
|
441 |
// compare text: for instance, "RC1" will be less than "RC2", so this works out.
|
442 |
#[allow(clippy::comparison_chain)]
|
443 |
if val_lwr < other_val_lwr {
|
288 |
// Also, the risk of having non-exhaustive checks is low.
|
289 |
#[allow(clippy::comparison_chain)]
|
290 |
pub fn block_signal(num: c_int) -> SignalResult<()> {
|
355 |
#[allow(clippy::comparison_chain)]
|
356 |
pub fn stake_activating_and_deactivating(
|
61 |
#[allow(clippy::comparison_chain)]
|
62 |
async fn add(client: &mut Client, args: &[String]) {
|
2125 |
#[allow(clippy::cognitive_complexity)]
|
2126 |
#[allow(clippy::comparison_chain)]
|
2127 |
#[allow(clippy::while_let_on_iterator)]
|
119 |
// TODO: [refactor] [beginner] [small] rewrite
|
120 |
#[allow(clippy::comparison_chain)]
|
121 |
pub fn mul(p: &Affine, scalar: &ScalarFieldElement) -> Jacobian {
|
147 |
// TODO: [refactor] [beginner] [small] rewrite
|
148 |
#[allow(clippy::comparison_chain)]
|
149 |
pub fn double_mul(
|
188 |
// TODO: [refactor] [beginner] [small] rewrite
|
189 |
#[allow(clippy::comparison_chain)]
|
190 |
#[must_use]
|
214 |
// TODO: [refactor] [beginner] [small] rewrite
|
215 |
#[allow(clippy::comparison_chain)]
|
216 |
#[must_use]
|
337 |
#[allow(clippy::many_single_char_names)]
|
338 |
#[allow(clippy::comparison_chain)]
|
339 |
fn is_boundary(x: usize, boundaries: &[usize; 32]) -> Option<usize> {
|
306 |
#![allow(
|
307 |
clippy::comparison_chain,
|
308 |
clippy::deprecated_cfg_attr,
|
17 |
//! ```
|
18 |
#![allow(clippy::comparison_chain)]
|
19 |
#![allow(clippy::manual_range_contains)]
|
191 |
#![allow(clippy::needless_range_loop)]
|
192 |
#![allow(clippy::comparison_chain)]
|
193 |
#![cfg_attr(feature = "try_support", feature(try_trait_v2))]
|
6 |
#![allow(clippy::needless_range_loop)]
|
7 |
#![allow(clippy::comparison_chain)]
|
8 |
#![cfg_attr(feature = "const_support", feature(const_trait_impl))]
|
4 |
#![allow(clippy::new_without_default)]
|
5 |
#![allow(clippy::comparison_chain)]
|
6 |
#![warn(missing_docs)]
|
285 |
#![allow(clippy::new_without_default)]
|
286 |
#![allow(clippy::comparison_chain)]//is this really clearer???
|
287 |
#![allow(clippy::single_match)]
|
12 |
)]
|
13 |
#![allow(clippy::comparison_chain)]
|
1 |
#![allow(clippy::collapsible_if)]
|
2 |
#![allow(clippy::comparison_chain)]
|
5 |
#![allow(clippy::needless_return)]
|
6 |
#![allow(clippy::comparison_chain)]
|
7 |
// Clippy is confused by the complex configuration
|
43 |
#![feature(core_intrinsics)]
|
44 |
#![allow(clippy::comparison_chain)]
|
45 |
#![allow(clippy::enum_variant_names)]
|
1 |
#![doc = include_str!("../README.md")]
|
2 |
#![allow(clippy::comparison_chain)]
|
3 |
#![allow(clippy::len_without_is_empty)]
|
1 |
#![allow(clippy::comparison_chain)]
|
2 |
#![allow(clippy::manual_range_contains)]
|
47 |
clippy::collapsible_else_if,
|
48 |
clippy::comparison_chain,
|
49 |
clippy::match_same_arms,
|
6 |
#![allow(clippy::cast_lossless)]
|
7 |
#![allow(clippy::comparison_chain)]
|
8 |
#![allow(clippy::int_plus_one)]
|
2 |
#![allow(clippy::bool_to_int_with_if)]
|
3 |
#![allow(clippy::comparison_chain)]
|
4 |
#![allow(clippy::if_same_then_else)]
|
56 |
clippy::cast_sign_loss,
|
57 |
clippy::comparison_chain,
|
58 |
clippy::doc_markdown,
|
84 |
#![deny(rust_2018_idioms)]
|
85 |
#![allow(clippy::comparison_chain)]
|
1 |
#![allow(clippy::comparison_chain)] // I think the two instances in here are clearer written the way they are
|
15 |
clippy::too_many_arguments,
|
16 |
clippy::comparison_chain
|
17 |
)]
|
43 |
#![allow(clippy::nonminimal_bool)]
|
44 |
#![allow(clippy::comparison_chain)]
|
45 |
#![allow(clippy::needless_lifetimes)]
|
5 |
// hard to read code.
|
6 |
#![allow(clippy::comparison_chain)]
|
1 |
#![recursion_limit = "1024"]
|
2 |
#![allow(clippy::comparison_chain)]
|
31 |
#![allow(clippy::collapsible_else_if)]
|
32 |
#![allow(clippy::comparison_chain)]
|
33 |
#![allow(clippy::manual_range_contains)]
|
84 |
#![deny(rust_2018_idioms)]
|
85 |
#![allow(clippy::comparison_chain)]
|
76 |
clippy::wildcard_imports,
|
77 |
clippy::comparison_chain,
|
78 |
clippy::bool_to_int_with_if,
|
76 |
clippy::wildcard_imports,
|
77 |
clippy::comparison_chain,
|
78 |
clippy::bool_to_int_with_if,
|
41 |
#![allow(clippy::comparison_chain)]
|
42 |
#![allow(clippy::cognitive_complexity)]
|
37 |
clippy::cognitive_complexity,
|
38 |
clippy::comparison_chain,
|
39 |
clippy::default_trait_access,
|
37 |
clippy::cognitive_complexity,
|
38 |
clippy::comparison_chain,
|
39 |
clippy::default_trait_access,
|
84 |
#![deny(rust_2018_idioms)]
|
85 |
#![allow(clippy::comparison_chain)]
|
22 |
#![allow(clippy::single_match)]
|
23 |
#![allow(clippy::comparison_chain)]
|
24 |
#![allow(clippy::inconsistent_struct_constructor)]
|
59 |
#![allow(clippy::collapsible_if)]
|
60 |
#![allow(clippy::comparison_chain)]
|
61 |
#![allow(clippy::match_like_matches_macro)]
|
45 |
#![allow(clippy::new_without_default)]
|
46 |
#![allow(clippy::comparison_chain)]
|
47 |
use std::io;
|
2 |
#![warn(clippy::cargo)]
|
3 |
#![allow(clippy::comparison_chain)]
|
4 |
#![doc = include_str!("../README.md")]
|
47 |
#![allow(clippy::missing_safety_doc)]
|
48 |
#![allow(clippy::comparison_chain)]
|
49 |
#![allow(clippy::upper_case_acronyms)]
|
73 |
pub fn pad_left(&self, len: usize) -> Result<ByteVector, Error> {
|
74 |
#![allow(clippy::unknown_clippy_lints, clippy::comparison_chain)]
|
92 |
pub fn pad_right(&self, len: usize) -> Result<ByteVector, Error> {
|
93 |
#![allow(clippy::unknown_clippy_lints, clippy::comparison_chain)]
|
23 |
)]
|
24 |
#![allow(clippy::comparison_chain)]
|
25 |
#![doc(html_no_source)]
|
306 |
clippy::collapsible_else_if,
|
307 |
clippy::comparison_chain,
|
308 |
clippy::deprecated_cfg_attr,
|
6 |
clippy::cast_sign_loss,
|
7 |
clippy::comparison_chain,
|
8 |
clippy::doc_markdown,
|
314 |
#![allow(
|
315 |
clippy::comparison_chain,
|
316 |
clippy::deprecated_cfg_attr,
|
306 |
#![allow(
|
307 |
clippy::comparison_chain,
|
308 |
clippy::deprecated_cfg_attr,
|
6 |
clippy::collapsible_if,
|
7 |
clippy::comparison_chain,
|
8 |
clippy::derive_partial_eq_without_eq,
|
6 |
clippy::collapsible_if,
|
7 |
clippy::comparison_chain,
|
8 |
clippy::derive_partial_eq_without_eq,
|
9 |
// expressions.
|
10 |
#![allow(clippy::comparison_chain)]
|
1 |
#![allow(clippy::comparison_chain)]
|
2 |
#![doc = include_str!("../README.md")]
|
1 |
#![allow(clippy::comparison_chain)]
|
387 |
#![allow(clippy::wrong_self_convention)]
|
388 |
#![allow(clippy::comparison_chain)]
|
389 |
#![allow(clippy::missing_safety_doc)]
|
13 |
#![warn(clippy::pedantic)]
|
14 |
#![allow(clippy::comparison_chain)]
|
15 |
// TODO: check https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
|
5 |
#![recursion_limit = "1024"]
|
6 |
#![allow(clippy::comparison_chain)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
9 |
// justification.
|
10 |
#![allow(clippy::comparison_chain)]
|
11 |
#![allow(clippy::excessive_precision)]
|
10 |
// justification.
|
11 |
#![allow(clippy::comparison_chain)]
|
12 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
11 |
// justification.
|
12 |
#![allow(clippy::comparison_chain)]
|
13 |
#![allow(clippy::excessive_precision)]
|
9 |
// justification.
|
10 |
#![allow(clippy::comparison_chain)]
|
11 |
#![allow(clippy::excessive_precision)]
|
1 |
#![feature(negative_impls)]
|
2 |
#![allow(clippy::comparison_chain)]
|
3 |
#![allow(unused, dead_code)]
|
1 |
#![allow(clippy::comparison_chain)]
|
2 |
use std::cmp;
|
1 |
#![allow(clippy::comparison_chain)]
|
2 |
use std::fmt;
|
144 |
#![allow(clippy::comparison_chain, clippy::missing_safety_doc)]
|
19 |
#![allow(clippy::collapsible_if)]
|
20 |
#![allow(clippy::comparison_chain)]
|
21 |
#![allow(clippy::enum_variant_names)]
|
8 |
clippy::collapsible_if,
|
9 |
clippy::comparison_chain
|
10 |
)]
|
1822 |
fn month_compare(a: &str, b: &str) -> Ordering {
|
1823 |
#![allow(clippy::comparison_chain)]
|
1824 |
let ma = month_parse(a);
|
11 |
clippy::enum_variant_names,
|
12 |
clippy::comparison_chain,
|
13 |
clippy::option_map_unit_fn,
|
6 |
clippy::large_enum_variant,
|
7 |
clippy::comparison_chain,
|
8 |
clippy::derive_ord_xor_partial_ord,
|
78 |
clippy::unusual_byte_groupings,
|
79 |
clippy::comparison_chain
|
80 |
)]
|
1 |
#![allow(clippy::comparison_chain)]
|
1 |
#![allow(clippy::comparison_chain)]
|
1 |
#![allow(clippy::comparison_chain)]
|
2 |
//! A pure-Rust library to manage extended attributes.
|