chore: checkpoint before Python removal

vendor/proc-macro2/tests/comments.rs

@@ -0,0 +1,105 @@
+#![allow(clippy::assertions_on_result_states, clippy::uninlined_format_args)]
+
+use proc_macro2::{Delimiter, Literal, Spacing, TokenStream, TokenTree};
+
+// #[doc = "..."] -> "..."
+fn lit_of_outer_doc_comment(tokens: &TokenStream) -> Literal {
+    lit_of_doc_comment(tokens, false)
+}
+
+// #![doc = "..."] -> "..."
+fn lit_of_inner_doc_comment(tokens: &TokenStream) -> Literal {
+    lit_of_doc_comment(tokens, true)
+}
+
+fn lit_of_doc_comment(tokens: &TokenStream, inner: bool) -> Literal {
+    let mut iter = tokens.clone().into_iter();
+    match iter.next().unwrap() {
+        TokenTree::Punct(punct) => {
+            assert_eq!(punct.as_char(), '#');
+            assert_eq!(punct.spacing(), Spacing::Alone);
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    }
+    if inner {
+        match iter.next().unwrap() {
+            TokenTree::Punct(punct) => {
+                assert_eq!(punct.as_char(), '!');
+                assert_eq!(punct.spacing(), Spacing::Alone);
+            }
+            _ => panic!("wrong token {:?}", tokens),
+        }
+    }
+    iter = match iter.next().unwrap() {
+        TokenTree::Group(group) => {
+            assert_eq!(group.delimiter(), Delimiter::Bracket);
+            assert!(iter.next().is_none(), "unexpected token {:?}", tokens);
+            group.stream().into_iter()
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    };
+    match iter.next().unwrap() {
+        TokenTree::Ident(ident) => assert_eq!(ident.to_string(), "doc"),
+        _ => panic!("wrong token {:?}", tokens),
+    }
+    match iter.next().unwrap() {
+        TokenTree::Punct(punct) => {
+            assert_eq!(punct.as_char(), '=');
+            assert_eq!(punct.spacing(), Spacing::Alone);
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    }
+    match iter.next().unwrap() {
+        TokenTree::Literal(literal) => {
+            assert!(iter.next().is_none(), "unexpected token {:?}", tokens);
+            literal
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    }
+}
+
+#[test]
+fn closed_immediately() {
+    let stream = "/**/".parse::<TokenStream>().unwrap();
+    let tokens = stream.into_iter().collect::<Vec<_>>();
+    assert!(tokens.is_empty(), "not empty -- {:?}", tokens);
+}
+
+#[test]
+fn incomplete() {
+    assert!("/*/".parse::<TokenStream>().is_err());
+}
+
+#[test]
+fn lit() {
+    let stream = "/// doc".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc\"");
+
+    let stream = "//! doc".parse::<TokenStream>().unwrap();
+    let lit = lit_of_inner_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc\"");
+
+    let stream = "/** doc */".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc \"");
+
+    let stream = "/*! doc */".parse::<TokenStream>().unwrap();
+    let lit = lit_of_inner_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc \"");
+}
+
+#[test]
+fn carriage_return() {
+    let stream = "///\r\n".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\"\"");
+
+    let stream = "/**\r\n*/".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\"\\r\\n\"");
+
+    "///\r".parse::<TokenStream>().unwrap_err();
+    "///\r \n".parse::<TokenStream>().unwrap_err();
+    "/**\r \n*/".parse::<TokenStream>().unwrap_err();
+}

vendor/proc-macro2/tests/features.rs

@@ -0,0 +1,10 @@
+#![allow(clippy::assertions_on_constants, clippy::ignore_without_reason)]
+
+#[test]
+#[ignore]
+fn make_sure_no_proc_macro() {
+    assert!(
+        !cfg!(feature = "proc-macro"),
+        "still compiled with proc_macro?"
+    );
+}

vendor/proc-macro2/tests/marker.rs

