+ names: [self, rustc_tests, ripgrep-13.0.0, webrender-2022, diesel-1.4.8, hyper-0.14.18]

+ - name: Download rustc_tests metrics

+ uses: actions/download-artifact@v3

+ with:

+ name: rustc_tests-${{ github.sha }}

+

+ jq -s ".[0] * .[1] * .[2] * .[3] * .[4] * .[5] * .[6]" build.json self.json rustc_tests.json ripgrep-13.0.0.json webrender-2022.json diesel-1.4.8.json hyper-0.14.18.json -c >> metrics/metrics.json

+ "line-index 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

+version = "0.1.1"

+version = "0.1.1"

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

+checksum = "67d61795376ae2683928c218fda7d7d7db136fd38c06b7552904667f0d55580a"

+ "walkdir",

+line-index = { version = "0.1.1" }

+ _ = Self::ASSERT_MAX_FILE_ID_IS_SAME;

+ assert!(id.index() <= Self::MAX_HIR_FILE_ID, "FileId index {} is too large", id.index());

+ _ = Self::ASSERT_MAX_FILE_ID_IS_SAME;

+ assert!(id <= Self::MAX_HIR_FILE_ID, "MacroCallId index {} is too large", id);

+ const ASSERT_MAX_FILE_ID_IS_SAME: () =

+ [()][(Self::MAX_HIR_FILE_ID != FileId::MAX_FILE_ID) as usize];

+

+ const MAX_HIR_FILE_ID: u32 = u32::MAX ^ Self::MACRO_FILE_TAG_MASK;

+//! It was last synchronized with upstream commit c3def263a44e07e09ae6d57abfc8650227fb4972.

+ gated!(coverage, Normal, template!(Word, List: "on|off"), WarnFollowing, coverage_attribute, experimental!(coverage)),

+ rustc_attr!(

+ rustc_confusables, Normal,

+ template!(List: r#""name1", "name2", ..."#),

+ ErrorFollowing,

+ INTERNAL_UNSTABLE,

+ ),

+ // Ensure the argument to this function is &&str during const-check.

+ rustc_attr!(

+ rustc_const_panic_str, Normal, template!(Word), WarnFollowing, INTERNAL_UNSTABLE

+ ),

+ rustc_never_returns_null_ptr, Normal, template!(Word), ErrorFollowing,

+ "#[rustc_never_returns_null_ptr] is used to mark functions returning non-null pointers."

+ ),

