rust-analyzer subtree update

src/tools/rust-analyzer/.codecov.yml

@@ -0,0 +1,10 @@
+coverage:
+  range: 40...60
+  status:
+    patch: off
+    project:
+      default:
+        informational: true
+
+# Don't leave comments on PRs
+comment: false

src/tools/rust-analyzer/.github/workflows/coverage.yaml

@@ -0,0 +1,44 @@
+name: Coverage
+
+on: [pull_request, push]
+
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CI: 1
+  RUST_BACKTRACE: short
+  RUSTUP_MAX_RETRIES: 10
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        run: |
+          rustup update --no-self-update nightly
+          rustup default nightly
+          rustup component add --toolchain nightly rust-src rustc-dev rustfmt
+          # We also install a nightly rustfmt, because we use `--file-lines` in
+          # a test.
+          rustup toolchain install nightly --profile minimal --component rustfmt
+
+          rustup toolchain install nightly --component llvm-tools-preview
+
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+
+      - name: Install nextest
+        uses: taiki-e/install-action@nextest
+
+      - name: Generate code coverage
+        run: cargo llvm-cov --workspace --lcov --output-path lcov.info
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          files: lcov.info
+          fail_ci_if_error: false
+          token: ${{ secrets.CODECOV_TOKEN }}
+          verbose: true

src/tools/rust-analyzer/AGENTS.md

@@ -0,0 +1 @@
+CLAUDE.md

src/tools/rust-analyzer/CLAUDE.md

@@ -0,0 +1,40 @@
+**Reminder: All AI usage must be disclosed in commit messages, see
+CONTRIBUTING.md for more details.**
+
+## Build Commands
+
+```bash
+cargo build                    # Build all crates
+cargo test                     # Run all tests
+cargo test -p <crate>          # Run tests for a specific crate (e.g., cargo test -p hir-ty)
+cargo lint                     # Run clippy on all targets
+cargo xtask codegen            # Run code generation
+cargo xtask tidy               # Run tidy checks
+UPDATE_EXPECT=1 cargo test     # Update test expectations (snapshot tests)
+RUN_SLOW_TESTS=1 cargo test    # Run heavy/slow tests
+```
+
+## Key Architectural Invariants
+
+- Typing in a function body never invalidates global derived data
+- Parser/syntax tree is built per-file to enable parallel parsing
+- The server is stateless (HTTP-like); context must be re-created from request parameters
+- Cancellation uses salsa's cancellation mechanism; computations panic with a `Cancelled` payload
+
+### Code Generation
+
+Generated code is committed to the repo. Grammar and AST are generated from `ungrammar`. Run `cargo test -p xtask` after adding inline parser tests (`// test test_name` comments).
+
+## Testing
+
+Tests are snapshot-based using `expect-test`. Test fixtures use a mini-language:
+- `$0` marks cursor position
+- `// ^^^^` labels attach to the line above
+- `//- minicore: sized, fn` includes parts of minicore (minimal core library)
+- `//- /path/to/file.rs crate:name deps:dep1,dep2` declares files/crates
+
+## Style Notes
+
+- Use `stdx::never!` and `stdx::always!` instead of `assert!` for recoverable invariants
+- Use `T![fn]` macro instead of `SyntaxKind::FN_KW`
+- Use keyword name mangling over underscore prefixing for identifiers: `crate` → `krate`, `fn` → `func`, `struct` → `strukt`, `type` → `ty`

src/tools/rust-analyzer/Cargo.lock

