"The parser seems stuck" on recent versions of ra

[imtsuki]

The output is like:

[ERROR rust_analyzer::main_loop] overly long loop turn: 2.110227582s
thread '<unnamed>' panicked at 'the parser seems stuck', crates/ra_parser/src/parser.rs:51:9
stack backtrace:
   0: <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt
   1: core::fmt::write
   2: std::io::Write::write_fmt
   3: std::panicking::default_hook::{{closure}}
   4: std::panicking::default_hook
   5: std::panicking::rust_panic_with_hook
   6: std::panicking::begin_panic
   7: ra_parser::grammar::expressions::atom::atom_expr
   8: ra_parser::grammar::expressions::lhs
   9: ra_parser::grammar::expressions::expr_bp
  10: ra_parser::grammar::expressions::stmt
  11: ra_parser::grammar::expressions::naked_block
  12: ra_parser::grammar::expressions::atom::block_expr
  13: ra_parser::grammar::items::maybe_item
  14: ra_parser::grammar::items::item_or_macro
  15: ra_parser::grammar::items::traits::impl_item_list
  16: ra_parser::grammar::items::maybe_item
  17: ra_parser::grammar::items::item_or_macro
  18: ra_parser::grammar::items::mod_contents
  19: ra_parser::grammar::fragments::macro_items
  20: ra_parser::parse_fragment
  21: ra_mbe::syntax_bridge::token_tree_to_syntax_node
  22: ra_hir_expand::db::parse_macro_with_arg
  23: ra_hir_expand::db::parse_macro
  24: salsa::runtime::Runtime<DB>::execute_query_implementation
  25: salsa::derived::slot::Slot<DB,Q,MP>::read_upgrade
  26: salsa::derived::slot::Slot<DB,Q,MP>::read
  27: <salsa::derived::DerivedStorage<DB,Q,MP> as salsa::plumbing::QueryStorageOps<DB,Q>>::try_fetch
  28: <T as ra_hir_expand::db::AstDatabase>::parse_macro
  29: ra_hir_expand::db::parse_or_expand
  30: <T as ra_hir_expand::db::AstDatabase>::parse_or_expand
  31: ra_hir_expand::db::ast_id_map
  32: salsa::runtime::Runtime<DB>::execute_query_implementation
  33: salsa::derived::slot::Slot<DB,Q,MP>::read_upgrade
  34: salsa::derived::slot::Slot<DB,Q,MP>::read
  35: <salsa::derived::DerivedStorage<DB,Q,MP> as salsa::plumbing::QueryStorageOps<DB,Q>>::try_fetch
  36: <T as ra_hir_expand::db::AstDatabase>::ast_id_map
  37: ra_hir_def::nameres::raw::RawItems::raw_items_query
  38: salsa::runtime::Runtime<DB>::execute_query_implementation
  39: salsa::derived::slot::Slot<DB,Q,MP>::read_upgrade
  40: salsa::derived::slot::Slot<DB,Q,MP>::read
  41: <salsa::derived::DerivedStorage<DB,Q,MP> as salsa::plumbing::QueryStorageOps<DB,Q>>::try_fetch
  42: <T as ra_hir_def::db::DefDatabase>::raw_items
  43: ra_hir_def::nameres::collector::collect_defs
  44: ra_hir_def::nameres::CrateDefMap::crate_def_map_query
  45: salsa::runtime::Runtime<DB>::execute_query_implementation
  46: salsa::derived::slot::Slot<DB,Q,MP>::read_upgrade
  47: salsa::derived::slot::Slot<DB,Q,MP>::read
  48: <salsa::derived::DerivedStorage<DB,Q,MP> as salsa::plumbing::QueryStorageOps<DB,Q>>::try_fetch
  49: <T as ra_hir_def::db::DefDatabase>::crate_def_map_query
  50: <T as ra_hir_def::db::DefDatabase>::crate_def_map
  51: ra_hir_def::nameres::collector::collect_defs
  52: ra_hir_def::nameres::CrateDefMap::crate_def_map_query
  53: salsa::runtime::Runtime<DB>::execute_query_implementation
  54: salsa::derived::slot::Slot<DB,Q,MP>::read_upgrade
  55: salsa::derived::slot::Slot<DB,Q,MP>::read
  56: <salsa::derived::DerivedStorage<DB,Q,MP> as salsa::plumbing::QueryStorageOps<DB,Q>>::try_fetch
  57: <T as ra_hir_def::db::DefDatabase>::crate_def_map_query
  58: <T as ra_hir_def::db::DefDatabase>::crate_def_map
  59: ra_hir::semantics::source_to_def::SourceToDefCtx::file_to_def
  60: ra_hir::semantics::Semantics<DB>::to_module_def
  61: ra_ide::diagnostics::diagnostics
  62: std::panicking::try::do_call
  63: __rust_maybe_catch_panic
  64: ra_ide::Analysis::diagnostics
  65: rust_analyzer::main_loop::handlers::publish_diagnostics
  66: <F as threadpool::FnBox>::call_box
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
[ERROR rust_analyzer::main_loop] overly long loop turn: 2.110227582s

