rust-analyzer subtree update

src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs

@@ -26,6 +26,9 @@ const _: () = {
         krate: Crate,
     }
 
+    // FIXME: This poses an invalidation problem, if one constructs an `EditionedFileId` with a
+    // different crate then whatever the input of a memo used, it will invalidate the memo causing
+    // it to recompute even if the crate is not really used.
     /// We like to include the origin crate in an `EditionedFileId` (for use in the item tree),
     /// but this poses us a problem.
     ///

src/tools/rust-analyzer/crates/hir-def/src/expr_store.rs

@@ -57,8 +57,7 @@ impl HygieneId {
         Self(ctx)
     }
 
-    // FIXME: Inline this
-    pub(crate) fn lookup(self) -> SyntaxContext {
+    pub(crate) fn syntax_context(self) -> SyntaxContext {
         self.0
     }
 
@@ -73,7 +72,8 @@ pub type ExprSource = InFile<ExprPtr>;
 pub type PatPtr = AstPtr<ast::Pat>;
 pub type PatSource = InFile<PatPtr>;
 
-pub type LabelPtr = AstPtr<ast::Label>;
+/// BlockExpr -> Desugared label from try block
+pub type LabelPtr = AstPtr<Either<ast::Label, ast::BlockExpr>>;
 pub type LabelSource = InFile<LabelPtr>;
 
 pub type FieldPtr = AstPtr<ast::RecordExprField>;
@@ -942,7 +942,7 @@ impl ExpressionStoreSourceMap {
     }
 
     pub fn node_label(&self, node: InFile<&ast::Label>) -> Option<LabelId> {
-        let src = node.map(AstPtr::new);
+        let src = node.map(AstPtr::new).map(AstPtr::wrap_left);
         self.expr_only()?.label_map.get(&src).cloned()
     }
 

src/tools/rust-analyzer/crates/hir-def/src/expr_store/expander.rs

@@ -11,7 +11,7 @@ use hir_expand::{
     ExpandError, ExpandErrorKind, ExpandResult, HirFileId, InFile, Lookup, MacroCallId,
     eager::EagerCallBackFn, mod_path::ModPath, span_map::SpanMap,
 };
-use span::{AstIdMap, Edition, SyntaxContext};
+use span::{AstIdMap, SyntaxContext};
 use syntax::ast::HasAttrs;
 use syntax::{AstNode, Parse, ast};
 use triomphe::Arc;
@@ -75,11 +75,6 @@ impl Expander {
         AttrFlags::is_cfg_enabled_for(owner, cfg_options)
     }
 
-    pub(super) fn call_syntax_ctx(&self) -> SyntaxContext {
-        // FIXME:
-        SyntaxContext::root(Edition::CURRENT_FIXME)
-    }
-
     pub(super) fn enter_expand<T: ast::AstNode>(
         &mut self,
         db: &dyn DefDatabase,

src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs

@@ -1096,7 +1096,7 @@ impl<'db> ExprCollector<'db> {
             ast::Expr::WhileExpr(e) => self.collect_while_loop(syntax_ptr, e),
             ast::Expr::ForExpr(e) => self.collect_for_loop(syntax_ptr, e),
             ast::Expr::CallExpr(e) => {
-                // FIXME: Remove this once we drop support for <1.86, https://github.com/rust-lang/rust/commit/ac9cb908ac4301dfc25e7a2edee574320022ae2c
+                // FIXME(MINIMUM_SUPPORTED_TOOLCHAIN_VERSION): Remove this once we drop support for <1.86, https://github.com/rust-lang/rust/commit/ac9cb908ac4301dfc25e7a2edee574320022ae2c
                 let is_rustc_box = {
                     let attrs = e.attrs();
                     attrs.filter_map(|it| it.as_simple_atom()).any(|it| it == "rustc_box")
@@ -1649,7 +1649,7 @@ impl<'db> ExprCollector<'db> {
     fn desugar_try_block(&mut self, e: BlockExpr) -> ExprId {
         let try_from_output = self.lang_path(self.lang_items().TryTraitFromOutput);
         let label = self.generate_new_name();
-        let label = self.alloc_label_desugared(Label { name: label });
+        let label = self.alloc_label_desugared(Label { name: label }, AstPtr::new(&e).wrap_right());
         let old_label = self.current_try_block_label.replace(label);
 
         let ptr = AstPtr::new(&e).upcast();
@@ -2319,7 +2319,6 @@ impl<'db> ExprCollector<'db> {
             ast::Pat::SlicePat(p) => {
                 let SlicePatComponents { prefix, slice, suffix } = p.components();
 
-                // FIXME properly handle `RestPat`
                 Pat::Slice {
                     prefix: prefix.into_iter().map(|p| self.collect_pat(p, binding_list)).collect(),
                     slice: slice.map(|p| self.collect_pat(p, binding_list)),
@@ -2399,7 +2398,6 @@ impl<'db> ExprCollector<'db> {
                 };
                 let start = range_part_lower(p.start());
                 let end = range_part_lower(p.end());
-                // FIXME: Exclusive ended pattern range is stabilised
                 match p.op_kind() {
                     Some(range_type) => Pat::Range { start, end, range_type },
                     None => Pat::Missing,
@@ -2519,9 +2517,9 @@ impl<'db> ExprCollector<'db> {
         let mut hygiene_info = if hygiene_id.is_root() {
             None
         } else {
-            hygiene_id.lookup().outer_expn(self.db).map(|expansion| {
+            hygiene_id.syntax_context().outer_expn(self.db).map(|expansion| {
                 let expansion = self.db.lookup_intern_macro_call(expansion.into());
-                (hygiene_id.lookup().parent(self.db), expansion.def)
+                (hygiene_id.syntax_context().parent(self.db), expansion.def)
             })
         };
         let name = Name::new_lifetime(&lifetime.text());
@@ -2727,17 +2725,17 @@ impl ExprCollector<'_> {
         self.store.pats.alloc(Pat::Missing)
     }
 
-    fn alloc_label(&mut self, label: Label, ptr: LabelPtr) -> LabelId {
+    fn alloc_label(&mut self, label: Label, ptr: AstPtr<ast::Label>) -> LabelId {
+        self.alloc_label_desugared(label, ptr.wrap_left())
+    }
+
+    fn alloc_label_desugared(&mut self, label: Label, ptr: LabelPtr) -> LabelId {
         let src = self.expander.in_file(ptr);
         let id = self.store.labels.alloc(label);
         self.store.label_map_back.insert(id, src);
         self.store.label_map.insert(src, id);
         id
     }
-    // FIXME: desugared labels don't have ptr, that's wrong and should be fixed somehow.
-    fn alloc_label_desugared(&mut self, label: Label) -> LabelId {
-        self.store.labels.alloc(label)
-    }
 
     fn is_lowering_awaitable_block(&self) -> &Awaitable {
         self.awaitable_context.as_ref().unwrap_or(&Awaitable::No("unknown"))

src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/format_args.rs

@@ -3,6 +3,7 @@
 use base_db::FxIndexSet;
 use hir_expand::name::Name;
 use intern::{Symbol, sym};
+use span::SyntaxContext;
 use syntax::{AstPtr, AstToken as _, ast};
 
 use crate::{
@@ -49,7 +50,7 @@ impl<'db> ExprCollector<'db> {
             self.expand_macros_to_string(template.clone()).map(|it| (it, template))
         }) {
             Some(((s, is_direct_literal), template)) => {
-                let call_ctx = self.expander.call_syntax_ctx();
+                let call_ctx = SyntaxContext::root(self.def_map.edition());
                 let hygiene = self.hygiene_id_for(s.syntax().text_range());
                 let fmt = format_args::parse(
                     &s,

src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs

@@ -20,8 +20,7 @@ pub type LocalLifetimeParamId = Idx<LifetimeParamData>;
 /// Data about a generic type parameter (to a function, struct, impl, ...).
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TypeParamData {
-    /// [`None`] only if the type ref is an [`crate::type_ref::TypeRef::ImplTrait`]. FIXME: Might be better to just
-    /// make it always be a value, giving impl trait a special name.
+    /// [`None`] only if the type ref is an [`crate::type_ref::TypeRef::ImplTrait`].
     pub name: Option<Name>,
     pub default: Option<TypeRefId>,
     pub provenance: TypeParamProvenance,

src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs

@@ -1,21 +1,18 @@
 //! HIR for references to types. Paths in these are not yet resolved. They can
 //! be directly created from an ast::TypeRef, without further queries.
 
-use std::fmt::Write;
-
 use hir_expand::name::Name;
 use intern::Symbol;
 use la_arena::Idx;
 use thin_vec::ThinVec;
 
 use crate::{
     LifetimeParamId, TypeParamId,
-    builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
     expr_store::{
         ExpressionStore,
         path::{GenericArg, Path},
     },
-    hir::{ExprId, Literal},
+    hir::ExprId,
 };
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
@@ -275,56 +272,3 @@ impl TypeBound {
 pub struct ConstRef {
     pub expr: ExprId,
 }
-
-/// A literal constant value
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum LiteralConstRef {
-    Int(i128),
-    UInt(u128),
-    Bool(bool),
-    Char(char),
-
-    /// Case of an unknown value that rustc might know but we don't
-    // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
-    // constants
-    // https://github.com/rust-lang/rust-analyzer/pull/8813#issuecomment-840679177
-    // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348
-    Unknown,
-}
-
-impl LiteralConstRef {
-    pub fn builtin_type(&self) -> BuiltinType {
-        match self {
-            LiteralConstRef::UInt(_) | LiteralConstRef::Unknown => {
-                BuiltinType::Uint(BuiltinUint::U128)
-            }
-            LiteralConstRef::Int(_) => BuiltinType::Int(BuiltinInt::I128),
-            LiteralConstRef::Char(_) => BuiltinType::Char,
-            LiteralConstRef::Bool(_) => BuiltinType::Bool,
-        }
-    }
-}
-
-impl From<Literal> for LiteralConstRef {
-    fn from(literal: Literal) -> Self {
-        match literal {
-            Literal::Char(c) => Self::Char(c),
-            Literal::Bool(flag) => Self::Bool(flag),
-            Literal::Int(num, _) => Self::Int(num),
-            Literal::Uint(num, _) => Self::UInt(num),
-            _ => Self::Unknown,
-        }
-    }
-}
-
-impl std::fmt::Display for LiteralConstRef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            LiteralConstRef::Int(num) => num.fmt(f),
-            LiteralConstRef::UInt(num) => num.fmt(f),
-            LiteralConstRef::Bool(flag) => flag.fmt(f),
-            LiteralConstRef::Char(c) => write!(f, "'{c}'"),
-            LiteralConstRef::Unknown => f.write_char('_'),
-        }
-    }
-}

src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs

@@ -158,7 +158,7 @@ pub struct ItemScope {
     /// declared.
     declarations: ThinVec<ModuleDefId>,
 
-    impls: ThinVec<ImplId>,
+    impls: ThinVec<(ImplId, /* trait impl */ bool)>,
     builtin_derive_impls: ThinVec<BuiltinDeriveImplId>,
     extern_blocks: ThinVec<ExternBlockId>,
     unnamed_consts: ThinVec<ConstId>,
@@ -327,7 +327,15 @@ impl ItemScope {
     }
 
     pub fn impls(&self) -> impl ExactSizeIterator<Item = ImplId> + '_ {
-        self.impls.iter().copied()
+        self.impls.iter().map(|&(id, _)| id)
+    }
+
+    pub fn trait_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
+        self.impls.iter().filter(|&&(_, is_trait_impl)| is_trait_impl).map(|&(id, _)| id)
+    }
+
+    pub fn inherent_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
+        self.impls.iter().filter(|&&(_, is_trait_impl)| !is_trait_impl).map(|&(id, _)| id)
     }
 
     pub fn builtin_derive_impls(&self) -> impl ExactSizeIterator<Item = BuiltinDeriveImplId> + '_ {
@@ -472,8 +480,8 @@ impl ItemScope {
         self.legacy_macros.get(name).map(|it| &**it)
     }
 
-    pub(crate) fn define_impl(&mut self, imp: ImplId) {
-        self.impls.push(imp);
+    pub(crate) fn define_impl(&mut self, imp: ImplId, is_trait_impl: bool) {
+        self.impls.push((imp, is_trait_impl));
     }
 
     pub(crate) fn define_builtin_derive_impl(&mut self, imp: BuiltinDeriveImplId) {

src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs

@@ -614,7 +614,9 @@ pub struct Trait {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Impl {}
+pub struct Impl {
+    pub is_trait_impl: bool,
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TypeAlias {

src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs

@@ -271,7 +271,7 @@ impl<'a> Ctx<'a> {
         let ast_id = self.source_ast_id_map.ast_id(impl_def);
         // 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 res = Impl {};
+        let res = Impl { is_trait_impl: impl_def.trait_().is_some() };
         self.tree.small_data.insert(ast_id.upcast(), SmallModItem::Impl(res));
         ast_id
     }

src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs

@@ -258,7 +258,7 @@ impl Printer<'_> {
                 w!(self, "trait {} {{ ... }}", name.display(self.db, self.edition));
             }
             ModItemId::Impl(ast_id) => {
-                let Impl {} = &self.tree[ast_id];
+                let Impl { is_trait_impl: _ } = &self.tree[ast_id];
                 self.print_ast_id(ast_id.erase());
                 w!(self, "impl {{ ... }}");
             }

src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs

@@ -40,8 +40,12 @@ pub fn crate_lang_items(db: &dyn DefDatabase, krate: Crate) -> Option<Box<LangIt
 
     let crate_def_map = crate_def_map(db, krate);
 
+    if !crate_def_map.is_unstable_feature_enabled(&sym::lang_items) {
+        return None;
+    }
+
     for (_, module_data) in crate_def_map.modules() {
-        for impl_def in module_data.scope.impls() {
+        for impl_def in module_data.scope.inherent_impls() {
             lang_items.collect_lang_item(db, impl_def);
             for &(_, assoc) in impl_def.impl_items(db).items.iter() {
                 match assoc {

src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/mod.rs

@@ -16,7 +16,7 @@ mod proc_macros;
 
 use std::{any::TypeId, iter, ops::Range, sync};
 
-use base_db::{RootQueryDb, SourceDatabase};
+use base_db::RootQueryDb;
 use expect_test::Expect;
 use hir_expand::{
     AstId, ExpansionInfo, InFile, MacroCallId, MacroCallKind, MacroKind,
@@ -387,7 +387,7 @@ struct IdentityWhenValidProcMacroExpander;
 impl ProcMacroExpander for IdentityWhenValidProcMacroExpander {
     fn expand(
         &self,
-        _: &dyn SourceDatabase,
+        _: &dyn ExpandDatabase,
         subtree: &TopSubtree,
         _: Option<&TopSubtree>,
         _: &base_db::Env,

src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs

@@ -2028,7 +2028,9 @@ impl ModCollector<'_, '_> {
                     let impl_id =
                         ImplLoc { container: module_id, id: InFile::new(self.file_id(), imp) }
                             .intern(db);
-                    self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
+                    self.def_collector.def_map.modules[self.module_id]
+                        .scope
+                        .define_impl(impl_id, self.item_tree[imp].is_trait_impl)
                 }
                 ModItemId::Function(id) => {
                     let it = &self.item_tree[id];

src/tools/rust-analyzer/crates/hir-def/src/nameres/path_resolution.rs

@@ -267,7 +267,6 @@ impl DefMap {
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
             // rust-lang/rust#57745)
-            // FIXME there must be a nicer way to write this condition
             PathKind::Plain | PathKind::Abs
                 if self.data.edition == Edition::Edition2015
                     && (path.kind == PathKind::Abs || mode == ResolveMode::Import) =>
@@ -383,7 +382,6 @@ impl DefMap {
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
             // rust-lang/rust#57745)
-            // FIXME there must be a nicer way to write this condition
             PathKind::Plain | PathKind::Abs
                 if self.data.edition == Edition::Edition2015
                     && (path.kind == PathKind::Abs || mode == ResolveMode::Import) =>

src/tools/rust-analyzer/crates/hir-def/src/resolver.rs

@@ -950,7 +950,7 @@ fn hygiene_info(
     hygiene_id: HygieneId,
 ) -> Option<(SyntaxContext, MacroDefId)> {
     if !hygiene_id.is_root() {
-        let ctx = hygiene_id.lookup();
+        let ctx = hygiene_id.syntax_context();
         ctx.outer_expn(db).map(|expansion| {
             let expansion = db.lookup_intern_macro_call(expansion.into());
             (ctx.parent(db), expansion.def)