code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/syn-3.0.9/tests/test_receiver.rs

@@ -0,0 +1,275 @@
+#![allow(
+    clippy::elidable_lifetime_names,
+    clippy::needless_lifetimes,
+    clippy::uninlined_format_args
+)]
+
+#[macro_use]
+mod snapshot;
+
+mod debug;
+
+use syn::{parse_quote, TraitItemFn};
+
+#[test]
+fn test_by_value() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn by_value(self: Self);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Typed(
+            Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "Self",
+                        },
+                    ],
+                },
+            },
+        ),
+    })
+    "#);
+}
+
+#[test]
+fn test_by_mut_value() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn by_mut(mut self: Self);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        mutability: Some,
+        kind: ReceiverKind::Typed(
+            Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "Self",
+                        },
+                    ],
+                },
+            },
+        ),
+    })
+    "#);
+}
+
+#[test]
+fn test_by_ref() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn by_ref(self: &Self);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Typed(
+            Type::Reference {
+                elem: Type::Path {
+                    path: Path {
+                        segments: [
+                            PathSegment {
+                                ident: "Self",
+                            },
+                        ],
+                    },
+                },
+            },
+        ),
+    })
+    "#);
+}
+
+#[test]
+fn test_by_box() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn by_box(self: Box<Self>);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Typed(
+            Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "Box",
+                            arguments: PathArguments::AngleBracketed {
+                                args: [
+                                    GenericArgument::Type(Type::Path {
+                                        path: Path {
+                                            segments: [
+                                                PathSegment {
+                                                    ident: "Self",
+                                                },
+                                            ],
+                                        },
+                                    }),
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+        ),
+    })
+    "#);
+}
+
+#[test]
+fn test_by_pin() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn by_pin(self: Pin<Self>);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Typed(
+            Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "Pin",
+                            arguments: PathArguments::AngleBracketed {
+                                args: [
+                                    GenericArgument::Type(Type::Path {
+                                        path: Path {
+                                            segments: [
+                                                PathSegment {
+                                                    ident: "Self",
+                                                },
+                                            ],
+                                        },
+                                    }),
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+        ),
+    })
+    "#);
+}
+
+#[test]
+fn test_explicit_type() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn explicit_type(self: Pin<MyType>);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Typed(
+            Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "Pin",
+                            arguments: PathArguments::AngleBracketed {
+                                args: [
+                                    GenericArgument::Type(Type::Path {
+                                        path: Path {
+                                            segments: [
+                                                PathSegment {
+                                                    ident: "MyType",
+                                                },
+                                            ],
+                                        },
+                                    }),
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+        ),
+    })
+    "#);
+}
+
+#[test]
+fn test_value_shorthand() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn value_shorthand(self);
+    };
+    snapshot!(&sig.inputs[0], @"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Value,
+    })
+    ");
+}
+
+#[test]
+fn test_mut_value_shorthand() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn mut_value_shorthand(mut self);
+    };
+    snapshot!(&sig.inputs[0], @"
+    FnArg::Receiver(Receiver {
+        mutability: Some,
+        kind: ReceiverKind::Value,
+    })
+    ");
+}
+
+#[test]
+fn test_ref_shorthand() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn ref_shorthand(&self);
+    };
+    snapshot!(&sig.inputs[0], @"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Reference(
+            None,
+            None,
+        ),
+    })
+    ");
+}
+
+#[test]
+fn test_ref_shorthand_with_lifetime() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn ref_shorthand(&'a self);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Reference(
+            Some(Lifetime {
+                ident: "a",
+            }),
+            None,
+        ),
+    })
+    "#);
+}
+
+#[test]
+fn test_ref_mut_shorthand() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn ref_mut_shorthand(&mut self);
+    };
+    snapshot!(&sig.inputs[0], @"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Reference(
+            None,
+            Some,
+        ),
+    })
+    ");
+}
+
+#[test]
+fn test_ref_mut_shorthand_with_lifetime() {
+    let TraitItemFn { sig, .. } = parse_quote! {
+        fn ref_mut_shorthand(&'a mut self);
+    };
+    snapshot!(&sig.inputs[0], @r#"
+    FnArg::Receiver(Receiver {
+        kind: ReceiverKind::Reference(
+            Some(Lifetime {
+                ident: "a",
+            }),
+            Some,
+        ),
+    })
+    "#);
+}

data/ext/cargo-vendor/syn-3.0.9/tests/test_round_trip.rs

@@ -0,0 +1,226 @@
+#![cfg(not(syn_disable_nightly_tests))]
+#![cfg(not(miri))]
+#![recursion_limit = "1024"]
+#![feature(rustc_private)]
+#![allow(
+    clippy::assert_is_empty,
+    clippy::blocks_in_conditions,
+    clippy::elidable_lifetime_names,
+    clippy::manual_assert,
+    clippy::manual_let_else,
+    clippy::match_like_matches_macro,
+    clippy::needless_lifetimes,
+    clippy::uninlined_format_args
+)]
+#![allow(mismatched_lifetime_syntaxes)]
+
+extern crate rustc_ast;
+extern crate rustc_ast_pretty;
+extern crate rustc_data_structures;
+extern crate rustc_driver;
+extern crate rustc_error_messages;
+extern crate rustc_errors;
+extern crate rustc_expand;
+extern crate rustc_parse;
+extern crate rustc_session;
+extern crate rustc_span;
+
+use crate::common::eq::SpanlessEq;
+use quote::quote;
+use rustc_ast::ast::{
+    AngleBracketedArg, Crate, GenericArg, GenericArgs, GenericParamKind, Generics,
+};
+use rustc_ast::mut_visit::{self, MutVisitor};
+use rustc_ast_pretty::pprust;
+use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
+use rustc_error_messages::DiagMessage;
+use rustc_errors::{Diag, PResult};
+use rustc_parse::lexer::StripTokens;
+use rustc_session::parse::ParseSess;
+use rustc_span::FileName;
+use std::borrow::Cow;
+use std::fs;
+use std::panic;
+use std::path::Path;
+use std::process;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Instant;
+
+#[macro_use]
+mod macros;
+
+mod common;
+mod repo;
+
+#[test]
+fn test_round_trip() {
+    repo::rayon_init();
+    repo::clone_rust();
+    let abort_after = repo::abort_after();
+    if abort_after == 0 {
+        panic!("skipping all round_trip tests");
+    }
+
+    let failed = AtomicUsize::new(0);
+
+    repo::for_each_rust_file(|path| test(path, &failed, abort_after));
+
+    let failed = failed.into_inner();
+    if failed > 0 {
+        panic!("{} failures", failed);
+    }
+}
+
+fn test(path: &Path, failed: &AtomicUsize, abort_after: usize) {
+    let failed = || {
+        let prev_failed = failed.fetch_add(1, Ordering::Relaxed);
+        if prev_failed + 1 >= abort_after {
+            process::exit(1);
+        }
+    };
+
+    let content = fs::read_to_string(path).unwrap();
+
+    let (back, elapsed) = match panic::catch_unwind(|| {
+        let start = Instant::now();
+        let result = syn::parse_file(&content);
+        let elapsed = start.elapsed();
+        result.map(|krate| (quote!(#krate).to_string(), elapsed))
+    }) {
+        Err(_) => {
+            errorf!("=== {}: syn panic\n", path.display());
+            failed();
+            return;
+        }
+        Ok(Err(msg)) => {
+            errorf!("=== {}: syn failed to parse\n{:?}\n", path.display(), msg);
+            failed();
+            return;
+        }
+        Ok(Ok(result)) => result,
+    };
+
+    let edition = repo::edition(path).parse().unwrap();
+
+    rustc_span::create_session_if_not_set_then(edition, |_| {
+        let equal = match panic::catch_unwind(|| {
+            let sess = ParseSess::new();
+            let before = match librustc_parse(content, &sess) {
+                Ok(before) => before,
+                Err(diagnostic) => {
+                    errorf!(
+                        "=== {}: ignore - librustc failed to parse original content: {}\n",
+                        path.display(),
+                        translate_message(&diagnostic),
+                    );
+                    diagnostic.cancel();
+                    return Err(true);
+                }
+            };
+            let after = match librustc_parse(back, &sess) {
+                Ok(after) => after,
+                Err(diagnostic) => {
+                    errorf!("=== {}: librustc failed to parse", path.display());
+                    diagnostic.emit();
+                    return Err(false);
+                }
+            };
+            Ok((before, after))
+        }) {
+            Err(_) => {
+                errorf!("=== {}: ignoring librustc panic\n", path.display());
+                true
+            }
+            Ok(Err(equal)) => equal,
+            Ok(Ok((mut before, mut after))) => {
+                normalize(&mut before);
+                normalize(&mut after);
+                if SpanlessEq::eq(&before, &after) {
+                    errorf!(
+                        "=== {}: pass in {}ms\n",
+                        path.display(),
+                        elapsed.as_secs() * 1000 + u64::from(elapsed.subsec_nanos()) / 1_000_000
+                    );
+                    true
+                } else {
+                    errorf!(
+                        "=== {}: FAIL\n{}\n!=\n{}\n",
+                        path.display(),
+                        pprust::crate_to_string_for_macros(&before),
+                        pprust::crate_to_string_for_macros(&after),
+                    );
+                    false
+                }
+            }
+        };
+        if !equal {
+            failed();
+        }
+    });
+}
+
+fn librustc_parse(content: String, sess: &ParseSess) -> PResult<Crate> {
+    static COUNTER: AtomicUsize = AtomicUsize::new(0);
+    let counter = COUNTER.fetch_add(1, Ordering::Relaxed);
+    let name = FileName::Custom(format!("test_round_trip{}", counter));
+    let mut parser = rustc_parse::new_parser_from_source_str(
+        sess,
+        name,
+        content,
+        StripTokens::ShebangAndFrontmatter,
+    )
+    .unwrap();
+    parser.parse_crate_mod()
+}
+
+fn translate_message(diagnostic: &Diag) -> Cow<'static, str> {
+    match &diagnostic.messages[0].0 {
+        DiagMessage::Str(msg) | DiagMessage::Inline(msg) => msg.clone(),
+    }
+}
+
+fn normalize(krate: &mut Crate) {
+    struct NormalizeVisitor;
+
+    impl MutVisitor for NormalizeVisitor {
+        fn visit_generic_args(&mut self, e: &mut GenericArgs) {
+            if let GenericArgs::AngleBracketed(e) = e {
+                #[derive(Ord, PartialOrd, Eq, PartialEq)]
+                enum Group {
+                    Lifetimes,
+                    TypesAndConsts,
+                    Constraints,
+                }
+                e.args.sort_by_key(|arg| match arg {
+                    AngleBracketedArg::Arg(arg) => match arg {
+                        GenericArg::Lifetime(_) => Group::Lifetimes,
+                        GenericArg::Type(_) | GenericArg::Const(_) => Group::TypesAndConsts,
+                    },
+                    AngleBracketedArg::Constraint(_) => Group::Constraints,
+                });
+            }
+            mut_visit::walk_generic_args(self, e);
+        }
+
+        fn visit_generics(&mut self, e: &mut Generics) {
+            #[derive(Ord, PartialOrd, Eq, PartialEq)]
+            enum Group {
+                Lifetimes,
+                TypesAndConsts,
+            }
+            e.params.sort_by_key(|param| match param.kind {
+                GenericParamKind::Lifetime => Group::Lifetimes,
+                GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
+                    Group::TypesAndConsts
+                }
+            });
+            e.params
+                .flat_map_in_place(|param| self.flat_map_generic_param(param));
+            if e.where_clause.predicates.is_empty() {
+                e.where_clause.has_where_token = false;
+            }
+        }
+    }
+
+    NormalizeVisitor.visit_crate(krate);
+}

data/ext/cargo-vendor/syn-3.0.9/tests/test_shebang.rs

@@ -0,0 +1,77 @@
+#![allow(
+    clippy::elidable_lifetime_names,
+    clippy::needless_lifetimes,
+    clippy::uninlined_format_args
+)]
+
+#[macro_use]
+mod snapshot;
+
+mod debug;
+
+#[test]
+fn test_basic() {
+    let content = "#!/usr/bin/env rustx\nfn main() {}";
+    let file = syn::parse_file(content).unwrap();
+    snapshot!(file, @r##"
+    File {
+        shebang: Some("#!/usr/bin/env rustx"),
+        items: [
+            Item::Fn {
+                vis: Visibility::Inherited,
+                modifiers: FnModifiers,
+                sig: Signature {
+                    safety: Safety::Default,
+                    ident: "main",
+                    generics: Generics,
+                    output: ReturnType::Default,
+                },
+                block: Block {
+                    stmts: [],
+                },
+            },
+        ],
+    }
+    "##);
+}
+
+#[test]
+fn test_comment() {
+    let content = "#!//am/i/a/comment\n[allow(dead_code)] fn main() {}";
+    let file = syn::parse_file(content).unwrap();
+    snapshot!(file, @r#"
+    File {
+        attrs: [
+            Attribute {
+                style: AttrStyle::Inner,
+                meta: Meta::List {
+                    path: Path {
+                        segments: [
+                            PathSegment {
+                                ident: "allow",
+                            },
+                        ],
+                    },
+                    delimiter: MacroDelimiter::Paren,
+                    tokens: TokenStream(`dead_code`),
+                },
+            },
+        ],
+        items: [
+            Item::Fn {
+                vis: Visibility::Inherited,
+                modifiers: FnModifiers,
+                sig: Signature {
+                    safety: Safety::Default,
+                    ident: "main",
+                    generics: Generics,
+                    output: ReturnType::Default,
+                },
+                block: Block {
+                    stmts: [],
+                },
+            },
+        ],
+    }
+    "#);
+}

data/ext/cargo-vendor/syn-3.0.9/tests/test_size.rs

@@ -0,0 +1,54 @@
+// Assumes proc-macro2's "span-locations" feature is off.
+
+use std::mem;
+use syn::{Expr, Item, Lit, Pat, Type};
+
+#[rustversion::attr(before(2022-11-24), ignore = "requires nightly-2022-11-24 or newer")]
+#[rustversion::attr(
+    since(2022-11-24),
+    cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")
+)]
+#[test]
+fn test_expr_size() {
+    assert_eq!(mem::size_of::<Expr>(), 168);
+}
+
+#[rustversion::attr(before(2022-09-09), ignore = "requires nightly-2022-09-09 or newer")]
+#[rustversion::attr(
+    since(2022-09-09),
+    cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")
+)]
+#[test]
+fn test_item_size() {
+    assert_eq!(mem::size_of::<Item>(), 360);
+}
+
+#[rustversion::attr(before(2023-04-29), ignore = "requires nightly-2023-04-29 or newer")]
+#[rustversion::attr(
+    since(2023-04-29),
+    cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")
+)]
+#[test]
+fn test_type_size() {
+    assert_eq!(mem::size_of::<Type>(), 248);
+}
+
+#[rustversion::attr(before(2023-04-29), ignore = "requires nightly-2023-04-29 or newer")]
+#[rustversion::attr(
+    since(2023-04-29),
+    cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")
+)]
+#[test]
+fn test_pat_size() {
+    assert_eq!(mem::size_of::<Pat>(), 184);
+}
+
+#[rustversion::attr(before(2023-12-20), ignore = "requires nightly-2023-12-20 or newer")]
+#[rustversion::attr(
+    since(2023-12-20),
+    cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")
+)]
+#[test]
+fn test_lit_size() {
+    assert_eq!(mem::size_of::<Lit>(), 24);
+}