Can be reproduced on this repo:

https://github.com/imtsuki/xv7

[edwin0cheng]

Seem related to macro expansion, the actual code it failed :

Code

use core::fmt;

/// RGB color.
pub trait RgbColor: PixelColor {
    /// Returns the red channel value.
    fn r(&self) -> u8;

    /// Returns the green channel value.
    fn g(&self) -> u8;

    /// Returns the blue channel value.
    fn b(&self) -> u8;

    /// The maximum value in the red channel.
    const MAX_R: u8;

    /// The maximum value in the green channel.
    const MAX_G: u8;

    /// The maximum value in the blue channel.
    const MAX_B: u8;

    /// Black color (R: 0%, G: 0%, B: 0%)
    const BLACK: Self;

    /// Red color (R: 100%, G: 0%, B: 0%)
    const RED: Self;

    /// Green color (R: 0%, G: 100%, B: 0%)
    const GREEN: Self;

    /// Blue color (R: 0%, G: 0%, B: 100%)
    const BLUE: Self;

    /// Yellow color (R: 100%, G: 100%, B: 0%)
    const YELLOW: Self;

    /// Magenta color (R: 100%, G: 0%, B: 100%)
    const MAGENTA: Self;

    /// Cyan color (R: 0%, G: 100%, B: 100%)
    const CYAN: Self;

    /// White color (R: 100%, G: 100%, B: 100%)
    const WHITE: Self;
}

/// Macro to implement a RgbColor type with the given channel bit positions.
macro_rules! impl_rgb_color {
    (
        $type:ident,
        $data_type:ty,
        $storage_type:ty,
        ($r_bits:expr, $g_bits:expr, $b_bits:expr),
        ($r_pos:expr, $g_pos:expr, $b_pos:expr),
        $type_str:expr
    ) => {
        #[doc = $type_str]
        #[doc = "color."]
        #[doc = ""]
        #[doc = "Use the methods provided by the [`RgbColor`] trait to access"]
        #[doc = "individual color channels and predefined color constants."]
        #[doc = ""]
        #[doc = "See the [module-level documentation] for more information about"]
        #[doc = "conversion between this type and raw data."]
        #[doc = ""]
        #[doc = "[`RgbColor`]: trait.RgbColor.html"]
        #[doc = "[module-level documentation]: index.html"]
        #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Default)]
        pub struct $type($storage_type);

        impl $type {
            const R_MASK: $storage_type = ($type::MAX_R as $storage_type) << $r_pos;
            const G_MASK: $storage_type = ($type::MAX_G as $storage_type) << $g_pos;
            const B_MASK: $storage_type = ($type::MAX_B as $storage_type) << $b_pos;
            const RGB_MASK: $storage_type = Self::R_MASK | Self::B_MASK | Self::G_MASK;
        }

        impl fmt::Debug for $type {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                write!(
                    f,
                    "{}(r: {}, g: {}, b: {})",
                    stringify!($type),
                    self.r(),
                    self.g(),
                    self.b()
                )
            }
        }

        impl $type
        where
            Self: RgbColor,
        {
            #[doc = "Creates a new"]
            #[doc = $type_str]
            #[doc = "color.\n"]
            #[doc = "Too large channel values will be limited by setting the"]
            #[doc = "unused most significant bits to zero."]
            pub const fn new(r: u8, g: u8, b: u8) -> Self {
                let r_shifted = (r & Self::MAX_R) as $storage_type << $r_pos;
                let g_shifted = (g & Self::MAX_G) as $storage_type << $g_pos;
                let b_shifted = (b & Self::MAX_B) as $storage_type << $b_pos;

                Self(r_shifted | g_shifted | b_shifted)
            }
        }

        impl RgbColor for $type {
            fn r(&self) -> u8 {
                #![allow(trivial_numeric_casts)]

                (self.0 >> $r_pos) as u8 & Self::MAX_R
            }

            fn g(&self) -> u8 {
                #![allow(trivial_numeric_casts)]

                (self.0 >> $g_pos) as u8 & Self::MAX_G
            }

            fn b(&self) -> u8 {
                #![allow(trivial_numeric_casts)]

                (self.0 >> $b_pos) as u8 & Self::MAX_B
            }

            const MAX_R: u8 = ((1usize << $r_bits) - 1) as u8;
            const MAX_G: u8 = ((1usize << $g_bits) - 1) as u8;
            const MAX_B: u8 = ((1usize << $b_bits) - 1) as u8;

            const BLACK: Self = Self::new(0, 0, 0);
            const RED: Self = Self::new(Self::MAX_R, 0, 0);
            const GREEN: Self = Self::new(0, Self::MAX_G, 0);
            const BLUE: Self = Self::new(0, 0, Self::MAX_B);
            const YELLOW: Self = Self::new(Self::MAX_R, Self::MAX_G, 0);
            const MAGENTA: Self = Self::new(Self::MAX_R, 0, Self::MAX_B);
            const CYAN: Self = Self::new(0, Self::MAX_G, Self::MAX_B);
            const WHITE: Self = Self::new(Self::MAX_R, Self::MAX_G, Self::MAX_B);
        }

        impl PixelColor for $type {
            type Raw = $data_type;
        }

        impl From<$data_type> for $type {
            fn from(data: $data_type) -> Self {
                let data = data.into_inner();

                Self(data & Self::RGB_MASK)
            }
        }

        impl From<$type> for $data_type {
            fn from(color: $type) -> Self {
                Self::new(color.0)
            }
        }
    };

    // Recursive macro to stringify the type.
    (
        $type:ident,
        $data_type:ty,
        $storage_type:ty,
        ($r_bits:expr, $g_bits:expr, $b_bits:expr),
        ($r_pos:expr, $g_pos:expr, $b_pos:expr)
    ) => {
        impl_rgb_color!(
            $type,
            $data_type,
            $storage_type,
            ($r_bits, $g_bits, $b_bits),
            ($r_pos, $g_pos, $b_pos),
            stringify!($type)
        );
    };
}

