rustc: pass Option<&Substs> and Namespace around in ty::item_path.
This commit is contained in:
parent
ed2be6fa89
commit
3e1cef7007
26 changed files with 159 additions and 94 deletions
|
@ -1,8 +1,10 @@
|
|||
use crate::hir::def::Namespace;
|
||||
use crate::hir::map::DefPathData;
|
||||
use crate::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
|
||||
use crate::ty::{self, DefIdTree, Ty, TyCtxt};
|
||||
use crate::ty::print::PrintCx;
|
||||
use crate::ty::subst::{Subst, Substs};
|
||||
use crate::middle::cstore::{ExternCrate, ExternCrateSource};
|
||||
use ty::print::PrintCx;
|
||||
use syntax::ast;
|
||||
use syntax::symbol::{keywords, Symbol};
|
||||
|
||||
|
@ -54,18 +56,48 @@ pub fn with_crate_prefix<F: FnOnce() -> R, R>(f: F) -> R {
|
|||
}
|
||||
|
||||
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
||||
// HACK(eddyb) get rid of `item_path_str` and/or pass `Namespace` explicitly always
|
||||
// (but also some things just print a `DefId` generally so maybe we need this?)
|
||||
fn guess_def_namespace(self, def_id: DefId) -> Namespace {
|
||||
match self.def_key(def_id).disambiguated_data.data {
|
||||
DefPathData::ValueNs(..) |
|
||||
DefPathData::EnumVariant(..) |
|
||||
DefPathData::Field(..) |
|
||||
DefPathData::AnonConst |
|
||||
DefPathData::ClosureExpr |
|
||||
DefPathData::StructCtor => Namespace::ValueNS,
|
||||
|
||||
DefPathData::MacroDef(..) => Namespace::MacroNS,
|
||||
|
||||
_ => Namespace::TypeNS,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a string identifying this `DefId`. This string is
|
||||
/// suitable for user output. It is relative to the current crate
|
||||
/// root, unless with_forced_absolute_paths was used.
|
||||
pub fn item_path_str(self, def_id: DefId) -> String {
|
||||
debug!("item_path_str: def_id={:?}", def_id);
|
||||
pub fn item_path_str_with_substs_and_ns(
|
||||
self,
|
||||
def_id: DefId,
|
||||
substs: Option<&Substs<'tcx>>,
|
||||
ns: Namespace,
|
||||
) -> String {
|
||||
debug!("item_path_str: def_id={:?}, substs={:?}, ns={:?}", def_id, substs, ns);
|
||||
if FORCE_ABSOLUTE.with(|force| force.get()) {
|
||||
PrintCx::new(self, AbsolutePathPrinter).print_item_path(def_id)
|
||||
PrintCx::new(self, AbsolutePathPrinter).print_item_path(def_id, substs, ns)
|
||||
} else {
|
||||
PrintCx::new(self, LocalPathPrinter).print_item_path(def_id)
|
||||
PrintCx::new(self, LocalPathPrinter).print_item_path(def_id, substs, ns)
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a string identifying this def-id. This string is
|
||||
/// suitable for user output. It is relative to the current crate
|
||||
/// root, unless with_forced_absolute_paths was used.
|
||||
pub fn item_path_str(self, def_id: DefId) -> String {
|
||||
let ns = self.guess_def_namespace(def_id);
|
||||
self.item_path_str_with_substs_and_ns(def_id, None, ns)
|
||||
}
|
||||
|
||||
/// Returns a string identifying this local node-id.
|
||||
pub fn node_path_str(self, id: ast::NodeId) -> String {
|
||||
self.item_path_str(self.hir().local_def_id(id))
|
||||
|
@ -75,13 +107,19 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
|||
/// suitable for user output. It always begins with a crate identifier.
|
||||
pub fn absolute_item_path_str(self, def_id: DefId) -> String {
|
||||
debug!("absolute_item_path_str: def_id={:?}", def_id);
|
||||
PrintCx::new(self, AbsolutePathPrinter).print_item_path(def_id)
|
||||
let ns = self.guess_def_namespace(def_id);
|
||||
PrintCx::new(self, AbsolutePathPrinter).print_item_path(def_id, None, ns)
|
||||
}
|
||||
}
|
||||
|
||||
impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
|
||||
pub fn default_print_item_path(&mut self, def_id: DefId) -> P::Path {
|
||||
debug!("default_print_item_path: def_id={:?}", def_id);
|
||||
pub fn default_print_item_path(
|
||||
&mut self,
|
||||
def_id: DefId,
|
||||
substs: Option<&Substs<'tcx>>,
|
||||
ns: Namespace,
|
||||
) -> P::Path {
|
||||
debug!("default_print_item_path: def_id={:?}, substs={:?}, ns={:?}", def_id, substs, ns);
|
||||
let key = self.tcx.def_key(def_id);
|
||||
debug!("default_print_item_path: key={:?}", key);
|
||||
match key.disambiguated_data.data {
|
||||
|
@ -91,7 +129,7 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
|
|||
}
|
||||
|
||||
DefPathData::Impl => {
|
||||
self.print_impl_path(def_id)
|
||||
self.print_impl_path(def_id, substs, ns)
|
||||
}
|
||||
|
||||
// Unclear if there is any value in distinguishing these.
|
||||
|
@ -117,18 +155,23 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
|
|||
data @ DefPathData::ImplTrait |
|
||||
data @ DefPathData::GlobalMetaData(..) => {
|
||||
let parent_did = self.tcx.parent_def_id(def_id).unwrap();
|
||||
let path = self.print_item_path(parent_did);
|
||||
let path = self.print_item_path(parent_did, None, ns);
|
||||
self.path_append(path, &data.as_interned_str().as_symbol().as_str())
|
||||
},
|
||||
|
||||
DefPathData::StructCtor => { // present `X` instead of `X::{{constructor}}`
|
||||
let parent_def_id = self.tcx.parent_def_id(def_id).unwrap();
|
||||
self.print_item_path(parent_def_id)
|
||||
self.print_item_path(parent_def_id, substs, ns)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn default_print_impl_path(&mut self, impl_def_id: DefId) -> P::Path {
|
||||
fn default_print_impl_path(
|
||||
&mut self,
|
||||
impl_def_id: DefId,
|
||||
substs: Option<&Substs<'tcx>>,
|
||||
ns: Namespace,
|
||||
) -> P::Path {
|
||||
debug!("default_print_impl_path: impl_def_id={:?}", impl_def_id);
|
||||
let parent_def_id = self.tcx.parent_def_id(impl_def_id).unwrap();
|
||||
|
||||
|
@ -137,13 +180,19 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
|
|||
// users may find it useful. Currently, we omit the parent if
|
||||
// the impl is either in the same module as the self-type or
|
||||
// as the trait.
|
||||
let self_ty = self.tcx.type_of(impl_def_id);
|
||||
let mut self_ty = self.tcx.type_of(impl_def_id);
|
||||
if let Some(substs) = substs {
|
||||
self_ty = self_ty.subst(self.tcx, substs);
|
||||
}
|
||||
let in_self_mod = match characteristic_def_id_of_type(self_ty) {
|
||||
None => false,
|
||||
Some(ty_def_id) => self.tcx.parent_def_id(ty_def_id) == Some(parent_def_id),
|
||||
};
|
||||
|
||||
let impl_trait_ref = self.tcx.impl_trait_ref(impl_def_id);
|
||||
let mut impl_trait_ref = self.tcx.impl_trait_ref(impl_def_id);
|
||||
if let Some(substs) = substs {
|
||||
impl_trait_ref = impl_trait_ref.subst(self.tcx, substs);
|
||||
}
|
||||
let in_trait_mod = match impl_trait_ref {
|
||||
None => false,
|
||||
Some(trait_ref) => self.tcx.parent_def_id(trait_ref.def_id) == Some(parent_def_id),
|
||||
|
@ -153,7 +202,7 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
|
|||
// If the impl is not co-located with either self-type or
|
||||
// trait-type, then fallback to a format that identifies
|
||||
// the module more clearly.
|
||||
let path = self.print_item_path(parent_def_id);
|
||||
let path = self.print_item_path(parent_def_id, None, ns);
|
||||
if let Some(trait_ref) = impl_trait_ref {
|
||||
return self.path_append(path, &format!("<impl {} for {}>", trait_ref, self_ty));
|
||||
} else {
|
||||
|
@ -174,15 +223,14 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
|
|||
// anything other than a simple path.
|
||||
match self_ty.sty {
|
||||
ty::Adt(adt_def, substs) => {
|
||||
// FIXME(eddyb) always print without <> here.
|
||||
if substs.types().next().is_none() { // ignore regions
|
||||
self.print_item_path(adt_def.did)
|
||||
} else {
|
||||
self.path_impl(&format!("<{}>", self_ty))
|
||||
}
|
||||
// FIXME(eddyb) this should recurse to build the path piecewise.
|
||||
// self.print_item_path(adt_def.did, Some(substs), ns)
|
||||
let mut s = String::new();
|
||||
crate::util::ppaux::parameterized(&mut s, adt_def.did, substs, ns).unwrap();
|
||||
self.path_impl(&s)
|
||||
}
|
||||
|
||||
ty::Foreign(did) => self.print_item_path(did),
|
||||
ty::Foreign(did) => self.print_item_path(did, None, ns),
|
||||
|
||||
ty::Bool |
|
||||
ty::Char |
|
||||
|
@ -263,11 +311,21 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
|
|||
pub trait ItemPathPrinter: Sized {
|
||||
type Path;
|
||||
|
||||
fn print_item_path(self: &mut PrintCx<'_, '_, '_, Self>, def_id: DefId) -> Self::Path {
|
||||
self.default_print_item_path(def_id)
|
||||
fn print_item_path(
|
||||
self: &mut PrintCx<'_, '_, 'tcx, Self>,
|
||||
def_id: DefId,
|
||||
substs: Option<&Substs<'tcx>>,
|
||||
ns: Namespace,
|
||||
) -> Self::Path {
|
||||
self.default_print_item_path(def_id, substs, ns)
|
||||
}
|
||||
fn print_impl_path(self: &mut PrintCx<'_, '_, '_, Self>, impl_def_id: DefId) -> Self::Path {
|
||||
self.default_print_impl_path(impl_def_id)
|
||||
fn print_impl_path(
|
||||
self: &mut PrintCx<'_, '_, 'tcx, Self>,
|
||||
impl_def_id: DefId,
|
||||
substs: Option<&Substs<'tcx>>,
|
||||
ns: Namespace,
|
||||
) -> Self::Path {
|
||||
self.default_print_impl_path(impl_def_id, substs, ns)
|
||||
}
|
||||
|
||||
fn path_crate(self: &mut PrintCx<'_, '_, '_, Self>, cnum: CrateNum) -> Self::Path;
|
||||
|
@ -312,6 +370,7 @@ impl LocalPathPrinter {
|
|||
fn try_print_visible_item_path(
|
||||
self: &mut PrintCx<'_, '_, '_, Self>,
|
||||
def_id: DefId,
|
||||
ns: Namespace,
|
||||
) -> Option<<Self as ItemPathPrinter>::Path> {
|
||||
debug!("try_print_visible_item_path: def_id={:?}", def_id);
|
||||
|
||||
|
@ -343,7 +402,7 @@ impl LocalPathPrinter {
|
|||
}) => {
|
||||
debug!("try_print_visible_item_path: def_id={:?}", def_id);
|
||||
let path = if !span.is_dummy() {
|
||||
self.print_item_path(def_id)
|
||||
self.print_item_path(def_id, None, ns)
|
||||
} else {
|
||||
self.path_crate(cnum)
|
||||
};
|
||||
|
@ -376,7 +435,7 @@ impl LocalPathPrinter {
|
|||
}
|
||||
|
||||
let visible_parent = visible_parent_map.get(&def_id).cloned()?;
|
||||
let path = self.try_print_visible_item_path(visible_parent)?;
|
||||
let path = self.try_print_visible_item_path(visible_parent, ns)?;
|
||||
let actual_parent = self.tcx.parent(def_id);
|
||||
|
||||
let data = cur_def_key.disambiguated_data.data;
|
||||
|
@ -444,11 +503,21 @@ impl LocalPathPrinter {
|
|||
impl ItemPathPrinter for LocalPathPrinter {
|
||||
type Path = String;
|
||||
|
||||
fn print_item_path(self: &mut PrintCx<'_, '_, '_, Self>, def_id: DefId) -> Self::Path {
|
||||
self.try_print_visible_item_path(def_id)
|
||||
.unwrap_or_else(|| self.default_print_item_path(def_id))
|
||||
fn print_item_path(
|
||||
self: &mut PrintCx<'_, '_, 'tcx, Self>,
|
||||
def_id: DefId,
|
||||
substs: Option<&Substs<'tcx>>,
|
||||
ns: Namespace,
|
||||
) -> Self::Path {
|
||||
self.try_print_visible_item_path(def_id, ns)
|
||||
.unwrap_or_else(|| self.default_print_item_path(def_id, substs, ns))
|
||||
}
|
||||
fn print_impl_path(self: &mut PrintCx<'_, '_, '_, Self>, impl_def_id: DefId) -> Self::Path {
|
||||
fn print_impl_path(
|
||||
self: &mut PrintCx<'_, '_, 'tcx, Self>,
|
||||
impl_def_id: DefId,
|
||||
substs: Option<&Substs<'tcx>>,
|
||||
ns: Namespace,
|
||||
) -> Self::Path {
|
||||
// Always use types for non-local impls, where types are always
|
||||
// available, and filename/line-number is mostly uninteresting.
|
||||
let use_types = !impl_def_id.is_local() || {
|
||||
|
@ -463,12 +532,12 @@ impl ItemPathPrinter for LocalPathPrinter {
|
|||
// only occur very early in the compiler pipeline.
|
||||
// FIXME(eddyb) this should just be using `tcx.def_span(impl_def_id)`
|
||||
let parent_def_id = self.tcx.parent_def_id(impl_def_id).unwrap();
|
||||
let path = self.print_item_path(parent_def_id);
|
||||
let path = self.print_item_path(parent_def_id, None, ns);
|
||||
let span = self.tcx.def_span(impl_def_id);
|
||||
return self.path_append(path, &format!("<impl at {:?}>", span));
|
||||
}
|
||||
|
||||
self.default_print_impl_path(impl_def_id)
|
||||
self.default_print_impl_path(impl_def_id, substs, ns)
|
||||
}
|
||||
|
||||
fn path_crate(self: &mut PrintCx<'_, '_, '_, Self>, cnum: CrateNum) -> Self::Path {
|
||||
|
|
|
@ -317,23 +317,15 @@ impl<F: fmt::Write> PrintCx<'a, 'gcx, 'tcx, FmtPrinter<F>> {
|
|||
}
|
||||
}
|
||||
} else {
|
||||
// Try to print `impl`s more like how you'd refer to their associated items.
|
||||
if let DefPathData::Impl = key.disambiguated_data.data {
|
||||
if let Some(trait_ref) = self.tcx.impl_trait_ref(def_id) {
|
||||
// HACK(eddyb) this is in lieu of more specific disambiguation.
|
||||
print!(self, write("{}", self.tcx.item_path_str(def_id)))?;
|
||||
// FIXME(eddyb) recurse through printing a path via `self`, instead
|
||||
// instead of using the `tcx` method that produces a `String`.
|
||||
print!(self, write("{}",
|
||||
self.tcx.item_path_str_with_substs_and_ns(def_id, Some(substs), ns)))?;
|
||||
|
||||
let trait_ref = trait_ref.subst(self.tcx, substs);
|
||||
print!(self, print_debug(trait_ref))?;
|
||||
} else {
|
||||
let self_ty = self.tcx.type_of(def_id).subst(self.tcx, substs);
|
||||
// FIXME(eddyb) omit the <> where possible.
|
||||
print!(self, write("<"), print(self_ty), write(">"))?;
|
||||
}
|
||||
// For impls, the above call already prints relevant generics args.
|
||||
if let DefPathData::Impl = key.disambiguated_data.data {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
print!(self, write("{}", self.tcx.item_path_str(def_id)))?;
|
||||
}
|
||||
|
||||
let mut empty = true;
|
||||
|
|
|
@ -87,6 +87,7 @@
|
|||
//! virtually impossible. Thus, symbol hash generation exclusively relies on
|
||||
//! DefPaths which are much more robust in the face of changes to the code base.
|
||||
|
||||
use rustc::hir::def::Namespace;
|
||||
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
|
||||
use rustc::hir::Node;
|
||||
use rustc::hir::CodegenFnAttrFlags;
|
||||
|
@ -225,7 +226,9 @@ fn get_symbol_hash<'a, 'tcx>(
|
|||
|
||||
fn def_symbol_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> ty::SymbolName {
|
||||
item_path::with_forced_absolute_paths(|| {
|
||||
PrintCx::new(tcx, SymbolPathPrinter).print_item_path(def_id).into_interned()
|
||||
PrintCx::new(tcx, SymbolPathPrinter)
|
||||
.print_item_path(def_id, None, Namespace::ValueNS)
|
||||
.into_interned()
|
||||
})
|
||||
}
|
||||
|
||||
|
|
|
@ -18,7 +18,7 @@ use rustc::middle::lang_items;
|
|||
use rustc::middle::stability;
|
||||
use rustc::mir::interpret::GlobalId;
|
||||
use rustc::hir::{self, GenericArg, HirVec};
|
||||
use rustc::hir::def::{self, Def, CtorKind};
|
||||
use rustc::hir::def::{self, Def, CtorKind, Namespace};
|
||||
use rustc::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
|
||||
use rustc::ty::subst::{InternalSubsts, SubstsRef};
|
||||
use rustc::ty::{self, TyCtxt, Region, RegionVid, Ty, AdtKind};
|
||||
|
@ -4249,7 +4249,8 @@ where F: Fn(DefId) -> Def {
|
|||
}
|
||||
}
|
||||
|
||||
let names = PrintCx::new(tcx, AbsolutePathPrinter).print_item_path(def_id);
|
||||
let names = PrintCx::new(tcx, AbsolutePathPrinter)
|
||||
.print_item_path(def_id, None, Namespace::TypeNS);
|
||||
|
||||
hir::Path {
|
||||
span: DUMMY_SP,
|
||||
|
|
|
@ -32,27 +32,27 @@ pub fn bar() ({
|
|||
(($crate::fmt::format as
|
||||
for<'r> fn(std::fmt::Arguments<'r>) -> std::string::String {std::fmt::format})(((<$crate::fmt::Arguments>::new_v1
|
||||
as
|
||||
fn(&[&str], &[std::fmt::ArgumentV1<'_>]) -> std::fmt::Arguments<'_> {std::fmt::Arguments<'_>::new_v1})((&([("test"
|
||||
fn(&[&str], &[std::fmt::ArgumentV1<'_>]) -> std::fmt::Arguments<'_> {std::fmt::Arguments::<'_>::new_v1})((&([("test"
|
||||
as
|
||||
&'static str)]
|
||||
as
|
||||
&'static str)]
|
||||
[&str; 1])
|
||||
as
|
||||
[&str; 1])
|
||||
as
|
||||
&[&str; 1]),
|
||||
(&(match (()
|
||||
&[&str; 1]),
|
||||
(&(match (()
|
||||
as
|
||||
())
|
||||
{
|
||||
()
|
||||
=>
|
||||
([]
|
||||
as
|
||||
())
|
||||
{
|
||||
()
|
||||
=>
|
||||
([]
|
||||
as
|
||||
[std::fmt::ArgumentV1<'_>; 0]),
|
||||
}
|
||||
[std::fmt::ArgumentV1<'_>; 0]),
|
||||
}
|
||||
as
|
||||
[std::fmt::ArgumentV1<'_>; 0])
|
||||
as
|
||||
[std::fmt::ArgumentV1<'_>; 0])
|
||||
as
|
||||
&[std::fmt::ArgumentV1<'_>; 0]))
|
||||
&[std::fmt::ArgumentV1<'_>; 0]))
|
||||
as
|
||||
std::fmt::Arguments<'_>))
|
||||
as std::string::String);
|
||||
|
|
|
@ -22,7 +22,7 @@ LL | let x: Vec<Trait + Sized> = Vec::new();
|
|||
|
|
||||
= help: the trait `std::marker::Sized` is not implemented for `dyn Trait`
|
||||
= note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
|
||||
= note: required by `<std::vec::Vec<T>>::new`
|
||||
= note: required by `std::vec::Vec::<T>::new`
|
||||
|
||||
error: aborting due to 3 previous errors
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@ error[E0493]: destructors cannot be evaluated at compile-time
|
|||
LL | const F: u32 = (U::X, 42).1;
|
||||
| ^^^^^^^^^^ constants cannot evaluate destructors
|
||||
|
||||
error: `<std::vec::Vec<T>>::new` is not yet stable as a const fn
|
||||
error: `std::vec::Vec::<T>::new` is not yet stable as a const fn
|
||||
--> $DIR/feature-gate-unleash_the_miri_inside_of_you.rs:18:25
|
||||
|
|
||||
LL | const X: Vec<u32> = Vec::new();
|
||||
|
|
|
@ -9,7 +9,7 @@ mod foo {
|
|||
}
|
||||
|
||||
pub macro m() {
|
||||
let _: () = S.f(); //~ ERROR type `for<'r> fn(&'r foo::S) {<foo::S>::f}` is private
|
||||
let _: () = S.f(); //~ ERROR type `for<'r> fn(&'r foo::S) {foo::S::f}` is private
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error: type `for<'r> fn(&'r foo::S) {<foo::S>::f}` is private
|
||||
error: type `for<'r> fn(&'r foo::S) {foo::S::f}` is private
|
||||
--> $DIR/impl_items.rs:12:23
|
||||
|
|
||||
LL | let _: () = S.f();
|
||||
|
|
|
@ -6,7 +6,7 @@ LL | (|| Box::new(*(&[0][..])))();
|
|||
|
|
||||
= help: the trait `std::marker::Sized` is not implemented for `[{integer}]`
|
||||
= note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
|
||||
= note: required by `<std::boxed::Box<T>>::new`
|
||||
= note: required by `std::boxed::Box::<T>::new`
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
@ -50,7 +50,7 @@ struct D (Box<A>);
|
|||
|
||||
impl D {
|
||||
pub fn matches<F: Fn()>(&self, f: &F) {
|
||||
//~^ ERROR reached the type-length limit while instantiating `<D>::matches::<[closure
|
||||
//~^ ERROR reached the type-length limit while instantiating `D::matches::<[closure
|
||||
let &D(ref a) = self;
|
||||
a.matches(f)
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error: reached the type-length limit while instantiating `<D>::matches::$CLOSURE`
|
||||
error: reached the type-length limit while instantiating `D::matches::$CLOSURE`
|
||||
--> $DIR/issue-22638.rs:52:5
|
||||
|
|
||||
LL | / pub fn matches<F: Fn()>(&self, f: &F) {
|
||||
|
|
|
@ -5,7 +5,7 @@ LL | let x: &fn(&B) -> u32 = &B::func;
|
|||
| ^^^^^^^^ expected fn pointer, found fn item
|
||||
|
|
||||
= note: expected type `&for<'r> fn(&'r B) -> u32`
|
||||
found type `&for<'r> fn(&'r B) -> u32 {<B>::func}`
|
||||
found type `&for<'r> fn(&'r B) -> u32 {B::func}`
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
@ -13,7 +13,7 @@ fn func() -> Ret {
|
|||
|
||||
fn main() {
|
||||
Obj::func.x();
|
||||
//~^ ERROR no method named `x` found for type `fn() -> Ret {<Obj>::func}` in the current scope
|
||||
//~^ ERROR no method named `x` found for type `fn() -> Ret {Obj::func}` in the current scope
|
||||
func.x();
|
||||
//~^ ERROR no method named `x` found for type `fn() -> Ret {func}` in the current scope
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error[E0599]: no method named `x` found for type `fn() -> Ret {<Obj>::func}` in the current scope
|
||||
error[E0599]: no method named `x` found for type `fn() -> Ret {Obj::func}` in the current scope
|
||||
--> $DIR/issue-29124.rs:15:15
|
||||
|
|
||||
LL | Obj::func.x();
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error: reached the type-length limit while instantiating `<T as Foo><(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(), &()), &(&()...`
|
||||
error: reached the type-length limit while instantiating `<(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(&(), &()), &(&(), &())), &...`
|
||||
--> $DIR/issue-37311.rs:13:5
|
||||
|
|
||||
LL | / fn recurse(&self) {
|
||||
|
|
|
@ -8,7 +8,7 @@ error[E0080]: evaluation of constant value failed
|
|||
--> $DIR/issue-39559-2.rs:14:24
|
||||
|
|
||||
LL | let array: [usize; Dim3::dim()]
|
||||
| ^^^^^^^^^^^ calling non-const function `<Dim3 as Dim><Dim3 as Dim>::dim`
|
||||
| ^^^^^^^^^^^ calling non-const function `<Dim3 as Dim>::dim`
|
||||
|
||||
error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
|
||||
--> $DIR/issue-39559-2.rs:17:15
|
||||
|
@ -20,7 +20,7 @@ error[E0080]: evaluation of constant value failed
|
|||
--> $DIR/issue-39559-2.rs:17:15
|
||||
|
|
||||
LL | = [0; Dim3::dim()];
|
||||
| ^^^^^^^^^^^ calling non-const function `<Dim3 as Dim><Dim3 as Dim>::dim`
|
||||
| ^^^^^^^^^^^ calling non-const function `<Dim3 as Dim>::dim`
|
||||
|
||||
error: aborting due to 4 previous errors
|
||||
|
||||
|
|
|
@ -11,11 +11,11 @@ mod priv_nominal {
|
|||
|
||||
pub macro mac() {
|
||||
let value = Pub::method;
|
||||
//~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {<priv_nominal::Pub>::method}` is private
|
||||
//~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
|
||||
value;
|
||||
//~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {<priv_nominal::Pub>::method}` is private
|
||||
//~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
|
||||
Pub.method();
|
||||
//~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {<priv_nominal::Pub>::method}` is private
|
||||
//~^ ERROR type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
|
||||
Pub::CONST;
|
||||
//~^ ERROR associated constant `CONST` is private
|
||||
// let _: Pub::AssocTy;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error: type `for<'r> fn(&'r priv_nominal::Pub) {<priv_nominal::Pub>::method}` is private
|
||||
error: type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
|
||||
--> $DIR/associated-item-privacy-inherent.rs:13:21
|
||||
|
|
||||
LL | let value = Pub::method;
|
||||
|
@ -7,7 +7,7 @@ LL | let value = Pub::method;
|
|||
LL | priv_nominal::mac!();
|
||||
| --------------------- in this macro invocation
|
||||
|
||||
error: type `for<'r> fn(&'r priv_nominal::Pub) {<priv_nominal::Pub>::method}` is private
|
||||
error: type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
|
||||
--> $DIR/associated-item-privacy-inherent.rs:15:9
|
||||
|
|
||||
LL | value;
|
||||
|
@ -16,7 +16,7 @@ LL | value;
|
|||
LL | priv_nominal::mac!();
|
||||
| --------------------- in this macro invocation
|
||||
|
||||
error: type `for<'r> fn(&'r priv_nominal::Pub) {<priv_nominal::Pub>::method}` is private
|
||||
error: type `for<'r> fn(&'r priv_nominal::Pub) {priv_nominal::Pub::method}` is private
|
||||
--> $DIR/associated-item-privacy-inherent.rs:17:13
|
||||
|
|
||||
LL | Pub.method();
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
// error-pattern:type `fn() {<u8 as ext::PrivTrait>::method}` is private
|
||||
// error-pattern:type `fn(u8) -> ext::PrivTupleStruct {ext::PrivTupleStruct}` is private
|
||||
// error-pattern:type `fn(u8) -> ext::PubTupleStruct {ext::PubTupleStruct}` is private
|
||||
// error-pattern:type `for<'r> fn(&'r ext::Pub<u8>) {<ext::Pub<u8>>::priv_method}` is private
|
||||
// error-pattern:type `for<'r> fn(&'r ext::Pub<u8>) {ext::Pub::<u8>::priv_method}` is private
|
||||
|
||||
#![feature(decl_macro)]
|
||||
|
||||
|
|
|
@ -46,7 +46,7 @@ LL | ext::m!();
|
|||
|
|
||||
= note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
|
||||
|
||||
error: type `for<'r> fn(&'r ext::Pub<u8>) {<ext::Pub<u8>>::priv_method}` is private
|
||||
error: type `for<'r> fn(&'r ext::Pub<u8>) {ext::Pub::<u8>::priv_method}` is private
|
||||
--> $DIR/private-inferred-type-3.rs:16:5
|
||||
|
|
||||
LL | ext::m!();
|
||||
|
|
|
@ -47,7 +47,7 @@ mod m {
|
|||
PubTupleStruct;
|
||||
//~^ ERROR type `fn(u8) -> m::PubTupleStruct {m::PubTupleStruct}` is private
|
||||
Pub(0u8).priv_method();
|
||||
//~^ ERROR type `for<'r> fn(&'r m::Pub<u8>) {<m::Pub<u8>>::priv_method}` is private
|
||||
//~^ ERROR type `for<'r> fn(&'r m::Pub<u8>) {m::Pub::<u8>::priv_method}` is private
|
||||
}
|
||||
|
||||
trait Trait {}
|
||||
|
|
|
@ -151,7 +151,7 @@ LL | PubTupleStruct;
|
|||
LL | m::m!();
|
||||
| -------- in this macro invocation
|
||||
|
||||
error: type `for<'r> fn(&'r m::Pub<u8>) {<m::Pub<u8>>::priv_method}` is private
|
||||
error: type `for<'r> fn(&'r m::Pub<u8>) {m::Pub::<u8>::priv_method}` is private
|
||||
--> $DIR/private-inferred-type.rs:49:18
|
||||
|
|
||||
LL | Pub(0u8).priv_method();
|
||||
|
|
|
@ -11,7 +11,7 @@ LL | 0 ..= <S as Tr>::A::f::<u8> => {}
|
|||
| ^^^^^^^^^^^^^^^^^^^^^ ranges require char or numeric types
|
||||
|
|
||||
= note: start type: {integer}
|
||||
= note: end type: fn() {<S>::f::<u8>}
|
||||
= note: end type: fn() {S::f::<u8>}
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
|
|
|
@ -5,7 +5,7 @@ mod foo {
|
|||
pub struct Foo { x: u32 }
|
||||
|
||||
impl Foo {
|
||||
#[rustc_symbol_name] //~ ERROR _ZN5impl13foo3Foo3bar
|
||||
#[rustc_symbol_name] //~ ERROR _ZN15impl1..foo..Foo3bar
|
||||
#[rustc_item_path] //~ ERROR item-path(foo::Foo::bar)
|
||||
fn bar() { }
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error: symbol-name(_ZN5impl13foo3Foo3bar17hc487d6ec13fe9124E)
|
||||
error: symbol-name(_ZN15impl1..foo..Foo3bar17hc487d6ec13fe9124E)
|
||||
--> $DIR/impl1.rs:8:9
|
||||
|
|
||||
LL | #[rustc_symbol_name]
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue