Chore: Bump nightly -> 2023-12-28

.github/workflows/ci.yml

@@ -234,4 +234,20 @@ jobs:
       # There may be bugs in the release build of our binaries. For example, in the past
       # we saw that LTO could lead to exit code: 0xc0000005, STATUS_ACCESS_VIOLATION crash
 
-      - run: cargo marker -l 'marker_lints="*"'
+      # FIXME: The stable version of Marker tested by this command might use a different toolchain
+      # version then the one used for the development of rustc driver. Running Marker only loads the
+      # library files for the toolchain it's executed with and "ignores" the toolchain defined in
+      # `rust-toolchain.toml`. Therefore, it's not possible to run the stable version of marker
+      # on `marker_rustc_driver`.
+      # In the future it would be better to run this smoke test on bigger libraries like tokio, serde
+      # bevy etc. For that, it would be good to extract the lintcheck tool from Clippy into a standalone
+      # tool.
+      - run: >-
+          cargo +stable marker
+          -l 'marker_lints="*"'
+          -- 
+          --workspace
+          --exclude marker_rustc_driver
+          --exclude marker_lints
+          --exclude marker_uitest
+

CHANGELOG.md

@@ -28,6 +28,12 @@ The following components are considered to be internal and they are excluded fro
 
 ## [Unreleased]
 