@@ -0,0 +1,97 @@
+#![allow(clippy::extra_unused_type_parameters)]
+
+use proc_macro2::{
+    Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
+};
+
+macro_rules! assert_impl {
+    ($ty:ident is $($marker:ident) and +) => {
+        #[test]
+        #[allow(non_snake_case)]
+        fn $ty() {
+            fn assert_implemented<T: $($marker +)+>() {}
+            assert_implemented::<$ty>();
+        }
+    };
+
+    ($ty:ident is not $($marker:ident) or +) => {
+        #[test]
+        #[allow(non_snake_case)]
+        fn $ty() {
+            $(
+                {
+                    // Implemented for types that implement $marker.
+                    #[allow(dead_code)]
+                    trait IsNotImplemented {
+                        fn assert_not_implemented() {}
+                    }
+                    impl<T: $marker> IsNotImplemented for T {}
+
+                    // Implemented for the type being tested.
+                    trait IsImplemented {
+                        fn assert_not_implemented() {}
+                    }
+                    impl IsImplemented for $ty {}
+
+                    // If $ty does not implement $marker, there is no ambiguity
+                    // in the following trait method call.
+                    <$ty>::assert_not_implemented();
+                }
+            )+
+        }
+    };
+}
+
+assert_impl!(Delimiter is Send and Sync);
+assert_impl!(Spacing is Send and Sync);
+
+assert_impl!(Group is not Send or Sync);
+assert_impl!(Ident is not Send or Sync);
+assert_impl!(LexError is not Send or Sync);
+assert_impl!(Literal is not Send or Sync);
+assert_impl!(Punct is not Send or Sync);
+assert_impl!(Span is not Send or Sync);
+assert_impl!(TokenStream is not Send or Sync);
+assert_impl!(TokenTree is not Send or Sync);
+
+#[cfg(procmacro2_semver_exempt)]
+mod semver_exempt {
+    use proc_macro2::LineColumn;
+
+    assert_impl!(LineColumn is Send and Sync);
+}
+
+mod unwind_safe {
+    #[cfg(procmacro2_semver_exempt)]
+    use proc_macro2::LineColumn;
+    use proc_macro2::{
+        Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
+    };
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    macro_rules! assert_unwind_safe {
+        ($($types:ident)*) => {
+            $(
+                assert_impl!($types is UnwindSafe and RefUnwindSafe);
+            )*
+        };
+    }
+
+    assert_unwind_safe! {
+        Delimiter
+        Group
+        Ident
+        LexError
+        Literal
+        Punct
+        Spacing
+        Span
+        TokenStream
+        TokenTree
+    }
+
+    #[cfg(procmacro2_semver_exempt)]
+    assert_unwind_safe! {
+        LineColumn
+    }
+}

vendor/proc-macro2/tests/test_fmt.rs

@@ -0,0 +1,28 @@
+#![allow(clippy::from_iter_instead_of_collect)]
+
+use proc_macro2::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
+use std::iter;
+
+#[test]
+fn test_fmt_group() {
+    let ident = Ident::new("x", Span::call_site());
+    let inner = TokenStream::from_iter(iter::once(TokenTree::Ident(ident)));
+    let parens_empty = Group::new(Delimiter::Parenthesis, TokenStream::new());
+    let parens_nonempty = Group::new(Delimiter::Parenthesis, inner.clone());
+    let brackets_empty = Group::new(Delimiter::Bracket, TokenStream::new());
+    let brackets_nonempty = Group::new(Delimiter::Bracket, inner.clone());
+    let braces_empty = Group::new(Delimiter::Brace, TokenStream::new());
+    let braces_nonempty = Group::new(Delimiter::Brace, inner.clone());
+    let none_empty = Group::new(Delimiter::None, TokenStream::new());
+    let none_nonempty = Group::new(Delimiter::None, inner);
+
+    // Matches libproc_macro.
+    assert_eq!("()", parens_empty.to_string());
+    assert_eq!("(x)", parens_nonempty.to_string());
+    assert_eq!("[]", brackets_empty.to_string());
+    assert_eq!("[x]", brackets_nonempty.to_string());
+    assert_eq!("{ }", braces_empty.to_string());
+    assert_eq!("{ x }", braces_nonempty.to_string());
+    assert_eq!("", none_empty.to_string());
+    assert_eq!("x", none_nonempty.to_string());
+}

vendor/proc-macro2/tests/test_size.rs

