+

+# subtree syncs

+932d85b52946d917deab2c23ead552f7f713b828

+3e358a6827d83e8d6473913a5e304734aadfed04

+9d2cb42a413e51deb50b36794a2e1605381878fc

+f532576ac53ddcc666bc8d59e0b6437065e2f599

+c48062fe2ab9a2d913d1985a6b0aec4bf936bfc1

+ rustup component add --toolchain ${{ env.RUST_CHANNEL }} rustfmt rust-src

+ uses: Swatinem/rust-cache@9bdad043e88c75890e36ad3bbc8d27f0090dd609

+ uses: Swatinem/rust-cache@9bdad043e88c75890e36ad3bbc8d27f0090dd609

+ build_metrics:

+

+ rustup component add --toolchain stable rust-src

+ - name: Cache cargo

+ needs: build_metrics

+ - name: Install Rust toolchain

+ run: |

+ rustup update --no-self-update stable

+ rustup default stable

+ rustup component add --toolchain stable rust-src

+

+ uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0

+version = "1.0.83"

+checksum = "25bdb32cbbdce2b519a9cd7df3a678443100e265d5e25ca763b7572a5104f5f3"

+version = "1.3.0"

+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"

+version = "0.3.71"

+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"

+version = "2.5.0"

+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"

+version = "0.1.8"

+checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"

+version = "1.0.97"

+checksum = "099a5357d84c4c61eb35fc8eafa9a79a902c2f76911e5747ced4e032edd8d9b4"

+name = "cfg_aliases"

+version = "0.1.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"

+

+[[package]]

+ "bitflags 2.5.0",

+version = "3.4.4"

+checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345"

+ "nix 0.28.0",

+name = "directories"

+version = "5.0.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "9a49173b84e034382284f27f1af4dcbbd231ffa358c0fe316541a7337f376a35"

+dependencies = [

+ "dirs-sys",

+]

+

+[[package]]

+name = "dirs-sys"

+version = "0.4.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"

+dependencies = [

+ "libc",

+ "option-ext",

+ "redox_users",

+ "windows-sys 0.48.0",

+]

+

+[[package]]

+version = "1.0.9"

+checksum = "59f8e79d1fbf76bdfbde321e902714bf6c49df88a7dda6fc682fc2979226962d"

+version = "1.11.0"

+checksum = "a47c1c47d2f5964e29c61246e81db715514cd532db6b5116a25ea3c03d6780a2"

+version = "0.14.3"

+checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5"

+version = "1.5.0"

+checksum = "9e0be0a561335815e06dab7c62e50353134c796e7a6155402a64bcff66b6a5e0"

+ "redox_syscall 0.4.1",

+version = "1.0.30"

+checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"

+version = "0.2.15"

+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"

+version = "0.14.5"

+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"

+ "bitflags 2.5.0",

+ "bitflags 2.5.0",

+ "ra-ap-rustc_index 0.53.0",

+ "bitflags 2.5.0",

+version = "2.2.6"

+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"

+version = "1.0.11"

+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"

+version = "0.2.154"

+checksum = "ae743338b92ff9146ce83992f766a31066a91a8c84a45e0e9f21e7cf6de6d346"

+ "windows-targets 0.52.5",

+version = "0.1.37"

+checksum = "81eb4061c0582dedea1cbc7aff2240300dd6982e0239d1c99e65c1dbf4a30ba7"

+name = "libredox"

+version = "0.1.3"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"

+dependencies = [

+ "bitflags 2.5.0",

+ "libc",

+]

+

+[[package]]

+version = "0.4.12"

+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"

+version = "0.11.3"

+checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"

+version = "2.7.2"

+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"

+version = "0.9.1"

+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"

+version = "0.1.41"

+checksum = "9f41a2280ded0da56c8cf898babb86e8f10651a34adcfff190ae9a1159c6908d"

+version = "0.28.0"

+checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"

+ "bitflags 2.5.0",

+ "cfg_aliases",

+ "bitflags 2.5.0",

+name = "option-ext"

+version = "0.2.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"

+

+[[package]]

+version = "0.12.2"

+checksum = "7e4af0ca4f6caed20e900d564c242b8e5d4903fdacf31d3daf527b66fe6f42fb"

+version = "0.9.10"

+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"

+ "redox_syscall 0.5.1",

+ "windows-targets 0.52.5",

+version = "1.0.15"

+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

+version = "0.6.5"

+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"

+version = "0.2.14"

+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"

+version = "1.0.82"

+checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b"

+ "windows-sys 0.52.0",

+ "bitflags 2.5.0",

+version = "1.0.36"

+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"

+version = "0.53.0"

+checksum = "80b1d613eee933486c0613a7bc26e515e46f43adf479d1edd5e537f983e9ce46"

+ "bitflags 2.5.0",

+ "ra-ap-rustc_index 0.53.0",

+ "ra-ap-rustc_index_macros 0.44.0",

+ "smallvec",

+]

+

+[[package]]

+name = "ra-ap-rustc_index"

+version = "0.53.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "f072060ac77e9e1a02cc20028095993af7e72cc0804779c68bcbf47b16de49c9"

