Merge remote-tracking branch 'origin/master' into extension-configuration

Author: michaelgruenewald

.github/workflows/ci.yaml

@@ -293,7 +293,7 @@ jobs:
     timeout-minutes: 10
     env:
       FORCE_COLOR: 1
-      TYPOS_VERSION: v1.28.3
+      TYPOS_VERSION: v1.38.1
     steps:
       - name: download typos
         run: curl -LsSf https://github.com/crate-ci/typos/releases/download/$TYPOS_VERSION/typos-$TYPOS_VERSION-x86_64-unknown-linux-musl.tar.gz | tar zxf - -C ${CARGO_HOME:-~/.cargo}/bin

.typos.toml

@@ -32,6 +32,7 @@ makro = "makro"
 trivias = "trivias"
 thir = "thir"
 jod = "jod"
+tructure = "tructure"
 
 [default.extend-identifiers]
 anc = "anc"

Cargo.lock

@@ -52,6 +52,7 @@ debug = 2
 
 [workspace.dependencies]
 # local crates
+macros = { path = "./crates/macros", version = "0.0.0" }
 base-db = { path = "./crates/base-db", version = "0.0.0" }
 cfg = { path = "./crates/cfg", version = "0.0.0", features = ["tt"] }
 hir = { path = "./crates/hir", version = "0.0.0" }

Cargo.toml

@@ -349,6 +349,7 @@ bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
     pub struct ImplFlags: u8 {
         const NEGATIVE = 1 << 1;
+        const DEFAULT = 1 << 2;
         const UNSAFE = 1 << 3;
     }
 }
@@ -374,6 +375,9 @@ impl ImplSignature {
         if src.value.excl_token().is_some() {
             flags.insert(ImplFlags::NEGATIVE);
         }
+        if src.value.default_token().is_some() {
+            flags.insert(ImplFlags::DEFAULT);
+        }
 
         let (store, source_map, self_ty, target_trait, generic_params) =
             crate::expr_store::lower::lower_impl(db, loc.container, src, id);
@@ -389,6 +393,16 @@ impl ImplSignature {
             Arc::new(source_map),
         )
     }
+
+    #[inline]
+    pub fn is_negative(&self) -> bool {
+        self.flags.contains(ImplFlags::NEGATIVE)
+    }
+
+    #[inline]
+    pub fn is_default(&self) -> bool {
+        self.flags.contains(ImplFlags::DEFAULT)
+    }
 }
 
 bitflags::bitflags! {

crates/hir-def/src/signatures.rs

@@ -50,6 +50,7 @@ tracing-tree.workspace = true
 
 # local deps
 stdx.workspace = true
+macros.workspace = true
 intern.workspace = true
 hir-def.workspace = true
 hir-expand.workspace = true

crates/hir-ty/Cargo.toml

@@ -5,23 +5,21 @@
 
 use std::fmt;
 
-use hir_def::TraitId;
-use hir_def::{TypeAliasId, lang_item::LangItem};
+use hir_def::{TraitId, TypeAliasId, lang_item::LangItem};
 use rustc_type_ir::inherent::{IntoKind, Ty as _};
 use tracing::debug;
 use triomphe::Arc;
 
-use crate::next_solver::TraitRef;
-use crate::next_solver::infer::InferOk;
-use crate::next_solver::infer::traits::Obligation;
 use crate::{
     TraitEnvironment,
     db::HirDatabase,
     infer::unify::InferenceTable,
     next_solver::{
-        Ty, TyKind,
-        infer::traits::{ObligationCause, PredicateObligations},
-        mapping::{ChalkToNextSolver, NextSolverToChalk},
+        Canonical, TraitRef, Ty, TyKind,
+        infer::{
+            InferOk,
+            traits::{Obligation, ObligationCause, PredicateObligations},
+        },
         obligation_ctxt::ObligationCtxt,
     },
 };
@@ -38,17 +36,16 @@ const AUTODEREF_RECURSION_LIMIT: usize = 20;
 pub fn autoderef<'db>(
     db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment<'db>>,
-    ty: crate::Canonical<crate::Ty>,
-) -> impl Iterator<Item = crate::Ty> + use<> {
+    ty: Canonical<'db, Ty<'db>>,
+) -> impl Iterator<Item = Ty<'db>> + use<'db> {
     let mut table = InferenceTable::new(db, env);
-    let interner = table.interner();
-    let ty = table.instantiate_canonical(ty.to_nextsolver(interner));
+    let ty = table.instantiate_canonical(ty);
     let mut autoderef = Autoderef::new_no_tracking(&mut table, ty);
     let mut v = Vec::new();
     while let Some((ty, _steps)) = autoderef.next() {
         // `ty` may contain unresolved inference variables. Since there's no chance they would be
         // resolved, just replace with fallback type.
-        let resolved = autoderef.table.resolve_completely(ty).to_chalk(interner);
+        let resolved = autoderef.table.resolve_completely(ty);
 
         // If the deref chain contains a cycle (e.g. `A` derefs to `B` and `B` derefs to `A`), we
         // would revisit some already visited types. Stop here to avoid duplication.

crates/hir-ty/src/autoderef.rs

@@ -130,11 +130,14 @@ impl<D> TyBuilder<D> {
     }
 
     pub fn fill_with_unknown(self) -> Self {
+        let interner = DbInterner::conjure();
         // self.fill is inlined to make borrow checker happy
         let mut this = self;
         let filler = this.param_kinds[this.vec.len()..].iter().map(|x| match x {
             ParamKind::Type => TyKind::Error.intern(Interner).cast(Interner),
-            ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()),
+            ParamKind::Const(ty) => {
+                unknown_const_as_generic(ty.to_nextsolver(interner)).to_chalk(interner)
+            }
             ParamKind::Lifetime => error_lifetime().cast(Interner),
         });
         this.vec.extend(filler.casted(Interner));
@@ -219,13 +222,16 @@ impl TyBuilder<()> {
     }
 
     pub fn unknown_subst(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution {
+        let interner = DbInterner::conjure();
         let params = generics(db, def.into());
         Substitution::from_iter(
             Interner,
             params.iter_id().map(|id| match id {
                 GenericParamId::TypeParamId(_) => TyKind::Error.intern(Interner).cast(Interner),
                 GenericParamId::ConstParamId(id) => {
-                    unknown_const_as_generic(db.const_param_ty(id)).cast(Interner)
+                    unknown_const_as_generic(db.const_param_ty_ns(id))
+                        .to_chalk(interner)
+                        .cast(Interner)
                 }
                 GenericParamId::LifetimeParamId(_) => error_lifetime().cast(Interner),
             }),
@@ -267,6 +273,7 @@ impl TyBuilder<hir_def::AdtId> {
         db: &dyn HirDatabase,
         mut fallback: impl FnMut() -> Ty,
     ) -> Self {
+        let interner = DbInterner::conjure();
         // Note that we're building ADT, so we never have parent generic parameters.
         let defaults = db.generic_defaults(self.data.into());
 
@@ -287,7 +294,9 @@ impl TyBuilder<hir_def::AdtId> {
         // The defaults may be missing if no param has default, so fill that.
         let filler = self.param_kinds[self.vec.len()..].iter().map(|x| match x {
             ParamKind::Type => fallback().cast(Interner),
-            ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()),
+            ParamKind::Const(ty) => {
+                unknown_const_as_generic(ty.to_nextsolver(interner)).to_chalk(interner)
+            }
             ParamKind::Lifetime => error_lifetime().cast(Interner),
         });
         self.vec.extend(filler.casted(Interner));