+[#345]: https://github.com/rust-marker/marker/pull/345
+
+### Internal
+
+- [#345]: Bumped the used nightly toolchain version to 2023-12-28
+
 ## [0.5.0] - 2023-12-28
 
 [#322]: https://github.com/rust-marker/marker/pull/322

cargo-marker/src/backend/driver.rs

@@ -18,7 +18,7 @@ pub fn marker_driver_bin_name() -> String {
 pub(crate) fn default_driver_info() -> DriverVersionInfo {
     DriverVersionInfo {
         // region replace rust toolchain dev
-        toolchain: "nightly-2023-11-16".to_string(),
+        toolchain: "nightly-2023-12-28".to_string(),
         // endregion replace rust toolchain dev
         // region replace marker version dev
         version: "0.6.0-dev".to_string(),

marker_api/src/lib.rs

@@ -6,6 +6,7 @@
 #![allow(clippy::unused_self)] // `self` is needed to change the behavior later
 #![allow(clippy::missing_panics_doc)] // Temporary allow for `todo!`s
 #![allow(clippy::new_without_default)] // Not very helpful as `new` is almost always cfged
+#![allow(clippy::no_effect_underscore_binding)] // FP with derive macros clippy#12045
 #![cfg_attr(not(feature = "driver-api"), allow(dead_code))]
 #![cfg_attr(marker, warn(marker::marker_lints::not_using_has_span_trait))]
 

marker_rustc_driver/src/context.rs

@@ -112,7 +112,6 @@ impl<'ast, 'tcx: 'ast> MarkerContextDriver<'ast> for RustcContext<'ast, 'tcx> {
                         _ => unreachable!(),
                     }
                 }
-                builder
             },
         );
     }
@@ -261,7 +260,7 @@ fn select_children_with_name(
             let hir = tcx.hir();
 
             let root_mod;
-            let item = match hir.find_by_def_id(local_id) {
+            let item = match tcx.opt_hir_node_by_def_id(local_id) {
                 Some(hir::Node::Crate(r#mod)) => {
                     root_mod = hir::ItemKind::Mod(r#mod);
                     Some(&root_mod)

marker_rustc_driver/src/conversion/marker.rs

@@ -96,7 +96,7 @@ impl<'ast, 'tcx> MarkerConverter<'ast, 'tcx> {
         }
 
         self.with_body(hir_id, |inner| {
-            let Some(hir::Node::Stmt(stmt)) = inner.rustc_cx.hir().find(hir_id) else {
+            let Some(hir::Node::Stmt(stmt)) = inner.rustc_cx.opt_hir_node(hir_id) else {
                 return None;
             };
             inner.to_stmt(stmt)
@@ -111,7 +111,7 @@ impl<'ast, 'tcx> MarkerConverter<'ast, 'tcx> {
         }
 
         self.with_body(hir_id, |inner| {
-            let Some(hir::Node::Expr(expr)) = inner.rustc_cx.hir().find(hir_id) else {
+            let Some(hir::Node::Expr(expr)) = inner.rustc_cx.opt_hir_node(hir_id) else {
                 return None;
             };
             Some(inner.to_expr(expr))

marker_rustc_driver/src/conversion/marker/ast/expr.rs

@@ -84,7 +84,7 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 }
             },
             hir::ExprKind::Call(operand, args) => match &operand.kind {
-                hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, _, _)) => {
+                hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, _)) => {
                     ExprKind::Range(self.alloc({
                         RangeExpr::new(data, Some(self.to_expr(&args[0])), Some(self.to_expr(&args[1])), true)
                     }))
@@ -156,24 +156,24 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 )))
             },
             hir::ExprKind::Struct(path, fields, base) => match path {
-                hir::QPath::LangItem(hir::LangItem::RangeFull, _, _) => {
+                hir::QPath::LangItem(hir::LangItem::RangeFull, _) => {
                     ExprKind::Range(self.alloc(RangeExpr::new(data, None, None, false)))
                 },
-                hir::QPath::LangItem(hir::LangItem::RangeFrom, _, _) => {
+                hir::QPath::LangItem(hir::LangItem::RangeFrom, _) => {
                     ExprKind::Range(self.alloc(RangeExpr::new(data, Some(self.to_expr(fields[0].expr)), None, false)))
                 },
-                hir::QPath::LangItem(hir::LangItem::RangeTo, _, _) => {
+                hir::QPath::LangItem(hir::LangItem::RangeTo, _) => {
                     ExprKind::Range(self.alloc(RangeExpr::new(data, None, Some(self.to_expr(fields[0].expr)), false)))
                 },
-                hir::QPath::LangItem(hir::LangItem::Range, _, _) => ExprKind::Range(self.alloc({
+                hir::QPath::LangItem(hir::LangItem::Range, _) => ExprKind::Range(self.alloc({
                     RangeExpr::new(
                         data,
                         Some(self.to_expr(fields[0].expr)),
                         Some(self.to_expr(fields[1].expr)),
                         false,
                     )
                 })),
-                hir::QPath::LangItem(hir::LangItem::RangeToInclusive, _, _) => {
+                hir::QPath::LangItem(hir::LangItem::RangeToInclusive, _) => {
                     ExprKind::Range(self.alloc(RangeExpr::new(data, None, Some(self.to_expr(fields[0].expr)), true)))
                 },
                 _ => {
@@ -424,8 +424,11 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
     ) -> ExprKind<'ast> {
         let body_id = closure.body;
         let body = self.rustc_cx.hir().body(body_id);
-        match body.coroutine_kind {
-            Some(hir::CoroutineKind::Async(hir::CoroutineSource::Fn)) => {
+        match closure.kind {
+            hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
+                hir::CoroutineDesugaring::Async,
+                hir::CoroutineSource::Fn,
+            )) => {
                 if let hir::ExprKind::Block(block, None) = body.value.kind
                     && let Some(temp_drop) = block.expr
                     && let hir::ExprKind::DropTemps(inner_block) = temp_drop.kind
@@ -435,7 +438,10 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
 
                 unreachable!("`async fn` body desugar always has the same structure")
             },
-            Some(hir::CoroutineKind::Async(hir::CoroutineSource::Block)) => {
+            hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(
+                hir::CoroutineDesugaring::Async,
+                hir::CoroutineSource::Block,
+            )) => {
                 let block_expr = body.value;
                 if let hir::ExprKind::Block(block, None) = block_expr.kind {
                     let api_block_expr = self.with_body(body_id, || {
@@ -451,12 +457,12 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 }
                 unreachable!("`async` block desugar always has the same structure")
             },
-            Some(
-                hir::CoroutineKind::Async(hir::CoroutineSource::Closure)
-                | hir::CoroutineKind::Coroutine
-                | hir::CoroutineKind::Gen(_),
+            hir::ClosureKind::Coroutine(
+                hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen | hir::CoroutineDesugaring::AsyncGen, _)
+                | hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, hir::CoroutineSource::Closure)
+                | hir::CoroutineKind::Coroutine(_),
             ) => ExprKind::Unstable(self.alloc(UnstableExpr::new(data, ExprPrecedence::Closure))),
-            None => ExprKind::Closure(self.alloc(self.to_closure_expr(data, closure))),
+            hir::ClosureKind::Closure => ExprKind::Closure(self.alloc(self.to_closure_expr(data, closure))),
         }
     }
 

marker_rustc_driver/src/conversion/marker/ast/generic.rs

@@ -1,7 +1,7 @@
 use marker_api::ast::{
     BindingArg, ConstArg, ConstParam, GenericArgKind, GenericArgs, GenericParamKind, GenericParams, Lifetime,
-    LifetimeArg, LifetimeClause, LifetimeKind, LifetimeParam, TraitBound, TraitRef, TyArg, TyClause, TyParam,
-    TyParamBound, WhereClauseKind,
+    LifetimeArg, LifetimeClause, LifetimeKind, LifetimeParam, TraitBound, TyArg, TyClause, TyParam, TyParamBound,
+    WhereClauseKind,
 };
 use rustc_hir as hir;
 
@@ -39,8 +39,8 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
         let mut args: Vec<_> = rustc_args
             .args
             .iter()
-            .filter(|rustc_arg| !rustc_arg.is_synthetic())
             .filter_map(|rustc_arg| match rustc_arg {
+                rustc_hir::GenericArg::Lifetime(rust_lt) if rust_lt.ident.name.is_empty() => None,
                 rustc_hir::GenericArg::Lifetime(rust_lt) => self
                     .to_lifetime(rust_lt)
                     .map(|lifetime| GenericArgKind::Lifetime(self.alloc(LifetimeArg::new(lifetime)))),
@@ -93,7 +93,9 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                                     .iter()
                                     .filter_map(|bound| match bound {
                                         hir::GenericBound::Outlives(lifetime) => self.to_lifetime(lifetime),
-                                        _ => unreachable!("lifetimes can only be bound by lifetimes"),
+                                        hir::GenericBound::Trait(..) => {
+                                            unreachable!("lifetimes can only be bound by lifetimes")
+                                        },
                                     })
                                     .collect();
                                 let bounds = if bounds.is_empty() {
@@ -141,15 +143,17 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                     hir::GenericParamKind::Type { synthetic: false, .. } => {
                         Some(GenericParamKind::Ty(self.alloc(TyParam::new(Some(span), name, id))))
                     },
-                    hir::GenericParamKind::Const { ty, default } => {
-                        Some(GenericParamKind::Const(self.alloc(ConstParam::new(
-                            id,
-                            name,
-                            self.to_syn_ty(ty),
-                            default.map(|anon| self.to_const_expr(anon)),
-                            span,
-                        ))))
-                    },
+                    hir::GenericParamKind::Const {
+                        ty,
+                        default,
+                        is_host_effect: _,
+                    } => Some(GenericParamKind::Const(self.alloc(ConstParam::new(
+                        id,
+                        name,
+                        self.to_syn_ty(ty),
+                        default.map(|anon| self.to_const_expr(anon)),
+                        span,
+                    )))),
                     _ => None,
                 }
             })
@@ -174,21 +178,6 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                         self.to_span_id(bound.span()),
                     ))))
                 },
-                hir::GenericBound::LangItemTrait(lang_item, span, _, rustc_args) => Some(TyParamBound::TraitBound(
-                    self.alloc(TraitBound::new(
-                        false,
-                        TraitRef::new(
-                            self.to_item_id(
-                                self.rustc_cx
-                                    .get_lang_items(())
-                                    .get(*lang_item)
-                                    .expect("the lang item is used and should therefore be loaded"),
-                            ),
-                            self.to_syn_generic_args(Some(rustc_args)),
-                        ),
-                        self.to_span_id(*span),
-                    )),
-                )),
                 hir::GenericBound::Outlives(rust_lt) => self
                     .to_lifetime(rust_lt)
                     .map(|api_lt| TyParamBound::Lifetime(self.alloc(api_lt))),

marker_rustc_driver/src/conversion/marker/ast/item.rs

@@ -1,9 +1,8 @@
 use marker_api::{
     ast::{
-        self, AdtKind, AssocItemKind, Body, CommonItemData, CommonPatData, ConstItem, EnumItem, EnumVariant,
-        ExternBlockItem, ExternCrateItem, ExternItemKind, FnItem, FnParam, IdentPat, ImplItem, ItemField, ItemKind,
-        ModItem, PatKind, StaticItem, StructItem, TraitItem, TyAliasItem, UnionItem, UnstableItem, UseItem, UseKind,
-        Visibility,
+        AdtKind, AssocItemKind, Body, CommonItemData, CommonPatData, ConstItem, EnumItem, EnumVariant, ExternBlockItem,
+        ExternCrateItem, ExternItemKind, FnItem, FnParam, IdentPat, ImplItem, ItemField, ItemKind, ModItem, PatKind,
+        StaticItem, StructItem, TraitItem, TyAliasItem, UnionItem, UnstableItem, UseItem, UseKind, Visibility,
     },
     common::{Abi, Constness, Mutability, Safety, Syncness},
     prelude::*,
@@ -209,8 +208,10 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 && let hir::TyKind::OpaqueDef(item_id, _bounds, _) = rust_ty.kind
                 && let item = self.rustc_cx.hir().item(item_id)
                 && let hir::ItemKind::OpaqueTy(opty) = &item.kind
-                && let [output_bound] = opty.bounds
-                && let hir::GenericBound::LangItemTrait(_lang_item, _span, _hir_id, rustc_args) = output_bound
+                && let [hir::GenericBound::Trait(trait_ref, _)] = opty.bounds
+                && let Some(hir::PathSegment {
+                    args: Some(rustc_args), ..
+                }) = trait_ref.trait_ref.path.segments.last()
                 && let [output_bound] = rustc_args.bindings
             {
                 Some(self.to_syn_ty(output_bound.ty()))
@@ -267,7 +268,7 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
 
     fn to_adt_kind(&self, var_data: &'tcx hir::VariantData) -> AdtKind<'ast> {
         match var_data {
-            hir::VariantData::Struct(fields, _recovered) => AdtKind::Field(self.to_fields(fields).into()),
+            hir::VariantData::Struct { fields, recovered: _ } => AdtKind::Field(self.to_fields(fields).into()),
             hir::VariantData::Tuple(fields, ..) => AdtKind::Tuple(self.to_fields(fields).into()),
             hir::VariantData::Unit(..) => AdtKind::Unit,
         }
@@ -480,17 +481,6 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
             return body;
         }
 
-        // Yield expressions are currently unstable
-        if let Some(hir::CoroutineKind::Coroutine) = body.coroutine_kind {
-            return self.alloc(Body::new(
-                self.to_item_id(self.rustc_cx.hir().body_owner_def_id(body.id())),
-                ast::ExprKind::Unstable(self.alloc(ast::UnstableExpr::new(
-                    ast::CommonExprData::new(self.to_expr_id(body.value.hir_id), self.to_span_id(body.value.span)),
-                    ast::ExprPrecedence::Unstable(0),
-                ))),
-            ));
-        }
-
         self.with_body(body.id(), || {
             let owner = self.to_item_id(self.rustc_cx.hir().body_owner_def_id(body.id()));
             let api_body = self.alloc(Body::new(owner, self.to_expr(body.value)));

marker_rustc_driver/src/conversion/marker/ast/pat.rs

@@ -102,7 +102,6 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 };
                 PatKind::Tuple(self.alloc(TuplePat::new(data, pats)))
             },
-            hir::PatKind::Box(_) => PatKind::Unstable(self.alloc(UnstablePat::new(data))),
             hir::PatKind::Ref(pat, muta) => PatKind::Ref(
                 self.alloc(
                     RefPat::builder()
@@ -137,6 +136,19 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 end.map(|expr| self.to_expr(expr)),
                 matches!(kind, hir::RangeEnd::Included),
             ))),
+            #[allow(clippy::match_same_arms)]
+            hir::PatKind::Box(_) => {
+                // Unstable:
+                // * Feature `box_patterns`
+                // * Tracking issue: rust#29641
+                PatKind::Unstable(self.alloc(UnstablePat::new(data)))
+            },
+            rustc_hir::PatKind::Never => {
+                // Unstable:
+                // * Feature `never_patterns`
+                // * Tracking issue: rust#118155
+                PatKind::Unstable(self.alloc(UnstablePat::new(data)))
+            },
         }
     }
 

marker_rustc_driver/src/conversion/marker/ast/ty.rs

@@ -138,7 +138,7 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 | hir::def::Res::NonMacroAttr(_) => unreachable!("not a syntactic type {path:#?}"),
                 hir::def::Res::Err => unreachable!("would have triggered a rustc error"),
             },
-            hir::QPath::TypeRelative(_, _) | hir::QPath::LangItem(_, _, _) => {
+            hir::QPath::TypeRelative(_, _) | hir::QPath::LangItem(_, _) => {
                 TyKind::Path(self.alloc(PathTy::new(data, self.to_qpath_from_ty(qpath, rustc_ty))))
             },
         }

marker_rustc_driver/src/conversion/marker/common.rs

@@ -282,7 +282,7 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
                 AstQPath::new(None, Some(marker_ty), path, res)
             },
             // I recommend reading the comment of `Self::lang_item_map` for context
-            hir::QPath::LangItem(item, span, _) => {
+            hir::QPath::LangItem(item, span) => {
                 let id = self
                     .rustc_cx
                     .lang_items()

marker_rustc_driver/src/conversion/rustc/common.rs

@@ -140,9 +140,7 @@ impl<'ast, 'tcx> RustcConverter<'ast, 'tcx> {
             _ => unreachable!(),
         };
 
-        def_id
-            .as_local()
-            .map(|id| self.rustc_cx.hir().local_def_id_to_hir_id(id))
+        def_id.as_local().map(|id| self.rustc_cx.local_def_id_to_hir_id(id))
     }
 
     #[must_use]

marker_rustc_driver/src/lib.rs

@@ -45,7 +45,7 @@ use marker_error::Context;
 use crate::conversion::rustc::RustcConverter;
 
 // region replace rust toolchain dev
-const RUSTC_TOOLCHAIN_VERSION: &str = "nightly-2023-11-16";
+const RUSTC_TOOLCHAIN_VERSION: &str = "nightly-2023-12-28";
 // endregion replace rust toolchain dev
 
 pub const MARKER_SYSROOT_ENV: &str = "MARKER_SYSROOT";

marker_rustc_driver/src/lint_pass.rs

@@ -60,7 +60,11 @@ fn process_crate_lifetime<'ast, 'tcx: 'ast>(
     storage: &'ast Storage<'ast>,
     adapter: &Adapter,
 ) {
-    let driver_cx = RustcContext::new(rustc_cx.tcx, rustc_cx.lint_store, storage);
+    let driver_cx = RustcContext::new(
+        rustc_cx.tcx,
+        rustc_lint::unerased_lint_store(rustc_cx.tcx.sess),
+        storage,
+    );
 
     // To support debug printing of AST nodes, as these might sometimes require the
     // context. Note that this only sets the cx for the rustc side. Each lint crate