+ rustc_attr!(

+ rustc_deny_explicit_impl,

+ AttributeType::Normal,

+ template!(List: "implement_via_object = (true|false)"),

+ ErrorFollowing,

+ @only_local: true,

+ rustc_attr!(

+ rustc_safe_intrinsic, Normal, template!(Word), WarnFollowing,

+ "the `#[rustc_safe_intrinsic]` attribute is used internally to mark intrinsics as safe"

+ ),

+ rustc_attr!(TEST, rustc_variance_of_opaques, Normal, template!(Word), WarnFollowing),

+ rustc_attr!(TEST, rustc_hidden_type_of_opaques, Normal, template!(Word), WarnFollowing),

+ rustc_attr!(TEST, rustc_abi, Normal, template!(List: "field1, field2, ..."), WarnFollowing),

+ rustc_attr!(TEST, rustc_dump_user_args, Normal, template!(Word), WarnFollowing),

+use hir_expand::{attrs::collect_attrs, HirFileId};

+ if let Some((_, Either::Left(attr))) =

+ collect_attrs(&adt).nth(attr_id.ast_index())

+ // Don't create an `Expander` if not needed since this

+ // could cause a reparse after the `ItemTree` has been created due to the spanmap.

+ let mut expander =

+ Lazy::new(|| (module.def_map(db), Expander::new(db, loc.id.file_id(), module)));

+use stdx::format_to;

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

+ pub fn dump(&self, db: &dyn DefDatabase) -> String {

+ let mut out = String::new();

+ for (k, v) in self.map.iter() {

+ format_to!(out, "{:?} ({:?}) -> ", k, v.1);

+ for v in &v.0 {

+ format_to!(out, "{}:{:?}, ", v.name.display(db.upcast()), v.container);

+ }

+ format_to!(out, "\n");

+ }

+ out

+ }

+

+ .flat_map(|(&item, (info, is_assoc))| {

+ info.iter().map(move |info| {

+ (item, *is_assoc, info.name.as_str().unwrap().to_ascii_lowercase())

+ })

+ importables.sort_by(|(_, l_is_assoc, lhs_name), (_, r_is_assoc, rhs_name)| {

+ lhs_name.cmp(rhs_name).then_with(|| l_is_assoc.cmp(r_is_assoc))

+ });

+ let iter = importables

+ .iter()

+ .enumerate()

+ .dedup_by(|(_, (_, _, lhs)), (_, (_, _, rhs))| lhs == rhs);

+ for (start_idx, (_, _, name)) in iter {

+ importables: importables.into_iter().map(|(item, _, _)| item).collect(),

+ fn import_matches(&self, import: &ImportInfo, enforce_lowercase: bool) -> bool {

+ let input = import.name.to_smol_str();

+ let mut _s_slot;

+ let input = if case_insensitive {

+ _s_slot = String::from(input);

+ _s_slot.make_ascii_lowercase();

+ &*_s_slot

+ } else {

+ &*input

+ };

+ if !input_chars.any(|it| it == query_char) {

+

+ // FIXME: Improve this, its rather unreadable and does duplicate amount of work

+ // Fetch all the known names of this importable item (to handle import aliases/renames)

+ .filter(|&info| query.import_matches(info, true))

+

+ let &(ref import_infos, _) = &import_map.map[item];

+ import_infos.iter().any(|info| query.import_matches(info, false))

+ if never!(syntax.kind() == SyntaxKind::ERROR, "{:?} from {:?} {}", file_id, syntax, syntax) {

+ return Default::default();

+ }

+/// Something that holds types, required for the current const arg lowering implementation as they

+/// need to be able to query where they are defined.

+ TypeOwnerId::InTypeConstId(_) | TypeOwnerId::StaticId(_) => return None,

+ EnumVariantId

+ // FIXME(const-generic-body): The expected type should not be

+ pub expected_ty: Box<dyn OpaqueInternableThing>,

+ self.id == other.id

+ && self.owner == other.owner

+ && &*self.expected_ty == &*other.expected_ty

+ () => (

+ $crate::__rust_force_expr!($crate::vec::Vec::new())

+ );

+ ($elem:expr; $n:expr) => (

+ $crate::__rust_force_expr!($crate::vec::from_elem($elem, $n))

+ );

+ ($($x:expr),+ $(,)?) => (

+ $crate::__rust_force_expr!(<[_]>::into_vec(

+ // This rustc_box is not required, but it produces a dramatic improvement in compile

+ // time when constructing arrays with many elements.

+ #[rustc_box]

+ $crate::boxed::Box::new([$($x),+])

+ ))

+ );

+}

+

+macro_rules! __rust_force_expr {

+ ($e:expr) => {

+ $e

+ };

+

+ vec![a.];

+ () => (

+ $crate::__rust_force_expr!($crate::vec::Vec::new())

+ );

+ ($elem:expr; $n:expr) => (

+ $crate::__rust_force_expr!($crate::vec::from_elem($elem, $n))

+ );

+ ($($x:expr),+ $(,)?) => (

+ $crate::__rust_force_expr!(<[_]>::into_vec(

+ // This rustc_box is not required, but it produces a dramatic improvement in compile

+ // time when constructing arrays with many elements.

+ #[rustc_box]

+ $crate::boxed::Box::new([$($x),+])

+ ))

+ );

+}

+

+macro_rules! __rust_force_expr {

+ ($e:expr) => {

+ $e

+ };

+

+ $crate::__rust_force_expr!($crate:: vec:: Vec:: new());

+ $crate::__rust_force_expr!(<[_]>:: into_vec(#[rustc_box]$crate:: boxed:: Box:: new([1u32, 2])));

+ /* error: expected Expr */$crate::__rust_force_expr!($crate:: vec:: from_elem((a.), $n));

+}

+"#]],

+ );

+ // FIXME we should ahev testing infra for multi level expansion tests

+ check(

+ r#"

+macro_rules! __rust_force_expr {

+ ($e:expr) => {

+ $e

+}

+

+fn main() {

+ __rust_force_expr!(crate:: vec:: Vec:: new());

+ __rust_force_expr!(<[_]>:: into_vec(#[rustc_box] crate:: boxed:: Box:: new([1u32, 2])));

+ __rust_force_expr/*+errors*/!(crate:: vec:: from_elem((a.), $n));

+}

+"#,

+ expect![[r#"

+macro_rules! __rust_force_expr {

+ ($e:expr) => {

+ $e

+

+fn main() {

+ (crate ::vec::Vec::new());

+ (<[_]>::into_vec(#[rustc_box] crate ::boxed::Box::new([1u32, 2])));

+ /* error: expected Expr *//* parse error: expected field name or number */

+/* parse error: expected expression */

+/* parse error: expected R_PAREN */

+/* parse error: expected COMMA */

+/* parse error: expected expression, item or let statement */

+(crate ::vec::from_elem((a.), $n));

+}

+ pub fn type_owner(&self) -> Option<TypeOwnerId> {

+ self.scopes().find_map(|scope| match scope {

+ Scope::BlockScope(_) => None,

+ &Scope::GenericParams { def, .. } => Some(def.into()),

+ &Scope::ImplDefScope(id) => Some(id.into()),

+ &Scope::AdtScope(adt) => Some(adt.into()),

+ Scope::ExprScope(it) => Some(it.owner.into()),

+ })

+ }

+

+ ast::{self, HasAttrs},

+ attrs::{collect_attrs, RawAttrs},

+ fixup::{self, reverse_fixups, SyntaxFixupUndoInfo},

+ collect_attrs(&item)

+ .and_then(|x| Either::left(x.1))

+ {

+ let mut tt = mbe::syntax_node_to_token_tree_modified(

+ &syntax,

+ map.as_ref(),

+ fixups.append.clone(),

+ fixups.remove.clone(),

+ );

+ reverse_fixups(&mut tt, &fixups.undo_info);

+ }

+ collect_attrs(&ast::Item::cast(node.clone())?)

+ .and_then(|x| Either::left(x.1))

+ eager: Some(Arc::new(EagerCallInfo { arg: Arc::new(subtree), arg_id, error: err.clone() })),

+use stdx::never;

+use tt::{Spacing, Span};

+const FIXUP_DUMMY_FILE: FileId = FileId::from_raw(FileId::MAX_FILE_ID);

+const FIXUP_DUMMY_AST_ID: ErasedFileAstId = ErasedFileAstId::from_raw(RawIdx::from_u32(!0));

+const FIXUP_DUMMY_RANGE: TextRange = TextRange::empty(TextSize::new(0));

+const FIXUP_DUMMY_RANGE_END: TextSize = TextSize::new(!0);

+ let dummy_range = FIXUP_DUMMY_RANGE;

+ let dummy_anchor = SpanAnchor { file_id: FIXUP_DUMMY_FILE, ast_id: FIXUP_DUMMY_AST_ID };

+ range: TextRange::new(TextSize::new(idx), FIXUP_DUMMY_RANGE_END),

+ if never!(

+ tt.delimiter.close.anchor.file_id == FIXUP_DUMMY_FILE

+ || tt.delimiter.open.anchor.file_id == FIXUP_DUMMY_FILE

+ ) {

+ tt.delimiter.close = SpanData::DUMMY;

+ tt.delimiter.open = SpanData::DUMMY;

+ }

+ let is_real_leaf = span.anchor.file_id != FIXUP_DUMMY_FILE;

+ let is_replaced_node = span.range.end() == FIXUP_DUMMY_RANGE_END;

+ is_real_leaf || is_replaced_node

+ if tt.delimiter.close.anchor.file_id == FIXUP_DUMMY_FILE

+ || tt.delimiter.open.anchor.file_id == FIXUP_DUMMY_FILE

+ {

+ // Even though fixup never creates subtrees with fixup spans, the old proc-macro server

+ // might copy them if the proc-macro asks for it, so we need to filter those out

+ // here as well.

+ return SmallVec::new_const();

+ }

+ if leaf.span().anchor.file_id == FIXUP_DUMMY_FILE {

+ // we have a fake node here, we need to replace it again with the original

+ // just a normal leaf

+use attrs::collect_attrs;

+ ast::{self, AstNode},

+ eager: Option<Arc<EagerCallInfo>>,

+ collect_attrs(&it)

+ .and_then(|it| match it.1 {

+ collect_attrs(&it)

+ .and_then(|it| match it.1 {

+ collect_attrs(&ast_id.to_node(db))

+ .1

+ MacroCallKind::Attr { ast_id, invoc_attr_index, .. } => {

+ collect_attrs(&ast_id.to_node(db))

+ .nth(invoc_attr_index.ast_index())

+ .expect("missing attribute")

+ .1

+ .expect_left("attribute macro is a doc comment?")

+ .syntax()

+ .text_range()

+ }

+ let tt = collect_attrs(&ast_id.to_node(db))

+ .and_then(|x| Either::left(x.1))?

+ end: TextSize,

+ RealSpanMap {

+ file_id,

+ pairs: Box::from([(TextSize::new(0), ROOT_ERASED_FILE_AST_ID)]),

+ end: TextSize::new(!0),

+ }

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

+ pairs

+ .extend(tree.items().map(|item| {

+ (item.syntax().text_range().start(), ast_id_map.ast_id(&item).erase())

+ }));

+ RealSpanMap {

+ file_id,

+ pairs: pairs.into_boxed_slice(),

+ end: tree.syntax().text_range().end(),

+ }

+ assert!(

+ range.end() <= self.end,

+ "range {range:?} goes beyond the end of the file {:?}",

+ self.end

+ );

+ .expected_ty

+ if self.is_non_ref_pat(self.body, pat) {

+ fn is_non_ref_pat(&mut self, body: &hir_def::body::Body, pat: PatId) -> bool {

+ match &body[pat] {

+ Pat::Tuple { .. }

+ | Pat::TupleStruct { .. }

+ | Pat::Record { .. }

+ | Pat::Range { .. }

+ | Pat::Slice { .. } => true,

+ Pat::Or(pats) => pats.iter().all(|p| self.is_non_ref_pat(body, *p)),

+ Pat::Path(p) => {

+ let v = self.resolve_value_path_inner(p, pat.into());

+ v.is_some_and(|x| !matches!(x.0, hir_def::resolver::ValueNs::ConstId(_)))

+ }

+ Pat::ConstBlock(..) => false,

+ Pat::Lit(expr) => !matches!(

+ body[*expr],

+ Expr::Literal(Literal::String(..) | Literal::CString(..) | Literal::ByteString(..))

+ ),

+ Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Box { .. } | Pat::Missing => {

+ false

+ }

+ }

+ let (value, self_subst) = self.resolve_value_path_inner(path, id)?;

+ pub(super) fn resolve_value_path_inner(

+ &mut self,

+ path: &Path,

+ id: ExprOrPatId,

+ ) -> Option<(ValueNs, Option<chalk_ir::Substitution<Interner>>)> {

+ let (value, self_subst) = if let Some(type_ref) = path.type_anchor() {

+ let last = path.segments().last()?;

+

+ // Don't use `self.make_ty()` here as we need `orig_ns`.

+ let ctx =

+ crate::lower::TyLoweringContext::new(self.db, &self.resolver, self.owner.into());

+ let (ty, orig_ns) = ctx.lower_ty_ext(type_ref);

+ let ty = self.table.insert_type_vars(ty);

+ let ty = self.table.normalize_associated_types_in(ty);

+

+ let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1);

+ let (ty, _) = ctx.lower_ty_relative_path(ty, orig_ns, remaining_segments_for_ty);

+ let ty = self.table.insert_type_vars(ty);

+ let ty = self.table.normalize_associated_types_in(ty);

+ self.resolve_ty_assoc_item(ty, last.name, id).map(|(it, substs)| (it, Some(substs)))?

+ } else {

+ // FIXME: report error, unresolved first path segment

+ let value_or_partial =

+ self.resolver.resolve_path_in_value_ns(self.db.upcast(), path)?;

+

+ match value_or_partial {

+ ResolveValueResult::ValueNs(it, _) => (it, None),

+ ResolveValueResult::Partial(def, remaining_index, _) => self

+ .resolve_assoc_item(def, path, remaining_index, id)

+ .map(|(it, substs)| (it, Some(substs)))?,

+ }

+ };

+ Some((value, self_subst))

+ }

+

+ // FIXME: Should not be an `Option` but `Resolver` currently does not return owners in all cases

+ // where expected

+ owner: Option<TypeOwnerId>,

+ Self::new_maybe_unowned(db, resolver, Some(owner))

+ }

+

+ pub fn new_maybe_unowned(

+ db: &'a dyn HirDatabase,

+ resolver: &'a Resolver,

+ owner: Option<TypeOwnerId>,

+ ) -> Self {

+ let Some(owner) = self.owner else { return unknown_const(const_type) };

+ owner,

+ let type_alias_data = db.type_alias_data(t);

+ if type_alias_data.is_extern {

+ let type_ref = &type_alias_data.type_ref;

+ expected_ty: Box::new(InTypeConstIdMetadata(expected_ty.clone())),

+//- /lib.rs

+fn foo() -> i32 {

+ $01 + 1

+}",

+fn foo() -> i32 {

+ 1

+ +

+ 1

+}";

+

+#[test]

+fn typing_inside_a_function_should_not_invalidate_types_in_another() {

+ let (mut db, pos) = TestDB::with_position(

+ "

+//- /lib.rs

+fn foo() -> f32 {

+ 1.0 + 2.0

+}

+fn bar() -> i32 {

+ $01 + 1

+}

+fn baz() -> i32 {

+ 1 + 1

+}",

+ );

+ {

+ let events = db.log_executed(|| {

+ let module = db.module_for_file(pos.file_id);

+ let crate_def_map = module.def_map(&db);

+ visit_module(&db, &crate_def_map, module.local_id, &mut |def| {

+ db.infer(def);

+ });

+ });

+ assert!(format!("{events:?}").contains("infer"))

+ }

+

+ let new_text = "

+fn foo() -> f32 {

+ 1.0 + 2.0

+}

+fn bar() -> i32 {

+ 53

+}

+fn baz() -> i32 {

+ 1 + 1

+}

+";

+

+ db.set_file_text(pos.file_id, Arc::from(new_text));

+

+ {

+ let events = db.log_executed(|| {

+ let module = db.module_for_file(pos.file_id);

+ let crate_def_map = module.def_map(&db);

+ visit_module(&db, &crate_def_map, module.local_id, &mut |def| {

+ db.infer(def);

+ });

+ });

+ assert!(format!("{events:?}").matches("infer").count() == 1, "{events:#?}")

+ }

+}

+

+#[test]

+fn type_mismatch_pat_const_reference() {

+ check_no_mismatches(

+ r#"

+const TEST_STR: &'static str = "abcd";

+

+fn main() {

+ let s = "abcd";

+ match s {

+ TEST_STR => (),

+ _ => (),

+ }

+}

+

+ "#,

+ );

+ check(

+ r#"

+struct Foo<T>(T);

+

+impl<T> Foo<T> {

+ const TEST_I32_REF: &'static i32 = &3;

+ const TEST_I32: i32 = 3;

+}

+

+fn main() {

+ match &6 {

+ Foo::<i32>::TEST_I32_REF => (),

+ Foo::<i32>::TEST_I32 => (),

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

+ _ => (),

+ }

+}

+

+ "#,

+ );

+}

+ attrs::collect_attrs, db::ExpandDatabase, files::InRealFile, name::AsName, ExpansionInfo,

+ InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt,

+ ast::{self, HasAttrs as _, HasGenericParams, HasLoopBody, IsString as _},

+ // FIXME: here, the attribute's text range is used to strip away all

+ // entries from the start of the attribute "list" up the the invoking

+ // attribute. But in

+ // ```

+ // mod foo {

+ // #![inner]

+ // }

+ // ```

+ // we don't wanna strip away stuff in the `mod foo {` range, that is

+ // here if the id corresponds to an inner attribute we got strip all

+ // text ranges of the outer ones, and then all of the inner ones up

+ // to the invoking attribute so that the inbetween is ignored.

+ let start = collect_attrs(&item)

+ .map(|attr| match attr.1 {

+ let ty = hir_ty::TyLoweringContext::new_maybe_unowned(

+ analyze.resolver.type_owner(),

+ let (_, res) =

+ TyLoweringContext::new_maybe_unowned(db, resolver, resolver.type_owner())

+ .lower_ty_ext(type_ref);

+ pub is_assoc: bool,

+ self.push_decl(id, false);

+ ModuleDefId::AdtId(AdtId::StructId(id)) => self.push_decl(id, false),

+ ModuleDefId::AdtId(AdtId::EnumId(id)) => self.push_decl(id, false),

+ ModuleDefId::AdtId(AdtId::UnionId(id)) => self.push_decl(id, false),

+ self.push_decl(id, false);

+ self.push_decl(id, false);

+ self.push_decl(id, false);

+ self.push_decl(id, false);

+ self.push_decl(id, false);

+ MacroId::Macro2Id(id) => self.push_decl(id, false),

+ MacroId::MacroRulesId(id) => self.push_decl(id, false),

+ MacroId::ProcMacroId(id) => self.push_decl(id, false),

+ is_assoc: false,

+ MacroId::Macro2Id(id) => self.push_decl(id, false),

+ MacroId::MacroRulesId(id) => self.push_decl(id, false),

+ MacroId::ProcMacroId(id) => self.push_decl(id, false),

+ AssocItemId::FunctionId(id) => self.push_decl(id, true),

+ AssocItemId::ConstId(id) => self.push_decl(id, true),

+ AssocItemId::TypeAliasId(id) => self.push_decl(id, true),

+ fn push_decl<L>(&mut self, id: L, is_assoc: bool)

+ is_assoc,

+ is_assoc,

+ is_assoc: false,

+ is_assoc: false,

+ edit.replace(ctx.sema.original_range(name_ref.syntax()).range, name.text());

+ label_detail.replace(SmolStr::from(format!(

+ "{} (use {})",

+ label_detail.as_deref().unwrap_or_default(),

+ import_edit.import_path.display(db)

+ )));

+ Some((path.len() > 1).then(|| LocatedImport::new(path.clone(), item, item)))

+ ct SPECIAL_CONST (use dep::test_mod::TestTrait) u8 DEPRECATED

+ st Item (use foo::bar) Item

+use foo::bar;

+mod foo {

+ pub mod bar {

+ pub mod baz {

+ pub struct Item;

+ }

+}

+fn main() {

+ bar::baz::Item

+}"#,

+ ct TEST_ASSOC (use foo::bar) usize

+

+ AsAssocItem, AssocItem, AssocItemContainer, Crate, ItemInNs, ModPath, Module, ModuleDef, Name,

+use itertools::{EitherOrBoth, Itertools};

+use rustc_hash::{FxHashMap, FxHashSet};

+ AstNode, SmolStr, SyntaxNode,

+ pub qualifier: Option<Vec<SmolStr>>,

+ pub fn new(import_path: ModPath, item_to_import: ItemInNs, original_item: ItemInNs) -> Self {

+ Self { import_path, item_to_import, original_item }

+ Some(LocatedImport::new(mod_path, item, item))

+ Some(qualifier) => items_locator::items_with_name(

+ sema,

+ current_crate,

+ path_candidate.name.clone(),

+ AssocSearchMode::Include,

+ Some(DEFAULT_QUERY_SEARCH_LIMIT.inner()),

+ )

+ .filter_map(|item| import_for_item(sema.db, mod_path, &qualifier, item))

+ .collect(),

+ unresolved_qualifier: &[SmolStr],

+ let [first_segment, ..] = unresolved_qualifier else { return None };

+ let item_as_assoc = item_as_assoc(db, original_item);

+

+ let (original_item_candidate, trait_item_to_import) = match item_as_assoc {

+ Some(assoc_item) => match assoc_item.container(db) {

+ AssocItemContainer::Trait(trait_) => {

+ let trait_ = ItemInNs::from(ModuleDef::from(trait_));

+ (trait_, Some(trait_))

+ }

+ AssocItemContainer::Impl(impl_) => {

+ (ItemInNs::from(ModuleDef::from(impl_.self_ty(db).as_adt()?)), None)

+ }

+ },

+ None => (original_item, None),

+ };

+ let mut import_path_candidate_segments = import_path_candidate.segments().iter().rev();

+ let predicate = |it: EitherOrBoth<&SmolStr, &Name>| match it {

+ // segments match, check next one

+ EitherOrBoth::Both(a, b) if b.as_str() == Some(&**a) => None,

+ // segments mismatch / qualifier is longer than the path, bail out

+ EitherOrBoth::Both(..) | EitherOrBoth::Left(_) => Some(false),

+ // all segments match and we have exhausted the qualifier, proceed

+ EitherOrBoth::Right(_) => Some(true),

+ if item_as_assoc.is_none() {

+ let item_name = item_name(db, original_item)?.as_text()?;

+ let last_segment = import_path_candidate_segments.next()?;

+ if last_segment.as_str() != Some(&*item_name) {

+ return None;

+ }

+ }

+ let ends_with = unresolved_qualifier

+ .iter()

+ .rev()

+ .zip_longest(import_path_candidate_segments)

+ .find_map(predicate)

+ .unwrap_or(true);

+ if !ends_with {

+ let segment_import = find_import_for_segment(db, original_item_candidate, first_segment)?;

+

+ (false, Some(trait_to_import)) => {

+ LocatedImport::new(mod_path(trait_to_import)?, trait_to_import, original_item)

+ }

+ (true, None) => {

+ LocatedImport::new(import_path_candidate, original_item_candidate, original_item)

+ }

+ (false, None) => {

+ LocatedImport::new(mod_path(segment_import)?, segment_import, original_item)

+ }

+ Some(assoc_item) => item_for_path_search_assoc(db, assoc_item)?,

+fn item_for_path_search_assoc(db: &RootDatabase, assoc_item: AssocItem) -> Option<ItemInNs> {

+ Some(match assoc_item.container(db) {

+ AssocItemContainer::Trait(trait_) => ItemInNs::from(ModuleDef::from(trait_)),

+ AssocItemContainer::Impl(impl_) => {

+ ItemInNs::from(ModuleDef::from(impl_.self_ty(db).as_adt()?))

+ }

+ })

+}

+

+ let mut trait_import_paths = FxHashMap::default();

+ let import_path = trait_import_paths

+ .entry(trait_item)

+ .or_insert_with(|| mod_path(trait_item))

+ .clone()?;

+ import_path,

+ assoc_to_item(assoc),

+ let import_path = trait_import_paths

+ .entry(trait_item)

+ .or_insert_with(|| mod_path(trait_item))

+ .clone()?;

+ import_path,

+ assoc_to_item(assoc),

+ if qualifier.first_qualifier().map_or(true, |it| sema.resolve_path(&it).is_none()) {

+ let mut qualifier = qualifier

+ .segments_of_this_path_only_rev()

+ .map(|seg| seg.name_ref().map(|name| SmolStr::new(name.text())))

+ .collect::<Option<Vec<_>>>()?;

+ qualifier.reverse();

+ ImportCandidate::Path(PathImportCandidate { qualifier: Some(qualifier), name })

+use hir::{import_map, Crate, ItemInNs, Semantics};

+pub static DEFAULT_QUERY_SEARCH_LIMIT: Limit = Limit::new(100);

+ let mut external_query =

+ // import_map::Query::new(exact_name).assoc_search_mode(assoc_item_search);

+ import_map::Query::new(exact_name);

+ AssocSearchMode::Exclude => !candidate.is_assoc,

+ AssocSearchMode::AssocItemsOnly => candidate.is_assoc,

+#[derive(Debug, Clone)]

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: true,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: true,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+ is_assoc: false,

+

+ #[test]

+ fn regression_panic_with_inner_attribute_in_presence_of_unresolved_crate() {

+ check_diagnostics(

+ r#"

+ mod _test_inner {

+ #![empty_attr]

+ //^^^^^^^^^^^^^^ error: unresolved macro `empty_attr`

+ }

+"#,

+ );

+ }

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

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

+pub enum RangeLimit {

+ Fixed(TextRange),

+ NearestParent(TextSize),

+}

+

+ range_limit: Option<RangeLimit>,

+ Some(RangeLimit::Fixed(range)) => match file.covering_element(range) {

+ Some(RangeLimit::NearestParent(position)) => {

+ match file.token_at_offset(position).left_biased() {

+ Some(token) => {

+ if let Some(parent_block) =

+ token.parent_ancestors().find_map(ast::BlockExpr::cast)

+ {

+ parent_block.syntax().descendants().for_each(hints)

+ } else if let Some(parent_item) =

+ token.parent_ancestors().find_map(ast::Item::cast)

+ {

+ parent_item.syntax().descendants().for_each(hints)

+ } else {

+ return acc;

+ }

+ }

+ None => return acc,

+ }

+ }

+ use crate::{

+ fixture,

+ inlay_hints::{InlayHintsConfig, RangeLimit},

+ ClosureReturnTypeHints,

+ };

+ Some(RangeLimit::Fixed(TextRange::new(TextSize::from(500), TextSize::from(600)))),

+ InlayHintsConfig, InlayKind, InlayTooltip, LifetimeElisionHints, RangeLimit,

+pub use ide_diagnostics::{

+ Diagnostic, DiagnosticCode, DiagnosticsConfig, ExprFillDefaultMode, Severity,

+};

+ range: Option<RangeLimit>,

+ span: conv.span_for(TextRange::new(

+ while curr != cursor {

+ let Some(token) = curr.token_tree() else { break };

+ res.push(token.cloned());

+ curr = curr.bump();

+ }

+ fn injected_env_var(&mut self, _var: &str) -> Option<String> {

+ None

+ }

+

+walkdir = "2.3.2"

+ flags::RustAnalyzerCmd::RustcTests(cmd) => cmd.run()?,

+mod rustc_tests;

+ /// Run unit tests of the project using mir interpreter

+ cmd rustc-tests {

+ /// Directory with Cargo.toml.

+ required rustc_repo: PathBuf

+

+ /// Only run tests with filter as substring

+ optional --filter path: String

+ }

+

+ RustcTests(RustcTests),

+pub struct RustcTests {

+ pub rustc_repo: PathBuf,

+ pub filter: Option<String>,

+}

+

+#[derive(Debug)]

+//! Run all tests in a project, similar to `cargo test`, but using the mir interpreter.

+

+use std::{

+ cell::RefCell, collections::HashMap, fs::read_to_string, panic::AssertUnwindSafe, path::PathBuf,

+};

+

+use hir::Crate;

+use ide::{AnalysisHost, Change, DiagnosticCode, DiagnosticsConfig};

+use profile::StopWatch;

+use project_model::{CargoConfig, ProjectWorkspace, RustLibSource, Sysroot};

+

+use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};

+use triomphe::Arc;

+use vfs::{AbsPathBuf, FileId};

+use walkdir::WalkDir;

+

+use crate::cli::{flags, report_metric, Result};

+

+struct Tester {

+ host: AnalysisHost,

+ root_file: FileId,

+ pass_count: u64,

+ ignore_count: u64,

+ fail_count: u64,

+ stopwatch: StopWatch,

+}

+

+fn string_to_diagnostic_code_leaky(code: &str) -> DiagnosticCode {

+ thread_local! {

+ static LEAK_STORE: RefCell<HashMap<String, DiagnosticCode>> = RefCell::new(HashMap::new());

+ }

+ LEAK_STORE.with_borrow_mut(|s| match s.get(code) {

+ Some(c) => *c,

+ None => {

+ let v = DiagnosticCode::RustcHardError(format!("E{code}").leak());

+ s.insert(code.to_owned(), v);

+ v

+ }

+ })

+}

+

+fn detect_errors_from_rustc_stderr_file(p: PathBuf) -> HashMap<DiagnosticCode, usize> {

+ let text = read_to_string(p).unwrap();

+ let mut result = HashMap::new();

+ {

+ let mut text = &*text;

+ while let Some(p) = text.find("error[E") {

+ text = &text[p + 7..];

+ let code = string_to_diagnostic_code_leaky(&text[..4]);

+ *result.entry(code).or_insert(0) += 1;

+ }

+ }

+ result

+}

+

+impl Tester {

+ fn new() -> Result<Self> {

+ let tmp_file = AbsPathBuf::assert("/tmp/ra-rustc-test.rs".into());

+ std::fs::write(&tmp_file, "")?;

+ let mut cargo_config = CargoConfig::default();

+ cargo_config.sysroot = Some(RustLibSource::Discover);

+ let workspace = ProjectWorkspace::DetachedFiles {

+ files: vec![tmp_file.clone()],

+ sysroot: Ok(

+ Sysroot::discover(tmp_file.parent().unwrap(), &cargo_config.extra_env).unwrap()

+ ),

+ rustc_cfg: vec![],

+ };

+ let load_cargo_config = LoadCargoConfig {

+ load_out_dirs_from_check: false,

+ with_proc_macro_server: ProcMacroServerChoice::Sysroot,

+ prefill_caches: false,

+ };

+ let (host, _vfs, _proc_macro) =

+ load_workspace(workspace, &cargo_config.extra_env, &load_cargo_config)?;

+ let db = host.raw_database();

+ let krates = Crate::all(db);

+ let root_crate = krates.iter().cloned().find(|krate| krate.origin(db).is_local()).unwrap();

+ let root_file = root_crate.root_file(db);

+ Ok(Self {

+ host,

+ root_file,

+ pass_count: 0,

+ ignore_count: 0,

+ fail_count: 0,

+ stopwatch: StopWatch::start(),

+ })

+ }

+

+ fn test(&mut self, p: PathBuf) {

+ if p.parent().unwrap().file_name().unwrap() == "auxiliary" {

+ // These are not tests

+ return;

+ }

+ if IGNORED_TESTS.iter().any(|ig| p.file_name().is_some_and(|x| x == *ig)) {

+ println!("{p:?} IGNORE");

+ self.ignore_count += 1;

+ return;

+ }

+ let stderr_path = p.with_extension("stderr");

+ let expected = if stderr_path.exists() {

+ detect_errors_from_rustc_stderr_file(stderr_path)

+ } else {

+ HashMap::new()

+ };

+ let text = read_to_string(&p).unwrap();

+ let mut change = Change::new();

+ // Ignore unstable tests, since they move too fast and we do not intend to support all of them.

+ let mut ignore_test = text.contains("#![feature");

+ // Ignore test with extern crates, as this infra don't support them yet.

+ ignore_test |= text.contains("// aux-build:") || text.contains("// aux-crate:");

+ // Ignore test with extern modules similarly.

+ ignore_test |= text.contains("mod ");

+ // These should work, but they don't, and I don't know why, so ignore them.

+ ignore_test |= text.contains("extern crate proc_macro");

+ let should_have_no_error = text.contains("// check-pass")

+ || text.contains("// build-pass")

+ || text.contains("// run-pass");

+ change.change_file(self.root_file, Some(Arc::from(text)));

+ self.host.apply_change(change);

+ let diagnostic_config = DiagnosticsConfig::test_sample();

+ let diags = self

+ .host

+ .analysis()

+ .diagnostics(&diagnostic_config, ide::AssistResolveStrategy::None, self.root_file)

+ .unwrap();

+ let mut actual = HashMap::new();

+ for diag in diags {

+ if !matches!(diag.code, DiagnosticCode::RustcHardError(_)) {

+ continue;

+ }

+ if !should_have_no_error && !SUPPORTED_DIAGNOSTICS.contains(&diag.code) {

+ continue;

+ }

+ *actual.entry(diag.code).or_insert(0) += 1;

+ }

+ // Ignore tests with diagnostics that we don't emit.

+ ignore_test |= expected.keys().any(|k| !SUPPORTED_DIAGNOSTICS.contains(k));

+ if ignore_test {

+ println!("{p:?} IGNORE");

+ self.ignore_count += 1;

+ } else if actual == expected {

+ println!("{p:?} PASS");

+ self.pass_count += 1;

+ } else {

+ println!("{p:?} FAIL");

+ println!("actual (r-a) = {:?}", actual);

+ println!("expected (rustc) = {:?}", expected);

+ self.fail_count += 1;

+ }

+ }

+

+ fn report(&mut self) {

+ println!(

+ "Pass count = {}, Fail count = {}, Ignore count = {}",

+ self.pass_count, self.fail_count, self.ignore_count

+ );

+ println!("Testing time and memory = {}", self.stopwatch.elapsed());

+ report_metric("rustc failed tests", self.fail_count, "#");

+ report_metric("rustc testing time", self.stopwatch.elapsed().time.as_millis() as u64, "ms");

+ }

+}

+

+/// These tests break rust-analyzer (either by panicking or hanging) so we should ignore them.

+const IGNORED_TESTS: &[&str] = &[

+ "trait-with-missing-associated-type-restriction.rs", // #15646

+ "trait-with-missing-associated-type-restriction-fixable.rs", // #15646

+ "resolve-self-in-impl.rs",

+ "basic.rs", // ../rust/tests/ui/associated-type-bounds/return-type-notation/basic.rs

+ "issue-26056.rs",

+ "float-field.rs",

+ "invalid_operator_trait.rs",

+ "type-alias-impl-trait-assoc-dyn.rs",

+ "deeply-nested_closures.rs", // exponential time

+ "hang-on-deeply-nested-dyn.rs", // exponential time

+ "dyn-rpit-and-let.rs", // unexpected free variable with depth `^1.0` with outer binder ^0

+ "issue-16098.rs", // Huge recursion limit for macros?

+ "issue-83471.rs", // crates/hir-ty/src/builder.rs:78:9: assertion failed: self.remaining() > 0

+];

+

+const SUPPORTED_DIAGNOSTICS: &[DiagnosticCode] = &[

+ DiagnosticCode::RustcHardError("E0023"),

+ DiagnosticCode::RustcHardError("E0046"),

+ DiagnosticCode::RustcHardError("E0063"),

+ DiagnosticCode::RustcHardError("E0107"),

+ DiagnosticCode::RustcHardError("E0117"),

+ DiagnosticCode::RustcHardError("E0133"),

+ DiagnosticCode::RustcHardError("E0210"),

+ DiagnosticCode::RustcHardError("E0268"),

+ DiagnosticCode::RustcHardError("E0308"),

+ DiagnosticCode::RustcHardError("E0384"),

+ DiagnosticCode::RustcHardError("E0407"),

+ DiagnosticCode::RustcHardError("E0432"),

+ DiagnosticCode::RustcHardError("E0451"),

+ DiagnosticCode::RustcHardError("E0507"),

+ DiagnosticCode::RustcHardError("E0583"),

+ DiagnosticCode::RustcHardError("E0559"),

+ DiagnosticCode::RustcHardError("E0616"),

+ DiagnosticCode::RustcHardError("E0618"),

+ DiagnosticCode::RustcHardError("E0624"),

+ DiagnosticCode::RustcHardError("E0774"),

+ DiagnosticCode::RustcHardError("E0767"),

+ DiagnosticCode::RustcHardError("E0777"),

+];

+

+impl flags::RustcTests {

+ pub fn run(self) -> Result<()> {

+ let mut tester = Tester::new()?;

+ let walk_dir = WalkDir::new(self.rustc_repo.join("tests/ui"));

+ for i in walk_dir {

+ let i = i?;

+ let p = i.into_path();

+ if let Some(f) = &self.filter {

+ if !p.as_os_str().to_string_lossy().contains(f) {

+ continue;

+ }

+ }

+ if p.extension().map_or(true, |x| x != "rs") {

+ continue;

+ }

+ if let Err(e) = std::panic::catch_unwind({

+ let tester = AssertUnwindSafe(&mut tester);

+ let p = p.clone();

+ move || {

+ let tester = tester;

+ tester.0.test(p);

+ }

+ }) {

+ println!("panic detected at test {:?}", p);

+ std::panic::resume_unwind(e);

+ }

+ }

+ tester.report();

+ Ok(())

+ }

+}

+ // FIXME: This should be an AbsolutePathBuf

+ HoverAction, HoverGotoTypeData, InlayFieldsToResolve, Query, RangeInfo, RangeLimit,

+ ReferenceCategory, Runnable, RunnableKind, SingleResolve, SourceChange, TextEdit,

+ .inlay_hints(&inlay_hints_config, file_id, Some(RangeLimit::Fixed(range)))?

+ let hint_position = from_proto::offset(&line_index, original_hint.position)?;

+ Some(RangeLimit::NearestParent(hint_position)),

+ let cargo_config = CargoConfig {

+ sysroot: Some(project_model::RustLibSource::Discover),

+ ..CargoConfig::default()

+ };

+ let cargo_config = CargoConfig {

+ sysroot: Some(project_model::RustLibSource::Discover),

+ ..CargoConfig::default()

+ };

+ // kick off parsing and index population

+

+ let completion_offset = {

+ let _it = stdx::timeit("change");

+ let mut text = host.analysis().file_text(file_id).unwrap().to_string();

+ let completion_offset =

+ patch(&mut text, "db.struct_data(self.id)", "sel;\ndb.struct_data(self.id)")

+ + "sel".len();

+ let mut change = Change::new();

+ change.change_file(file_id, Some(Arc::from(text)));

+ host.apply_change(change);

+ completion_offset

+ };

+

+ let _span = profile::cpu_span();

+ let config = CompletionConfig {

+ enable_postfix_completions: true,

+ enable_imports_on_the_fly: true,

+ enable_self_on_the_fly: true,

+ enable_private_editable: true,

+ full_function_signatures: false,

+ callable: Some(CallableSnippets::FillArguments),

+ snippet_cap: SnippetCap::new(true),

+ insert_use: InsertUseConfig {

+ granularity: ImportGranularity::Crate,

+ prefix_kind: hir::PrefixKind::ByCrate,

+ enforce_granularity: true,

+ group: true,

+ skip_glob_imports: true,

+ },

+ snippets: Vec::new(),

+ prefer_no_std: false,

+ prefer_prelude: true,

+ limit: None,

+ };

+ let position =

+ FilePosition { file_id, offset: TextSize::try_from(completion_offset).unwrap() };

+ analysis.completions(&config, position, None).unwrap();

+ patch(&mut text, "sel;\ndb.struct_data(self.id)", ";sel;\ndb.struct_data(self.id)")

+ + ";sel".len();

+ pub fn first_qualifier(&self) -> Option<ast::Path> {

+ successors(self.qualifier(), ast::Path::qualifier).last()

+ }

+

+ // FIXME: Check usages of Self::segments, they might be wrong because of the logic of the bloew function

+ pub fn segments_of_this_path_only_rev(&self) -> impl Iterator<Item = ast::PathSegment> + Clone {

+ self.qualifiers_and_self().filter_map(|it| it.segment())

+ }

+

+ pub fn qualifiers_and_self(&self) -> impl Iterator<Item = ast::Path> + Clone {

+ successors(Some(self.clone()), |p| p.qualifier())

+ }

+

+use crate::SyntaxKind;

+// pub struct FileId(NonMaxU32);

+ // FIXME: To be removed once we get rid of all `SpanData::DUMMY` usages.

+ pub const MAX_FILE_ID: u32 = 0x7fff_ffff;

+ pub const fn from_raw(raw: u32) -> FileId {

+ assert!(raw <= Self::MAX_FILE_ID);

+version = "0.1.1"

+ RustcTests,

+ "rustc_tests" => Ok(Self::RustcTests),

+ Self::RustcTests => "rustc_tests",

+ MeasurementType::RustcTests => {

+ metrics.measure_rustc_tests(sh)?;

+ }

+ metrics.measure_rustc_tests(sh)?;

+

+ fn measure_rustc_tests(&mut self, sh: &Shell) -> anyhow::Result<()> {

+ eprintln!("\nMeasuring rustc tests");

+

+ cmd!(sh, "git clone --depth=1 https://github.com/rust-lang/rust").run()?;

+

+ let output = cmd!(sh, "./target/release/rust-analyzer rustc-tests ./rust").read()?;

+ for (metric, value, unit) in parse_metrics(&output) {

+ self.report(metric, value, unit.into());

+ }

+ Ok(())

+ }

+