/// Contains the "representative" region of each SCC.

/// It is defined as the one with the minimal RegionVid, favoring

/// free regions, then placeholders, then existential regions.

///

/// It is a hacky way to manage checking regions for equality,

/// For each SCC, we compute a unique `RegionVid`. See the

let mut scc_representatives = IndexVec::from_elem_n(RegionVid::MAX, num_sccs);

// Iterate over all RegionVids *in-order* and pick the least RegionVid as the

// representative of its SCC. This naturally prefers free regions over others.

for (vid, def) in definitions.iter_enumerated() {

let repr = &mut scc_representatives[constraints_scc.scc(vid)];

if *repr == ty::RegionVid::MAX {

*repr = vid;

} else if matches!(def.origin, NllRegionVariableOrigin::Placeholder(_))

&& matches!(definitions[*repr].origin, NllRegionVariableOrigin::Existential { .. })

{

// Pick placeholders over existentials even if they have a greater RegionVid.

*repr = vid;

}

/// Returns `true` if fr1 is known to equal fr2.

///

/// This will only ever be true for universally quantified regions.

pub(crate) fn equal(&self, fr1: RegionVid, fr2: RegionVid) -> bool {

self.outlives.contains(fr1, fr2) && self.outlives.contains(fr2, fr1)

}

// Convert all regions to nll vars.

let (opaque_type_key, hidden_type) =

infcx.tcx.fold_regions((opaque_type_key, hidden_type), |region, _| {

match region.kind() {

ty::ReVar(_) => region,

ty::RePlaceholder(placeholder) => checker

.borrowck_context

.constraints

.placeholder_region(infcx, placeholder),

_ => ty::Region::new_var(

infcx.tcx,

checker.borrowck_context.universal_regions.to_region_vid(region),

),

}

});

impl<'tcx> OpaqueTypeKey<'tcx> {

pub fn iter_captured_args(

self,

tcx: TyCtxt<'tcx>,

) -> impl Iterator<Item = (usize, GenericArg<'tcx>)> {

std::iter::zip(self.args, tcx.variances_of(self.def_id)).enumerate().filter_map(

|(i, (arg, v))| match (arg.unpack(), v) {

(_, ty::Invariant) => Some((i, arg)),

(ty::GenericArgKind::Lifetime(_), ty::Bivariant) => None,

_ => bug!("unexpected opaque type arg variance"),

},

)

}

pub fn fold_captured_lifetime_args(

self,

tcx: TyCtxt<'tcx>,

mut f: impl FnMut(Region<'tcx>) -> Region<'tcx>,

) -> Self {

let Self { def_id, args } = self;

let args = std::iter::zip(args, tcx.variances_of(def_id)).map(|(arg, v)| {

match (arg.unpack(), v) {

(ty::GenericArgKind::Lifetime(_), ty::Bivariant) => arg,

(ty::GenericArgKind::Lifetime(lt), _) => f(lt).into(),

_ => arg,

}

});

let args = tcx.mk_args_from_iter(args);

Self { def_id, args }

}

error[E0792]: expected generic lifetime parameter, found `'_`

--> $DIR/defining-use-captured-non-universal-region.rs:13:18

|

LL | fn foo<'a>() -> impl Sized + 'a {

| -- this generic parameter must be used with a generic lifetime parameter

...

LL | let i: i32 = foo::<'_>();

| ^^^^^^^^^^^

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0792`.

fn foo<'a>() -> impl Sized + 'a {

#[cfg(statik)]

let i: i32 = foo::<'static>();

//[statik]~^ ERROR expected generic lifetime parameter, found `'static`

#[cfg(infer)]

let i: i32 = foo::<'_>();

//[infer]~^ ERROR expected generic lifetime parameter, found `'_`

#[cfg(fixed)]

let i: i32 = foo::<'a>();

i

fn main() {}

error[E0792]: expected generic lifetime parameter, found `'static`

--> $DIR/defining-use-captured-non-universal-region.rs:9:18

|

LL | fn foo<'a>() -> impl Sized + 'a {

| -- cannot use static lifetime; use a bound lifetime instead or remove the lifetime parameter from the opaque type

LL | #[cfg(statik)]

LL | let i: i32 = foo::<'static>();

| ^^^^^^^^^^^^^^^^

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0792`.

use std::{collections::BTreeMap, num::ParseIntError, str::FromStr};

enum FileSystem {

File(usize),

Directory(BTreeMap<String, FileSystem>),

impl FromStr for FileSystem {

type Err = ParseIntError;

fn from_str(s: &str) -> Result<Self, Self::Err> {

if s.starts_with("dir") {

Ok(Self::new_dir())

} else {

Ok(Self::File(s.split_whitespace().next().unwrap().parse()?))

}

}

impl FileSystem {

fn new_dir() -> FileSystem {

FileSystem::Directory(BTreeMap::new())

}

fn insert(&mut self, name: String, other: FileSystem) -> Option<FileSystem> {

match self {

FileSystem::File(_) => panic!("can only insert into directory!"),

FileSystem::Directory(tree) => tree.insert(name, other),

}

}

// Recursively build a tree from commands. This uses (abuses?)

// the fact that `cd /` only appears at the start and that

// subsequent `cd`s can only move ONE level to use the recursion

// stack as the filesystem stack

fn build<'a>(

&mut self,

mut commands: impl Iterator<Item = &'a str> + 'a,

) -> Option<impl Iterator<Item = &'a str> + 'a> {

let cmd = commands.next()?;

let mut elements = cmd.lines();

match elements.next().map(str::trim) {

Some("cd /") | None => self.build(commands),

Some("cd ..") => {

// return to higher scope

Some(commands)

}

Some("ls") => {

for item in elements {

let name = item.split_whitespace().last().unwrap();

let prior = self.insert(name.to_string(), item.parse().unwrap());

debug_assert!(prior.is_none());

}

// continue on

self.build(commands)

}

Some(other_cd) => {

let name = other_cd

.trim()

.strip_prefix("cd ")

.expect("expected a cd command");

let mut directory = FileSystem::new_dir();

let further_commands = directory.build(commands);

self.insert(name.to_string(), directory);

self.build(further_commands?) // THIS LINE FAILS TO COMPILE

}

}

}

fn main() {}

trait Bar<const FOO: &'static str> {}

impl Bar<"asdf"> for () {}

fn foo<const FOO: &'static str>() -> impl Bar<"asdf"> {

()

fn main() {}

fn foo<'a: 'a>() -> impl Sized {

let _: () = foo::<'a>();

loop {}

fn bar<'a: 'a>() -> impl Sized + 'a {

let _: *mut &'a () = bar::<'a>();

loop {}

fn main() {}

error: {foo<'{erased}>::{closure#0} closure_kind_ty=i8 closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=()}

error: {foo<'{erased}>::{closure#0} closure_kind_ty=i8 closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=()}

//~^ ERROR '{erased}>::{closure#0} closure_kind_ty=i8 closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=()}

//~^ ERROR expected generic lifetime parameter, found `'_`

error[E0792]: expected generic lifetime parameter, found `'_`

--> $DIR/impl-fn-predefined-lifetimes.rs:5:9

| -- this generic parameter must be used with a generic lifetime parameter

LL | |x| x

| ^

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0792`.

//~| ERROR expected generic lifetime parameter, found `'static`

error[E0792]: expected generic lifetime parameter, found `'static`

--> $DIR/bad-item-bound-within-rpitit-2.rs:5:45

|

LL | fn bar<'other: 'a>() -> impl Sized + 'a {}

| ------ ^^

| |

| cannot use static lifetime; use a bound lifetime instead or remove the lifetime parameter from the opaque type

error: aborting due to 3 previous errors

Some errors have detailed explanations: E0261, E0792.

For more information about an error, try `rustc --explain E0261`.

//~^ ERROR expected generic lifetime parameter, found `'_`