Bump rest of versions #410
clippy
273 warnings
Details
Results
| Message level | Amount |
|---|---|
| Internal compiler error | 0 |
| Error | 0 |
| Warning | 273 |
| Note | 0 |
| Help | 0 |
Versions
- rustc 1.79.0 (129f3b996 2024-06-10)
- cargo 1.79.0 (ffa9cf99a 2024-06-03)
- clippy 0.1.79 (129f3b9 2024-06-10)
Annotations
Check warning on line 653 in specta-zod/src/lib.rs
github-actions / clippy
`panic` should not be present in production code
warning: `panic` should not be present in production code
--> specta-zod/src/lib.rs:653:22
|
653 | _ => panic!("unhandled literal type!"),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#panic
= note: requested on the command line with `-W clippy::panic`
Check warning on line 119 in specta-zod/src/lib.rs
github-actions / clippy
this expression always evaluates to true
warning: this expression always evaluates to true
--> specta-zod/src/lib.rs:119:47
|
119 | let prefix = match start_with_newline && !comments.is_empty() {
| ^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#const_is_empty
= note: `-W clippy::const-is-empty` implied by `-W clippy::all`
= help: to override `-W clippy::all` add `#[allow(clippy::const_is_empty)]`
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-zod` is missing `package.readme` metadata
warning: package `specta-zod` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-util` is missing `package.readme` metadata
warning: package `specta-util` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-typescript` is missing `package.readme` metadata
warning: package `specta-typescript` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-swift` is missing `package.readme` metadata
warning: package `specta-swift` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-serde` is missing `package.readme` metadata
warning: package `specta-serde` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-rust` is missing `package.readme` metadata
warning: package `specta-rust` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-openapi` is missing `package.readme` metadata
warning: package `specta-openapi` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-kotlin` is missing `package.readme` metadata
warning: package `specta-kotlin` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-go` is missing `package.readme` metadata
warning: package `specta-go` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta-datatype-from` is missing `package.readme` metadata
warning: package `specta-datatype-from` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
Check warning on line 1 in specta-zod/src/lib.rs
github-actions / clippy
package `specta` is missing `package.readme` metadata
warning: package `specta` is missing `package.readme` metadata
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
= note: `-W clippy::cargo-common-metadata` implied by `-W clippy::cargo`
= help: to override `-W clippy::cargo` add `#[allow(clippy::cargo_common_metadata)]`
Check warning on line 8 in specta-zod/src/context.rs
github-actions / clippy
field `0` is never read
warning: field `0` is never read
--> specta-zod/src/context.rs:8:18
|
8 | TypeExtended(Cow<'static, str>, ImplLocation),
| ------------ ^^^^^^^^^^^^^^^^^
| |
| field in this variant
|
= note: `#[warn(dead_code)]` on by default
help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field
|
8 | TypeExtended((), ImplLocation),
| ~~
Check warning on line 796 in specta-typescript/src/lib.rs
github-actions / clippy
passing a unit value to a function
warning: passing a unit value to a function
--> specta-typescript/src/lib.rs:656:5
|
656 | / Ok(match &e.repr() {
657 | | EnumRepr::Untagged => {
658 | | let mut variants = e
659 | | .variants()
... |
795 | | }
796 | | })
| |______^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
help: move the expression in front of the call and replace it with the unit literal `()`
|
656 ~ match &e.repr() {
657 + EnumRepr::Untagged => {
658 + let mut variants = e
659 + .variants()
660 + .iter()
661 + .filter(|(_, variant)| !variant.skip())
662 + .map(|(name, variant)| {
663 + Ok(match variant.inner() {
664 + EnumVariants::Unit => NULL.to_string(),
665 + _ => inner_comments(
666 + ctx.clone(),
667 + variant.deprecated(),
668 + variant.docs(),
669 + enum_variant_datatype(
670 + ctx.with(PathItem::Variant(name.clone())),
671 + type_map,
672 + name.clone(),
673 + variant,
674 + )?
675 + .expect("Invalid Serde type"),
676 + true,
677 + ),
678 + })
679 + })
680 + .collect::<Result<Vec<_>>>()?;
681 + variants.dedup();
682 + s.push_str(&variants.join(" | "));
683 + }
684 + repr => {
685 + let mut variants = e
686 + .variants()
687 + .iter()
688 + .filter(|(_, variant)| !variant.skip())
689 + .map(|(variant_name, variant)| {
690 + let sanitised_name = sanitise_key(variant_name.clone(), true);
691 +
692 + Ok(inner_comments(
693 + ctx.clone(),
694 + variant.deprecated(),
695 + variant.docs(),
696 + match (repr, &variant.inner()) {
697 + (EnumRepr::Untagged, _) => unreachable!(),
698 + (EnumRepr::Internal { tag }, EnumVariants::Unit) => {
699 + format!("{{ {tag}: {sanitised_name} }}")
700 + }
701 + (EnumRepr::Internal { tag }, EnumVariants::Unnamed(tuple)) => {
702 + let fields = skip_fields(tuple.fields()).collect::<Vec<_>>();
703 +
704 + // This field is only required for `{ty}` not `[...]` so we only need to check when there one field
705 + let dont_join_ty = if tuple.fields().len() == 1 {
706 + let (_, ty) = fields.first().expect("checked length above");
707 + validate_type_for_tagged_intersection(
708 + ctx.clone(),
709 + (**ty).clone(),
710 + type_map,
711 + )?
712 + } else {
713 + false
714 + };
715 +
716 + let mut typ = String::new();
717 +
718 + unnamed_fields_datatype(ctx.clone(), &fields, type_map, &mut typ)?;
719 +
720 + if dont_join_ty {
721 + format!("({{ {tag}: {sanitised_name} }})")
722 + } else {
723 + // We wanna be sure `... & ... | ...` becomes `... & (... | ...)`
724 + if typ.contains('|') {
725 + typ = format!("({typ})");
726 + }
727 + format!("({{ {tag}: {sanitised_name} }} & {typ})")
728 + }
729 + }
730 + (EnumRepr::Internal { tag }, EnumVariants::Named(obj)) => {
731 + let mut fields = vec![format!("{tag}: {sanitised_name}")];
732 +
733 + for (name, field) in skip_fields_named(obj.fields()) {
734 + let mut other = String::new();
735 + object_field_to_ts(
736 + ctx.with(PathItem::Field(name.clone())),
737 + name.clone(),
738 + field,
739 + type_map,
740 + &mut other,
741 + )?;
742 + fields.push(other);
743 + }
744 +
745 + format!("{{ {} }}", fields.join("; "))
746 + }
747 + (EnumRepr::External, EnumVariants::Unit) => sanitised_name.to_string(),
748 + (EnumRepr::External, _) => {
749 + let ts_values = enum_variant_datatype(
750 + ctx.with(PathItem::Variant(variant_name.clone())),
751 + type_map,
752 + variant_name.clone(),
753 + variant,
754 + )?;
755 + let sanitised_name = sanitise_key(variant_name.clone(), false);
756 +
757 + match ts_values {
758 + Some(ts_values) => {
759 + format!("{{ {sanitised_name}: {ts_values} }}")
760 + }
761 + None => format!(r#""{sanitised_name}""#),
762 + }
763 + }
764 + (EnumRepr::Adjacent { tag, .. }, EnumVariants::Unit) => {
765 + format!("{{ {tag}: {sanitised_name} }}")
766 + }
767 + (EnumRepr::Adjacent { tag, content }, _) => {
768 + let ts_value = enum_variant_datatype(
769 + ctx.with(PathItem::Variant(variant_name.clone())),
770 + type_map,
771 + variant_name.clone(),
772 + variant,
773 + )?;
774 +
775 + let mut s = String::new();
776 +
777 + s.push_str("{ ");
778 +
779 + write!(s, "{tag}: {sanitised_name}")?;
780 + if let Some(ts_value) = ts_value {
781 + write!(s, "; {content}: {ts_value}")?;
782 + }
783 +
784 + s.push_str(" }");
785 +
786 + s
787 + }
788 + },
789 + true,
790 + ))
791 + })
792 + .collect::<Result<Vec<_>>>()?;
793 + variants.dedup();
794 + s.push_str(&variants.join(" | "));
795 + }
796 + };
797 + Ok(())
|
Check warning on line 513 in specta-typescript/src/lib.rs
github-actions / clippy
passing a unit value to a function
warning: passing a unit value to a function
--> specta-typescript/src/lib.rs:510:24
|
510 | return Ok(match named.tag().as_ref() {
| ________________________^
511 | | Some(tag) => write!(s, r#"{{ "{tag}": "{key}" }}"#)?,
512 | | None => write!(s, "Record<{STRING}, {NEVER}>")?,
513 | | });
| |__________________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
help: move the expression in front of the call and replace it with the unit literal `()`
|
510 ~ return {
511 + match named.tag().as_ref() {
512 + Some(tag) => write!(s, r#"{{ "{tag}": "{key}" }}"#)?,
513 + None => write!(s, "Record<{STRING}, {NEVER}>")?,
514 + };
515 + Ok(())
516 ~ };
|
Check warning on line 570 in specta-typescript/src/lib.rs
github-actions / clippy
passing a unit value to a function
warning: passing a unit value to a function
--> specta-typescript/src/lib.rs:498:5
|
498 | / Ok(match &strct.fields() {
499 | | StructFields::Unit => s.push_str(NULL),
500 | | StructFields::Unnamed(unnamed) => unnamed_fields_datatype(
501 | | ctx,
... |
569 | | }
570 | | })
| |______^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
help: move the expression in front of the call and replace it with the unit literal `()`
|
498 ~ match &strct.fields() {
499 + StructFields::Unit => s.push_str(NULL),
500 + StructFields::Unnamed(unnamed) => unnamed_fields_datatype(
501 + ctx,
502 + &skip_fields(unnamed.fields()).collect::<Vec<_>>(),
503 + type_map,
504 + s,
505 + )?,
506 + StructFields::Named(named) => {
507 + let fields = skip_fields_named(named.fields()).collect::<Vec<_>>();
508 +
509 + if fields.is_empty() {
510 + return Ok(match named.tag().as_ref() {
511 + Some(tag) => write!(s, r#"{{ "{tag}": "{key}" }}"#)?,
512 + None => write!(s, "Record<{STRING}, {NEVER}>")?,
513 + });
514 + }
515 +
516 + let (flattened, non_flattened): (Vec<_>, Vec<_>) =
517 + fields.iter().partition(|(_, (f, _))| f.flatten());
518 +
519 + let mut field_sections = flattened
520 + .into_iter()
521 + .map(|(key, (field, ty))| {
522 + let mut s = String::new();
523 + datatype_inner(ctx.with(PathItem::Field(key.clone())), ty, type_map, &mut s)
524 + .map(|_| {
525 + inner_comments(
526 + ctx.clone(),
527 + field.deprecated(),
528 + field.docs(),
529 + format!("({s})"),
530 + true,
531 + )
532 + })
533 + })
534 + .collect::<Result<Vec<_>>>()?;
535 +
536 + let mut unflattened_fields = non_flattened
537 + .into_iter()
538 + .map(|(key, field_ref)| {
539 + let (field, _) = field_ref;
540 +
541 + let mut other = String::new();
542 + object_field_to_ts(
543 + ctx.with(PathItem::Field(key.clone())),
544 + key.clone(),
545 + field_ref,
546 + type_map,
547 + &mut other,
548 + )?;
549 +
550 + Ok(inner_comments(
551 + ctx.clone(),
552 + field.deprecated(),
553 + field.docs(),
554 + other,
555 + true,
556 + ))
557 + })
558 + .collect::<Result<Vec<_>>>()?;
559 +
560 + if let Some(tag) = &named.tag() {
561 + unflattened_fields.push(format!("{tag}: \"{key}\""));
562 + }
563 +
564 + if !unflattened_fields.is_empty() {
565 + field_sections.push(format!("{{ {} }}", unflattened_fields.join("; ")));
566 + }
567 +
568 + s.push_str(&field_sections.join(" & "));
569 + }
570 + };
571 + Ok(())
|
Check warning on line 472 in specta-typescript/src/lib.rs
github-actions / clippy
passing a unit value to a function
warning: passing a unit value to a function
--> specta-typescript/src/lib.rs:439:5
|
439 | / Ok(match fields {
440 | | [(field, ty)] => {
441 | | let mut v = String::new();
442 | | datatype_inner(ctx.clone(), ty, type_map, &mut v)?;
... |
471 | | }
472 | | })
| |______^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
help: move the expression in front of the call and replace it with the unit literal `()`
|
439 ~ match fields {
440 + [(field, ty)] => {
441 + let mut v = String::new();
442 + datatype_inner(ctx.clone(), ty, type_map, &mut v)?;
443 + s.push_str(&inner_comments(
444 + ctx,
445 + field.deprecated(),
446 + field.docs(),
447 + v,
448 + true,
449 + ));
450 + }
451 + fields => {
452 + s.push('[');
453 +
454 + for (i, (field, ty)) in fields.iter().enumerate() {
455 + if i != 0 {
456 + s.push_str(", ");
457 + }
458 +
459 + let mut v = String::new();
460 + datatype_inner(ctx.clone(), ty, type_map, &mut v)?;
461 + s.push_str(&inner_comments(
462 + ctx.clone(),
463 + field.deprecated(),
464 + field.docs(),
465 + v,
466 + true,
467 + ));
468 + }
469 +
470 + s.push(']');
471 + }
472 + };
473 + Ok(())
|
Check warning on line 409 in specta-typescript/src/lib.rs
github-actions / clippy
this expression creates a reference which is immediately dereferenced by the compiler
warning: this expression creates a reference which is immediately dereferenced by the compiler
--> specta-typescript/src/lib.rs:409:28
|
409 | s.push_str(&reference.name());
| ^^^^^^^^^^^^^^^^^ help: change this to: `reference.name()`
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
Check warning on line 407 in specta-typescript/src/lib.rs
github-actions / clippy
this expression creates a reference which is immediately dereferenced by the compiler
warning: this expression creates a reference which is immediately dereferenced by the compiler
--> specta-typescript/src/lib.rs:407:30
|
407 | [] => s.push_str(&reference.name()),
| ^^^^^^^^^^^^^^^^^ help: change this to: `reference.name()`
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
Check warning on line 334 in specta-typescript/src/lib.rs
github-actions / clippy
this expression creates a reference which is immediately dereferenced by the compiler
warning: this expression creates a reference which is immediately dereferenced by the compiler
--> specta-typescript/src/lib.rs:334:33
|
334 | datatype_inner(ctx, &def.ty(), type_map, &mut dt)?;
| ^^^^^^^^^ help: change this to: `def.ty()`
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
= note: `-W clippy::needless-borrow` implied by `-W clippy::all`
= help: to override `-W clippy::all` add `#[allow(clippy::needless_borrow)]`
Check warning on line 429 in specta-typescript/src/lib.rs
github-actions / clippy
passing a unit value to a function
warning: passing a unit value to a function
--> specta-typescript/src/lib.rs:276:5
|
276 | / Ok(match &typ {
277 | | DataType::Any => s.push_str(ANY),
278 | | DataType::Unknown => s.push_str(UNKNOWN),
279 | | DataType::Primitive(p) => {
... |
428 | | DataType::Generic(ident) => s.push_str(&ident.to_string()),
429 | | })
| |______^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
= note: `-W clippy::unit-arg` implied by `-W clippy::all`
= help: to override `-W clippy::all` add `#[allow(clippy::unit_arg)]`
help: move the expression in front of the call and replace it with the unit literal `()`
|
276 ~ match &typ {
277 + DataType::Any => s.push_str(ANY),
278 + DataType::Unknown => s.push_str(UNKNOWN),
279 + DataType::Primitive(p) => {
280 + let ctx = ctx.with(PathItem::Type(p.to_rust_str().into()));
281 + let str = match p {
282 + primitive_def!(i8 i16 i32 u8 u16 u32 f32 f64) => NUMBER,
283 + primitive_def!(usize isize i64 u64 i128 u128) => match ctx.cfg.bigint {
284 + BigIntExportBehavior::String => STRING,
285 + BigIntExportBehavior::Number => NUMBER,
286 + BigIntExportBehavior::BigInt => BIGINT,
287 + BigIntExportBehavior::Fail => {
288 + return Err(ExportError::BigIntForbidden(ctx.export_path()));
289 + }
290 + BigIntExportBehavior::FailWithReason(reason) => {
291 + return Err(ExportError::Other(ctx.export_path(), reason.to_owned()))
292 + }
293 + },
294 + primitive_def!(String char) => STRING,
295 + primitive_def!(bool) => BOOLEAN,
296 + };
297 +
298 + s.push_str(str);
299 + }
300 + DataType::Literal(literal) => match literal {
301 + LiteralType::i8(v) => write!(s, "{v}")?,
302 + LiteralType::i16(v) => write!(s, "{v}")?,
303 + LiteralType::i32(v) => write!(s, "{v}")?,
304 + LiteralType::u8(v) => write!(s, "{v}")?,
305 + LiteralType::u16(v) => write!(s, "{v}")?,
306 + LiteralType::u32(v) => write!(s, "{v}")?,
307 + LiteralType::f32(v) => write!(s, "{v}")?,
308 + LiteralType::f64(v) => write!(s, "{v}")?,
309 + LiteralType::bool(v) => write!(s, "{v}")?,
310 + LiteralType::String(v) => write!(s, r#""{v}""#)?,
311 + LiteralType::char(v) => write!(s, r#""{v}""#)?,
312 + LiteralType::None => s.write_str(NULL)?,
313 + _ => unreachable!(),
314 + },
315 + DataType::Nullable(def) => {
316 + datatype_inner(ctx, def, type_map, s)?;
317 +
318 + let or_null = format!(" | {NULL}");
319 + if !s.ends_with(&or_null) {
320 + s.push_str(&or_null);
321 + }
322 + }
323 + DataType::Map(def) => {
324 + // We use this instead of `Record<K, V>` to avoid issues with circular references.
325 + s.push_str("{ [key in ");
326 + datatype_inner(ctx.clone(), def.key_ty(), type_map, s)?;
327 + s.push_str("]: ");
328 + datatype_inner(ctx.clone(), def.value_ty(), type_map, s)?;
329 + s.push_str(" }");
330 + }
331 + // We use `T[]` instead of `Array<T>` to avoid issues with circular references.
332 + DataType::List(def) => {
333 + let mut dt = String::new();
334 + datatype_inner(ctx, &def.ty(), type_map, &mut dt)?;
335 +
336 + let dt = if (dt.contains(' ') && !dt.ends_with('}'))
337 + // This is to do with maintaining order of operations.
338 + // Eg `{} | {}` must be wrapped in parens like `({} | {})[]` but `{}` doesn't cause `{}[]` is valid
339 + || (dt.contains(' ') && (dt.contains('&') || dt.contains('|')))
340 + {
341 + format!("({dt})")
342 + } else {
343 + dt
344 + };
345 +
346 + if let Some(length) = def.length() {
347 + s.push('[');
348 +
349 + for n in 0..length {
350 + if n != 0 {
351 + s.push_str(", ");
352 + }
353 +
354 + s.push_str(&dt);
355 + }
356 +
357 + s.push(']');
358 + } else {
359 + write!(s, "{dt}[]")?;
360 + }
361 + }
362 + DataType::Struct(item) => struct_datatype(
363 + ctx.with(
364 + item.sid()
365 + .and_then(|sid| type_map.get(*sid))
366 + .and_then(|v| v.ext())
367 + .map(|v| PathItem::TypeExtended(item.name().clone(), *v.impl_location()))
368 + .unwrap_or_else(|| PathItem::Type(item.name().clone())),
369 + ),
370 + item.name(),
371 + item,
372 + type_map,
373 + s,
374 + )?,
375 + DataType::Enum(item) => {
376 + let mut ctx = ctx.clone();
377 + let cfg = ctx.cfg.clone().bigint(BigIntExportBehavior::Number);
378 + if item.skip_bigint_checks() {
379 + ctx.cfg = &cfg;
380 + }
381 +
382 + enum_datatype(
383 + ctx.with(PathItem::Variant(item.name().clone())),
384 + item,
385 + type_map,
386 + s,
387 + )?
388 + }
389 + DataType::Tuple(tuple) => s.push_str(&tuple_datatype(ctx, tuple, type_map)?),
390 + DataType::Result(result) => {
391 + let mut variants = vec![
392 + {
393 + let mut v = String::new();
394 + datatype_inner(ctx.clone(), &result.0, type_map, &mut v)?;
395 + v
396 + },
397 + {
398 + let mut v = String::new();
399 + datatype_inner(ctx, &result.1, type_map, &mut v)?;
400 + v
401 + },
402 + ];
403 + variants.dedup();
404 + s.push_str(&variants.join(" | "));
405 + }
406 + DataType::Reference(reference) => match &reference.generics()[..] {
407 + [] => s.push_str(&reference.name()),
408 + generics => {
409 + s.push_str(&reference.name());
410 + s.push('<');
411 +
412 + for (i, (_, v)) in generics.iter().enumerate() {
413 + if i != 0 {
414 + s.push_str(", ");
415 + }
416 +
417 + datatype_inner(
418 + ctx.with(PathItem::Type(reference.name().clone())),
419 + v,
420 + type_map,
421 + s,
422 + )?;
423 + }
424 +
425 + s.push('>');
426 + }
427 + },
428 + DataType::Generic(ident) => s.push_str(&ident.to_string()),
429 + };
430 + Ok(())
|
Check warning on line 220 in specta-typescript/src/lib.rs
github-actions / clippy
using `clone` on type `Option<&NamedDataTypeExt>` which implements the `Copy` trait
warning: using `clone` on type `Option<&NamedDataTypeExt>` which implements the `Copy` trait
--> specta-typescript/src/lib.rs:220:9
|
220 | ext.clone()
| ^^^^^^^^^^^ help: try removing the `clone` call: `ext`
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy
= note: `-W clippy::clone-on-copy` implied by `-W clippy::all`
= help: to override `-W clippy::all` add `#[allow(clippy::clone_on_copy)]`
Check warning on line 182 in specta-typescript/src/lib.rs
github-actions / clippy
calling `push_str()` using a single-character string literal
warning: calling `push_str()` using a single-character string literal
--> specta-typescript/src/lib.rs:182:5
|
182 | s.push_str(";");
| ^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `s.push(';')`
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
Check warning on line 175 in specta-typescript/src/lib.rs
github-actions / clippy
calling `push_str()` using a single-character string literal
warning: calling `push_str()` using a single-character string literal
--> specta-typescript/src/lib.rs:175:5
|
175 | s.push_str(")");
| ^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `s.push(')')`
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str