diff --git a/compiler/rustc_codegen_llvm/messages.ftl b/compiler/rustc_codegen_llvm/messages.ftl index ce9a51b539d83..c9d28160d66f7 100644 --- a/compiler/rustc_codegen_llvm/messages.ftl +++ b/compiler/rustc_codegen_llvm/messages.ftl @@ -1,4 +1,5 @@ codegen_llvm_autodiff_without_enable = using the autodiff feature requires -Z autodiff=Enable +codegen_llvm_autodiff_without_lto = using the autodiff feature requires setting `lto="fat"` in your Cargo.toml codegen_llvm_copy_bitcode = failed to copy bitcode to object file: {$err} diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs index 627b0c9ff3b33..629afee8a6677 100644 --- a/compiler/rustc_codegen_llvm/src/errors.rs +++ b/compiler/rustc_codegen_llvm/src/errors.rs @@ -32,6 +32,10 @@ impl Diagnostic<'_, G> for ParseTargetMachineConfig<'_> { } } +#[derive(Diagnostic)] +#[diag(codegen_llvm_autodiff_without_lto)] +pub(crate) struct AutoDiffWithoutLto; + #[derive(Diagnostic)] #[diag(codegen_llvm_autodiff_without_enable)] pub(crate) struct AutoDiffWithoutEnable; diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index 739b33f34962c..653202e633f78 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -25,7 +25,7 @@ use crate::abi::FnAbiLlvmExt; use crate::builder::Builder; use crate::builder::autodiff::{adjust_activity_to_abi, generate_enzyme_call}; use crate::context::CodegenCx; -use crate::errors::AutoDiffWithoutEnable; +use crate::errors::{AutoDiffWithoutEnable, AutoDiffWithoutLto}; use crate::llvm::{self, Metadata, Type, Value}; use crate::type_of::LayoutLlvmExt; use crate::va_arg::emit_va_arg; @@ -1146,6 +1146,9 @@ fn codegen_autodiff<'ll, 'tcx>( if !tcx.sess.opts.unstable_opts.autodiff.contains(&rustc_session::config::AutoDiff::Enable) { let _ = tcx.dcx().emit_almost_fatal(AutoDiffWithoutEnable); } + if tcx.sess.lto() != rustc_session::config::Lto::Fat { + let _ = tcx.dcx().emit_almost_fatal(AutoDiffWithoutLto); + } let fn_args = instance.args; let callee_ty = instance.ty(tcx, bx.typing_env()); diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index f27b32de565da..e52475cdd5bde 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -594,14 +594,6 @@ impl Session { /// Calculates the flavor of LTO to use for this compilation. pub fn lto(&self) -> config::Lto { - // Autodiff currently requires fat-lto to have access to the llvm-ir of all (indirectly) used functions and types. - // fat-lto is the easiest solution to this requirement, but quite expensive. - // FIXME(autodiff): Make autodiff also work with embed-bc instead of fat-lto. - // Don't apply fat-lto to proc-macro crates as they cannot use fat-lto without -Zdylib-lto - if self.opts.autodiff_enabled() && !self.opts.crate_types.contains(&CrateType::ProcMacro) { - return config::Lto::Fat; - } - // If our target has codegen requirements ignore the command line if self.target.requires_lto { return config::Lto::Fat; diff --git a/library/core/src/mem/manually_drop.rs b/library/core/src/mem/manually_drop.rs index 334a4b7119a11..7d49da8509577 100644 --- a/library/core/src/mem/manually_drop.rs +++ b/library/core/src/mem/manually_drop.rs @@ -217,8 +217,9 @@ impl ManuallyDrop { /// #[must_use = "if you don't need the value, you can use `ManuallyDrop::drop` instead"] #[stable(feature = "manually_drop_take", since = "1.42.0")] + #[rustc_const_unstable(feature = "const_manually_drop_take", issue = "148773")] #[inline] - pub unsafe fn take(slot: &mut ManuallyDrop) -> T { + pub const unsafe fn take(slot: &mut ManuallyDrop) -> T { // SAFETY: we are reading from a reference, which is guaranteed // to be valid for reads. unsafe { ptr::read(&slot.value) } diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs index b180e88fd49bc..844030119c44d 100644 --- a/library/core/src/mem/mod.rs +++ b/library/core/src/mem/mod.rs @@ -808,7 +808,8 @@ pub const fn swap(x: &mut T, y: &mut T) { /// ``` #[inline] #[stable(feature = "mem_take", since = "1.40.0")] -pub fn take(dest: &mut T) -> T { +#[rustc_const_unstable(feature = "const_default", issue = "143894")] +pub const fn take(dest: &mut T) -> T { replace(dest, T::default()) } diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs index 45308c4b3e9c5..ab7389a1300c5 100644 --- a/library/core/src/str/mod.rs +++ b/library/core/src/str/mod.rs @@ -1251,6 +1251,8 @@ impl str { /// ending will return the same lines as an otherwise identical string /// without a final line ending. /// + /// An empty string returns an empty iterator. + /// /// # Examples /// /// Basic usage: @@ -1281,6 +1283,15 @@ impl str { /// /// assert_eq!(None, lines.next()); /// ``` + /// + /// An empty string returns an empty iterator: + /// + /// ``` + /// let text = ""; + /// let mut lines = text.lines(); + /// + /// assert_eq!(lines.next(), None); + /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn lines(&self) -> Lines<'_> { diff --git a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile index c005eceb6ef4a..c9c3e3d2a3306 100644 --- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile +++ b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile @@ -21,6 +21,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends \ mingw-w64 \ && rm -rf /var/lib/apt/lists/* +RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-27/wasi-sdk-27.0-x86_64-linux.tar.gz | \ + tar -xz +ENV WASI_SDK_PATH=/wasi-sdk-27.0-x86_64-linux + ENV RUST_CONFIGURE_ARGS="--set rust.validate-mir-opts=3" COPY scripts/sccache.sh /scripts/ @@ -30,6 +34,10 @@ ENV SCRIPT \ python3 ../x.py check && \ python3 ../x.py clippy ci --stage 2 && \ python3 ../x.py test --stage 1 core alloc std test proc_macro && \ + # Elsewhere, we run all tests for the host. A number of codegen tests are sensitive to the target pointer + # width, for example because they mention a usize. wasm32-wasip1 in test-various, so using it here can't make + # PR CI more strict than full CI. + python3 ../x.py test --stage 1 tests/codegen-llvm --target wasm32-wasip1 && \ python3 ../x.py test --stage 1 src/tools/compiletest && \ python3 ../x.py doc bootstrap --stage 1 && \ # Build both public and internal documentation. diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index 8527f7e8128f4..ddcda91c13d01 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -2766,12 +2766,11 @@ impl<'test> TestCx<'test> { .map_err(|err| format!("failed to load expected output from `{}`: {}", path, err)) } + /// Attempts to delete a file, succeeding if the file does not exist. fn delete_file(&self, file: &Utf8Path) { - if !file.exists() { - // Deleting a nonexistent file would error. - return; - } - if let Err(e) = fs::remove_file(file.as_std_path()) { + if let Err(e) = fs::remove_file(file.as_std_path()) + && e.kind() != io::ErrorKind::NotFound + { self.fatal(&format!("failed to delete `{}`: {}", file, e,)); } } diff --git a/tests/ui/autodiff/no_lto_flag.no_lto.stderr b/tests/ui/autodiff/no_lto_flag.no_lto.stderr new file mode 100644 index 0000000000000..abc6af5b62965 --- /dev/null +++ b/tests/ui/autodiff/no_lto_flag.no_lto.stderr @@ -0,0 +1,4 @@ +error: using the autodiff feature requires setting `lto="fat"` in your Cargo.toml + +error: aborting due to 1 previous error + diff --git a/tests/ui/autodiff/no_lto_flag.rs b/tests/ui/autodiff/no_lto_flag.rs new file mode 100644 index 0000000000000..6194b1effc34f --- /dev/null +++ b/tests/ui/autodiff/no_lto_flag.rs @@ -0,0 +1,31 @@ +//@ needs-enzyme +//@ no-prefer-dynamic +//@ revisions: with_lto no_lto +//@[with_lto] compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=fat +//@[no_lto] compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=thin + +#![feature(autodiff)] +//@[no_lto] build-fail +//@[with_lto] build-pass + +// Autodiff requires users to enable lto=fat (for now). +// In the past, autodiff did not run if users forget to enable fat-lto, which caused functions to +// returning zero-derivatives. That's obviously wrong and confusing to users. We now added a check +// which will abort compilation instead. + +use std::autodiff::autodiff_reverse; +//[no_lto]~? ERROR using the autodiff feature requires setting `lto="fat"` in your Cargo.toml + +#[autodiff_reverse(d_square, Duplicated, Active)] +fn square(x: &f64) -> f64 { + *x * *x +} + +fn main() { + let xf64: f64 = std::hint::black_box(3.0); + + let mut df_dxf64: f64 = std::hint::black_box(0.0); + + let _output_f64 = d_square(&xf64, &mut df_dxf64, 1.0); + assert_eq!(6.0, df_dxf64); +} diff --git a/tests/ui/proc-macro/auxiliary/nonfatal-parsing-body.rs b/tests/ui/proc-macro/auxiliary/nonfatal-parsing-body.rs new file mode 100644 index 0000000000000..854d27d7ed323 --- /dev/null +++ b/tests/ui/proc-macro/auxiliary/nonfatal-parsing-body.rs @@ -0,0 +1,143 @@ +use std::fmt::Debug; +use std::panic::catch_unwind; +use std::str::FromStr; + +use proc_macro::*; + +use self::Mode::*; + +// FIXME: all cases should become `NormalOk` or `NormalErr` +#[derive(PartialEq, Clone, Copy)] +enum Mode { + NormalOk, + NormalErr, + OtherError, + OtherWithPanic, +} + +fn parse(s: &str, mode: Mode) +where + T: FromStr + Debug, +{ + match mode { + NormalOk => { + let t = T::from_str(s); + println!("{:?}", t); + assert!(t.is_ok()); + } + NormalErr => { + let t = T::from_str(s); + println!("{:?}", t); + assert!(t.is_err()); + } + OtherError => { + println!("{:?}", T::from_str(s)); + } + OtherWithPanic => { + if catch_unwind(|| println!("{:?}", T::from_str(s))).is_ok() { + eprintln!("{s} did not panic"); + } + } + } +} + +fn stream(s: &str, mode: Mode) { + parse::(s, mode); +} + +fn lit(s: &str, mode: Mode) { + parse::(s, mode); + if mode == NormalOk { + let Ok(lit) = Literal::from_str(s) else { + panic!("literal was not ok"); + }; + let Ok(stream) = TokenStream::from_str(s) else { + panic!("tokenstream was not ok, but literal was"); + }; + let Some(tree) = stream.into_iter().next() else { + panic!("tokenstream should have a tokentree"); + }; + if let TokenTree::Literal(tokenstream_lit) = tree { + assert_eq!(lit.to_string(), tokenstream_lit.to_string()); + } + } +} + +pub fn run() { + // returns Ok(valid instance) + lit("123", NormalOk); + lit("\"ab\"", NormalOk); + lit("\'b\'", NormalOk); + lit("'b'", NormalOk); + lit("b\"b\"", NormalOk); + lit("c\"b\"", NormalOk); + lit("cr\"b\"", NormalOk); + lit("b'b'", NormalOk); + lit("256u8", NormalOk); + lit("-256u8", NormalOk); + stream("-256u8", NormalOk); + lit("0b11111000000001111i16", NormalOk); + lit("0xf32", NormalOk); + lit("0b0f32", NormalOk); + lit("2E4", NormalOk); + lit("2.2E-4f64", NormalOk); + lit("18u8E", NormalOk); + lit("18.0u8E", NormalOk); + lit("cr#\"// /* // \n */\"#", NormalOk); + lit("'\\''", NormalOk); + lit("'\\\''", NormalOk); + lit(&format!("r{0}\"a\"{0}", "#".repeat(255)), NormalOk); + stream("fn main() { println!(\"Hello, world!\") }", NormalOk); + stream("18.u8E", NormalOk); + stream("18.0f32", NormalOk); + stream("18.0f34", NormalOk); + stream("18.bu8", NormalOk); + stream("3//\n4", NormalOk); + stream( + "\'c\'/*\n + */", + NormalOk, + ); + stream("/*a*/ //", NormalOk); + + println!("### ERRORS"); + + // returns Err(LexError) + lit("\'c\'/**/", NormalErr); + lit(" 0", NormalErr); + lit("0 ", NormalErr); + lit("0//", NormalErr); + lit("3//\n4", NormalErr); + lit("18.u8E", NormalErr); + lit("/*a*/ //", NormalErr); + // FIXME: all of the cases below should return an Err and emit no diagnostics, but don't yet. + + // emits diagnostics and returns LexError + lit("r'r'", OtherError); + lit("c'r'", OtherError); + + // emits diagnostic and returns a seemingly valid tokenstream + stream("r'r'", OtherError); + stream("c'r'", OtherError); + + for parse in [stream as fn(&str, Mode), lit] { + // emits diagnostic(s), then panics + parse("1 ) 2", OtherWithPanic); + parse("( x [ ) ]", OtherWithPanic); + parse("r#", OtherWithPanic); + + // emits diagnostic(s), then returns Ok(Literal { kind: ErrWithGuar, .. }) + parse("0b2", OtherError); + parse("0bf32", OtherError); + parse("0b0.0f32", OtherError); + parse("'\''", OtherError); + parse( + "' +'", OtherError, + ); + parse(&format!("r{0}\"a\"{0}", "#".repeat(256)), OtherWithPanic); + + // emits diagnostic, then, when parsing as a lit, returns LexError, otherwise ErrWithGuar + parse("/*a*/ 0b2 //", OtherError); + } +} diff --git a/tests/ui/proc-macro/auxiliary/nonfatal-parsing.rs b/tests/ui/proc-macro/auxiliary/nonfatal-parsing.rs new file mode 100644 index 0000000000000..75db8ee3c5fc8 --- /dev/null +++ b/tests/ui/proc-macro/auxiliary/nonfatal-parsing.rs @@ -0,0 +1,11 @@ +extern crate proc_macro; +use proc_macro::*; + +#[path = "nonfatal-parsing-body.rs"] +mod body; + +#[proc_macro] +pub fn run(_: TokenStream) -> TokenStream { + body::run(); + TokenStream::new() +} diff --git a/tests/ui/proc-macro/nonfatal-parsing.rs b/tests/ui/proc-macro/nonfatal-parsing.rs new file mode 100644 index 0000000000000..853cbfd075e7b --- /dev/null +++ b/tests/ui/proc-macro/nonfatal-parsing.rs @@ -0,0 +1,19 @@ +//@ proc-macro: nonfatal-parsing.rs +//@ needs-unwind +//@ edition: 2024 +//@ dont-require-annotations: ERROR +//@ ignore-backends: gcc +// FIXME: should be a run-pass test once invalidly parsed tokens no longer result in diagnostics + +extern crate proc_macro; +extern crate nonfatal_parsing; + +#[path = "auxiliary/nonfatal-parsing-body.rs"] +mod body; + +fn main() { + nonfatal_parsing::run!(); + // FIXME: enable this once the standalone backend exists + // https://github.com/rust-lang/rust/issues/130856 + // body::run(); +} diff --git a/tests/ui/proc-macro/nonfatal-parsing.stderr b/tests/ui/proc-macro/nonfatal-parsing.stderr new file mode 100644 index 0000000000000..00c5c6ecfa8ea --- /dev/null +++ b/tests/ui/proc-macro/nonfatal-parsing.stderr @@ -0,0 +1,197 @@ +error: prefix `r` is unknown + --> :1:1 + | +LL | r'r' + | ^ unknown prefix + | + = note: prefixed identifiers and literals are reserved since Rust 2021 +help: consider inserting whitespace here + | +LL | r 'r' + | + + +error: prefix `c` is unknown + --> :1:1 + | +LL | c'r' + | ^ unknown prefix + | + = note: prefixed identifiers and literals are reserved since Rust 2021 +help: consider inserting whitespace here + | +LL | c 'r' + | + + +error: unexpected closing delimiter: `)` + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ unexpected closing delimiter + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: unexpected closing delimiter: `]` + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | -^^^^^^^^^^^^^^^^^^^^^^^ + | | + | the nearest open delimiter + | missing open `(` for this delimiter + | unexpected closing delimiter + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: found invalid character; only `#` is allowed in raw string delimitation: \u{0} + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: invalid digit for a base 2 literal + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0768]: no valid digits found for number + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: binary float literal is not supported + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: character constant must be escaped: `'` + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) +help: escape the character + | +LL - nonfatal_parsing::run!(); +LL + nonfatal_parsing::run!(\'; + | + +error: character constant must be escaped: `\n` + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) +help: escape the character + | +LL - nonfatal_parsing::run!(); +LL + nonfatal_parsing::run!(\n; + | + +error: too many `#` symbols: raw strings may be delimited by up to 255 `#` symbols, but found 256 + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: invalid digit for a base 2 literal + --> $DIR/nonfatal-parsing.rs:15:5 + | +LL | nonfatal_parsing::run!(); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` + = note: this error originates in the macro `nonfatal_parsing::run` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: unexpected closing delimiter: `)` + --> :1:3 + | +LL | 1 ) 2 + | ^ unexpected closing delimiter + +error: unexpected closing delimiter: `]` + --> :1:10 + | +LL | ( x [ ) ] + | - - ^ unexpected closing delimiter + | | | + | | missing open `(` for this delimiter + | the nearest open delimiter + +error: found invalid character; only `#` is allowed in raw string delimitation: \u{0} + --> :1:1 + | +LL | r# + | ^^ + +error: invalid digit for a base 2 literal + --> :1:3 + | +LL | 0b2 + | ^ + +error[E0768]: no valid digits found for number + --> :1:1 + | +LL | 0bf32 + | ^^ + +error: binary float literal is not supported + --> :1:1 + | +LL | 0b0.0f32 + | ^^^^^ + +error: character constant must be escaped: `'` + --> :1:2 + | +LL | ''' + | ^ + | +help: escape the character + | +LL | '\'' + | + + +error: character constant must be escaped: `\n` + --> :1:2 + | +LL | ' + | __^ +LL | | ' + | |_^ + | +help: escape the character + | +LL | '\n' + | ++ + +error: too many `#` symbols: raw strings may be delimited by up to 255 `#` symbols, but found 256 + --> :1:1 + | +LL | r#######################################...################################################## + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: invalid digit for a base 2 literal + --> :1:9 + | +LL | /*a*/ 0b2 // + | ^ + +error: aborting due to 22 previous errors + +For more information about this error, try `rustc --explain E0768`. diff --git a/tests/ui/proc-macro/nonfatal-parsing.stdout b/tests/ui/proc-macro/nonfatal-parsing.stdout new file mode 100644 index 0000000000000..08e0e6b1f8439 --- /dev/null +++ b/tests/ui/proc-macro/nonfatal-parsing.stdout @@ -0,0 +1,54 @@ +Ok(Literal { kind: Integer, symbol: "123", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Str, symbol: "ab", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Char, symbol: "b", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Char, symbol: "b", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: ByteStr, symbol: "b", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: CStr, symbol: "b", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: CStrRaw(0), symbol: "b", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Byte, symbol: "b", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Integer, symbol: "256", suffix: Some("u8"), span: #44 bytes(361..385) }) +Ok(Literal { kind: Integer, symbol: "-256", suffix: Some("u8"), span: #44 bytes(361..385) }) +Ok(TokenStream [Punct { ch: '-', spacing: Alone, span: #44 bytes(361..385) }, Literal { kind: Integer, symbol: "256", suffix: Some("u8"), span: #44 bytes(361..385) }]) +Ok(Literal { kind: Integer, symbol: "0b11111000000001111", suffix: Some("i16"), span: #44 bytes(361..385) }) +Ok(Literal { kind: Integer, symbol: "0xf32", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Integer, symbol: "0b0", suffix: Some("f32"), span: #44 bytes(361..385) }) +Ok(Literal { kind: Float, symbol: "2E4", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Float, symbol: "2.2E-4", suffix: Some("f64"), span: #44 bytes(361..385) }) +Ok(Literal { kind: Integer, symbol: "18", suffix: Some("u8E"), span: #44 bytes(361..385) }) +Ok(Literal { kind: Float, symbol: "18.0", suffix: Some("u8E"), span: #44 bytes(361..385) }) +Ok(Literal { kind: CStrRaw(1), symbol: "// /* // \n */", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Char, symbol: "\'", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: Char, symbol: "\'", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: StrRaw(255), symbol: "a", suffix: None, span: #44 bytes(361..385) }) +Ok(TokenStream [Ident { ident: "fn", span: #44 bytes(361..385) }, Ident { ident: "main", span: #44 bytes(361..385) }, Group { delimiter: Parenthesis, stream: TokenStream [], span: #44 bytes(361..385) }, Group { delimiter: Brace, stream: TokenStream [Ident { ident: "println", span: #44 bytes(361..385) }, Punct { ch: '!', spacing: Alone, span: #44 bytes(361..385) }, Group { delimiter: Parenthesis, stream: TokenStream [Literal { kind: Str, symbol: "Hello, world!", suffix: None, span: #44 bytes(361..385) }], span: #44 bytes(361..385) }], span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: Integer, symbol: "18", suffix: None, span: #44 bytes(361..385) }, Punct { ch: '.', spacing: Alone, span: #44 bytes(361..385) }, Ident { ident: "u8E", span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: Float, symbol: "18.0", suffix: Some("f32"), span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: Float, symbol: "18.0", suffix: Some("f34"), span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: Integer, symbol: "18", suffix: None, span: #44 bytes(361..385) }, Punct { ch: '.', spacing: Alone, span: #44 bytes(361..385) }, Ident { ident: "bu8", span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: Integer, symbol: "3", suffix: None, span: #44 bytes(361..385) }, Literal { kind: Integer, symbol: "4", suffix: None, span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: Char, symbol: "c", suffix: None, span: #44 bytes(361..385) }]) +Ok(TokenStream []) +### ERRORS +Err(LexError) +Err(LexError) +Err(LexError) +Err(LexError) +Err(LexError) +Err(LexError) +Err(LexError) +Err(LexError) +Err(LexError) +Ok(TokenStream [Ident { ident: "r", span: #44 bytes(361..385) }, Literal { kind: Char, symbol: "r", suffix: None, span: #44 bytes(361..385) }]) +Ok(TokenStream [Ident { ident: "c", span: #44 bytes(361..385) }, Literal { kind: Char, symbol: "r", suffix: None, span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b2", suffix: None, span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b", suffix: Some("f32"), span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b0.0", suffix: Some("f32"), span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "'''", suffix: None, span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "'\n'", suffix: None, span: #44 bytes(361..385) }]) +Ok(TokenStream [Literal { kind: ErrWithGuar, symbol: "0b2", suffix: None, span: #44 bytes(361..385) }]) +Ok(Literal { kind: ErrWithGuar, symbol: "0b2", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: ErrWithGuar, symbol: "0b", suffix: Some("f32"), span: #44 bytes(361..385) }) +Ok(Literal { kind: ErrWithGuar, symbol: "0b0.0", suffix: Some("f32"), span: #44 bytes(361..385) }) +Ok(Literal { kind: ErrWithGuar, symbol: "'''", suffix: None, span: #44 bytes(361..385) }) +Ok(Literal { kind: ErrWithGuar, symbol: "'\n'", suffix: None, span: #44 bytes(361..385) }) +Err(LexError) diff --git a/triagebot.toml b/triagebot.toml index 0bf310e8fd7ef..f901dc7efc1e6 100644 --- a/triagebot.toml +++ b/triagebot.toml @@ -1070,7 +1070,6 @@ source file via `./x run src/tools/unicode-table-generator` instead of editing \ message = "Some changes occurred in HTML/CSS/JS." cc = [ "@GuillaumeGomez", - "@jsha", "@lolbinarycat", ]