/// the message in `secondary_span` as the primary label, and apply the message that would
/// otherwise be used for the primary label on the `secondary_span` `Span`. This applies on
/// E0271, like `src/test/ui/issues/issue-39970.stderr`.
+ #[tracing::instrument(
+ level = "debug",
+ skip(self, diag, secondary_span, swap_secondary_and_primary, force_label)
+ )]
pub fn note_type_err(
&self,
diag: &mut Diagnostic,
force_label: bool,
) {
let span = cause.span(self.tcx);
- debug!("note_type_err cause={:?} values={:?}, terr={:?}", cause, values, terr);
// For some types of errors, expected-found does not make
// sense, so just ignore the values we were given.
}
};
- // Ignore msg for object safe coercion
- // since E0038 message will be printed
match terr {
+ // Ignore msg for object safe coercion
+ // since E0038 message will be printed
TypeError::ObjectUnsafeCoercion(_) => {}
_ => {
let mut label_or_note = |span: Span, msg: &str| {
// It reads better to have the error origin as the final
// thing.
self.note_error_origin(diag, cause, exp_found, terr);
+
+ debug!(?diag);
}
fn suggest_tuple_pattern(
ArgCount => write!(f, "incorrect number of function parameters"),
FieldMisMatch(adt, field) => write!(f, "field type mismatch: {}.{}", adt, field),
RegionsDoesNotOutlive(..) => write!(f, "lifetime mismatch"),
- RegionsInsufficientlyPolymorphic(br, _) => write!(
- f,
- "expected bound lifetime parameter{}, found concrete lifetime",
- br_string(br)
- ),
+ // Actually naming the region here is a bit confusing because context is lacking
+ RegionsInsufficientlyPolymorphic(..) => {
+ write!(f, "one type is more general than the other")
+ }
RegionsOverlyPolymorphic(br, _) => write!(
f,
"expected concrete lifetime, found bound lifetime parameter{}",
///
/// * From each pre-binding block to the next pre-binding block.
/// * From each otherwise block to the next pre-binding block.
+ #[tracing::instrument(level = "debug", skip(self, arms))]
pub(crate) fn match_expr(
&mut self,
destination: Place<'tcx>,
};
let mut pattern = self.pattern_from_hir(local.pat);
+ debug!(?pattern);
if let Some(ty) = &local.ty {
if let Some(&user_ty) =
}
}
+ #[tracing::instrument(level = "debug", skip(self))]
pub(crate) fn pattern_from_hir(&mut self, p: &hir::Pat<'_>) -> Pat<'tcx> {
let p = match self.tcx.hir().get(p.hir_id) {
Node::Pat(p) | Node::Binding(p) => p,
let mut all_arms_diverge = Diverges::WarnedAlways;
let expected = orig_expected.adjust_for_branches(self);
+ debug!(?expected);
let mut coercion = {
let coerce_first = match expected {
Some(&arm.body),
arm_ty,
Some(&mut |err: &mut Diagnostic| {
+ let Some(ret) = self.ret_type_span else {
+ return;
+ };
+ let Expectation::IsLast(stmt) = orig_expected else {
+ return
+ };
let can_coerce_to_return_ty = match self.ret_coercion.as_ref() {
Some(ret_coercion) if self.in_tail_expr => {
let ret_ty = ret_coercion.borrow().expected_ty();
}
_ => false,
};
- if let (Expectation::IsLast(stmt), Some(ret), true) =
- (orig_expected, self.ret_type_span, can_coerce_to_return_ty)
- {
- let semi_span = expr.span.shrink_to_hi().with_hi(stmt.hi());
- let mut ret_span: MultiSpan = semi_span.into();
- ret_span.push_span_label(
- expr.span,
- "this could be implicitly returned but it is a statement, not a \
- tail expression"
- .to_owned(),
- );
- ret_span.push_span_label(
- ret,
- "the `match` arms can conform to this return type".to_owned(),
- );
- ret_span.push_span_label(
- semi_span,
- "the `match` is a statement because of this semicolon, consider \
- removing it"
- .to_owned(),
- );
- err.span_note(
- ret_span,
- "you might have meant to return the `match` expression",
- );
- err.tool_only_span_suggestion(
- semi_span,
- "remove this semicolon",
- String::new(),
- Applicability::MaybeIncorrect,
- );
+ if !can_coerce_to_return_ty {
+ return;
}
+
+ let semi_span = expr.span.shrink_to_hi().with_hi(stmt.hi());
+ let mut ret_span: MultiSpan = semi_span.into();
+ ret_span.push_span_label(
+ expr.span,
+ "this could be implicitly returned but it is a statement, not a \
+ tail expression"
+ .to_owned(),
+ );
+ ret_span.push_span_label(
+ ret,
+ "the `match` arms can conform to this return type".to_owned(),
+ );
+ ret_span.push_span_label(
+ semi_span,
+ "the `match` is a statement because of this semicolon, consider \
+ removing it"
+ .to_owned(),
+ );
+ err.span_note(
+ ret_span,
+ "you might have meant to return the `match` expression",
+ );
+ err.tool_only_span_suggestion(
+ semi_span,
+ "remove this semicolon",
+ String::new(),
+ Applicability::MaybeIncorrect,
+ );
}),
false,
);
// We won't diverge unless the scrutinee or all arms diverge.
self.diverges.set(scrut_diverges | all_arms_diverge);
- coercion.complete(self)
+ let match_ty = coercion.complete(self);
+ debug!(?match_ty);
+ match_ty
}
fn get_appropriate_arm_semicolon_removal_span(
F: FnOnce(Ty<'tcx>) -> Vec<Adjustment<'tcx>>,
G: FnOnce(Ty<'tcx>) -> Vec<Adjustment<'tcx>>,
{
- if let ty::FnPtr(fn_ty_b) = b.kind()
- && let (hir::Unsafety::Normal, hir::Unsafety::Unsafe) =
- (fn_ty_a.unsafety(), fn_ty_b.unsafety())
- {
- let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(fn_ty_a);
- return self.unify_and(unsafe_a, b, to_unsafe);
- }
- self.unify_and(a, b, normal)
+ self.commit_unconditionally(|snapshot| {
+ let result = if let ty::FnPtr(fn_ty_b) = b.kind()
+ && let (hir::Unsafety::Normal, hir::Unsafety::Unsafe) =
+ (fn_ty_a.unsafety(), fn_ty_b.unsafety())
+ {
+ let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(fn_ty_a);
+ self.unify_and(unsafe_a, b, to_unsafe)
+ } else {
+ self.unify_and(a, b, normal)
+ };
+
+ // FIXME(#73154): This is a hack. Currently LUB can generate
+ // unsolvable constraints. Additionally, it returns `a`
+ // unconditionally, even when the "LUB" is `b`. In the future, we
+ // want the coerced type to be the actual supertype of these two,
+ // but for now, we want to just error to ensure we don't lock
+ // ourselves into a specific behavior with NLL.
+ self.leak_check(false, snapshot)?;
+
+ result
+ })
}
fn coerce_from_fn_pointer(
let (adjustments, target) = self.register_infer_ok_obligations(ok);
self.apply_adjustments(new, adjustments);
debug!(
- "coercion::try_find_coercion_lub: was able to coerce from previous type {:?} to new type {:?}",
- prev_ty, new_ty,
+ "coercion::try_find_coercion_lub: was able to coerce from new type {:?} to previous type {:?} ({:?})",
+ new_ty, prev_ty, target
);
return Ok(target);
}
}
}
Ok(ok) => {
- debug!(
- "coercion::try_find_coercion_lub: was able to coerce previous type {:?} to new type {:?}",
- prev_ty, new_ty,
- );
let (adjustments, target) = self.register_infer_ok_obligations(ok);
for expr in exprs {
let expr = expr.as_coercion_site();
self.apply_adjustments(expr, adjustments.clone());
}
+ debug!(
+ "coercion::try_find_coercion_lub: was able to coerce previous type {:?} to new type {:?} ({:?})",
+ prev_ty, new_ty, target
+ );
Ok(target)
}
}
})
};
+ debug!(?result);
match result {
Ok(v) => {
self.final_ty = Some(v);
augment_error(&mut err);
}
- if let Some(expr) = expression {
+ let is_insufficiently_polymorphic =
+ matches!(coercion_error, TypeError::RegionsInsufficientlyPolymorphic(..));
+
+ if !is_insufficiently_polymorphic && let Some(expr) = expression {
fcx.emit_coerce_suggestions(
&mut err,
expr,
///
/// N.B., this code relies on `self.diverges` to be accurate. In particular, assignments to `!`
/// will be permitted if the diverges flag is currently "always".
+ #[tracing::instrument(level = "debug", skip(self, expr, expected_ty_expr, allow_two_phase))]
pub fn demand_coerce_diag(
&self,
expr: &hir::Expr<'tcx>,
let expr_ty = self.resolve_vars_with_obligations(checked_ty);
let mut err = self.report_mismatched_types(&cause, expected, expr_ty, e.clone());
- self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr, Some(e));
+ let is_insufficiently_polymorphic =
+ matches!(e, TypeError::RegionsInsufficientlyPolymorphic(..));
+
+ // FIXME(#73154): For now, we do leak check when coercing function
+ // pointers in typeck, instead of only during borrowck. This can lead
+ // to these `RegionsInsufficientlyPolymorphic` errors that aren't helpful.
+ if !is_insufficiently_polymorphic {
+ self.emit_coerce_suggestions(
+ &mut err,
+ expr,
+ expr_ty,
+ expected,
+ expected_ty_expr,
+ Some(e),
+ );
+ }
(expected, Some(err))
}
/// A trait for implementing arbitrary return types in the `main` function.
///
-/// The C-main function only supports to return integers as return type.
+/// The C-main function only supports returning integers.
/// So, every type implementing the `Termination` trait has to be converted
/// to an integer.
///
env = os.environ.copy()
env["BOOTSTRAP_PARENT_ID"] = str(os.getpid())
env["BOOTSTRAP_PYTHON"] = sys.executable
- env["RUSTC_BOOTSTRAP"] = '1'
if build.rustc_commit is not None:
env["BOOTSTRAP_DOWNLOAD_RUSTC"] = '1'
run(args, env=env, verbose=build.verbose, is_bootstrap=True)
// this), as well as #63012 which is the tracking issue for this
// feature on the rustc side.
cargo.arg("-Zbinary-dep-depinfo");
+ match mode {
+ Mode::ToolBootstrap => {
+ // Restrict the allowed features to those passed by rustbuild, so we don't depend on nightly accidentally.
+ // HACK: because anyhow does feature detection in build.rs, we need to allow the backtrace feature too.
+ rustflags.arg("-Zallow-features=binary-dep-depinfo,backtrace");
+ }
+ Mode::Std | Mode::Rustc | Mode::ToolStd | Mode::Codegen | Mode::ToolRustc => {}
+ }
cargo.arg("-j").arg(self.jobs().to_string());
// Remove make-related flags to ensure Cargo can correctly set things up
configured_targets.append(target)
for target in configured_targets:
targets[target] = sections['target'][:]
- targets[target][0] = targets[target][0].replace("x86_64-unknown-linux-gnu", target)
+ targets[target][0] = targets[target][0].replace("x86_64-unknown-linux-gnu", "'{}'".format(target))
def is_number(value):
if self.validate {
cmd.arg("--validate");
}
+ if !builder.unstable_features() {
+ // We need to validate nightly features, even on the stable channel.
+ cmd.env("RUSTC_BOOTSTRAP", "1");
+ }
// If the lib directories are in an unusual location (changed in
// config.toml), then this needs to explicitly update the dylib search
// path.
--- /dev/null
+// check-pass
+pub trait Subscriber {
+ type Input;
+}
+
+pub trait Processor: Subscriber<Input = <Self as Processor>::Input> {
+ type Input;
+}
+
+fn main() {}
--- /dev/null
+pub trait Subscriber {
+ type Input;
+}
+
+pub trait Processor: Subscriber<Input = Self::Input> {
+ //~^ ERROR cycle detected
+ type Input;
+}
+
+fn main() {}
--- /dev/null
+error[E0391]: cycle detected when computing the super traits of `Processor` with associated type name `Input`
+ --> $DIR/issue-20825.rs:5:1
+ |
+LL | pub trait Processor: Subscriber<Input = Self::Input> {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: ...which immediately requires computing the super traits of `Processor` with associated type name `Input` again
+note: cycle used when computing the super traits of `Processor`
+ --> $DIR/issue-20825.rs:5:1
+ |
+LL | pub trait Processor: Subscriber<Input = Self::Input> {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0391`.
error[E0308]: mismatched types
- --> $DIR/placeholder-pattern-fail.rs:9:12
+ --> $DIR/placeholder-pattern-fail.rs:9:47
|
LL | let _: for<'a, 'b> fn(Inv<'a>, Inv<'b>) = sub;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+ | ^^^ one type is more general than the other
|
= note: expected fn pointer `for<'a, 'b> fn(Inv<'a>, Inv<'b>)`
found fn pointer `for<'a> fn(Inv<'a>, Inv<'a>)`
-error[E0308]: mismatched types
- --> $DIR/placeholder-pattern-fail.rs:9:12
- |
-LL | let _: for<'a, 'b> fn(Inv<'a>, Inv<'b>) = sub;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
- |
- = note: expected fn pointer `for<'a, 'b> fn(Inv<'a>, Inv<'b>)`
- found fn pointer `for<'a> fn(Inv<'a>, Inv<'a>)`
-
-error: lifetime may not live long enough
- --> $DIR/placeholder-pattern-fail.rs:14:13
- |
-LL | fn simple1<'c>(x: (&'c i32,)) {
- | -- lifetime `'c` defined here
-LL | let _x: (&'static i32,) = x;
- | ^^^^^^^^^^^^^^^ type annotation requires that `'c` must outlive `'static`
-
-error: lifetime may not live long enough
- --> $DIR/placeholder-pattern-fail.rs:19:12
- |
-LL | fn simple2<'c>(x: (&'c i32,)) {
- | -- lifetime `'c` defined here
-LL | let _: (&'static i32,) = x;
- | ^^^^^^^^^^^^^^^ type annotation requires that `'c` must outlive `'static`
-
-error: aborting due to 4 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.
error[E0308]: mismatched types
- --> $DIR/hrtb-exists-forall-fn.rs:17:12
+ --> $DIR/hrtb-exists-forall-fn.rs:17:34
|
LL | let _: for<'b> fn(&'b u32) = foo();
- | ^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+ | ^^^^^ one type is more general than the other
|
= note: expected fn pointer `for<'b> fn(&'b u32)`
found fn pointer `fn(&u32)`
--- /dev/null
+// check-pass
+
+macro_rules! foo { () => {
+ let x = 1;
+ macro_rules! bar { () => {x} }
+ let _ = bar!();
+}}
+
+macro_rules! m { // test issue #31856
+ ($n:ident) => (
+ let a = 1;
+ let $n = a;
+ )
+}
+
+macro_rules! baz {
+ ($i:ident) => {
+ let mut $i = 2;
+ $i = $i + 1;
+ }
+}
+
+fn main() {
+ foo! {};
+ bar! {};
+
+ let mut a = true;
+ baz!(a);
+}
--- /dev/null
+// check-pass
+#![deny(non_camel_case_types)]
+
+#[allow(dead_code)]
+fn qqq(lol: impl Iterator<Item=u32>) -> impl Iterator<Item=u64> {
+ lol.map(|x|x as u64)
+}
+
+fn main() {}
+++ /dev/null
-#![crate_type = "lib"]
-
-pub trait Foo {
- fn foo();
-}
+++ /dev/null
-// run-pass
-#![allow(unused_mut)]
-// ignore-emscripten no processes
-// ignore-sgx no processes
-
-use std::env;
-use std::io::prelude::*;
-use std::io;
-use std::process::{Command, Stdio};
-use std::str;
-
-fn main() {
- let args: Vec<String> = env::args().collect();
- if args.len() > 1 && args[1] == "child" {
- child();
- } else {
- parent();
- }
-}
-
-fn parent() {
- let args: Vec<String> = env::args().collect();
- let mut p = Command::new(&args[0]).arg("child")
- .stdout(Stdio::piped())
- .stdin(Stdio::piped())
- .spawn().unwrap();
- p.stdin.as_mut().unwrap().write_all(b"test1\ntest2\ntest3").unwrap();
- let out = p.wait_with_output().unwrap();
- assert!(out.status.success());
- let s = str::from_utf8(&out.stdout).unwrap();
- assert_eq!(s, "test1\ntest2\ntest3\n");
-}
-
-fn child() {
- let mut stdin = io::stdin();
- for line in stdin.lock().lines() {
- println!("{}", line.unwrap());
- }
-}
+++ /dev/null
-// check-pass
-pub trait Subscriber {
- type Input;
-}
-
-pub trait Processor: Subscriber<Input = <Self as Processor>::Input> {
- type Input;
-}
-
-fn main() {}
+++ /dev/null
-pub trait Subscriber {
- type Input;
-}
-
-pub trait Processor: Subscriber<Input = Self::Input> {
- //~^ ERROR cycle detected
- type Input;
-}
-
-fn main() {}
+++ /dev/null
-error[E0391]: cycle detected when computing the super traits of `Processor` with associated type name `Input`
- --> $DIR/issue-20825.rs:5:1
- |
-LL | pub trait Processor: Subscriber<Input = Self::Input> {
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = note: ...which immediately requires computing the super traits of `Processor` with associated type name `Input` again
-note: cycle used when computing the super traits of `Processor`
- --> $DIR/issue-20825.rs:5:1
- |
-LL | pub trait Processor: Subscriber<Input = Self::Input> {
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0391`.
+++ /dev/null
-// compile-flags: -Zsave-analysis
-
-fn main() {
- match 'a' {
- char{ch} => true
- //~^ ERROR expected struct, variant or union type, found builtin type `char`
- };
-}
+++ /dev/null
-error[E0574]: expected struct, variant or union type, found builtin type `char`
- --> $DIR/issue-26459.rs:5:9
- |
-LL | char{ch} => true
- | ^^^^ not a struct, variant or union type
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0574`.
+++ /dev/null
-// run-pass
-
-// This test is bogus (i.e., should be check-fail) during the period
-// where #54986 is implemented and #54987 is *not* implemented. For
-// now: just ignore it
-//
-// ignore-test
-
-// These are variants of issue-26996.rs. In all cases we are writing
-// into a record field that has been moved out of, and ensuring that
-// such a write won't overwrite the state of the thing it was moved
-// into.
-//
-// That's a fine thing to test when this code is accepted by the
-// compiler, and this code is being transcribed accordingly into
-// the ui test issue-21232-partial-init-and-use.rs
-
-fn main() {
- let mut c = (1, (1, "".to_owned()));
- match c {
- c2 => { (c.1).0 = 2; assert_eq!((c2.1).0, 1); }
- }
-
- let mut c = (1, (1, (1, "".to_owned())));
- match c.1 {
- c2 => { ((c.1).1).0 = 3; assert_eq!((c2.1).0, 1); }
- }
-}
+++ /dev/null
-// run-pass
-#![allow(unused_variables)]
-#![allow(dead_code)]
-
-macro_rules! piece(
- ($piece:pat) => ($piece);
-);
-
-enum Piece {A, B}
-
-fn main() {
- match Piece::A {
- piece!(pt@ Piece::A) | piece!(pt@ Piece::B) => {}
- }
-}
+++ /dev/null
-// check-pass
-
-macro_rules! foo { () => {
- let x = 1;
- macro_rules! bar { () => {x} }
- let _ = bar!();
-}}
-
-macro_rules! m { // test issue #31856
- ($n:ident) => (
- let a = 1;
- let $n = a;
- )
-}
-
-macro_rules! baz {
- ($i:ident) => {
- let mut $i = 2;
- $i = $i + 1;
- }
-}
-
-fn main() {
- foo! {};
- bar! {};
-
- let mut a = true;
- baz!(a);
-}
+++ /dev/null
-// run-pass
-#![allow(dead_code)]
-
-#[macro_export]
-macro_rules! state {
- ( $( $name:ident : $field:ty )* ) => (
- #[derive(Default)]
- struct State {
- $($name : $field),*
- }
- )
-}
-
-state! { x: i64 }
-
-pub fn main() {
-}
+++ /dev/null
-// aux-build:issue-36708.rs
-
-extern crate issue_36708 as lib;
-
-struct Bar;
-
-impl lib::Foo for Bar {
- fn foo<T>() {}
- //~^ ERROR E0049
-}
-
-fn main() {}
+++ /dev/null
-error[E0049]: method `foo` has 1 type parameter but its trait declaration has 0 type parameters
- --> $DIR/issue-36708.rs:8:12
- |
-LL | fn foo<T>() {}
- | ^ found 1 type parameter, expected 0
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0049`.
+++ /dev/null
-// check-pass
-
-#![allow(dead_code)]
-
-trait Structure<E>: Sized where E: Encoding {
- type RefTarget: ?Sized;
- type FfiPtr;
- unsafe fn borrow_from_ffi_ptr<'a>(ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget>;
-}
-
-enum Slice {}
-
-impl<E> Structure<E> for Slice where E: Encoding {
- type RefTarget = [E::Unit];
- type FfiPtr = (*const E::FfiUnit, usize);
- unsafe fn borrow_from_ffi_ptr<'a>(_ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget> {
- panic!()
- }
-}
-
-trait Encoding {
- type Unit: Unit;
- type FfiUnit;
-}
-
-trait Unit {}
-
-enum Utf16 {}
-
-impl Encoding for Utf16 {
- type Unit = Utf16Unit;
- type FfiUnit = u16;
-}
-
-struct Utf16Unit(pub u16);
-
-impl Unit for Utf16Unit {}
-
-type SUtf16Str = SeStr<Slice, Utf16>;
-
-struct SeStr<S, E> where S: Structure<E>, E: Encoding {
- _data: S::RefTarget,
-}
-
-impl<S, E> SeStr<S, E> where S: Structure<E>, E: Encoding {
- pub unsafe fn from_ptr<'a>(_ptr: S::FfiPtr) -> Option<&'a Self> {
- panic!()
- }
-}
-
-fn main() {
- const TEXT_U16: &'static [u16] = &[];
- let _ = unsafe { SUtf16Str::from_ptr((TEXT_U16.as_ptr(), TEXT_U16.len())).unwrap() };
-}
+++ /dev/null
-// check-pass
-
-#![allow(dead_code)]
-
-trait Structure<E>: Sized where E: Encoding {
- type RefTarget: ?Sized;
- type FfiPtr;
- unsafe fn borrow_from_ffi_ptr<'a>(ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget>;
-}
-
-enum Slice {}
-
-impl<E> Structure<E> for Slice where E: Encoding {
- type RefTarget = [E::Unit];
- type FfiPtr = (*const E::FfiUnit, usize);
- unsafe fn borrow_from_ffi_ptr<'a>(_ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget> {
- panic!()
- }
-}
-
-trait Encoding {
- type Unit: Unit;
- type FfiUnit;
-}
-
-trait Unit {}
-
-enum Utf16 {}
-
-impl Encoding for Utf16 {
- type Unit = Utf16Unit;
- type FfiUnit = u16;
-}
-
-struct Utf16Unit(pub u16);
-
-impl Unit for Utf16Unit {}
-
-struct SUtf16Str {
- _data: <Slice as Structure<Utf16>>::RefTarget,
-}
-
-impl SUtf16Str {
- pub unsafe fn from_ptr<'a>(ptr: <Slice as Structure<Utf16>>::FfiPtr)
- -> Option<&'a Self> {
- std::mem::transmute::<Option<&[<Utf16 as Encoding>::Unit]>, _>(
- <Slice as Structure<Utf16>>::borrow_from_ffi_ptr(ptr))
- }
-}
-
-fn main() {
- const TEXT_U16: &'static [u16] = &[];
- let _ = unsafe { SUtf16Str::from_ptr((TEXT_U16.as_ptr(), TEXT_U16.len())).unwrap() };
-}
+++ /dev/null
-// check-pass
-#![deny(non_camel_case_types)]
-
-#[allow(dead_code)]
-fn qqq(lol: impl Iterator<Item=u32>) -> impl Iterator<Item=u64> {
- lol.map(|x|x as u64)
-}
-
-fn main() {}
--- /dev/null
+error[E0308]: `match` arms have incompatible types
+ --> $DIR/old-lub-glb-hr-noteq1.rs:17:14
+ |
+LL | let z = match 22 {
+ | _____________-
+LL | | 0 => x,
+ | | - this is found to be of type `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+LL | | _ => y,
+ | | ^ one type is more general than the other
+LL | |
+... |
+LL | |
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+ found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+error[E0308]: `match` arms have incompatible types
+ --> $DIR/old-lub-glb-hr-noteq1.rs:17:14
+ |
+LL | let z = match 22 {
+ | _____________-
+LL | | 0 => x,
+ | | - this is found to be of type `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+LL | | _ => y,
+ | | ^ one type is more general than the other
+LL | |
+... |
+LL | |
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+ found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/old-lub-glb-hr-noteq1.rs:11:14
- |
-LL | _ => y,
- | ^ one type is more general than the other
- |
- = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
- found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+error[E0308]: `match` arms have incompatible types
+ --> $DIR/old-lub-glb-hr-noteq1.rs:17:14
+ |
+LL | let z = match 22 {
+ | _____________-
+LL | | 0 => x,
+ | | - this is found to be of type `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+LL | | _ => y,
+ | | ^ one type is more general than the other
+LL | |
+... |
+LL | |
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+ found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/old-lub-glb-hr-noteq1.rs:17:14
+ |
+LL | _ => y,
+ | ^ one type is more general than the other
+ |
+ = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+ found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
// general than the other. Test the case where the more general type (`x`) is the first
// match arm specifically.
+// revisions: baseleak basenoleak nllleak nllnoleak
+// ignore-compare-mode-nll
+//[nllleak] compile-flags: -Zborrowck=mir
+//[nllnoleak] compile-flags: -Zborrowck=mir -Zno-leak-check
+//[basenoleak] compile-flags:-Zno-leak-check
+
fn foo(x: for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8, y: for<'a> fn(&'a u8, &'a u8) -> &'a u8) {
// The two types above are not equivalent. With the older LUB/GLB
// algorithm, this may have worked (I don't remember), but now it
// doesn't because we require equality.
let z = match 22 {
0 => x,
- _ => y, //~ ERROR `match` arms have incompatible types
+ _ => y,
+ //[baseleak]~^ ERROR `match` arms have incompatible types
+ //[nllleak]~^^ ERROR `match` arms have incompatible types
+ //[basenoleak]~^^^ ERROR `match` arms have incompatible types
+ //[nllnoleak]~^^^^ ERROR mismatched types
};
}
+++ /dev/null
-error[E0308]: `match` arms have incompatible types
- --> $DIR/old-lub-glb-hr-noteq1.rs:11:14
- |
-LL | let z = match 22 {
- | _____________-
-LL | | 0 => x,
- | | - this is found to be of type `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
-LL | | _ => y,
- | | ^ one type is more general than the other
-LL | | };
- | |_____- `match` arms have incompatible types
- |
- = note: expected fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
- found fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+error[E0308]: `match` arms have incompatible types
+ --> $DIR/old-lub-glb-hr-noteq2.rs:28:14
+ |
+LL | let z = match 22 {
+ | _____________-
+LL | | 0 => y,
+ | | - this is found to be of type `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+LL | | _ => x,
+ | | ^ one type is more general than the other
+LL | |
+LL | |
+LL | |
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+ found fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+error[E0308]: `match` arms have incompatible types
+ --> $DIR/old-lub-glb-hr-noteq2.rs:28:14
+ |
+LL | let z = match 22 {
+ | _____________-
+LL | | 0 => y,
+ | | - this is found to be of type `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+LL | | _ => x,
+ | | ^ one type is more general than the other
+LL | |
+LL | |
+LL | |
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+ found fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+error[E0308]: `match` arms have incompatible types
+ --> $DIR/old-lub-glb-hr-noteq2.rs:28:14
+ |
+LL | let z = match 22 {
+ | _____________-
+LL | | 0 => y,
+ | | - this is found to be of type `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+LL | | _ => x,
+ | | ^ one type is more general than the other
+LL | |
+LL | |
+LL | |
+LL | | };
+ | |_____- `match` arms have incompatible types
+ |
+ = note: expected fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
+ found fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
// one is more general than the other. Test the case where the more general type
// (`x`) is the second match arm specifically.
//
-// FIXME(#73154) Skip for compare-mode because the pure NLL checker accepts this
-// test. (Note that it still errors in old-lub-glb-hr-noteq1.rs). What happens
+// FIXME(#73154) Pure NLL checker without leak check accepts this test.
+// (Note that it still errors in old-lub-glb-hr-noteq1.rs). What happens
// is that, due to the ordering of the match arms, we pick the correct "more
// general" fn type, and we ignore the errors from the non-NLL type checker that
// requires equality. The NLL type checker only requires a subtyping
-// relationship, and that holds.
-//
+// relationship, and that holds. To unblock landing NLL - and ensure that we can
+// choose to make this always in error in the future - we perform the leak check
+// after coercing a function pointer.
+
+// revisions: baseleak basenoleak nllleak nllnoleak
// ignore-compare-mode-nll
-// ignore-compare-mode-polonius
+//[nllleak] compile-flags: -Zborrowck=mir
+//[nllnoleak] compile-flags: -Zborrowck=mir -Zno-leak-check
+//[basenoleak] compile-flags:-Zno-leak-check
+
+//[nllnoleak] check-pass
fn foo(x: for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8, y: for<'a> fn(&'a u8, &'a u8) -> &'a u8) {
// The two types above are not equivalent. With the older LUB/GLB
// doesn't because we require equality.
let z = match 22 {
0 => y,
- _ => x, //~ ERROR `match` arms have incompatible types
+ _ => x,
+ //[baseleak]~^ ERROR `match` arms have incompatible types
+ //[nllleak]~^^ ERROR `match` arms have incompatible types
+ //[basenoleak]~^^^ ERROR `match` arms have incompatible types
};
}
+++ /dev/null
-error[E0308]: `match` arms have incompatible types
- --> $DIR/old-lub-glb-hr-noteq2.rs:21:14
- |
-LL | let z = match 22 {
- | _____________-
-LL | | 0 => y,
- | | - this is found to be of type `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
-LL | | _ => x,
- | | ^ one type is more general than the other
-LL | | };
- | |_____- `match` arms have incompatible types
- |
- = note: expected fn pointer `for<'a> fn(&'a u8, &'a u8) -> &'a u8`
- found fn pointer `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// run-pass
+#![allow(dead_code)]
+
+#[macro_export]
+macro_rules! state {
+ ( $( $name:ident : $field:ty )* ) => (
+ #[derive(Default)]
+ struct State {
+ $($name : $field),*
+ }
+ )
+}
+
+state! { x: i64 }
+
+pub fn main() {
+}
--- /dev/null
+// run-pass
+
+// This test is bogus (i.e., should be check-fail) during the period
+// where #54986 is implemented and #54987 is *not* implemented. For
+// now: just ignore it
+//
+// ignore-test
+
+// These are variants of issue-26996.rs. In all cases we are writing
+// into a record field that has been moved out of, and ensuring that
+// such a write won't overwrite the state of the thing it was moved
+// into.
+//
+// That's a fine thing to test when this code is accepted by the
+// compiler, and this code is being transcribed accordingly into
+// the ui test issue-21232-partial-init-and-use.rs
+
+fn main() {
+ let mut c = (1, (1, "".to_owned()));
+ match c {
+ c2 => { (c.1).0 = 2; assert_eq!((c2.1).0, 1); }
+ }
+
+ let mut c = (1, (1, (1, "".to_owned())));
+ match c.1 {
+ c2 => { ((c.1).1).0 = 3; assert_eq!((c2.1).0, 1); }
+ }
+}
--- /dev/null
+// run-pass
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+macro_rules! piece(
+ ($piece:pat) => ($piece);
+);
+
+enum Piece {A, B}
+
+fn main() {
+ match Piece::A {
+ piece!(pt@ Piece::A) | piece!(pt@ Piece::B) => {}
+ }
+}
--- /dev/null
+// run-pass
+#![allow(unused_mut)]
+// ignore-emscripten no processes
+// ignore-sgx no processes
+
+use std::env;
+use std::io::prelude::*;
+use std::io;
+use std::process::{Command, Stdio};
+use std::str;
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() > 1 && args[1] == "child" {
+ child();
+ } else {
+ parent();
+ }
+}
+
+fn parent() {
+ let args: Vec<String> = env::args().collect();
+ let mut p = Command::new(&args[0]).arg("child")
+ .stdout(Stdio::piped())
+ .stdin(Stdio::piped())
+ .spawn().unwrap();
+ p.stdin.as_mut().unwrap().write_all(b"test1\ntest2\ntest3").unwrap();
+ let out = p.wait_with_output().unwrap();
+ assert!(out.status.success());
+ let s = str::from_utf8(&out.stdout).unwrap();
+ assert_eq!(s, "test1\ntest2\ntest3\n");
+}
+
+fn child() {
+ let mut stdin = io::stdin();
+ for line in stdin.lock().lines() {
+ println!("{}", line.unwrap());
+ }
+}
| ^^ ...but data from `y` flows into `x` here
error[E0623]: lifetime mismatch
- --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:20:7
+ --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:19:7
|
LL | fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
| --------- --------- these two types are declared with different lifetimes...
| ^ ...but data from `y` flows into `x` here
error[E0308]: mismatched types
- --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:28:43
+ --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:26:43
|
LL | let _: fn(&mut &isize, &mut &isize) = a;
| ^ one type is more general than the other
|
= note: expected fn pointer `for<'r, 's, 't0, 't1> fn(&'r mut &'s isize, &'t0 mut &'t1 isize)`
- found fn pointer `for<'r, 's> fn(&'r mut &isize, &'s mut &isize)`
+ found fn item `for<'r, 's> fn(&'r mut &isize, &'s mut &isize) {a::<'_, '_>}`
error: aborting due to 3 previous errors
-error: lifetime may not live long enough
- --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:12:5
- |
-LL | fn b<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) {
- | -- -- lifetime `'b` defined here
- | |
- | lifetime `'a` defined here
-LL | // Illegal now because there is no `'b:'a` declaration.
-LL | *x = *y;
- | ^^^^^^^ assignment requires that `'b` must outlive `'a`
- |
- = help: consider adding the following bound: `'b: 'a`
-
-error: lifetime may not live long enough
- --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:20:5
- |
-LL | fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
- | -- -- lifetime `'b` defined here
- | |
- | lifetime `'a` defined here
-...
-LL | a(x, y);
- | ^^^^^^^ argument requires that `'b` must outlive `'a`
- |
- = help: consider adding the following bound: `'b: 'a`
- = note: requirement occurs because of a mutable reference to `&isize`
- = note: mutable references are invariant over their type parameter
- = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
-
-error[E0308]: mismatched types
- --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:28:12
- |
-LL | let _: fn(&mut &isize, &mut &isize) = a;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
- |
- = note: expected fn pointer `for<'r, 's, 't0, 't1> fn(&'r mut &'s isize, &'t0 mut &'t1 isize)`
- found fn pointer `for<'r, 's> fn(&'r mut &isize, &'s mut &isize)`
-
error[E0308]: mismatched types
- --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:28:12
+ --> $DIR/region-lifetime-bounds-on-fns-where-clause.rs:26:43
|
LL | let _: fn(&mut &isize, &mut &isize) = a;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+ | ^ one type is more general than the other
|
= note: expected fn pointer `for<'r, 's, 't0, 't1> fn(&'r mut &'s isize, &'t0 mut &'t1 isize)`
- found fn pointer `for<'r, 's> fn(&'r mut &isize, &'s mut &isize)`
+ found fn item `for<'r, 's> fn(&'r mut &isize, &'s mut &isize) {a::<'_, '_>}`
-error: aborting due to 4 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.
// Illegal now because there is no `'b:'a` declaration.
*x = *y;
//[base]~^ ERROR E0623
- //[nll]~^^ ERROR lifetime may not live long enough
}
fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
// related as required.
a(x, y);
//[base]~^ ERROR lifetime mismatch [E0623]
- //[nll]~^^ ERROR lifetime may not live long enough
}
fn d() {
// inconstraints:
let _: fn(&mut &isize, &mut &isize) = a;
//~^ ERROR mismatched types [E0308]
- //[nll]~^^ ERROR mismatched types [E0308]
}
fn e() {
| ^^ ...but data from `y` flows into `x` here
error[E0623]: lifetime mismatch
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:16:10
+ --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:15:10
|
LL | fn b<'a, 'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) {
| --------- ---------
| ^^ ...but data from `y` flows into `z` here
error[E0623]: lifetime mismatch
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:22:7
+ --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:21:7
|
LL | fn c<'a,'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) {
| --------- --------- these two types are declared with different lifetimes...
| ^ ...but data from `y` flows into `x` here
error[E0308]: mismatched types
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:30:56
+ --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:28:56
|
LL | let _: fn(&mut &isize, &mut &isize, &mut &isize) = a;
| ^ one type is more general than the other
|
= note: expected fn pointer `for<'r, 's, 't0, 't1, 't2, 't3> fn(&'r mut &'s isize, &'t0 mut &'t1 isize, &'t2 mut &'t3 isize)`
- found fn pointer `for<'r, 's, 't0> fn(&'r mut &isize, &'s mut &isize, &'t0 mut &isize)`
+ found fn item `for<'r, 's, 't0> fn(&'r mut &isize, &'s mut &isize, &'t0 mut &isize) {a::<'_, '_, '_>}`
error: aborting due to 4 previous errors
-error: lifetime may not live long enough
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:13:5
- |
-LL | fn b<'a, 'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) {
- | -- -- lifetime `'b` defined here
- | |
- | lifetime `'a` defined here
-LL | // Illegal now because there is no `'b:'a` declaration.
-LL | *x = *y;
- | ^^^^^^^ assignment requires that `'b` must outlive `'a`
- |
- = help: consider adding the following bound: `'b: 'a`
-
-error: lifetime may not live long enough
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:22:5
- |
-LL | fn c<'a,'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) {
- | -- -- lifetime `'b` defined here
- | |
- | lifetime `'a` defined here
-...
-LL | a(x, y, z);
- | ^^^^^^^^^^ argument requires that `'b` must outlive `'a`
- |
- = help: consider adding the following bound: `'b: 'a`
- = note: requirement occurs because of a mutable reference to `&isize`
- = note: mutable references are invariant over their type parameter
- = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
-
-error[E0308]: mismatched types
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:30:12
- |
-LL | let _: fn(&mut &isize, &mut &isize, &mut &isize) = a;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
- |
- = note: expected fn pointer `for<'r, 's, 't0, 't1, 't2, 't3> fn(&'r mut &'s isize, &'t0 mut &'t1 isize, &'t2 mut &'t3 isize)`
- found fn pointer `for<'r, 's, 't0> fn(&'r mut &isize, &'s mut &isize, &'t0 mut &isize)`
-
-error[E0308]: mismatched types
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:30:12
- |
-LL | let _: fn(&mut &isize, &mut &isize, &mut &isize) = a;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
- |
- = note: expected fn pointer `for<'r, 's, 't0, 't1, 't2, 't3> fn(&'r mut &'s isize, &'t0 mut &'t1 isize, &'t2 mut &'t3 isize)`
- found fn pointer `for<'r, 's, 't0> fn(&'r mut &isize, &'s mut &isize, &'t0 mut &isize)`
-
error[E0308]: mismatched types
- --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:30:12
+ --> $DIR/region-multiple-lifetime-bounds-on-fns-where-clause.rs:28:56
|
LL | let _: fn(&mut &isize, &mut &isize, &mut &isize) = a;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+ | ^ one type is more general than the other
|
= note: expected fn pointer `for<'r, 's, 't0, 't1, 't2, 't3> fn(&'r mut &'s isize, &'t0 mut &'t1 isize, &'t2 mut &'t3 isize)`
- found fn pointer `for<'r, 's, 't0> fn(&'r mut &isize, &'s mut &isize, &'t0 mut &isize)`
+ found fn item `for<'r, 's, 't0> fn(&'r mut &isize, &'s mut &isize, &'t0 mut &isize) {a::<'_, '_, '_>}`
-error: aborting due to 5 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.
// Illegal now because there is no `'b:'a` declaration.
*x = *y;
//[base]~^ ERROR E0623
- //[nll]~^^ ERROR lifetime may not live long enough
*z = *y; //[base]~ ERROR E0623
}
// related as required.
a(x, y, z);
//[base]~^ ERROR lifetime mismatch [E0623]
- //[nll]~^^ ERROR lifetime may not live long enough
}
fn d() {
// inconstraints:
let _: fn(&mut &isize, &mut &isize, &mut &isize) = a;
//~^ ERROR E0308
- //[nll]~^^ ERROR mismatched types [E0308]
- //[nll]~| ERROR mismatched types [E0308]
}
fn e() {
--> $DIR/regions-fn-subtyping-return-static-fail.rs:52:12
|
LL | want_G(baz);
- | ^^^ one type is more general than the other
+ | ------ ^^^ one type is more general than the other
+ | |
+ | arguments to this function are incorrect
|
= note: expected fn pointer `for<'cx> fn(&'cx S) -> &'static S`
- found fn pointer `for<'r> fn(&'r S) -> &'r S`
+ found fn item `for<'r> fn(&'r S) -> &'r S {baz}`
+note: function defined here
+ --> $DIR/regions-fn-subtyping-return-static-fail.rs:24:4
+ |
+LL | fn want_G(f: G) {}
+ | ^^^^^^ ----
error: aborting due to previous error
error[E0308]: mismatched types
- --> $DIR/regions-fn-subtyping-return-static-fail.rs:52:5
+ --> $DIR/regions-fn-subtyping-return-static-fail.rs:52:12
|
LL | want_G(baz);
- | ^^^^^^^^^^^ one type is more general than the other
+ | ------ ^^^ one type is more general than the other
+ | |
+ | arguments to this function are incorrect
|
= note: expected fn pointer `for<'cx> fn(&'cx S) -> &'static S`
- found fn pointer `for<'r> fn(&'r S) -> &'r S`
+ found fn item `for<'r> fn(&'r S) -> &'r S {baz}`
+note: function defined here
+ --> $DIR/regions-fn-subtyping-return-static-fail.rs:24:4
+ |
+LL | fn want_G(f: G) {}
+ | ^^^^^^ ----
error: aborting due to previous error
| ^^ ...but data from `y` flows into `x` here
error[E0623]: lifetime mismatch
- --> $DIR/regions-lifetime-bounds-on-fns.rs:20:7
+ --> $DIR/regions-lifetime-bounds-on-fns.rs:19:7
|
LL | fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
| --------- --------- these two types are declared with different lifetimes...
| ^ ...but data from `y` flows into `x` here
error[E0308]: mismatched types
- --> $DIR/regions-lifetime-bounds-on-fns.rs:28:43
+ --> $DIR/regions-lifetime-bounds-on-fns.rs:26:43
|
LL | let _: fn(&mut &isize, &mut &isize) = a;
| ^ one type is more general than the other
|
= note: expected fn pointer `for<'r, 's, 't0, 't1> fn(&'r mut &'s isize, &'t0 mut &'t1 isize)`
- found fn pointer `for<'r, 's> fn(&'r mut &isize, &'s mut &isize)`
+ found fn item `for<'r, 's> fn(&'r mut &isize, &'s mut &isize) {a::<'_, '_>}`
error: aborting due to 3 previous errors
-error: lifetime may not live long enough
- --> $DIR/regions-lifetime-bounds-on-fns.rs:12:5
- |
-LL | fn b<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) {
- | -- -- lifetime `'b` defined here
- | |
- | lifetime `'a` defined here
-LL | // Illegal now because there is no `'b:'a` declaration.
-LL | *x = *y;
- | ^^^^^^^ assignment requires that `'b` must outlive `'a`
- |
- = help: consider adding the following bound: `'b: 'a`
-
-error: lifetime may not live long enough
- --> $DIR/regions-lifetime-bounds-on-fns.rs:20:5
- |
-LL | fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
- | -- -- lifetime `'b` defined here
- | |
- | lifetime `'a` defined here
-...
-LL | a(x, y);
- | ^^^^^^^ argument requires that `'b` must outlive `'a`
- |
- = help: consider adding the following bound: `'b: 'a`
- = note: requirement occurs because of a mutable reference to `&isize`
- = note: mutable references are invariant over their type parameter
- = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
-
-error[E0308]: mismatched types
- --> $DIR/regions-lifetime-bounds-on-fns.rs:28:12
- |
-LL | let _: fn(&mut &isize, &mut &isize) = a;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
- |
- = note: expected fn pointer `for<'r, 's, 't0, 't1> fn(&'r mut &'s isize, &'t0 mut &'t1 isize)`
- found fn pointer `for<'r, 's> fn(&'r mut &isize, &'s mut &isize)`
-
error[E0308]: mismatched types
- --> $DIR/regions-lifetime-bounds-on-fns.rs:28:12
+ --> $DIR/regions-lifetime-bounds-on-fns.rs:26:43
|
LL | let _: fn(&mut &isize, &mut &isize) = a;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+ | ^ one type is more general than the other
|
= note: expected fn pointer `for<'r, 's, 't0, 't1> fn(&'r mut &'s isize, &'t0 mut &'t1 isize)`
- found fn pointer `for<'r, 's> fn(&'r mut &isize, &'s mut &isize)`
+ found fn item `for<'r, 's> fn(&'r mut &isize, &'s mut &isize) {a::<'_, '_>}`
-error: aborting due to 4 previous errors
+error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.
// Illegal now because there is no `'b:'a` declaration.
*x = *y;
//[base]~^ ERROR lifetime mismatch [E0623]
- //[nll]~^^ ERROR lifetime may not live long enough
}
fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
// related as required.
a(x, y);
//[base]~^ ERROR lifetime mismatch [E0623]
- //[nll]~^^ ERROR lifetime may not live long enough
}
fn d() {
// inconstraints:
let _: fn(&mut &isize, &mut &isize) = a;
//~^ ERROR mismatched types [E0308]
- //[nll]~^^ ERROR mismatched types [E0308]
}
fn e() {
--- /dev/null
+// compile-flags: -Zsave-analysis
+
+fn main() {
+ match 'a' {
+ char{ch} => true
+ //~^ ERROR expected struct, variant or union type, found builtin type `char`
+ };
+}
--- /dev/null
+error[E0574]: expected struct, variant or union type, found builtin type `char`
+ --> $DIR/issue-26459.rs:5:9
+ |
+LL | char{ch} => true
+ | ^^^^ not a struct, variant or union type
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0574`.
--- /dev/null
+#![crate_type = "lib"]
+
+pub trait Foo {
+ fn foo();
+}
--- /dev/null
+// aux-build:issue-36708.rs
+
+extern crate issue_36708 as lib;
+
+struct Bar;
+
+impl lib::Foo for Bar {
+ fn foo<T>() {}
+ //~^ ERROR E0049
+}
+
+fn main() {}
--- /dev/null
+error[E0049]: method `foo` has 1 type parameter but its trait declaration has 0 type parameters
+ --> $DIR/issue-36708.rs:8:12
+ |
+LL | fn foo<T>() {}
+ | ^ found 1 type parameter, expected 0
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0049`.
--- /dev/null
+// check-pass
+
+#![allow(dead_code)]
+
+trait Structure<E>: Sized where E: Encoding {
+ type RefTarget: ?Sized;
+ type FfiPtr;
+ unsafe fn borrow_from_ffi_ptr<'a>(ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget>;
+}
+
+enum Slice {}
+
+impl<E> Structure<E> for Slice where E: Encoding {
+ type RefTarget = [E::Unit];
+ type FfiPtr = (*const E::FfiUnit, usize);
+ unsafe fn borrow_from_ffi_ptr<'a>(_ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget> {
+ panic!()
+ }
+}
+
+trait Encoding {
+ type Unit: Unit;
+ type FfiUnit;
+}
+
+trait Unit {}
+
+enum Utf16 {}
+
+impl Encoding for Utf16 {
+ type Unit = Utf16Unit;
+ type FfiUnit = u16;
+}
+
+struct Utf16Unit(pub u16);
+
+impl Unit for Utf16Unit {}
+
+type SUtf16Str = SeStr<Slice, Utf16>;
+
+struct SeStr<S, E> where S: Structure<E>, E: Encoding {
+ _data: S::RefTarget,
+}
+
+impl<S, E> SeStr<S, E> where S: Structure<E>, E: Encoding {
+ pub unsafe fn from_ptr<'a>(_ptr: S::FfiPtr) -> Option<&'a Self> {
+ panic!()
+ }
+}
+
+fn main() {
+ const TEXT_U16: &'static [u16] = &[];
+ let _ = unsafe { SUtf16Str::from_ptr((TEXT_U16.as_ptr(), TEXT_U16.len())).unwrap() };
+}
--- /dev/null
+// check-pass
+
+#![allow(dead_code)]
+
+trait Structure<E>: Sized where E: Encoding {
+ type RefTarget: ?Sized;
+ type FfiPtr;
+ unsafe fn borrow_from_ffi_ptr<'a>(ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget>;
+}
+
+enum Slice {}
+
+impl<E> Structure<E> for Slice where E: Encoding {
+ type RefTarget = [E::Unit];
+ type FfiPtr = (*const E::FfiUnit, usize);
+ unsafe fn borrow_from_ffi_ptr<'a>(_ptr: Self::FfiPtr) -> Option<&'a Self::RefTarget> {
+ panic!()
+ }
+}
+
+trait Encoding {
+ type Unit: Unit;
+ type FfiUnit;
+}
+
+trait Unit {}
+
+enum Utf16 {}
+
+impl Encoding for Utf16 {
+ type Unit = Utf16Unit;
+ type FfiUnit = u16;
+}
+
+struct Utf16Unit(pub u16);
+
+impl Unit for Utf16Unit {}
+
+struct SUtf16Str {
+ _data: <Slice as Structure<Utf16>>::RefTarget,
+}
+
+impl SUtf16Str {
+ pub unsafe fn from_ptr<'a>(ptr: <Slice as Structure<Utf16>>::FfiPtr)
+ -> Option<&'a Self> {
+ std::mem::transmute::<Option<&[<Utf16 as Encoding>::Unit]>, _>(
+ <Slice as Structure<Utf16>>::borrow_from_ffi_ptr(ptr))
+ }
+}
+
+fn main() {
+ const TEXT_U16: &'static [u16] = &[];
+ let _ = unsafe { SUtf16Str::from_ptr((TEXT_U16.as_ptr(), TEXT_U16.len())).unwrap() };
+}
const ENTRY_LIMIT: usize = 1000;
// FIXME: The following limits should be reduced eventually.
-const ROOT_ENTRY_LIMIT: usize = 974;
-const ISSUES_ENTRY_LIMIT: usize = 2248;
+const ROOT_ENTRY_LIMIT: usize = 971;
+const ISSUES_ENTRY_LIMIT: usize = 2234;
fn check_entries(path: &Path, bad: &mut bool) {
let dirs = walkdir::WalkDir::new(&path.join("test/ui"))
projects / rust.git / commitdiff