/// Helper macro to calculate bit positions for RGB and BGR colors
macro_rules! rgb_color {
    (
        $type:ident, $data_type:ty, $storage_type:ty,
        Rgb = ($r_bits:expr, $g_bits:expr, $b_bits:expr)
    ) => {
        impl_rgb_color!(
            $type,
            $data_type,
            $storage_type,
            ($r_bits, $g_bits, $b_bits),
            ($g_bits + $b_bits, $b_bits, 0)
        );
    };

    (
        $type:ident, $data_type:ty, $storage_type:ty,
        Bgr = ($r_bits:expr, $g_bits:expr, $b_bits:expr)
    ) => {
        impl_rgb_color!(
            $type,
            $data_type,
            $storage_type,
            ($r_bits, $g_bits, $b_bits),
            (0, $r_bits, $r_bits + $g_bits)
        );
    };
}

rgb_color!(Rgb555, RawU16, u16, Rgb = (5, 5, 5));
rgb_color!(Bgr555, RawU16, u16, Bgr = (5, 5, 5));
rgb_color!(Rgb565, RawU16, u16, Rgb = (5, 6, 5));
rgb_color!(Bgr565, RawU16, u16, Bgr = (5, 6, 5));

rgb_color!(Rgb888, RawU24, u32, Rgb = (8, 8, 8));
rgb_color!(Bgr888, RawU24, u32, Bgr = (8, 8, 8));

fn main() {}

Just copy & paste above code in a new project, and the same error will occur. I will do more investigation later.

[lnicola]

Minimized:

macro_rules! rgb_color {
    (
        $r_pos:expr
    ) => {
        pub fn new() {
            let r_shifted = 0 as u32 << $r_pos; // rustc wants (0 as u32) << $r_pos, but that works
        }
    };
}

rgb_color!(8 + 8);
// rgb_color!(8); works

fn main() {}

[edwin0cheng]

It is not related to macro, it just wrongly eaten a token, but that token is generated by mbe only (the magical L_DOLLAR) such that the parser will stuck.

[edwin0cheng]

#3892 should fix the stuck bug, but the deeper issue is not fixed. I opened #3893 for that and will close this one in favour of it. Feel free to reopen this if needed.