+dependencies = [

+ "arrayvec",

+ "ra-ap-rustc_index_macros 0.53.0",

+name = "ra-ap-rustc_index_macros"

+version = "0.53.0"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "82f3d6dcb30a66905388e14756b8f2216131d9f8004922c07f13335840e058d1"

+dependencies = [

+ "proc-macro2",

+ "quote",

+ "syn",

+ "synstructure",

+]

+

+[[package]]

+version = "0.53.0"

+checksum = "dbd8a2b0bdcba9892cbce0b25f6c953d31b0febc1f3420fc692884fce5a23ad8"

+version = "0.53.0"

+checksum = "70dad7a491c2554590222e0c9212dcb7c2e7aceb668875075012a35ea780d135"

+ "ra-ap-rustc_index 0.53.0",

+ "ra-ap-rustc_index 0.44.0",

+version = "1.10.0"

+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"

+name = "redox_syscall"

+version = "0.5.1"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e"

+dependencies = [

+ "bitflags 2.5.0",

+]

+

+[[package]]

+name = "redox_users"

+version = "0.4.5"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"

+dependencies = [

+ "getrandom",

+ "libredox",

+ "thiserror",

+]

+

+[[package]]

+ "windows-sys 0.52.0",

+version = "0.1.24"

+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"

+version = "1.0.18"

+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"

+version = "1.0.23"

+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"

+version = "1.0.201"

+checksum = "780f1cebed1629e4753a1a38a3c72d30b97ec044f0aef68cb26650a3c5cf363c"

+version = "1.0.201"

+checksum = "c5e405930b9796f1c00bee880d03fc7e0bb4b9a11afc776885ffe84320da2865"

+version = "1.0.117"

+checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"

+version = "0.1.19"

+checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"

+version = "1.13.2"

+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"

+ "windows-sys 0.52.0",

+version = "2.0.63"

+checksum = "bf5be731623ca1a1fb7d8be6f261a3be6d3e2337b8a1f97be944d020c8fcb704"

+version = "1.0.60"

+checksum = "579e9083ca58dd9dcf91a9923bb9054071b9ebbd800b342194c9feb0ee89fc18"

+version = "1.0.60"

+checksum = "e2470041c06ec3ac1ab38d0356a6119054dedaea53e12fbefc0de730a1c08524"

+version = "0.3.36"

+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"

+version = "0.8.12"

+checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3"

+version = "0.22.12"

+checksum = "d3328d4f68a705b2a4498da1d580585d39a6510f98318a2cec3018a7ec61ddef"

+ "tracing",

+version = "0.1.8"

+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"

+ "windows-sys 0.52.0",

+ "windows-targets 0.52.5",

+version = "0.52.5"

+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"

+ "windows_aarch64_gnullvm 0.52.5",

+ "windows_aarch64_msvc 0.52.5",

+ "windows_i686_gnu 0.52.5",

+ "windows_i686_gnullvm",

+ "windows_i686_msvc 0.52.5",

+ "windows_x86_64_gnu 0.52.5",

+ "windows_x86_64_gnullvm 0.52.5",

+ "windows_x86_64_msvc 0.52.5",

+version = "0.52.5"

+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"

+version = "0.52.5"

+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"

+version = "0.52.5"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"

+

+[[package]]

+name = "windows_i686_gnullvm"

+version = "0.52.5"

+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"

+version = "0.52.5"

+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"

+version = "0.52.5"

+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"

+version = "0.52.5"

+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"

+version = "0.52.5"

+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"

+version = "0.6.8"

+checksum = "c3c52e9c97a68071b23e836c9380edae937f17b9c4667bd021973efc689f618d"

+version = "0.2.6"

+checksum = "6db0ab86eae739efd1b054a8d3d16041914030ac4e01cd1dca0cf252fd8b6437"

+version = "0.2.6"

+checksum = "9d422e8e38ec76e2f06ee439ccc765e9c6a9638b9e7c9f2e8255e4d41e8bd852"

+ "directories",

+rust-version = "1.78"

+ra-ap-rustc_lexer = { version = "0.53.0", default-features = false }

+ra-ap-rustc_parse_format = { version = "0.53.0", default-features = false }

+ra-ap-rustc_index = { version = "0.53.0", default-features = false }

+ra-ap-rustc_abi = { version = "0.53.0", default-features = false }

+ let _p = tracing::span!(tracing::Level::INFO, "FileChange::apply").entered();

+ sysroot: bool,

+ Self { name, crate_id, prelude: true, sysroot: false }

+ pub fn with_prelude(name: CrateName, crate_id: CrateId, prelude: bool, sysroot: bool) -> Self {

+ Self { name, crate_id, prelude, sysroot }

+

+ /// Whether this dependency is a sysroot injected one.

+ pub fn is_sysroot(&self) -> bool {

+ self.sysroot

+ }

+use syntax::{ast, Parse, SourceFile, SyntaxError};

+ /// Crates whose root's source root is the same as the source root of `file_id`

+ /// Returns the set of errors obtained from parsing the file including validation errors.

+ fn parse_errors(&self, file_id: FileId) -> Option<Arc<[SyntaxError]>>;

+

+ let _p = tracing::span!(tracing::Level::INFO, "parse", ?file_id).entered();

+fn parse_errors(db: &dyn SourceDatabase, file_id: FileId) -> Option<Arc<[SyntaxError]>> {

+ let errors = db.parse(file_id).errors();

+ match &*errors {

+ [] => None,

+ [..] => Some(errors.into()),

+ }

+}

+

+ /// Crates whose root fool is in `id`.

+use mbe::{syntax_node_to_token_tree, DocCommentDesugarMode, DummyTestSpanMap, DUMMY};

+ let tt = syntax_node_to_token_tree(

+ tt.syntax(),

+ DummyTestSpanMap,

+ DUMMY,

+ DocCommentDesugarMode::ProcMacro,

+ );

+ let tt = syntax_node_to_token_tree(

+ tt.syntax(),

+ DummyTestSpanMap,

+ DUMMY,

+ DocCommentDesugarMode::ProcMacro,

+ );

+ let tt = syntax_node_to_token_tree(

+ tt.syntax(),

+ DummyTestSpanMap,

+ DUMMY,

+ DocCommentDesugarMode::ProcMacro,

+ );

+ let tt = syntax_node_to_token_tree(

+ tt.syntax(),

+ DummyTestSpanMap,

+ DUMMY,

+ DocCommentDesugarMode::ProcMacro,

+ );

+ manifest_path: Option<AbsPathBuf>,

+ let actor =

+ FlycheckActor::new(id, sender, config, sysroot_root, workspace_root, manifest_path);

+ manifest_path: Option<AbsPathBuf>,

+ manifest_path: Option<AbsPathBuf>,

+ manifest_path,

+ if let Some(manifest_path) = &self.manifest_path {

+ cmd.arg("--manifest-path");

+ cmd.arg(manifest_path);

+ if manifest_path.extension().map_or(false, |ext| ext == "rs") {

+ cmd.arg("-Zscript");

+ }

+ }

+use mbe::{syntax_node_to_token_tree, DocCommentDesugarMode};

+ DocCommentDesugarMode::ProcMacro,

+use hir_expand::{name::Name, InFile};

+use span::MacroFileId;

+ expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, MacroFileId>,

+ pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<MacroFileId> {

+ pub fn macro_calls(

+ &self,

+ ) -> impl Iterator<Item = (InFile<AstPtr<ast::MacroCall>>, MacroFileId)> + '_ {

+ self.expansions.iter().map(|(&a, &b)| (a, b))

+ }

+

+ self.source_map

+ .expansions

+ .insert(macro_call_ptr, self.expander.current_file_id().macro_file().unwrap());

+ let args = self.alloc_expr_desugared(Expr::Literal(Literal::Uint(

+ *n as u128,

+ Some(BuiltinUint::Usize),

+ )));

+ let count_is =

+ match LangItem::FormatCount.ty_rel_path(self.db, self.krate, name![Is]) {

+ Some(count_is) => self.alloc_expr_desugared(Expr::Path(count_is)),

+ None => self.missing_expr(),

+ };

+ self.alloc_expr_desugared(Expr::Call {

+ callee: count_is,

+ args: Box::new([args]),

+ is_assignee_expr: false,

+ })

+ let args = self.alloc_expr_desugared(Expr::Literal(Literal::Uint(

+ i as u128,

+ Some(BuiltinUint::Usize),

+ )));

+ let count_param = match LangItem::FormatCount.ty_rel_path(

+ self.db,

+ self.krate,

+ name![Param],

+ ) {

+ Some(count_param) => self.alloc_expr_desugared(Expr::Path(count_param)),

+ };

+ self.alloc_expr_desugared(Expr::Call {

+ callee: count_param,

+ args: Box::new([args]),

+ is_assignee_expr: false,

+ })

+ // FIXME: This drops arg causing it to potentially not be resolved/type checked

+ // when typing?

+

+ let new_fn = match LangItem::FormatArgument.ty_rel_path(

+ Some(new_fn) => self.alloc_expr_desugared(Expr::Path(new_fn)),

+ };

+ self.alloc_expr_desugared(Expr::Call {

+ callee: new_fn,

+ args: Box::new([arg]),

+ is_assignee_expr: false,

+ })

+ BlockId, ConstBlockId, DefWithBodyId,

+ let mut scopes = ExprScopes::new(&body, |const_block| {

+ db.lookup_intern_anonymous_const(const_block).root

+ });

+ fn new(

+ body: &Body,

+ resolve_const_block: impl (Fn(ConstBlockId) -> ExprId) + Copy,

+ ) -> ExprScopes {

+ compute_expr_scopes(body.body_expr, body, &mut scopes, &mut root, resolve_const_block);

+ resolve_const_block: impl (Fn(ConstBlockId) -> ExprId) + Copy,

+ compute_expr_scopes(*expr, body, scopes, scope, resolve_const_block);

+ compute_expr_scopes(*expr, body, scopes, scope, resolve_const_block);

+ compute_expr_scopes(*expr, body, scopes, scope, resolve_const_block);

+ compute_expr_scopes(expr, body, scopes, scope, resolve_const_block);

+fn compute_expr_scopes(

+ expr: ExprId,

+ body: &Body,

+ scopes: &mut ExprScopes,

+ scope: &mut ScopeId,

+ resolve_const_block: impl (Fn(ConstBlockId) -> ExprId) + Copy,

+) {

+ let compute_expr_scopes = |scopes: &mut ExprScopes, expr: ExprId, scope: &mut ScopeId| {

+ compute_expr_scopes(expr, body, scopes, scope, resolve_const_block)

+ };

+

+ compute_block_scopes(statements, *tail, body, scopes, &mut scope, resolve_const_block);

+ Expr::Const(id) => {

+ let mut scope = scopes.root_scope();

+ compute_expr_scopes(scopes, resolve_const_block(*id), &mut scope);

+ compute_block_scopes(statements, *tail, body, scopes, &mut scope, resolve_const_block);

+ compute_expr_scopes(scopes, *body_expr, &mut scope);

+ compute_expr_scopes(scopes, *body_expr, &mut scope);

+ compute_expr_scopes(scopes, *expr, scope);

+ compute_expr_scopes(scopes, guard, &mut scope);

+ compute_expr_scopes(scopes, arm.expr, &mut scope);

+ compute_expr_scopes(scopes, condition, &mut then_branch_scope);

+ compute_expr_scopes(scopes, then_branch, &mut then_branch_scope);

+ compute_expr_scopes(scopes, else_branch, scope);

+ compute_expr_scopes(scopes, expr, scope);

+ e => e.walk_child_exprs(|e| compute_expr_scopes(scopes, e, scope)),

+ {

+ $crate::panicking::panic_fmt(

+ builtin#lang(Arguments::new_v1_formatted)(

+ &[

+ "cc",

+ ],

+ &[],

+ &[],

+ unsafe {

+ builtin#lang(UnsafeArg::new)()

+ },

+ ),

+ );

+ };

+ pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,

+ let (items, macro_calls, diagnostics) = collector.finish();

+ macro_calls,

+ self.macro_calls.iter().flat_map(|it| it.iter()).copied()

+#[derive(Debug, PartialEq, Eq)]

+ pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,

+ let (items, macro_calls, diagnostics) = collector.finish();

+ macro_calls,

+ self.macro_calls.iter().flat_map(|it| it.iter()).copied()

+ macro_calls: Vec<(AstId<ast::Item>, MacroCallId)>,

+ macro_calls: Vec::new(),

+ if self.macro_calls.is_empty() { None } else { Some(Box::new(self.macro_calls)) },

+ self.macro_calls.push((ast_id, call_id));

+ self.collect_macro_items(res);

+ AssocItem::Const(id) => {

+ let item = &item_tree[id];

+ let Some(name) = item.name.clone() else { return };

+ let def = ConstLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(self.db);

+ self.items.push((name, def.into()));

+ }

+ self.macro_calls.push((InFile::new(file_id, ast_id.upcast()), call_id));

+ self.collect_macro_items(res);

+ fn collect_macro_items(&mut self, res: ExpandResult<Option<(Mark, Parse<ast::MacroItems>)>>) {

+ let Some((mark, _parse)) = res.value else { return };

+extern crate alloc;

+

+ item_tree::{AttrOwner, FileItemTreeId, GenericModItem, GenericsItemTreeNode, ItemTree},

+ self.fill_impl_trait_bounds(lower_ctx.take_impl_traits_bounds());

+ fn fill_impl_trait_bounds(&mut self, impl_bounds: Vec<Vec<Interned<TypeBound>>>) {

+ for bounds in impl_bounds {

+ let param = TypeParamData {

+ name: None,

+ default: None,

+ provenance: TypeParamProvenance::ArgumentImplTrait,

+ };

+ let param_id = self.type_or_consts.alloc(param.into());

+ for bound in bounds {

+ self.where_predicates.push(WherePredicate::TypeBound {

+ target: WherePredicateTypeTarget::TypeOrConstParam(param_id),

+ bound,

+ });

+ }

+ }

+ }

+

+ fn fill_implicit_impl_trait_args(

+ let enabled_params =

+ |params: &Interned<GenericParams>, item_tree: &ItemTree, parent: GenericModItem| {

+ let enabled = |param| item_tree.attrs(db, krate, param).is_cfg_enabled(cfg_options);

+ let attr_owner_ct = |param| AttrOwner::TypeOrConstParamData(parent, param);

+ let attr_owner_lt = |param| AttrOwner::LifetimeParamData(parent, param);

+

+ // In the common case, no parameters will by disabled by `#[cfg]` attributes.

+ // Therefore, make a first pass to check if all parameters are enabled and, if so,

+ // clone the `Interned<GenericParams>` instead of recreating an identical copy.

+ let all_type_or_consts_enabled =

+ params.type_or_consts.iter().all(|(idx, _)| enabled(attr_owner_ct(idx)));

+ let all_lifetimes_enabled =

+ params.lifetimes.iter().all(|(idx, _)| enabled(attr_owner_lt(idx)));

+

+ if all_type_or_consts_enabled && all_lifetimes_enabled {

+ params.clone()

+ } else {

+ Interned::new(GenericParams {

+ type_or_consts: all_type_or_consts_enabled

+ .then(|| params.type_or_consts.clone())

+ .unwrap_or_else(|| {

+ params

+ .type_or_consts

+ .iter()

+ .filter(|&(idx, _)| enabled(attr_owner_ct(idx)))

+ .map(|(_, param)| param.clone())

+ .collect()

+ }),

+ lifetimes: all_lifetimes_enabled

+ .then(|| params.lifetimes.clone())

+ .unwrap_or_else(|| {

+ params

+ .lifetimes

+ .iter()

+ .filter(|&(idx, _)| enabled(attr_owner_lt(idx)))

+ .map(|(_, param)| param.clone())

+ .collect()

+ }),

+ where_predicates: params.where_predicates.clone(),

+ })

+ }

+ };

+ enabled_params: impl Fn(

+ &Interned<GenericParams>,

+ &ItemTree,

+ GenericModItem,

+ ) -> Interned<GenericParams>,

+ ) -> Interned<GenericParams>

+ where

+ FileItemTreeId<Id>: Into<GenericModItem>,

+ {

+ enabled_params(item.generic_params(), &tree, id.value.into())

+ let enabled_params =

+ enabled_params(&item.explicit_generic_params, &tree, loc.id.value.into());

+ let text = bs.value().map_or_else(|_| Default::default(), Box::from);

+ let text = s.value().map_or_else(|_| Default::default(), Box::from);

+ let text = s.value().map_or_else(|_| Default::default(), Box::from);

+ pub fn all_macro_calls(&self) -> impl Iterator<Item = MacroCallId> + '_ {

+ self.macro_invocations.values().copied().chain(self.attr_macros.values().copied()).chain(

+ self.derive_macros.values().flat_map(|it| {

+ it.iter().flat_map(|it| it.derive_call_ids.iter().copied().flatten())

+ }),

+ )

+ }

+

+#![allow(unexpected_cfgs)]

+ generics::GenericParams,

+ BlockId, LocalLifetimeParamId, LocalTypeOrConstParamId, Lookup,

+ pub const PUB: Self = RawVisibilityId(u32::MAX);

+ pub const PRIV_IMPLICIT: Self = RawVisibilityId(u32::MAX - 1);

+ pub const PRIV_EXPLICIT: Self = RawVisibilityId(u32::MAX - 2);

+ pub const PUB_CRATE: Self = RawVisibilityId(u32::MAX - 3);

+ TypeOrConstParamData(GenericModItem, LocalTypeOrConstParamId),

+ LifetimeParamData(GenericModItem, LocalLifetimeParamId),

+ #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]

+ pub enum GenericModItem {

+ $(

+ $(

+ #[cfg_attr(ignore_fragment, $generic_params)]

+ $typ(FileItemTreeId<$typ>),

+ )?

+ )+

+ }

+

+ impl From<GenericModItem> for ModItem {

+ fn from(id: GenericModItem) -> ModItem {

+ match id {

+ $(

+ $(

+ #[cfg_attr(ignore_fragment, $generic_params)]

+ GenericModItem::$typ(id) => ModItem::$typ(id),

+ )?

+ )+

+ }

+ }

+ }

+

+ impl From<GenericModItem> for AttrOwner {

+ fn from(t: GenericModItem) -> AttrOwner {

+ AttrOwner::ModItem(t.into())

+ }

+ }

+

+ $(

+ #[cfg_attr(ignore_fragment, $generic_params)]

+ impl From<FileItemTreeId<$typ>> for GenericModItem {

+ fn from(id: FileItemTreeId<$typ>) -> GenericModItem {

+ GenericModItem::$typ(id)

+ }

+ }

+ )?

+use rustc_hash::FxHashMap;

+ Fields, FileItemTreeId, FnFlags, Function, GenericArgs, GenericModItem, Idx, IdxRange,

+ Impl, ImportAlias, Interned, ItemTree, ItemTreeData, ItemTreeNode, Macro2, MacroCall,

+ MacroRules, Mod, ModItem, ModKind, ModPath, Mutability, Name, Param, ParamAstId, Path,

+ Range, RawAttrs, RawIdx, RawVisibilityId, Static, Struct, StructKind, Trait, TraitAlias,

+ TypeAlias, Union, Use, UseTree, UseTreeKind, Variant,

+ generic_param_attr_buffer:

+ FxHashMap<Either<LocalTypeOrConstParamId, LocalLifetimeParamId>, RawAttrs>,

+ generic_param_attr_buffer: FxHashMap::default(),

+ assert!(self.generic_param_attr_buffer.is_empty());

+ assert!(self.generic_param_attr_buffer.is_empty());

+ assert!(self.generic_param_attr_buffer.is_empty());

+ let generic_params = self.lower_generic_params(HasImplicitSelf::No, strukt);

+ let id = id(self.data().structs.alloc(res));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ let generic_params = self.lower_generic_params(HasImplicitSelf::No, union);

+ let id = id(self.data().unions.alloc(res));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ let generic_params = self.lower_generic_params(HasImplicitSelf::No, enum_);

+ let id = id(self.data().enums.alloc(res));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ let id = id(self.data().functions.alloc(res));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ let id = id(self.data().type_aliases.alloc(res));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ let generic_params =

+ self.lower_generic_params(HasImplicitSelf::Yes(trait_def.type_bound_list()), trait_def);

+ let id = id(self.data().traits.alloc(def));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ let id = id(self.data().trait_aliases.alloc(alias));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ let target_trait = impl_def.trait_().and_then(|tr| self.lower_trait_ref(&tr));

+ // Note that trait impls don't get implicit `Self` unlike traits, because here they are a

+ // type alias rather than a type parameter, so this is handled by the resolver.

+ let generic_params = self.lower_generic_params(HasImplicitSelf::No, impl_def);

+ let id = id(self.data().impls.alloc(res));

+ self.write_generic_params_attributes(id.into());

+ Some(id)

+ fn write_generic_params_attributes(&mut self, parent: GenericModItem) {

+ self.generic_param_attr_buffer.drain().for_each(|(idx, attrs)| {

+ self.tree.attrs.insert(

+ match idx {

+ Either::Left(id) => AttrOwner::TypeOrConstParamData(parent, id),

+ Either::Right(id) => AttrOwner::LifetimeParamData(parent, id),

+ },

+ attrs,

+ );

+ })

+ }

+

+ debug_assert!(self.generic_param_attr_buffer.is_empty(),);

+ let add_param_attrs = |item: Either<LocalTypeOrConstParamId, LocalLifetimeParamId>,

+ param| {

+ let attrs = RawAttrs::new(self.db.upcast(), &param, self.body_ctx.span_map());

+ debug_assert!(self.generic_param_attr_buffer.insert(item, attrs).is_none());

+ };

+ self.body_ctx.take_impl_traits_bounds();

+ generics.fill_bounds(

+ &self.body_ctx,

+ bounds,

+ Either::Left(TypeRef::Path(name![Self].into())),

+ );

+ FileItemTreeId, FnFlags, Function, GenericModItem, GenericParams, Impl, Interned, ItemTree,

+ Macro2, MacroCall, MacroRules, Mod, ModItem, ModKind, Param, ParamAstId, Path, RawAttrs,

+ self.print_generic_params(explicit_generic_params, it.into());

+ self.print_generic_params(generic_params, it.into());

+ self.print_generic_params(generic_params, it.into());

+ self.print_generic_params(generic_params, it.into());

+ self.print_generic_params(generic_params, it.into());

+ self.print_generic_params(generic_params, it.into());

+ self.print_generic_params(generic_params, it.into());

+ self.print_generic_params(generic_params, it.into());

+ fn print_generic_params(&mut self, params: &GenericParams, parent: GenericModItem) {

+ self.print_attrs_of(AttrOwner::LifetimeParamData(parent, idx), " ");

+ self.print_attrs_of(AttrOwner::TypeOrConstParamData(parent, idx), " ");

+struct S<A, B, #[cfg(never)] C>;

+struct S<A, #[cfg(never)] B, C>;

+

+ // AstId: 2

+ pub(self) struct S<A, B, #[cfg(never)] C>;

+

+ // AstId: 3

+ pub(self) struct S<A, #[cfg(never)] B, C>;

+use std::cell::{OnceCell, RefCell};

+use intern::Interned;

+use crate::{db::DefDatabase, path::Path, type_ref::TypeBound};

+ impl_trait_bounds: RefCell<Vec<Vec<Interned<TypeBound>>>>,

+ LowerCtx {

+ db,

+ file_id,

+ span_map: OnceCell::new(),

+ ast_id_map: OnceCell::new(),

+ impl_trait_bounds: RefCell::new(Vec::new()),

+ }

+ LowerCtx {

+ db,

+ file_id,

+ span_map,

+ ast_id_map: OnceCell::new(),

+ impl_trait_bounds: RefCell::new(Vec::new()),

+ }

+

+ pub fn update_impl_traits_bounds(&self, bounds: Vec<Interned<TypeBound>>) {

+ self.impl_trait_bounds.borrow_mut().push(bounds);

+ }

+

+ pub fn take_impl_traits_bounds(&self) -> Vec<Vec<Interned<TypeBound>>> {

+ self.impl_trait_bounds.take()

+ }

+

+#[test]

+fn attribute_macro_doc_desugaring() {

+ check(

+ r#"

+//- proc_macros: identity

+#[proc_macros::identity]

+/// doc string \n with newline

+/**

+ MultiLines Doc

+ MultiLines Doc

+*/

+#[doc = "doc attr"]

+struct S;

+"#,

+ expect![[r##"

+#[proc_macros::identity]

+/// doc string \n with newline

+/**

+ MultiLines Doc

+ MultiLines Doc

+*/

+#[doc = "doc attr"]

+struct S;

+

+#[doc = " doc string \\n with newline"]

+#[doc = "\n MultiLines Doc\n MultiLines Doc\n"]

+#[doc = "doc attr"] struct S;"##]],

+ );

+}

+use base_db::{CrateId, CrateOrigin, Dependency, FileId, LangCrateOrigin};

+ ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,

+ let crate_graph = self.db.crate_graph();

+ let file_id = crate_graph[self.def_map.krate].root_file_id;

+ let mut process = true;

+ process = false;

+ break;

+ for (name, dep) in &self.deps {

+ if dep.is_prelude() {

+ // This is a bit confusing but the gist is that `no_core` and `no_std` remove the

+ // sysroot dependence on `core` and `std` respectively. Our `CrateGraph` is eagerly

+ // constructed with them in place no matter what though, since at that point we

+ // don't do pre-configured attribute resolution yet.

+ // So here check if we are no_core / no_std and we are trying to add the

+ // corresponding dep from the sysroot

+ let skip = match crate_graph[dep.crate_id].origin {

+ CrateOrigin::Lang(LangCrateOrigin::Core) => {

+ crate_data.no_core && dep.is_sysroot()

+ }

+ CrateOrigin::Lang(LangCrateOrigin::Std) => {

+ crate_data.no_std && dep.is_sysroot()

+ }

+ _ => false,

+ };

+ if skip {

+ continue;

+ }

+ crate_data

+ .extern_prelude

+ .insert(name.clone(), (CrateRootModuleId { krate: dep.crate_id }, None));

+ }

+ }

+

+ if !process {

+ return;

+ }

+

+ Arc::get_mut(&mut self.def_map.data).unwrap().shrink_to_fit();

+ } else if self.def_map.extern_prelude().any(|(name, _)| *name == name![std]) {

+ name![std]

+ // If `std` does not exist for some reason, fall back to core. This mostly helps

+ // keep r-a's own tests minimal.

+ name![core]

+use syntax::ast;

+ pub fn unresolved_proc_macro(

+ let type_ref = type_ref.inspect(|tr| {

+ tr.walk(&mut |tr| {

+ if let TypeRef::ImplTrait(bounds) = tr {

+ lower_ctx.update_impl_traits_bounds(bounds.clone());

+ }

+ });

+ });

+use std::{fmt, hash::BuildHasherDefault, iter, mem};

+ ) -> impl Iterator<Item = (&crate::generics::WherePredicate, &GenericDefId)> {

+ Scope::GenericParams { params, def } => Some((params, def)),

+ .flat_map(|(params, def)| params.where_predicates.iter().zip(iter::repeat(def)))

+use mbe::{syntax_node_to_token_tree, DelimiterKind, DocCommentDesugarMode, Punct};

+ let tree = syntax_node_to_token_tree(

+ tt.syntax(),

+ span_map,

+ span,

+ DocCommentDesugarMode::ProcMacro,

+ );

+ fn from_tt(db: &dyn ExpandDatabase, mut tt: &[tt::TokenTree], id: AttrId) -> Option<Attr> {

+ if matches!(tt,

+ [tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident { text, .. })), ..]

+ if text == "unsafe"

+ ) {

+ match tt.get(1) {

+ Some(tt::TokenTree::Subtree(subtree)) => tt = &subtree.token_trees,

+ _ => return None,

+ }

+ }

+ let first = &tt.first()?;

+ let ctxt = first.first_span().ctx;

+fn parse_cfg_attr_input(

+use mbe::DocCommentDesugarMode;

+ mbe::syntax_node_to_token_tree(

+ it.syntax(),

+ tm,

+ call_site,

+ DocCommentDesugarMode::ProcMacro,

+ )

+ ast::TypeOrConstParam::Type(it) => it.type_bound_list().map(|it| {

+ mbe::syntax_node_to_token_tree(

+ it.syntax(),

+ tm,

+ call_site,

+ DocCommentDesugarMode::ProcMacro,

+ )

+ }),

+ .map(|ty| {

+ mbe::syntax_node_to_token_tree(

+ ty.syntax(),

+ tm,

+ call_site,

+ DocCommentDesugarMode::ProcMacro,

+ )

+ })

+ .map(|it| {

+ mbe::syntax_node_to_token_tree(

+ it.syntax(),

+ tm,

+ call_site,

+ DocCommentDesugarMode::ProcMacro,

+ )

+ })

+ .map(|it| {

+ mbe::syntax_node_to_token_tree(

+ it.syntax(),

+ tm,

+ call_site,

+ DocCommentDesugarMode::ProcMacro,

+ )

+ })

+ token.value().ok().map(|it| (it.into_owned(), span))

+ token.value().ok().zip(Some(span))

+ token.value().ok().map(|it| (it.into_owned(), span))

+use mbe::{syntax_node_to_token_tree, DocCommentDesugarMode, MatchedArmIndex};

+ ) -> Option<Arc<ExpandResult<Arc<[SyntaxError]>>>>;

+ mbe::syntax_node_to_token_tree(

+ speculative_args,

+ span_map,

+ span,

+ if loc.def.is_proc_macro() {

+ DocCommentDesugarMode::ProcMacro

+ } else {

+ DocCommentDesugarMode::Mbe

+ },

+ ),

+ mbe::syntax_node_to_token_tree(

+ speculative_args,

+ span_map,

+ span,

+ DocCommentDesugarMode::ProcMacro,

+ ),

+ let mut fixups = fixup::fixup_syntax(

+ span_map,

+ speculative_args,

+ span,

+ DocCommentDesugarMode::ProcMacro,

+ );

+ DocCommentDesugarMode::ProcMacro,

+ let mut tree = syntax_node_to_token_tree(

+ token_tree.syntax(),

+ span_map,

+ span,

+ DocCommentDesugarMode::ProcMacro,

+ );

+) -> Option<Arc<ExpandResult<Arc<[SyntaxError]>>>> {

+ let e: ExpandResult<Arc<[SyntaxError]>> =

+ db.parse_macro_expansion(MacroFileId { macro_call_id }).map(|it| Arc::from(it.0.errors()));

+ if e.value.is_empty() && e.err.is_none() {

+ None

+ } else {

+ Some(Arc::new(e))

+ }

+ let mut tt = mbe::syntax_node_to_token_tree(

+ tt.syntax(),

+ map.as_ref(),

+ span,

+ if loc.def.is_proc_macro() {

+ DocCommentDesugarMode::ProcMacro

+ } else {

+ DocCommentDesugarMode::Mbe

+ },

+ );

+ let mut fixups =

+ fixup::fixup_syntax(map.as_ref(), syntax, span, DocCommentDesugarMode::ProcMacro);

+ DocCommentDesugarMode::ProcMacro,

+use mbe::DocCommentDesugarMode;

+ DocCommentDesugarMode::Mbe,

+ DocCommentDesugarMode::Mbe,

+use mbe::DocCommentDesugarMode;

+ let mut subtree = mbe::syntax_node_to_token_tree(

+ &expanded_eager_input,

+ arg_map,

+ span,

+ DocCommentDesugarMode::Mbe,

+ );

+use mbe::DocCommentDesugarMode;

+ mode: DocCommentDesugarMode,

+ let original_tree = mbe::syntax_node_to_token_tree(&node, span_map, call_site, mode);

+ use mbe::DocCommentDesugarMode;

+ DocCommentDesugarMode::Mbe,

+ DocCommentDesugarMode::Mbe,

+ DocCommentDesugarMode::Mbe,

+ Other(Arc<Box<str>>),

+ ProcMacroPanic(Arc<Box<str>>),

+ ExpandError::Other(Arc::new(msg.into()))

+use triomphe::Arc;

+ ExpandError::ProcMacroPanic(Arc::new(text.into_boxed_str())),

+ let _p = tracing::span!(tracing::Level::INFO, "impl_datum_query").entered();

+ fn is_str(&self) -> bool;

+ fn is_str(&self) -> bool {

+ matches!(self.kind(Interner), TyKind::Str)

+ }

+

+ kind @ (TyKind::Raw(m, t) | TyKind::Ref(m, _, t)) => {

+ if let TyKind::Ref(_, l, _) = kind {

+ f.write_char('&')?;

+ if cfg!(test) {

+ // rendering these unconditionally is probably too much (at least for inlay

+ // hints) so we gate it to testing only for the time being

+ l.hir_fmt(f)?;

+ f.write_char(' ')?;

+ }

+ match m {

+ Mutability::Not => (),

+ Mutability::Mut => f.write_str("mut ")?,

+ }

+ } else {

+

+ // FIXME: Remote this

+ // most of our lifetimes will be errors as we lack elision and inference

+ // so don't render them for now

+ let only_err_lifetimes = !cfg!(test)

+ && parameters_to_write.iter().all(|arg| {

+ matches!(

+ arg.data(Interner),

+ chalk_ir::GenericArgData::Lifetime(it) if *it.data(Interner) == LifetimeData::Error

+ )

+ });

+ if !parameters_to_write.is_empty() && !only_err_lifetimes {

+ // FIXME: Remove this

+ // most of our lifetimes will be errors as we lack elision and inference

+ // so don't render them for now

+ if !cfg!(test)

+ && matches!(

+ generic_arg.lifetime(Interner),

+ Some(l) if ***l.interned() == LifetimeData::Error

+ )

+ {

+ continue;

+ }

+

+ LifetimeData::Error => write!(f, "'?"),

+ LifetimeData::Erased => write!(f, "'<erased>"),

+ LifetimeData::Phantom(void, _) => match *void {},

+ variant: VariantId,

+ variant: def,

+ variant: def,

+ variant: def,

+ variant: def,

+ // Count the number of `impl Trait` things that appear within our bounds.

+ // Since t hose have been emitted as implicit type args already.

+ let kind = self

+ .generics()

+ .expect("param impl trait lowering must be in a generic def")

+ .iter()

+ .filter_map(|(id, data)| match (id, data) {

+ (

+ GenericParamId::TypeParamId(id),

+ GenericParamDataRef::TypeParamData(data),

+ ) if data.provenance == TypeParamProvenance::ArgumentImplTrait => {

+ Some(id)

+ }

+ _ => None,

+ })

+ .nth(idx as usize)

+ .map_or(TyKind::Error, |id| {

+ TyKind::Placeholder(to_placeholder_idx(self.db, id.into()))

+ });

+ kind.intern(Interner)

+ // Count the number of `impl Trait` things that appear within our bounds.

+ // Since t hose have been emitted as implicit type args already.

+ type_params,

+ ) = self

+ .generics()

+ .expect("variable impl trait lowering must be in a generic def")

+ .provenance_split();

+ idx as usize + self_params + type_params + const_params,

+ &def: &GenericDefId,

+ trait_ref.clone().map(WhereClause::Implemented).map(crate::wrap_empty_binders)

+ match (type_ref, &self.impl_trait_mode) {

+ (TypeRef::ImplTrait(_), ImplTraitLoweringState::Disallowed) => (),

+ (

+ _,

+ ImplTraitLoweringState::Disallowed | ImplTraitLoweringState::Opaque(_),

+ ) => {

+ let ty = self.lower_ty(type_ref);

+ let alias_eq =

+ AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty };

+ predicates

+ .push(crate::wrap_empty_binders(WhereClause::AliasEq(alias_eq)));

+ (

+ _,

+ ImplTraitLoweringState::Param(_) | ImplTraitLoweringState::Variable(_),

+ ) => {

+ // Find the generic index for the target of our `bound`

+ let target_param_idx = self

+ .resolver

+ .where_predicates_in_scope()

+ .find_map(|(p, _)| match p {

+ WherePredicate::TypeBound {

+ target: WherePredicateTypeTarget::TypeOrConstParam(idx),

+ bound: b,

+ } if b == bound => Some(idx),

+ _ => None,

+ });

+ let ty = if let Some(target_param_idx) = target_param_idx {

+ let mut counter = 0;

+ let generics = self.generics().expect("generics in scope");

+ for (idx, data) in generics.params.type_or_consts.iter() {

+ // Count the number of `impl Trait` things that appear before

+ // the target of our `bound`.

+ // Our counter within `impl_trait_mode` should be that number

+ // to properly lower each types within `type_ref`

+ if data.type_param().is_some_and(|p| {

+ p.provenance == TypeParamProvenance::ArgumentImplTrait

+ }) {

+ counter += 1;

+ if idx == *target_param_idx {

+ break;

+ let mut ext = TyLoweringContext::new_maybe_unowned(

+ self.db,

+ self.resolver,

+ self.owner,

+ )

+ .with_type_param_mode(self.type_param_mode);

+ match &self.impl_trait_mode {

+ ImplTraitLoweringState::Param(_) => {

+ ext.impl_trait_mode =

+ ImplTraitLoweringState::Param(Cell::new(counter));

+ }

+ ImplTraitLoweringState::Variable(_) => {

+ ext.impl_trait_mode =

+ ImplTraitLoweringState::Variable(Cell::new(counter));

+ }

+ _ => unreachable!(),

+ }

+ ext.lower_ty(type_ref)

+ } else {

+ self.lower_ty(type_ref)

+ };

+

+ let alias_eq =

+ AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty };

+ predicates

+ .push(crate::wrap_empty_binders(WhereClause::AliasEq(alias_eq)));

+ }

+ Some(bound_var) => bound_var

+ .shifted_out_to(DebruijnIndex::new(2))

+ .map(|bound_var| LifetimeData::BoundVar(bound_var).intern(Interner))

+ .unwrap_or(it),

+// FIXME: This does not handle macros!

+fn count_impl_traits(type_ref: &TypeRef) -> usize {

+ let mut count = 0;

+ type_ref.walk(&mut |type_ref| {

+ if matches!(type_ref, TypeRef::ImplTrait(_)) {

+ count += 1;

+ }

+ });

+ count

+}

+

+ let predicate = |(pred, &def): &(&_, _)| match pred {

+ .flat_map(|(pred, def)| {

+ ctx.lower_where_predicate(pred, def, true).map(|p| make_binders(db, &generics, p))

+ for (pred, def) in resolver.where_predicates_in_scope() {

+ for pred in ctx.lower_where_predicate(pred, def, false) {

+ .flat_map(|(pred, def)| {

+ ctx.lower_where_predicate(pred, def, false).map(|p| make_binders(db, &generics, p))

+ let _p = tracing::span!(tracing::Level::INFO, "incoherent_inherent_impl_crates").entered();

+

+ pub fn is_panic(&self) -> Option<&str> {

+ let mut err = self;

+ while let MirEvalError::InFunction(e, _) = err {

+ err = e;

+ }

+ match err {

+ MirEvalError::Panic(msg) => Some(msg),

+ _ => None,

+ }

+ }

+ let size = if ty.is_str() {

+

+ let result = self.exec_lang_item(it, generic_args, args, locals, span)?;

+ let attrs = self.db.attrs(def.into());

+

+ if attrs.by_key("rustc_const_panic_str").exists() {

+ // `#[rustc_const_panic_str]` is treated like `lang = "begin_panic"` by rustc CTFE.

+ return Some(LangItem::BeginPanic);

+ }

+

+ let candidate = attrs.by_key("lang").string_value().and_then(LangItem::from_str)?;

+

+ args: &[IntervalAndTy],

+ BeginPanic => {

+ let mut arg = args

+ .next()

+ .ok_or(MirEvalError::InternalError(

+ "argument of BeginPanic is not provided".into(),

+ ))?

+ .clone();

+ while let TyKind::Ref(_, _, ty) = arg.ty.kind(Interner) {

+ if ty.is_str() {

+ let (pointee, metadata) = arg.interval.get(self)?.split_at(self.ptr_size());

+ let len = from_bytes!(usize, metadata);

+

+ return {

+ Err(MirEvalError::Panic(

+ std::str::from_utf8(

+ self.read_memory(Address::from_bytes(pointee)?, len)?,

+ )

+ .unwrap()

+ .to_owned(),

+ ))

+ };

+ }

+ let size = self.size_of_sized(ty, locals, "begin panic arg")?;

+ let pointee = arg.interval.get(self)?;

+ arg = IntervalAndTy {

+ interval: Interval::new(Address::from_bytes(pointee)?, size),

+ ty: ty.clone(),

+ };

+ }

+ Err(MirEvalError::Panic(format!(

+ "unknown-panic-payload: {:?}",

+ arg.ty.kind(Interner)

+ )))

+ }

+ let arg = arg.get(self)?;

+ let arg = arg.interval.get(self)?.to_owned();

+

+fn check_panic(ra_fixture: &str, expected_panic: &str) {

+ let (db, file_ids) = TestDB::with_many_files(ra_fixture);

+ let file_id = *file_ids.last().unwrap();

+ let e = eval_main(&db, file_id).unwrap_err();

+ assert_eq!(e.is_panic().unwrap_or_else(|| panic!("unexpected error: {:?}", e)), expected_panic);

+}

+

+fn panic_fmt() {

+ // panic!

+ // -> panic_2021 (builtin macro redirection)

+ // -> #[lang = "panic_fmt"] core::panicking::panic_fmt (hooked by CTFE for redirection)

+ // -> core::panicking::const_panic_fmt

+ // -> #[rustc_const_panic_str] core::panicking::panic_display (hooked by CTFE for builtin panic)

+ // -> Err(ConstEvalError::Panic)

+ check_panic(

+ r#"

+//- minicore: fmt, panic

+fn main() {

+ panic!("hello, world!");

+}

+ "#,

+ "hello, world!",

+ );

+}

+

+#[test]

+fn panic_display() {

+ // panic!

+ // -> panic_2021 (builtin macro redirection)

+ // -> #[rustc_const_panic_str] core::panicking::panic_display (hooked by CTFE for builtin panic)

+ // -> Err(ConstEvalError::Panic)

+ check_panic(

+ r#"

+//- minicore: fmt, panic

+

+fn main() {

+ panic!("{}", "hello, world!");

+}

+ "#,

+ "hello, world!",

+ );

+}

+

+#[test]

+ //^^^^^^^^^ expected *mut i32, got &'? i32

+ //^^^^ expected &'? u32, got &'? Foo<{unknown}>

+ //^^^^^^^^^^^^^^^^^^^^^ expected &'? Foo<[usize]>, got &'? Foo<[i32; 3]>

+ //^^^^^^^^^^^^^^^^^^^^^^^^^^ expected &'? Bar<[usize]>, got &'? Bar<[i32; 3]>

+ //^ expected &'? dyn Foo, got &'? impl Foo + ?Sized

+ //^^^^expected V<&'? S>, got (V<&'? dyn Tr>,)

+ //^^^^expected V<&'? S>, got (V<&'? dyn Tr>,)

+ //^ expected &'static str, got i32

+ //^ expected &'static str, got i32

+ //^ expected &'static str, got i32

+ //^ expected &'static str, got i32

+ //^ expected &'static str, got i32

+ //^^^^^^^ expected (), got &'static str

+ //^^^^ expected (), got &'static str

+ //^ &'_ (dyn A<Assoc = ()> + Send)

+ //^ &'_ (dyn A<Assoc = ()> + Send)

+ //^ &'_ (dyn B<Assoc = ()>)

+ // ^^^ &'_ dyn Foo<'_>

+ //^ &'_ impl Foo + ?Sized

+ //^^^^^^^ &'_ impl ?Sized

+} //^ fn(&'_ impl Foo + ?Sized) -> &'_ impl Foo + ?Sized

+ 100..119 'for _ ...!() {}': &'? mut IntoIterator::IntoIter<isize>

+ 100..119 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&'? mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item>

+ 372..380 '&spam!()': &'? isize

+ 114..133 'for _ ...!() {}': &'? mut IntoIterator::IntoIter<isize>

+ 114..133 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&'? mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item>

+ 386..394 '&spam!()': &'? isize

+ //^ &'? MessageRef

+ !0..2 '""': &'static str

+ 73..74 'x': &'static str

+ !0..13 '"helloworld!"': &'static str

+ 75..76 'x': &'static str

+} //^ &'static str

+} //^ &'static str

+ !0..13 '"helloworld!"': &'static str

+ 113..114 'x': &'static str

+ //^ &'static str

+ //^ Option<&'static str>

+ 29..33 'self': &'? Self

+ 32..36 'self': &'? Self

+ //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (S, S, &'? S)

+ 51..55 'self': &'? Self

+ 176..177 'd': &'? dyn Trait

+ 197..198 'd': &'? dyn Trait

+ 75..79 'self': &'? S

+ 133..134 's': &'? S

+ 137..151 'unsafe { f() }': &'static S

+ 146..147 'f': fn f() -> &'static S

+ 146..149 'f()': &'static S

+ 157..158 's': &'? S

+ //^ &'? i32

+ //^ &'? i32

+ //^ &'? i32

+ //^^ A<C<&'? str>, i32>

+ //^ Option<&'static str>

+ 74..79 '"foo"': &'static str

+ 74..79: expected u32, got &'static str

+ 151..172 'for a ...eak; }': &'? mut {unknown}

+ 151..172 'for a ...eak; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>

+ 237..250 'for a in b {}': &'? mut {unknown}

+ 237..250 'for a in b {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>

+ 315..337 'for a ...urn; }': &'? mut {unknown}

+ 315..337 'for a ...urn; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>

+ 8..9 'x': &'? i32

+ 27..28 'y': &'? i32

+ 31..32 'x': &'? i32

+ 42..44 '&z': &'? i32

+ 47..48 'x': &'? i32

+ 73..79 '(c, d)': (i32, &'static str)

+ 77..78 'd': &'static str

+ 82..94 '(1, "hello")': (i32, &'static str)

+ 86..93 '"hello"': &'static str

+ 101..151 'for (e... }': &'? mut {unknown}

+ 101..151 'for (e... }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>

+ 217..225 'x @ true': &'? bool

+ 228..233 '&true': &'? bool

+ 298..310 'ref ref_to_x': &'? &'? i32

+ 313..314 'x': &'? i32

+ 324..333 'mut mut_x': &'? i32

+ 336..337 'x': &'? i32

+ 347..367 'ref mu...f_to_x': &'? mut &'? i32

+ 370..371 'x': &'? i32

+ 381..382 'k': &'? mut &'? i32

+ 385..397 'mut_ref_to_x': &'? mut &'? i32

+ 37..38 'x': &'? i32

+ 59..64 '"foo"': &'static str

+ 59..64 '"foo"': &'static str

+ 67..70 'any': fn any<&'static str>() -> &'static str

+ 67..72 'any()': &'static str

+ 8..9 'x': &'? i32

+ 39..40 'n': &'? i32

+ 44..49 '&A(1)': &'? A<i32>

+ 61..62 'n': &'? mut i32

+ 66..75 '&mut A(1)': &'? mut A<i32>

+ 20..21 'v': &'? (i32, &'? i32)

+ 24..32 '&(1, &2)': &'? (i32, &'? i32)

+ 25..32 '(1, &2)': (i32, &'? i32)

+ 29..31 '&2': &'? i32

+ 42..49 '(_, &w)': (i32, &'? i32)

+ 46..48 '&w': &'? i32

+ 52..53 'v': &'? (i32, &'? i32)

+ 20..25 'slice': &'? [f64]

+ 36..42 '&[0.0]': &'? [f64; 1]

+ 54..59 'slice': &'? [f64]

+ 70..73 '&[]': &'? [f64]

+ 89..93 '&[a]': &'? [f64]

+ 133..140 '&[b, c]': &'? [f64]

+ 194..195 '_': &'? [f64]

+ 20..21 's': &'? str

+ 30..37 '"hello"': &'static str

+ 49..50 's': &'? str

+ 61..68 '"hello"': &'static str

+ 61..68 '"hello"': &'static str

+ 83..84 '_': &'? str

+ 105..109 'self': &'? [T; N]

+ 157..180 '{ ... }': &'? [u8]

+ 216..222 'b"foo"': &'static [u8]

+ 216..222 'b"foo"': &'static [u8]

+ 225..230 '&v[S]': &'? [u8]

+ 245..251 'b"foo"': &'static [u8; 3]

+ 245..251 'b"foo"': &'static [u8; 3]

+ 254..256 '&v': &'? [u8; 3]

+ 20..21 's': &'? str

+ 30..37 '"hello"': &'static str

+ 49..50 's': &'? str

+ 61..68 '"hello"': &'static str

+ 61..68 '"hello"': &'static str

+ 61..78 '"hello...world"': &'? str

+ 71..78 '"world"': &'static str

+ 71..78 '"world"': &'static str

+ 93..94 '_': &'? str

+ 255..274 'ref d ...{ .. }': &'? E

+ 284..285 'd': &'? E

+ 61..62 's': &'? usize

+ 67..75 '&Foo(0,)': &'? Foo

+ 94..95 's': &'? mut usize

+ 100..112 '&mut Foo(0,)': &'? mut Foo

+ 27..31 'self': &'? S

+ "#]],

+ 78..81 'foo': fn foo<&'? (i32, &'? str), i32, impl FnOnce(&'? (i32, &'? str)) -> i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> i32) -> i32

+ 82..91 '&(1, "a")': &'? (i32, &'static str)

+ 83..91 '(1, "a")': (i32, &'static str)

+ 87..90 '"a"': &'static str

+ 93..104 '|&(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> i32

+ 94..101 '&(x, y)': &'? (i32, &'? str)

+ 95..101 '(x, y)': (i32, &'? str)

+ 99..100 'y': &'? str

+ 142..145 'foo': fn foo<&'? (i32, &'? str), &'? i32, impl FnOnce(&'? (i32, &'? str)) -> &'? i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> &'? i32) -> &'? i32

+ 142..168 'foo(&(...y)| x)': &'? i32

+ 146..155 '&(1, "a")': &'? (i32, &'static str)

+ 147..155 '(1, "a")': (i32, &'static str)

+ 151..154 '"a"': &'static str

+ 157..167 '|(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> &'? i32

+ 158..164 '(x, y)': (i32, &'? str)

+ 159..160 'x': &'? i32

+ 162..163 'y': &'? &'? str

+ 166..167 'x': &'? i32

+ 7..13 'params': &'? [i32]

+ 35..41 'params': &'? [i32]

+ 53..57 'head': &'? i32

+ 59..68 'tail @ ..': &'? [i32]

+ //^^^ VaListImpl<'?>

+ //^^^^^^^ expected &'? (), got &'? mut ()

+ //^^^ expected &'? mut (), got &'? ()

+ //^^^^ &'? u32

+ //^^^^ &'? u32

+ //^^^^^^^^^^^^^^^^^^^^ expected &'? i32, got i32

+ 41..43 '&y': &'? {unknown}

+ 20..21 'x': &'? {unknown}

+ 24..31 'unknown': &'? {unknown}

+ 58..76 '[(x, y..., &x)]': [(&'? {unknown}, {unknown}); 2]

+ 59..65 '(x, y)': (&'? {unknown}, {unknown})

+ 60..61 'x': &'? {unknown}

+ 67..75 '(&y, &x)': (&'? {unknown}, {unknown})

+ 68..70 '&y': &'? {unknown}

+ 72..74 '&x': &'? &'? {unknown}

+ 73..74 'x': &'? {unknown}

+ 105..122 'ref mu...ething': &'? mut {unknown}

+ 28..49 '&[0, b...b'\n']': &'? [u8; 4]

+ 32..320 'for co... }': &'? mut {unknown}

+ 32..320 'for co... }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>

+ 75..79 'name': &'? {unknown}

+ 82..166 'if doe... }': &'? {unknown}

+ 99..128 '{ ... }': &'? {unknown}

+ 113..118 'first': &'? {unknown}

+ 134..166 '{ ... }': &'? {unknown}

+ 148..156 '&content': &'? {unknown}

+ 181..188 'content': &'? {unknown}

+ 191..313 'if ICE... }': &'? {unknown}

+ 241..246 '&name': &'? &'? {unknown}

+ 242..246 'name': &'? {unknown}

+ 248..276 '{ ... }': &'? {unknown}

+ 262..266 'name': &'? {unknown}

+ 142..163 '&query....value': &'? QueryResponse<R>

+ 7..13 'params': &'? [usize]

+ 37..43 'params': &'? [usize]

+ 55..62 'ps @ ..': &'? [usize]