@@ -2635,7 +2635,7 @@ dependencies = [
 
 [[package]]
 name = "smol_str"
-version = "0.3.5"
+version = "0.3.6"
 dependencies = [
  "arbitrary",
  "borsh",

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

@@ -234,7 +234,7 @@ impl Visibility {
                 if mod_.krate(db) == krate { Some(Visibility::Module(mod_, exp)) } else { None }
             }
             (Visibility::Module(mod_a, expl_a), Visibility::Module(mod_b, expl_b)) => {
-                if mod_a.krate(db) != mod_b.krate(db) {
+                if mod_a == mod_b {
                     // Most module visibilities are `pub(self)`, and assuming no errors
                     // this will be the common and thus fast path.
                     return Some(Visibility::Module(

src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs

@@ -5,10 +5,7 @@ use std::borrow::Cow;
 use base_db::AnchoredPath;
 use cfg::CfgExpr;
 use either::Either;
-use intern::{
-    Symbol,
-    sym,
-};
+use intern::{Symbol, sym};
 use itertools::Itertools;
 use mbe::{DelimiterKind, expect_fragment};
 use span::{Edition, FileId, Span};

src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs

@@ -658,7 +658,7 @@ impl<'db> InferenceContext<'_, 'db> {
                     }
                 }
                 if let RecordSpread::Expr(expr) = *spread {
-                    self.infer_expr(expr, &Expectation::has_type(ty), ExprIsRead::Yes);
+                    self.infer_expr_coerce_never(expr, &Expectation::has_type(ty), ExprIsRead::Yes);
                 }
                 ty
             }

src/tools/rust-analyzer/crates/hir-ty/src/infer/op.rs

@@ -178,9 +178,9 @@ impl<'a, 'db> InferenceContext<'a, 'db> {
                 // trait matching creating lifetime constraints that are too strict.
                 // e.g., adding `&'a T` and `&'b T`, given `&'x T: Add<&'x T>`, will result
                 // in `&'a T <: &'x T` and `&'b T <: &'x T`, instead of `'a = 'b = 'x`.
-                let lhs_ty = self.infer_expr_no_expect(lhs_expr, ExprIsRead::No);
+                let lhs_ty = self.infer_expr_no_expect(lhs_expr, ExprIsRead::Yes);
                 let fresh_var = self.table.next_ty_var();
-                self.demand_coerce(lhs_expr, lhs_ty, fresh_var, AllowTwoPhase::No, ExprIsRead::No)
+                self.demand_coerce(lhs_expr, lhs_ty, fresh_var, AllowTwoPhase::No, ExprIsRead::Yes)
             }
         };
         let lhs_ty = self.table.resolve_vars_with_obligations(lhs_ty);
@@ -200,7 +200,7 @@ impl<'a, 'db> InferenceContext<'a, 'db> {
 
         // see `NB` above
         let rhs_ty =
-            self.infer_expr_coerce(rhs_expr, &Expectation::HasType(rhs_ty_var), ExprIsRead::No);
+            self.infer_expr_coerce(rhs_expr, &Expectation::HasType(rhs_ty_var), ExprIsRead::Yes);
         let rhs_ty = self.table.resolve_vars_with_obligations(rhs_ty);
 
         let return_ty = match result {
@@ -320,7 +320,11 @@ impl<'a, 'db> InferenceContext<'a, 'db> {
                 if let Some((rhs_expr, rhs_ty)) = opt_rhs
                     && rhs_ty.is_ty_var()
                 {
-                    self.infer_expr_coerce(rhs_expr, &Expectation::HasType(rhs_ty), ExprIsRead::No);
+                    self.infer_expr_coerce(
+                        rhs_expr,
+                        &Expectation::HasType(rhs_ty),
+                        ExprIsRead::Yes,
+                    );
                 }
 
                 // Construct an obligation `self_ty : Trait<input_tys>`

src/tools/rust-analyzer/crates/hir-ty/src/lower.rs

@@ -40,8 +40,7 @@ use rustc_hash::FxHashSet;
 use rustc_type_ir::{
     AliasTyKind, BoundVarIndexKind, ConstKind, DebruijnIndex, ExistentialPredicate,
     ExistentialProjection, ExistentialTraitRef, FnSig, Interner, OutlivesPredicate, TermKind,
-    TyKind,
-    TypeFoldable, TypeVisitableExt, Upcast, UpcastFrom, elaborate,
+    TyKind, TypeFoldable, TypeVisitableExt, Upcast, UpcastFrom, elaborate,
     inherent::{Clause as _, GenericArgs as _, IntoKind as _, Region as _, Ty as _},
 };
 use smallvec::SmallVec;
@@ -1681,10 +1680,16 @@ impl SupertraitsInfo {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-enum TypeParamAssocTypeShorthandError {
-    AssocTypeNotFound,
-    AmbiguousAssocType,
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum AssocTypeShorthandResolution {
+    Resolved(StoredEarlyBinder<(TypeAliasId, StoredGenericArgs)>),
+    Ambiguous {
+        /// If one resolution belongs to a sub-trait and one to a supertrait, this contains
+        /// the sub-trait's resolution. This can be `None` if there is no trait inheritance
+        /// relationship between the resolutions.
+        sub_trait_resolution: Option<StoredEarlyBinder<(TypeAliasId, StoredGenericArgs)>>,
+    },
+    NotFound,
     Cycle,
 }
 
@@ -1708,7 +1713,7 @@ fn resolve_type_param_assoc_type_shorthand(
     def: GenericDefId,
     param: TypeParamId,
     assoc_name: Name,
-) -> Result<StoredEarlyBinder<(TypeAliasId, StoredGenericArgs)>, TypeParamAssocTypeShorthandError> {
+) -> AssocTypeShorthandResolution {
     let generics = generics(db, def);
     let resolver = def.resolver(db);
     let mut ctx = TyLoweringContext::new(
@@ -1719,13 +1724,13 @@ fn resolve_type_param_assoc_type_shorthand(
         LifetimeElisionKind::AnonymousReportError,
     );
     let interner = ctx.interner;
-    let mut result = None;
     let param_ty = Ty::new_param(
         interner,
         param,
         generics.type_or_const_param_idx(param.into()).unwrap() as u32,
     );
 
+    let mut this_trait_resolution = None;
     if let GenericDefId::TraitId(containing_trait) = param.parent()
         && param.local_id() == GenericParams::SELF_PARAM_ID_IN_SELF
     {
@@ -1734,10 +1739,11 @@ fn resolve_type_param_assoc_type_shorthand(
             containing_trait.trait_items(db).associated_type_by_name(&assoc_name)
         {
             let args = GenericArgs::identity_for_item(interner, containing_trait.into());
-            result = Some(StoredEarlyBinder::bind((assoc_type, args.store())));
+            this_trait_resolution = Some(StoredEarlyBinder::bind((assoc_type, args.store())));
         }
     }
 
+    let mut supertraits_resolution = None;
     for maybe_parent_generics in
         std::iter::successors(Some(&generics), |generics| generics.parent_generics())
     {
@@ -1783,34 +1789,53 @@ fn resolve_type_param_assoc_type_shorthand(
                 TypeParamId::trait_self(bounded_trait),
                 assoc_name.clone(),
             );
-            let lookup_on_bounded_trait = match lookup_on_bounded_trait {
-                Ok(it) => it,
-                Err(
-                    err @ (TypeParamAssocTypeShorthandError::AmbiguousAssocType
-                    | TypeParamAssocTypeShorthandError::Cycle),
-                ) => return Err(*err),
-                Err(TypeParamAssocTypeShorthandError::AssocTypeNotFound) => {
+            let assoc_type_and_args = match &lookup_on_bounded_trait {
+                AssocTypeShorthandResolution::Resolved(trait_ref) => trait_ref,
+                AssocTypeShorthandResolution::Ambiguous {
+                    sub_trait_resolution: Some(trait_ref),
+                } => trait_ref,
+                AssocTypeShorthandResolution::Ambiguous { sub_trait_resolution: None } => {
+                    return AssocTypeShorthandResolution::Ambiguous {
+                        sub_trait_resolution: this_trait_resolution,
+                    };
+                }
+                AssocTypeShorthandResolution::NotFound => {
                     never!("we checked that the trait defines this assoc type");
                     continue;
                 }
+                AssocTypeShorthandResolution::Cycle => return AssocTypeShorthandResolution::Cycle,
             };
-            let (assoc_type, args) = lookup_on_bounded_trait
-                .get_with(|(assoc_type, args)| (*assoc_type, args.as_ref()))
-                .skip_binder();
-            let args = EarlyBinder::bind(args).instantiate(interner, bounded_trait_ref.args);
-            let current_result = StoredEarlyBinder::bind((assoc_type, args.store()));
-            // If we already have a result, this is an ambiguity - unless this is the same result, then we are fine
-            // (e.g. rustc allows to write the same bound twice without ambiguity).
-            if let Some(existing_result) = result
-                && existing_result != current_result
-            {
-                return Err(TypeParamAssocTypeShorthandError::AmbiguousAssocType);
+            if let Some(this_trait_resolution) = this_trait_resolution {
+                return AssocTypeShorthandResolution::Ambiguous {
+                    sub_trait_resolution: Some(this_trait_resolution),
+                };
+            } else if supertraits_resolution.is_some() {
+                return AssocTypeShorthandResolution::Ambiguous { sub_trait_resolution: None };
+            } else {
+                let (assoc_type, args) = assoc_type_and_args
+                    .get_with(|(assoc_type, args)| (*assoc_type, args.as_ref()))
+                    .skip_binder();
+                let args = EarlyBinder::bind(args).instantiate(interner, bounded_trait_ref.args);
+                let current_result = StoredEarlyBinder::bind((assoc_type, args.store()));
+                supertraits_resolution = Some(match lookup_on_bounded_trait {
+                    AssocTypeShorthandResolution::Resolved(_) => {
+                        AssocTypeShorthandResolution::Resolved(current_result)
+                    }
+                    AssocTypeShorthandResolution::Ambiguous { .. } => {
+                        AssocTypeShorthandResolution::Ambiguous {
+                            sub_trait_resolution: Some(current_result),
+                        }
+                    }
+                    AssocTypeShorthandResolution::NotFound
+                    | AssocTypeShorthandResolution::Cycle => unreachable!(),
+                });
             }
-            result = Some(current_result);
         }
     }
 
-    result.ok_or(TypeParamAssocTypeShorthandError::AssocTypeNotFound)
+    supertraits_resolution
+        .or_else(|| this_trait_resolution.map(AssocTypeShorthandResolution::Resolved))
+        .unwrap_or(AssocTypeShorthandResolution::NotFound)
 }
 
 fn resolve_type_param_assoc_type_shorthand_cycle_result(
@@ -1819,8 +1844,8 @@ fn resolve_type_param_assoc_type_shorthand_cycle_result(
     _def: GenericDefId,
     _param: TypeParamId,
     _assoc_name: Name,
-) -> Result<StoredEarlyBinder<(TypeAliasId, StoredGenericArgs)>, TypeParamAssocTypeShorthandError> {
-    Err(TypeParamAssocTypeShorthandError::Cycle)
+) -> AssocTypeShorthandResolution {
+    AssocTypeShorthandResolution::Cycle
 }
 
 #[inline]
@@ -2468,7 +2493,7 @@ fn fn_sig_for_struct_constructor(
     let inputs_and_output =
         Tys::new_from_iter(DbInterner::new_no_crate(db), params.chain(Some(ret.as_ref())));
     StoredEarlyBinder::bind(StoredPolyFnSig::new(Binder::dummy(FnSig {
-        abi: FnAbi::RustCall,
+        abi: FnAbi::Rust,
         c_variadic: false,
         safety: Safety::Safe,
         inputs_and_output,
@@ -2487,7 +2512,7 @@ fn fn_sig_for_enum_variant_constructor(
     let inputs_and_output =
         Tys::new_from_iter(DbInterner::new_no_crate(db), params.chain(Some(ret.as_ref())));
     StoredEarlyBinder::bind(StoredPolyFnSig::new(Binder::dummy(FnSig {
-        abi: FnAbi::RustCall,
+        abi: FnAbi::Rust,
         c_variadic: false,
         safety: Safety::Safe,
         inputs_and_output,
@@ -2569,19 +2594,22 @@ pub(crate) fn associated_ty_item_bounds<'db>(
     EarlyBinder::bind(BoundExistentialPredicates::new_from_slice(&bounds))
 }
 
-pub(crate) fn associated_type_by_name_including_super_traits<'db>(
+pub(crate) fn associated_type_by_name_including_super_traits_allow_ambiguity<'db>(
     db: &'db dyn HirDatabase,
     trait_ref: TraitRef<'db>,
     name: Name,
 ) -> Option<(TypeAliasId, GenericArgs<'db>)> {
-    let assoc_type = resolve_type_param_assoc_type_shorthand(
-        db,
-        trait_ref.def_id.0.into(),
-        TypeParamId::trait_self(trait_ref.def_id.0),
-        name.clone(),
-    )
-    .as_ref()
-    .ok()?;
+    let (AssocTypeShorthandResolution::Resolved(assoc_type)
+    | AssocTypeShorthandResolution::Ambiguous { sub_trait_resolution: Some(assoc_type) }) =
+        resolve_type_param_assoc_type_shorthand(
+            db,
+            trait_ref.def_id.0.into(),
+            TypeParamId::trait_self(trait_ref.def_id.0),
+            name.clone(),
+        )
+    else {
+        return None;
+    };
     let (assoc_type, trait_args) = assoc_type
         .get_with(|(assoc_type, trait_args)| (*assoc_type, trait_args.as_ref()))
         .skip_binder();