diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e2665fee..3db3f317 100644 --- a/.github/workflows/ci.yml +++ b/.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 + diff --git a/CHANGELOG.md b/CHANGELOG.md index fdb030ed..f3064e79 100644 --- a/CHANGELOG.md +++ b/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 diff --git a/cargo-marker/src/backend/driver.rs b/cargo-marker/src/backend/driver.rs index 69ece3cd..8d28e344 100644 --- a/cargo-marker/src/backend/driver.rs +++ b/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(), diff --git a/marker_api/src/lib.rs b/marker_api/src/lib.rs index 2d59ebde..5884f8cb 100644 --- a/marker_api/src/lib.rs +++ b/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))] diff --git a/marker_rustc_driver/src/context.rs b/marker_rustc_driver/src/context.rs index 77da9fa9..ebfe4e86 100644 --- a/marker_rustc_driver/src/context.rs +++ b/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) diff --git a/marker_rustc_driver/src/conversion/marker.rs b/marker_rustc_driver/src/conversion/marker.rs index 7ce49a62..d7082bad 100644 --- a/marker_rustc_driver/src/conversion/marker.rs +++ b/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)) diff --git a/marker_rustc_driver/src/conversion/marker/ast/expr.rs b/marker_rustc_driver/src/conversion/marker/ast/expr.rs index cf5eb4a8..998ef479 100644 --- a/marker_rustc_driver/src/conversion/marker/ast/expr.rs +++ b/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,16 +156,16 @@ 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)), @@ -173,7 +173,7 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> { 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))), } } diff --git a/marker_rustc_driver/src/conversion/marker/ast/generic.rs b/marker_rustc_driver/src/conversion/marker/ast/generic.rs index 95b3525c..c8e9eb3b 100644 --- a/marker_rustc_driver/src/conversion/marker/ast/generic.rs +++ b/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))), diff --git a/marker_rustc_driver/src/conversion/marker/ast/item.rs b/marker_rustc_driver/src/conversion/marker/ast/item.rs index db517c19..a9cf84b3 100644 --- a/marker_rustc_driver/src/conversion/marker/ast/item.rs +++ b/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))); diff --git a/marker_rustc_driver/src/conversion/marker/ast/pat.rs b/marker_rustc_driver/src/conversion/marker/ast/pat.rs index 984284e4..97839cf7 100644 --- a/marker_rustc_driver/src/conversion/marker/ast/pat.rs +++ b/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))) + }, } } diff --git a/marker_rustc_driver/src/conversion/marker/ast/ty.rs b/marker_rustc_driver/src/conversion/marker/ast/ty.rs index 5f7765bd..a43a22a6 100644 --- a/marker_rustc_driver/src/conversion/marker/ast/ty.rs +++ b/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)))) }, } diff --git a/marker_rustc_driver/src/conversion/marker/common.rs b/marker_rustc_driver/src/conversion/marker/common.rs index 45f0027a..6e364c7c 100644 --- a/marker_rustc_driver/src/conversion/marker/common.rs +++ b/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() diff --git a/marker_rustc_driver/src/conversion/rustc/common.rs b/marker_rustc_driver/src/conversion/rustc/common.rs index 4b96a33b..8bf58286 100644 --- a/marker_rustc_driver/src/conversion/rustc/common.rs +++ b/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] diff --git a/marker_rustc_driver/src/lib.rs b/marker_rustc_driver/src/lib.rs index 92692be1..6d11ea23 100644 --- a/marker_rustc_driver/src/lib.rs +++ b/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"; diff --git a/marker_rustc_driver/src/lint_pass.rs b/marker_rustc_driver/src/lint_pass.rs index 9e8e4949..1ad461f4 100644 --- a/marker_rustc_driver/src/lint_pass.rs +++ b/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 diff --git a/marker_rustc_driver/src/main.rs b/marker_rustc_driver/src/main.rs index ce262839..c9d24324 100644 --- a/marker_rustc_driver/src/main.rs +++ b/marker_rustc_driver/src/main.rs @@ -14,14 +14,14 @@ extern crate rustc_span; use std::env; use rustc_session::config::ErrorOutputType; -use rustc_session::EarlyErrorHandler; +use rustc_session::EarlyDiagCtxt; use marker_rustc_driver::{try_main, MainError}; const BUG_REPORT_URL: &str = "https://github.com/rust-marker/marker/issues/new?template=panic.yml"; fn main() { - let handler = EarlyErrorHandler::new(ErrorOutputType::default()); + let handler = EarlyDiagCtxt::new(ErrorOutputType::default()); rustc_driver::init_rustc_env_logger(&handler); // FIXME(xFrednet): The ICE hook would ideally distinguish where the error @@ -31,8 +31,8 @@ fn main() { // caused the panic in the lint crate. rust-marker/marker#10 rustc_driver::install_ice_hook(BUG_REPORT_URL, |handler| { - handler.note_without_error(format!("{}", rustc_tools_util::get_version_info!())); - handler.note_without_error("Achievement Unlocked: [Free Ice Cream]"); + handler.note(format!("{}", rustc_tools_util::get_version_info!())); + handler.note("Achievement Unlocked: [Free Ice Cream]"); }); std::process::exit(rustc_driver::catch_with_exit_code(|| { diff --git a/marker_uilints/tests/ui/lint_level_attributes.stderr b/marker_uilints/tests/ui/lint_level_attributes.stderr index 7f121035..2eebdf30 100644 --- a/marker_uilints/tests/ui/lint_level_attributes.stderr +++ b/marker_uilints/tests/ui/lint_level_attributes.stderr @@ -18,5 +18,5 @@ note: the lint level is defined here 6 | #[deny(marker::marker_uilints::item_with_test_name)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to previous error; 1 warning emitted +error: aborting due to 1 previous error; 1 warning emitted diff --git a/rust-toolchain.toml b/rust-toolchain.toml index dc046b5a..96cc3968 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,6 +1,6 @@ [toolchain] # region replace rust toolchain dev -channel = "nightly-2023-11-16" +channel = "nightly-2023-12-28" # endregion replace rust toolchain dev components = [ "cargo", diff --git a/scripts/release/install.ps1 b/scripts/release/install.ps1 index cb9f88fc..510a5f25 100755 --- a/scripts/release/install.ps1 +++ b/scripts/release/install.ps1 @@ -71,9 +71,9 @@ Using config env vars (override these if needed): $version = "0.5.0" # endregion replace marker version unstable -# region replace rust toolchain release +# region replace rust toolchain unstable $toolchain = "nightly-2023-11-16" -# endregion replace rust toolchain release +# endregion replace rust toolchain unstable # Log the command, execute, and fail if its exit code is non-zero. # Surprisingly PowerShell can't do the exit code checks for us out of the box. diff --git a/scripts/release/install.sh b/scripts/release/install.sh index 9667abe5..67f83b58 100755 --- a/scripts/release/install.sh +++ b/scripts/release/install.sh @@ -27,9 +27,9 @@ echo "Bash version: $BASH_VERSION" >&2 version=0.5.0 # endregion replace marker version unstable -# region replace rust toolchain release +# region replace rust toolchain unstable toolchain=nightly-2023-11-16 -# endregion replace rust toolchain release +# endregion replace rust toolchain unstable function step { local cmd="$1" diff --git a/scripts/release/set-version.diff b/scripts/release/set-version.diff index 4025b2b8..65401216 100644 --- a/scripts/release/set-version.diff +++ b/scripts/release/set-version.diff @@ -211,17 +211,9 @@ -$version = "X.Y.Z" +$version = "0.1.0" # endregion replace marker version unstable - # region replace rust toolchain release --$toolchain = "nightly-YYYY-MM-DD" -+$toolchain = "nightly-2023-01-01" - # endregion replace rust toolchain release === scripts/release/install.sh === # region replace marker version unstable -version=X.Y.Z +version=0.1.0 # endregion replace marker version unstable - # region replace rust toolchain release --toolchain=nightly-YYYY-MM-DD -+toolchain=nightly-2023-01-01 - # endregion replace rust toolchain release