@@ -0,0 +1,79 @@
+#![allow(unused_attributes)]
+
+extern crate proc_macro;
+
+use std::mem;
+
+#[cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")]
+#[cfg_attr(randomize_layout, ignore = "disabled due to randomized layout")]
+#[test]
+fn test_proc_macro_size() {
+    assert_eq!(mem::size_of::<proc_macro::Span>(), 4);
+    assert_eq!(mem::size_of::<Option<proc_macro::Span>>(), 4);
+    assert_eq!(mem::size_of::<proc_macro::Group>(), 20);
+    assert_eq!(mem::size_of::<proc_macro::Ident>(), 12);
+    assert_eq!(mem::size_of::<proc_macro::Punct>(), 8);
+    assert_eq!(mem::size_of::<proc_macro::Literal>(), 16);
+    assert_eq!(mem::size_of::<proc_macro::TokenStream>(), 4);
+}
+
+#[cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")]
+#[cfg_attr(randomize_layout, ignore = "disabled due to randomized layout")]
+#[cfg_attr(wrap_proc_macro, ignore = "wrapper mode")]
+#[cfg_attr(span_locations, ignore = "span locations are on")]
+#[test]
+fn test_proc_macro2_fallback_size_without_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 0);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 1);
+    assert_eq!(mem::size_of::<proc_macro2::Group>(), 16);
+    assert_eq!(mem::size_of::<proc_macro2::Ident>(), 24);
+    assert_eq!(mem::size_of::<proc_macro2::Punct>(), 8);
+    assert_eq!(mem::size_of::<proc_macro2::Literal>(), 24);
+    assert_eq!(mem::size_of::<proc_macro2::TokenStream>(), 8);
+}
+
+#[cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")]
+#[cfg_attr(randomize_layout, ignore = "disabled due to randomized layout")]
+#[cfg_attr(wrap_proc_macro, ignore = "wrapper mode")]
+#[cfg_attr(not(span_locations), ignore = "span locations are off")]
+#[test]
+fn test_proc_macro2_fallback_size_with_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 8);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 12);
+    assert_eq!(mem::size_of::<proc_macro2::Group>(), 24);
+    assert_eq!(mem::size_of::<proc_macro2::Ident>(), 32);
+    assert_eq!(mem::size_of::<proc_macro2::Punct>(), 16);
+    assert_eq!(mem::size_of::<proc_macro2::Literal>(), 32);
+    assert_eq!(mem::size_of::<proc_macro2::TokenStream>(), 8);
+}
+
+#[rustversion::attr(before(1.71), ignore = "requires Rust 1.71+")]
+#[cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")]
+#[cfg_attr(randomize_layout, ignore = "disabled due to randomized layout")]
+#[cfg_attr(not(wrap_proc_macro), ignore = "fallback mode")]
+#[cfg_attr(span_locations, ignore = "span locations are on")]
+#[test]
+fn test_proc_macro2_wrapper_size_without_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 4);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 8);
+    assert_eq!(mem::size_of::<proc_macro2::Group>(), 24);
+    assert_eq!(mem::size_of::<proc_macro2::Ident>(), 24);
+    assert_eq!(mem::size_of::<proc_macro2::Punct>(), 12);
+    assert_eq!(mem::size_of::<proc_macro2::Literal>(), 24);
+    assert_eq!(mem::size_of::<proc_macro2::TokenStream>(), 32);
+}
+
+#[cfg_attr(not(target_pointer_width = "64"), ignore = "only applicable to 64-bit")]
+#[cfg_attr(randomize_layout, ignore = "disabled due to randomized layout")]
+#[cfg_attr(not(wrap_proc_macro), ignore = "fallback mode")]
+#[cfg_attr(not(span_locations), ignore = "span locations are off")]
+#[test]
+fn test_proc_macro2_wrapper_size_with_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 12);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 12);
+    assert_eq!(mem::size_of::<proc_macro2::Group>(), 32);
+    assert_eq!(mem::size_of::<proc_macro2::Ident>(), 32);
+    assert_eq!(mem::size_of::<proc_macro2::Punct>(), 20);
+    assert_eq!(mem::size_of::<proc_macro2::Literal>(), 32);
+    assert_eq!(mem::size_of::<proc_macro2::TokenStream>(), 32);
+}