mkdir -p $HOME/.cargo
mkdir -p $objdir/tmp
-mkdir $objdir/cores
+mkdir -p $objdir/cores
args=
if [ "$SCCACHE_BUCKET" != "" ]; then
/// # Safety
///
/// The specified range must be valid for reading and writing.
-/// The type `T` must have non-zero size.
///
/// # Algorithm
///
loop {
let delta = cmp::min(left, right);
if delta <= RawArray::<T>::cap() {
+ // We will always hit this immediately for ZST.
break;
}
.emit();
}
- let mut has_wasm_import_module = false;
for attr in &item.attrs {
if attr.check_name("inline") {
self.check_inline(attr, &item.span, target)
} else if attr.check_name("non_exhaustive") {
self.check_non_exhaustive(attr, item, target)
- } else if attr.check_name("wasm_import_module") {
- has_wasm_import_module = true;
- if attr.value_str().is_none() {
- self.tcx.sess.span_err(attr.span, "\
- must be of the form #[wasm_import_module = \"...\"]");
- }
- if target != Target::ForeignMod {
- self.tcx.sess.span_err(attr.span, "\
- must only be attached to foreign modules");
- }
}
}
- if target == Target::ForeignMod &&
- !has_wasm_import_module &&
- self.tcx.sess.target.target.arch == "wasm32" &&
- false // FIXME: eventually enable this warning when stable
- {
- self.tcx.sess.span_warn(item.span, "\
- must have a #[wasm_import_module = \"...\"] attribute, this \
- will become a hard error before too long");
- }
-
self.check_repr(item, target);
self.check_used(item, target);
}
Enum(DefId),
Variant(DefId),
Trait(DefId),
+ /// `existential type Foo: Bar;`
Existential(DefId),
+ /// `type Foo = Bar;`
TyAlias(DefId),
TyForeign(DefId),
TraitAlias(DefId),
AssociatedTy(DefId),
+ /// `existential type Foo: Bar;`
+ AssociatedExistential(DefId),
PrimTy(hir::PrimTy),
TyParam(DefId),
SelfTy(Option<DefId> /* trait */, Option<DefId> /* impl */),
Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) |
Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) |
Def::AssociatedConst(id) | Def::Macro(id, ..) |
- Def::Existential(id) |
+ Def::Existential(id) | Def::AssociatedExistential(id) |
Def::GlobalAsm(id) | Def::TyForeign(id) => {
id
}
Def::TyAlias(..) => "type alias",
Def::TraitAlias(..) => "trait alias",
Def::AssociatedTy(..) => "associated type",
+ Def::AssociatedExistential(..) => "associated existential type",
Def::Struct(..) => "struct",
Def::StructCtor(.., CtorKind::Fn) => "tuple struct",
Def::StructCtor(.., CtorKind::Const) => "unit struct",
visitor.visit_id(impl_item.id);
visitor.visit_ty(ty);
}
+ ImplItemKind::Existential(ref bounds) => {
+ visitor.visit_id(impl_item.id);
+ walk_list!(visitor, visit_param_bound, bounds);
+ }
}
}
| ItemKind::Union(_, ref generics)
| ItemKind::Enum(_, ref generics)
| ItemKind::Ty(_, ref generics)
+ | ItemKind::Existential(_, ref generics)
| ItemKind::Trait(_, _, ref generics, ..) => {
let def_id = self.lctx.resolver.definitions().local_def_id(item.id);
let count = generics
self.lower_ty(t, ImplTraitContext::Disallowed),
self.lower_generics(generics, ImplTraitContext::Disallowed),
),
+ ItemKind::Existential(ref b, ref generics) => hir::ItemKind::Existential(hir::ExistTy {
+ generics: self.lower_generics(generics, ImplTraitContext::Disallowed),
+ bounds: self.lower_param_bounds(b, ImplTraitContext::Disallowed),
+ impl_trait_fn: None,
+ }),
ItemKind::Enum(ref enum_definition, ref generics) => hir::ItemKind::Enum(
hir::EnumDef {
variants: enum_definition
self.lower_generics(&i.generics, ImplTraitContext::Disallowed),
hir::ImplItemKind::Type(self.lower_ty(ty, ImplTraitContext::Disallowed)),
),
+ ImplItemKind::Existential(ref bounds) => (
+ self.lower_generics(&i.generics, ImplTraitContext::Disallowed),
+ hir::ImplItemKind::Existential(
+ self.lower_param_bounds(bounds, ImplTraitContext::Disallowed),
+ ),
+ ),
ImplItemKind::Macro(..) => panic!("Shouldn't exist any more"),
};
kind: match i.node {
ImplItemKind::Const(..) => hir::AssociatedItemKind::Const,
ImplItemKind::Type(..) => hir::AssociatedItemKind::Type,
+ ImplItemKind::Existential(..) => hir::AssociatedItemKind::Existential,
ImplItemKind::Method(ref sig, _) => hir::AssociatedItemKind::Method {
has_self: sig.decl.has_self(),
},
respan(v.span, node)
}
- fn lower_defaultness(&mut self, d: Defaultness, has_value: bool) -> hir::Defaultness {
+ fn lower_defaultness(&self, d: Defaultness, has_value: bool) -> hir::Defaultness {
match d {
Defaultness::Default => hir::Defaultness::Default {
has_value: has_value,
}
}
+impl MaybeFnLike for ast::ImplItem {
+ fn is_fn_like(&self) -> bool {
+ match self.node { ast::ImplItemKind::Method(..) => true, _ => false, }
+ }
+}
+
impl MaybeFnLike for ast::TraitItem {
fn is_fn_like(&self) -> bool {
match self.node {
let fn_like = match node {
map::NodeItem(item) => item.is_fn_like(),
map::NodeTraitItem(tm) => tm.is_fn_like(),
- map::NodeImplItem(_) => true,
+ map::NodeImplItem(it) => it.is_fn_like(),
map::NodeExpr(e) => e.is_fn_like(),
_ => false
};
ItemKind::Impl(..) => DefPathData::Impl,
ItemKind::Trait(..) => DefPathData::Trait(i.ident.as_interned_str()),
ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) |
- ItemKind::TraitAlias(..) |
+ ItemKind::TraitAlias(..) | ItemKind::Existential(..) |
ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) | ItemKind::Ty(..) =>
DefPathData::TypeNs(i.ident.as_interned_str()),
ItemKind::Mod(..) if i.ident == keywords::Invalid.ident() => {
ImplItemKind::Method(..) | ImplItemKind::Const(..) =>
DefPathData::ValueNs(ii.ident.as_interned_str()),
ImplItemKind::Type(..) => DefPathData::AssocTypeInImpl(ii.ident.as_interned_str()),
+ ImplItemKind::Existential(..) => {
+ DefPathData::AssocExistentialInImpl(ii.ident.as_interned_str())
+ },
ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id),
};
AssocTypeInTrait(InternedString),
/// An associated type **value** (i.e., in an impl)
AssocTypeInImpl(InternedString),
+ /// An existential associated type **value** (i.e., in an impl)
+ AssocExistentialInImpl(InternedString),
/// Something in the type NS
TypeNs(InternedString),
/// Something in the value NS
Trait(name) |
AssocTypeInTrait(name) |
AssocTypeInImpl(name) |
+ AssocExistentialInImpl(name) |
ValueNs(name) |
Module(name) |
MacroDef(name) |
Trait(name) |
AssocTypeInTrait(name) |
AssocTypeInImpl(name) |
+ AssocExistentialInImpl(name) |
ValueNs(name) |
Module(name) |
MacroDef(name) |
ImplItemKind::Const(..) => Some(Def::AssociatedConst(def_id)),
ImplItemKind::Method(..) => Some(Def::Method(def_id)),
ImplItemKind::Type(..) => Some(Def::AssociatedTy(def_id)),
+ ImplItemKind::Existential(..) => Some(Def::AssociatedExistential(def_id)),
}
}
NodeVariant(variant) => {
ItemKind::ForeignMod(..) => "foreign mod",
ItemKind::GlobalAsm(..) => "global asm",
ItemKind::Ty(..) => "ty",
- ItemKind::Existential(..) => "existential",
+ ItemKind::Existential(..) => "existential type",
ItemKind::Enum(..) => "enum",
ItemKind::Struct(..) => "struct",
ItemKind::Union(..) => "union",
ImplItemKind::Type(_) => {
format!("assoc type {} in {}{}", ii.ident, path_str(), id_str)
}
+ ImplItemKind::Existential(_) => {
+ format!("assoc existential type {} in {}{}", ii.ident, path_str(), id_str)
+ }
}
}
Some(NodeTraitItem(ti)) => {
Method(MethodSig, BodyId),
/// An associated type
Type(P<Ty>),
+ /// An associated existential type
+ Existential(GenericBounds),
}
// Bind a type to an associated type: `A=Foo`.
GlobalAsm(P<GlobalAsm>),
/// A type alias, e.g. `type Foo = Bar<u8>`
Ty(P<Ty>, Generics),
- /// A type alias, e.g. `type Foo = Bar<u8>`
+ /// An existential type definition, e.g. `existential type Foo: Bar;`
Existential(ExistTy),
/// An enum definition, e.g. `enum Foo<A, B> {C<A>, D<B>}`
Enum(EnumDef, Generics),
Some(match *self {
ItemKind::Fn(_, _, ref generics, _) |
ItemKind::Ty(_, ref generics) |
+ ItemKind::Existential(ExistTy { ref generics, impl_trait_fn: None, .. }) |
ItemKind::Enum(_, ref generics) |
ItemKind::Struct(_, ref generics) |
ItemKind::Union(_, ref generics) |
Const,
Method { has_self: bool },
Type,
+ Existential,
}
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
self.end()?
}
hir::ItemKind::Ty(ref ty, ref generics) => {
- self.ibox(indent_unit)?;
- self.ibox(0)?;
- self.word_nbsp(&visibility_qualified(&item.vis, "type"))?;
+ self.head(&visibility_qualified(&item.vis, "type"))?;
self.print_name(item.name)?;
self.print_generic_params(&generics.params)?;
self.end()?; // end the inner ibox
self.end()?; // end the outer ibox
}
hir::ItemKind::Existential(ref exist) => {
- self.ibox(indent_unit)?;
- self.ibox(0)?;
- self.word_nbsp(&visibility_qualified(&item.vis, "existential type"))?;
+ self.head(&visibility_qualified(&item.vis, "existential type"))?;
self.print_name(item.name)?;
self.print_generic_params(&exist.generics.params)?;
self.end()?; // end the inner ibox
hir::ImplItemKind::Type(ref ty) => {
self.print_associated_type(ii.ident, None, Some(ty))?;
}
+ hir::ImplItemKind::Existential(ref bounds) => {
+ self.word_space("existential")?;
+ self.print_associated_type(ii.ident, Some(bounds), None)?;
+ }
}
self.ann.post(self, NodeSubItem(ii.id))
}
kind,
name,
cfg,
- foreign_module
+ foreign_module,
+ wasm_import_module
});
impl_stable_hash_for!(struct middle::cstore::ForeignModule {
impl_stable_hash_for!(enum hir::ImplItemKind {
Const(t, body),
Method(sig, body),
+ Existential(bounds),
Type(t)
});
mem::discriminant(self).hash_stable(hcx, hasher);
match *self {
hir::AssociatedItemKind::Const |
+ hir::AssociatedItemKind::Existential |
hir::AssociatedItemKind::Type => {
// No fields to hash.
}
TyAlias(def_id),
TraitAlias(def_id),
AssociatedTy(def_id),
+ AssociatedExistential(def_id),
PrimTy(prim_ty),
TyParam(def_id),
SelfTy(trait_def_id, impl_def_id),
impl_stable_hash_for!(enum ty::AssociatedKind {
Const,
Method,
+ Existential,
Type
});
let tcx = self.infcx.tcx;
value.fold_with(&mut BottomUpFolder {
tcx,
+ reg_op: |reg| reg,
fldop: |ty| {
if let ty::TyAnon(def_id, substs) = ty.sty {
// Check that this is `impl Trait` type is
// }
// ```
if let Some(anon_node_id) = tcx.hir.as_local_node_id(def_id) {
- let anon_parent_def_id = match tcx.hir.expect_item(anon_node_id).node {
+ let in_definition_scope = match tcx.hir.expect_item(anon_node_id).node {
+ // impl trait
hir::ItemKind::Existential(hir::ExistTy {
impl_trait_fn: Some(parent),
..
- }) => parent,
+ }) => parent == self.parent_def_id,
+ // named existential types
+ hir::ItemKind::Existential(hir::ExistTy {
+ impl_trait_fn: None,
+ ..
+ }) => may_define_existential_type(
+ tcx,
+ self.parent_def_id,
+ anon_node_id,
+ ),
_ => {
let anon_parent_node_id = tcx.hir.get_parent(anon_node_id);
- tcx.hir.local_def_id(anon_parent_node_id)
+ self.parent_def_id == tcx.hir.local_def_id(anon_parent_node_id)
},
};
- if self.parent_def_id == anon_parent_def_id {
+ if in_definition_scope {
return self.fold_anon_ty(ty, def_id, substs);
}
debug!(
"instantiate_anon_types_in_map: \
- encountered anon with wrong parent \
- def_id={:?} \
- anon_parent_def_id={:?}",
- def_id, anon_parent_def_id
+ encountered anon outside it's definition scope \
+ def_id={:?}",
+ def_id,
);
}
}
let ty_var = infcx.next_ty_var(TypeVariableOrigin::TypeInference(span));
let predicates_of = tcx.predicates_of(def_id);
+ debug!(
+ "instantiate_anon_types: predicates: {:#?}",
+ predicates_of,
+ );
let bounds = predicates_of.instantiate(tcx, substs);
debug!("instantiate_anon_types: bounds={:?}", bounds);
required_region_bounds
);
+ // make sure that we are in fact defining the *entire* type
+ // e.g. `existential type Foo<T: Bound>: Bar;` needs to be
+ // defined by a function like `fn foo<T: Bound>() -> Foo<T>`.
+ debug!(
+ "instantiate_anon_types: param_env: {:#?}",
+ self.param_env,
+ );
+ debug!(
+ "instantiate_anon_types: generics: {:#?}",
+ tcx.generics_of(def_id),
+ );
+
self.anon_types.insert(
def_id,
AnonTypeDecl {
ty_var
}
}
+
+/// Whether `anon_node_id` is a sibling or a child of a sibling of `def_id`
+///
+/// ```rust
+/// pub mod foo {
+/// pub mod bar {
+/// pub existential type Baz;
+///
+/// fn f1() -> Baz { .. }
+/// }
+///
+/// fn f2() -> bar::Baz { .. }
+/// }
+/// ```
+///
+/// Here, `def_id` will be the `DefId` of the existential type `Baz`.
+/// `anon_node_id` is the `NodeId` of the reference to Baz -- so either the return type of f1 or f2.
+/// We will return true if the reference is within the same module as the existential type
+/// So true for f1, false for f2.
+pub fn may_define_existential_type(
+ tcx: TyCtxt,
+ def_id: DefId,
+ anon_node_id: ast::NodeId,
+) -> bool {
+ let mut node_id = tcx
+ .hir
+ .as_local_node_id(def_id)
+ .unwrap();
+ // named existential types can be defined by any siblings or
+ // children of siblings
+ let mod_id = tcx.hir.get_parent(anon_node_id);
+ // so we walk up the node tree until we hit the root or the parent
+ // of the anon type
+ while node_id != mod_id && node_id != ast::CRATE_NODE_ID {
+ node_id = tcx.hir.get_parent(node_id);
+ }
+ // syntactically we are allowed to define the concrete type
+ node_id == mod_id
+}
fn impl_item_scope_tag(item: &hir::ImplItem) -> &'static str {
match item.node {
hir::ImplItemKind::Method(..) => "method body",
- hir::ImplItemKind::Const(..) | hir::ImplItemKind::Type(_) => "associated item",
+ hir::ImplItemKind::Const(..) |
+ hir::ImplItemKind::Existential(..) |
+ hir::ImplItemKind::Type(..) => "associated item",
}
}
}
pub fn unsolved_variables(&self) -> Vec<Ty<'tcx>> {
- let mut variables = Vec::new();
-
- {
- let mut type_variables = self.type_variables.borrow_mut();
- variables.extend(
- type_variables
- .unsolved_variables()
- .into_iter()
- .map(|t| self.tcx.mk_var(t)));
- }
-
- {
- let mut int_unification_table = self.int_unification_table.borrow_mut();
- variables.extend(
+ let mut type_variables = self.type_variables.borrow_mut();
+ let mut int_unification_table = self.int_unification_table.borrow_mut();
+ let mut float_unification_table = self.float_unification_table.borrow_mut();
+
+ type_variables
+ .unsolved_variables()
+ .into_iter()
+ .map(|t| self.tcx.mk_var(t))
+ .chain(
(0..int_unification_table.len())
.map(|i| ty::IntVid { index: i as u32 })
.filter(|&vid| int_unification_table.probe_value(vid).is_none())
- .map(|v| self.tcx.mk_int_var(v)));
- }
-
- {
- let mut float_unification_table = self.float_unification_table.borrow_mut();
- variables.extend(
+ .map(|v| self.tcx.mk_int_var(v))
+ ).chain(
(0..float_unification_table.len())
.map(|i| ty::FloatVid { index: i as u32 })
.filter(|&vid| float_unification_table.probe_value(vid).is_none())
- .map(|v| self.tcx.mk_float_var(v)));
- }
-
- return variables;
+ .map(|v| self.tcx.mk_float_var(v))
+ ).collect()
}
fn combine_fields(&'a self, trace: TypeTrace<'tcx>, param_env: ty::ParamEnv<'tcx>)
use session::{Session, DiagnosticMessageId};
use std::hash;
use syntax::ast;
-use syntax::codemap::MultiSpan;
+use syntax::codemap::{MultiSpan, ExpnFormat};
use syntax::edition::Edition;
use syntax::symbol::Symbol;
use syntax::visit as ast_visit;
future_incompatible.reference);
err.warn(&explanation);
err.note(&citation);
+
+ // If this lint is *not* a future incompatibility warning then we want to be
+ // sure to not be too noisy in some situations. If this code originates in a
+ // foreign macro, aka something that this crate did not itself author, then
+ // it's likely that there's nothing this crate can do about it. We probably
+ // want to skip the lint entirely.
+ //
+ // For some lints though (like unreachable code) there's clear actionable
+ // items to take care of (delete the macro invocation). As a result we have
+ // a few lints we whitelist here for allowing a lint even though it's in a
+ // foreign macro invocation.
+ } else if lint_id != LintId::of(builtin::UNREACHABLE_CODE) &&
+ lint_id != LintId::of(builtin::DEPRECATED) {
+ if err.span.primary_spans().iter().any(|s| in_external_macro(sess, *s)) {
+ err.cancel();
+ }
}
return err
pub fn provide(providers: &mut Providers) {
providers.lint_levels = lint_levels;
}
+
+/// Returns whether `span` originates in a foreign crate's external macro.
+///
+/// This is used to test whether a lint should be entirely aborted above.
+pub fn in_external_macro(sess: &Session, span: Span) -> bool {
+ let info = match span.ctxt().outer().expn_info() {
+ Some(info) => info,
+ // no ExpnInfo means this span doesn't come from a macro
+ None => return false,
+ };
+
+ match info.format {
+ ExpnFormat::MacroAttribute(..) => return true, // definitely a plugin
+ ExpnFormat::CompilerDesugaring(_) => return true, // well, it's "external"
+ ExpnFormat::MacroBang(..) => {} // check below
+ }
+
+ let def_site = match info.def_site {
+ Some(span) => span,
+ // no span for the def_site means it's an external macro
+ None => return true,
+ };
+
+ match sess.codemap().span_to_snippet(def_site) {
+ Ok(code) => !code.starts_with("macro_rules"),
+ // no snippet = external macro or compiler-builtin expansion
+ Err(_) => true,
+ }
+}
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub struct NativeLibrary {
pub kind: NativeLibraryKind,
- pub name: Symbol,
+ pub name: Option<Symbol>,
pub cfg: Option<ast::MetaItem>,
pub foreign_module: Option<DefId>,
+ pub wasm_import_module: Option<Symbol>,
}
#[derive(Clone, Hash, RustcEncodable, RustcDecodable)]
fn create_and_seed_worklist<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
access_levels: &privacy::AccessLevels,
krate: &hir::Crate)
- -> Vec<ast::NodeId> {
- let mut worklist = Vec::new();
- for (id, _) in &access_levels.map {
- worklist.push(*id);
- }
-
- // Seed entry point
- if let Some((id, _, _)) = *tcx.sess.entry_fn.borrow() {
- worklist.push(id);
- }
+ -> Vec<ast::NodeId>
+{
+ let worklist = access_levels.map.iter().map(|(&id, _)| id).chain(
+ // Seed entry point
+ tcx.sess.entry_fn.borrow().map(|(id, _, _)| id)
+ ).collect::<Vec<_>>();
// Seed implemented trait items
let mut life_seeder = LifeSeeder {
}
self.visit_nested_body(body_id)
}
+ hir::ImplItemKind::Existential(..) |
hir::ImplItemKind::Type(..) => {}
}
}
}
}
}
+ hir::ImplItemKind::Existential(..) |
hir::ImplItemKind::Type(_) => false,
}
}
self.visit_nested_body(body)
}
}
+ hir::ImplItemKind::Existential(..) |
hir::ImplItemKind::Type(_) => {}
}
}
}
hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) => {
if let Def::Existential(exist_ty_did) = path.def {
+ let id = self.tcx.hir.as_local_node_id(exist_ty_did).unwrap();
+
+ // Resolve the lifetimes in the bounds to the lifetime defs in the generics.
+ // `fn foo<'a>() -> impl MyTrait<'a> { ... }` desugars to
+ // `abstract type MyAnonTy<'b>: MyTrait<'b>;`
+ // ^ ^ this gets resolved in the scope of
+ // the exist_ty generics
+ let (generics, bounds) = match self.tcx.hir.expect_item(id).node {
+ // named existential types don't need these hacks
+ hir::ItemKind::Existential(hir::ExistTy{ impl_trait_fn: None, .. }) => {
+ intravisit::walk_ty(self, ty);
+ return;
+ },
+ hir::ItemKind::Existential(hir::ExistTy{
+ ref generics,
+ ref bounds,
+ ..
+ }) => (
+ generics,
+ bounds,
+ ),
+ ref i => bug!("impl Trait pointed to non-existential type?? {:#?}", i),
+ };
+
assert!(exist_ty_did.is_local());
// Resolve the lifetimes that are applied to the existential type.
// These are resolved in the current scope.
}
}
- let id = self.tcx.hir.as_local_node_id(exist_ty_did).unwrap();
-
- // Resolve the lifetimes in the bounds to the lifetime defs in the generics.
- // `fn foo<'a>() -> impl MyTrait<'a> { ... }` desugars to
- // `abstract type MyAnonTy<'b>: MyTrait<'b>;`
- // ^ ^ this gets resolved in the scope of
- // the exist_ty generics
- let (generics, bounds) = match self.tcx.hir.expect_item(id).node {
- hir::ItemKind::Existential(
- hir::ExistTy { ref generics, ref bounds, .. }
- ) => (
- generics,
- bounds,
- ),
- ref i => bug!("impl Trait pointed to non-existential type?? {:#?}", i),
- };
-
// We want to start our early-bound indices at the end of the parent scope,
// not including any parent `impl Trait`s.
let mut index = self.next_early_index_for_abstract_type();
this.visit_ty(ty);
});
}
+ Existential(ref bounds) => {
+ let generics = &impl_item.generics;
+ let mut index = self.next_early_index();
+ let mut next_early_index = index;
+ debug!("visit_ty: index = {}", index);
+ let lifetimes = generics.params.iter().filter_map(|param| match param.kind {
+ GenericParamKind::Lifetime { .. } => {
+ Some(Region::early(&self.tcx.hir, &mut index, param))
+ }
+ GenericParamKind::Type { .. } => {
+ next_early_index += 1;
+ None
+ }
+ }).collect();
+
+ let scope = Scope::Binder {
+ lifetimes,
+ next_early_index,
+ s: self.scope,
+ track_lifetime_uses: true,
+ abstract_type_parent: true,
+ };
+ self.with(scope, |_old_scope, this| {
+ this.visit_generics(generics);
+ for bound in bounds {
+ this.visit_param_bound(bound);
+ }
+ });
+ }
Const(_, _) => {
// Only methods and types support generics.
assert!(impl_item.generics.params.is_empty());
hir::ItemKind::Struct(_, ref generics)
| hir::ItemKind::Union(_, ref generics)
| hir::ItemKind::Enum(_, ref generics)
+ | hir::ItemKind::Existential(hir::ExistTy { ref generics, impl_trait_fn: None, .. })
| hir::ItemKind::Ty(_, ref generics)
| hir::ItemKind::Trait(_, _, ref generics, ..) => {
let result = object_lifetime_defaults_for_item(tcx, generics);
///////////////////////////////////////////////////////////////////////////
// Some sample folders
-pub struct BottomUpFolder<'a, 'gcx: 'a+'tcx, 'tcx: 'a, F>
- where F: FnMut(Ty<'tcx>) -> Ty<'tcx>
+pub struct BottomUpFolder<'a, 'gcx: 'a+'tcx, 'tcx: 'a, F, G>
+ where F: FnMut(Ty<'tcx>) -> Ty<'tcx>,
+ G: FnMut(ty::Region<'tcx>) -> ty::Region<'tcx>,
{
pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
pub fldop: F,
+ pub reg_op: G,
}
-impl<'a, 'gcx, 'tcx, F> TypeFolder<'gcx, 'tcx> for BottomUpFolder<'a, 'gcx, 'tcx, F>
+impl<'a, 'gcx, 'tcx, F, G> TypeFolder<'gcx, 'tcx> for BottomUpFolder<'a, 'gcx, 'tcx, F, G>
where F: FnMut(Ty<'tcx>) -> Ty<'tcx>,
+ G: FnMut(ty::Region<'tcx>) -> ty::Region<'tcx>,
{
fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
let t1 = ty.super_fold_with(self);
(self.fldop)(t1)
}
+
+ fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
+ let r = r.super_fold_with(self);
+ (self.reg_op)(r)
+ }
}
///////////////////////////////////////////////////////////////////////////
data @ DefPathData::Trait(..) |
data @ DefPathData::AssocTypeInTrait(..) |
data @ DefPathData::AssocTypeInImpl(..) |
+ data @ DefPathData::AssocExistentialInImpl(..) |
data @ DefPathData::ValueNs(..) |
data @ DefPathData::Module(..) |
data @ DefPathData::TypeParam(..) |
pub enum AssociatedKind {
Const,
Method,
+ Existential,
Type
}
AssociatedKind::Const => Def::AssociatedConst(self.def_id),
AssociatedKind::Method => Def::Method(self.def_id),
AssociatedKind::Type => Def::AssociatedTy(self.def_id),
+ AssociatedKind::Existential => Def::AssociatedExistential(self.def_id),
}
}
/// for !
pub fn relevant_for_never<'tcx>(&self) -> bool {
match self.kind {
- AssociatedKind::Const => true,
+ AssociatedKind::Existential |
+ AssociatedKind::Const |
AssociatedKind::Type => true,
// FIXME(canndrew): Be more thorough here, check if any argument is uninhabited.
AssociatedKind::Method => !self.method_has_self_argument,
format!("{}", tcx.fn_sig(self.def_id).skip_binder())
}
ty::AssociatedKind::Type => format!("type {};", self.ident),
+ ty::AssociatedKind::Existential => format!("existential type {};", self.ident),
ty::AssociatedKind::Const => {
format!("const {}: {:?};", self.ident, tcx.type_of(self.def_id))
}
(ty::AssociatedKind::Method, has_self)
}
hir::AssociatedItemKind::Type => (ty::AssociatedKind::Type, false),
+ hir::AssociatedItemKind::Existential => bug!("only impls can have existentials"),
};
AssociatedItem {
(ty::AssociatedKind::Method, has_self)
}
hir::AssociatedItemKind::Type => (ty::AssociatedKind::Type, false),
+ hir::AssociatedItemKind::Existential => (ty::AssociatedKind::Existential, false),
};
AssociatedItem {
})
}
+/// Yields the parent function's `DefId` if `def_id` is an `impl Trait` definition
+pub fn is_impl_trait_defn(tcx: TyCtxt, def_id: DefId) -> Option<DefId> {
+ if let Some(node_id) = tcx.hir.as_local_node_id(def_id) {
+ if let hir::map::NodeItem(item) = tcx.hir.get(node_id) {
+ if let hir::ItemKind::Existential(ref exist_ty) = item.node {
+ return exist_ty.impl_trait_fn;
+ }
+ }
+ }
+ None
+}
+
/// See `ParamEnv` struct def'n for details.
fn param_env<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
-> ParamEnv<'tcx> {
- // The param_env of an existential type is its parent's param_env
- if let Some(Def::Existential(_)) = tcx.describe_def(def_id) {
- let parent = tcx.parent_def_id(def_id).expect("impl trait item w/o a parent");
+ // The param_env of an impl Trait type is its defining function's param_env
+ if let Some(parent) = is_impl_trait_defn(tcx, def_id) {
return param_env(tcx, parent);
}
// Compute the bounds on Self and the type parameters.
// Queries marked with `fatal_cycle` do not need the latter implementation,
// as they will raise an fatal error on query cycles instead.
define_queries! { <'tcx>
- /// Records the type of every item.
- [] fn type_of: TypeOfItem(DefId) -> Ty<'tcx>,
-
- /// Maps from the def-id of an item (trait/struct/enum/fn) to its
- /// associated generics.
- [] fn generics_of: GenericsOfItem(DefId) -> &'tcx ty::Generics,
-
- /// Maps from the def-id of an item (trait/struct/enum/fn) to the
- /// predicates (where clauses) that must be proven true in order
- /// to reference it. This is almost always the "predicates query"
- /// that you want.
- ///
- /// `predicates_of` builds on `predicates_defined_on` -- in fact,
- /// it is almost always the same as that query, except for the
- /// case of traits. For traits, `predicates_of` contains
- /// an additional `Self: Trait<...>` predicate that users don't
- /// actually write. This reflects the fact that to invoke the
- /// trait (e.g., via `Default::default`) you must supply types
- /// that actually implement the trait. (However, this extra
- /// predicate gets in the way of some checks, which are intended
- /// to operate over only the actual where-clauses written by the
- /// user.)
- [] fn predicates_of: PredicatesOfItem(DefId) -> ty::GenericPredicates<'tcx>,
-
- /// Maps from the def-id of an item (trait/struct/enum/fn) to the
- /// predicates (where clauses) directly defined on it. This is
- /// equal to the `explicit_predicates_of` predicates plus the
- /// `inferred_outlives_of` predicates.
- [] fn predicates_defined_on: PredicatesDefinedOnItem(DefId) -> ty::GenericPredicates<'tcx>,
-
- /// Returns the predicates written explicit by the user.
- [] fn explicit_predicates_of: ExplicitPredicatesOfItem(DefId) -> ty::GenericPredicates<'tcx>,
-
- /// Returns the inferred outlives predicates (e.g., for `struct
- /// Foo<'a, T> { x: &'a T }`, this would return `T: 'a`).
- [] fn inferred_outlives_of: InferredOutlivesOf(DefId) -> Lrc<Vec<ty::Predicate<'tcx>>>,
-
- /// Maps from the def-id of a trait to the list of
- /// super-predicates. This is a subset of the full list of
- /// predicates. We store these in a separate map because we must
- /// evaluate them even during type conversion, often before the
- /// full predicates are available (note that supertraits have
- /// additional acyclicity requirements).
- [] fn super_predicates_of: SuperPredicatesOfItem(DefId) -> ty::GenericPredicates<'tcx>,
-
- /// To avoid cycles within the predicates of a single item we compute
- /// per-type-parameter predicates for resolving `T::AssocTy`.
- [] fn type_param_predicates: type_param_predicates((DefId, DefId))
- -> ty::GenericPredicates<'tcx>,
-
- [] fn trait_def: TraitDefOfItem(DefId) -> &'tcx ty::TraitDef,
- [] fn adt_def: AdtDefOfItem(DefId) -> &'tcx ty::AdtDef,
- [] fn adt_destructor: AdtDestructor(DefId) -> Option<ty::Destructor>,
- [] fn adt_sized_constraint: SizedConstraint(DefId) -> &'tcx [Ty<'tcx>],
- [] fn adt_dtorck_constraint: DtorckConstraint(
- DefId
- ) -> Result<DtorckConstraint<'tcx>, NoSolution>,
-
- /// True if this is a const fn
- [] fn is_const_fn: IsConstFn(DefId) -> bool,
-
- /// True if this is a foreign item (i.e., linked via `extern { ... }`).
- [] fn is_foreign_item: IsForeignItem(DefId) -> bool,
-
- /// Get a map with the variance of every item; use `item_variance`
- /// instead.
- [] fn crate_variances: crate_variances(CrateNum) -> Lrc<ty::CrateVariancesMap>,
-
- /// Maps from def-id of a type or region parameter to its
- /// (inferred) variance.
- [] fn variances_of: ItemVariances(DefId) -> Lrc<Vec<ty::Variance>>,
-
- /// Maps from def-id of a type to its (inferred) outlives.
- [] fn inferred_outlives_crate: InferredOutlivesCrate(CrateNum)
- -> Lrc<ty::CratePredicatesMap<'tcx>>,
-
- /// Maps from an impl/trait def-id to a list of the def-ids of its items
- [] fn associated_item_def_ids: AssociatedItemDefIds(DefId) -> Lrc<Vec<DefId>>,
-
- /// Maps from a trait item to the trait item "descriptor"
- [] fn associated_item: AssociatedItems(DefId) -> ty::AssociatedItem,
-
- [] fn impl_trait_ref: ImplTraitRef(DefId) -> Option<ty::TraitRef<'tcx>>,
- [] fn impl_polarity: ImplPolarity(DefId) -> hir::ImplPolarity,
-
- /// Maps a DefId of a type to a list of its inherent impls.
- /// Contains implementations of methods that are inherent to a type.
- /// Methods in these implementations don't need to be exported.
- [] fn inherent_impls: InherentImpls(DefId) -> Lrc<Vec<DefId>>,
-
- /// Set of all the def-ids in this crate that have MIR associated with
- /// them. This includes all the body owners, but also things like struct
- /// constructors.
- [] fn mir_keys: mir_keys(CrateNum) -> Lrc<DefIdSet>,
-
- /// Maps DefId's that have an associated Mir to the result
- /// of the MIR qualify_consts pass. The actual meaning of
- /// the value isn't known except to the pass itself.
- [] fn mir_const_qualif: MirConstQualif(DefId) -> (u8, Lrc<IdxSetBuf<mir::Local>>),
-
- /// Fetch the MIR for a given def-id right after it's built - this includes
- /// unreachable code.
- [] fn mir_built: MirBuilt(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
-
- /// Fetch the MIR for a given def-id up till the point where it is
- /// ready for const evaluation.
- ///
- /// See the README for the `mir` module for details.
- [] fn mir_const: MirConst(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
-
- [] fn mir_validated: MirValidated(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
-
- /// MIR after our optimization passes have run. This is MIR that is ready
- /// for codegen. This is also the only query that can fetch non-local MIR, at present.
- [] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>,
-
- /// The result of unsafety-checking this def-id.
- [] fn unsafety_check_result: UnsafetyCheckResult(DefId) -> mir::UnsafetyCheckResult,
-
- /// HACK: when evaluated, this reports a "unsafe derive on repr(packed)" error
- [] fn unsafe_derive_on_repr_packed: UnsafeDeriveOnReprPacked(DefId) -> (),
-
- /// The signature of functions and closures.
- [] fn fn_sig: FnSignature(DefId) -> ty::PolyFnSig<'tcx>,
-
- /// Caches CoerceUnsized kinds for impls on custom types.
- [] fn coerce_unsized_info: CoerceUnsizedInfo(DefId)
- -> ty::adjustment::CoerceUnsizedInfo,
-
- [] fn typeck_item_bodies: typeck_item_bodies_dep_node(CrateNum) -> CompileResult,
-
- [] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>,
-
- [] fn used_trait_imports: UsedTraitImports(DefId) -> Lrc<DefIdSet>,
-
- [] fn has_typeck_tables: HasTypeckTables(DefId) -> bool,
-
- [] fn coherent_trait: CoherenceCheckTrait(DefId) -> (),
-
- [] fn borrowck: BorrowCheck(DefId) -> Lrc<BorrowCheckResult>,
-
- /// Borrow checks the function body. If this is a closure, returns
- /// additional requirements that the closure's creator must verify.
- [] fn mir_borrowck: MirBorrowCheck(DefId) -> mir::BorrowCheckResult<'tcx>,
-
- /// Gets a complete map from all types to their inherent impls.
- /// Not meant to be used directly outside of coherence.
- /// (Defined only for LOCAL_CRATE)
- [] fn crate_inherent_impls: crate_inherent_impls_dep_node(CrateNum) -> CrateInherentImpls,
-
- /// Checks all types in the krate for overlap in their inherent impls. Reports errors.
- /// Not meant to be used directly outside of coherence.
- /// (Defined only for LOCAL_CRATE)
- [] fn crate_inherent_impls_overlap_check: inherent_impls_overlap_check_dep_node(CrateNum) -> (),
-
- /// Results of evaluating const items or constants embedded in
- /// other items (such as enum variant explicit discriminants).
- [] fn const_eval: const_eval_dep_node(ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
- -> ConstEvalResult<'tcx>,
-
- /// Converts a constant value to an constant allocation
- [] fn const_value_to_allocation: const_value_to_allocation(
- &'tcx ty::Const<'tcx>
- ) -> &'tcx Allocation,
-
- [] fn check_match: CheckMatch(DefId)
- -> Result<(), ErrorReported>,
-
- /// Performs the privacy check and computes "access levels".
- [] fn privacy_access_levels: PrivacyAccessLevels(CrateNum) -> Lrc<AccessLevels>,
-
- [] fn reachable_set: reachability_dep_node(CrateNum) -> ReachableSet,
-
- /// Per-body `region::ScopeTree`. The `DefId` should be the owner-def-id for the body;
- /// in the case of closures, this will be redirected to the enclosing function.
- [] fn region_scope_tree: RegionScopeTree(DefId) -> Lrc<region::ScopeTree>,
-
- [] fn mir_shims: mir_shim_dep_node(ty::InstanceDef<'tcx>) -> &'tcx mir::Mir<'tcx>,
-
- [] fn def_symbol_name: SymbolName(DefId) -> ty::SymbolName,
- [] fn symbol_name: symbol_name_dep_node(ty::Instance<'tcx>) -> ty::SymbolName,
-
- [] fn describe_def: DescribeDef(DefId) -> Option<Def>,
- [] fn def_span: DefSpan(DefId) -> Span,
- [] fn lookup_stability: LookupStability(DefId) -> Option<&'tcx attr::Stability>,
- [] fn lookup_deprecation_entry: LookupDeprecationEntry(DefId) -> Option<DeprecationEntry>,
- [] fn item_attrs: ItemAttrs(DefId) -> Lrc<[ast::Attribute]>,
- [] fn codegen_fn_attrs: codegen_fn_attrs(DefId) -> CodegenFnAttrs,
- [] fn fn_arg_names: FnArgNames(DefId) -> Vec<ast::Name>,
- /// Gets the rendered value of the specified constant or associated constant.
- /// Used by rustdoc.
- [] fn rendered_const: RenderedConst(DefId) -> String,
- [] fn impl_parent: ImplParent(DefId) -> Option<DefId>,
- [] fn trait_of_item: TraitOfItem(DefId) -> Option<DefId>,
- [] fn const_is_rvalue_promotable_to_static: ConstIsRvaluePromotableToStatic(DefId) -> bool,
- [] fn rvalue_promotable_map: RvaluePromotableMap(DefId) -> Lrc<ItemLocalSet>,
- [] fn is_mir_available: IsMirAvailable(DefId) -> bool,
- [] fn vtable_methods: vtable_methods_node(ty::PolyTraitRef<'tcx>)
- -> Lrc<Vec<Option<(DefId, &'tcx Substs<'tcx>)>>>,
-
- [] fn codegen_fulfill_obligation: fulfill_obligation_dep_node(
- (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>)) -> Vtable<'tcx, ()>,
- [] fn trait_impls_of: TraitImpls(DefId) -> Lrc<ty::trait_def::TraitImpls>,
- [] fn specialization_graph_of: SpecializationGraph(DefId) -> Lrc<specialization_graph::Graph>,
- [] fn is_object_safe: ObjectSafety(DefId) -> bool,
-
- // Get the ParameterEnvironment for a given item; this environment
- // will be in "user-facing" mode, meaning that it is suitabe for
- // type-checking etc, and it does not normalize specializable
- // associated types. This is almost always what you want,
- // unless you are doing MIR optimizations, in which case you
- // might want to use `reveal_all()` method to change modes.
- [] fn param_env: ParamEnv(DefId) -> ty::ParamEnv<'tcx>,
-
- // Trait selection queries. These are best used by invoking `ty.moves_by_default()`,
- // `ty.is_copy()`, etc, since that will prune the environment where possible.
- [] fn is_copy_raw: is_copy_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
- [] fn is_sized_raw: is_sized_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
- [] fn is_freeze_raw: is_freeze_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
- [] fn needs_drop_raw: needs_drop_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
- [] fn layout_raw: layout_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>)
- -> Result<&'tcx ty::layout::LayoutDetails,
- ty::layout::LayoutError<'tcx>>,
-
- [] fn dylib_dependency_formats: DylibDepFormats(CrateNum)
- -> Lrc<Vec<(CrateNum, LinkagePreference)>>,
-
- [fatal_cycle] fn is_panic_runtime: IsPanicRuntime(CrateNum) -> bool,
- [fatal_cycle] fn is_compiler_builtins: IsCompilerBuiltins(CrateNum) -> bool,
- [fatal_cycle] fn has_global_allocator: HasGlobalAllocator(CrateNum) -> bool,
- [fatal_cycle] fn is_sanitizer_runtime: IsSanitizerRuntime(CrateNum) -> bool,
- [fatal_cycle] fn is_profiler_runtime: IsProfilerRuntime(CrateNum) -> bool,
- [fatal_cycle] fn panic_strategy: GetPanicStrategy(CrateNum) -> PanicStrategy,
- [fatal_cycle] fn is_no_builtins: IsNoBuiltins(CrateNum) -> bool,
-
- [] fn extern_crate: ExternCrate(DefId) -> Lrc<Option<ExternCrate>>,
-
- [] fn specializes: specializes_node((DefId, DefId)) -> bool,
- [] fn in_scope_traits_map: InScopeTraits(DefIndex)
- -> Option<Lrc<FxHashMap<ItemLocalId, Lrc<StableVec<TraitCandidate>>>>>,
- [] fn module_exports: ModuleExports(DefId) -> Option<Lrc<Vec<Export>>>,
- [] fn lint_levels: lint_levels_node(CrateNum) -> Lrc<lint::LintLevelMap>,
-
- [] fn impl_defaultness: ImplDefaultness(DefId) -> hir::Defaultness,
-
- [] fn check_item_well_formed: CheckItemWellFormed(DefId) -> (),
- [] fn check_trait_item_well_formed: CheckTraitItemWellFormed(DefId) -> (),
- [] fn check_impl_item_well_formed: CheckImplItemWellFormed(DefId) -> (),
-
- // The DefIds of all non-generic functions and statics in the given crate
- // that can be reached from outside the crate.
- //
- // We expect this items to be available for being linked to.
- //
- // This query can also be called for LOCAL_CRATE. In this case it will
- // compute which items will be reachable to other crates, taking into account
- // the kind of crate that is currently compiled. Crates with only a
- // C interface have fewer reachable things.
- //
- // Does not include external symbols that don't have a corresponding DefId,
- // like the compiler-generated `main` function and so on.
- [] fn reachable_non_generics: ReachableNonGenerics(CrateNum)
- -> Lrc<DefIdMap<SymbolExportLevel>>,
- [] fn is_reachable_non_generic: IsReachableNonGeneric(DefId) -> bool,
- [] fn is_unreachable_local_definition: IsUnreachableLocalDefinition(DefId) -> bool,
-
- [] fn upstream_monomorphizations: UpstreamMonomorphizations(CrateNum)
- -> Lrc<DefIdMap<Lrc<FxHashMap<&'tcx Substs<'tcx>, CrateNum>>>>,
- [] fn upstream_monomorphizations_for: UpstreamMonomorphizationsFor(DefId)
- -> Option<Lrc<FxHashMap<&'tcx Substs<'tcx>, CrateNum>>>,
-
- [] fn native_libraries: NativeLibraries(CrateNum) -> Lrc<Vec<NativeLibrary>>,
-
- [] fn foreign_modules: ForeignModules(CrateNum) -> Lrc<Vec<ForeignModule>>,
-
- [] fn plugin_registrar_fn: PluginRegistrarFn(CrateNum) -> Option<DefId>,
- [] fn derive_registrar_fn: DeriveRegistrarFn(CrateNum) -> Option<DefId>,
- [] fn crate_disambiguator: CrateDisambiguator(CrateNum) -> CrateDisambiguator,
- [] fn crate_hash: CrateHash(CrateNum) -> Svh,
- [] fn original_crate_name: OriginalCrateName(CrateNum) -> Symbol,
- [] fn extra_filename: ExtraFileName(CrateNum) -> String,
-
- [] fn implementations_of_trait: implementations_of_trait_node((CrateNum, DefId))
- -> Lrc<Vec<DefId>>,
- [] fn all_trait_implementations: AllTraitImplementations(CrateNum)
- -> Lrc<Vec<DefId>>,
-
- [] fn dllimport_foreign_items: DllimportForeignItems(CrateNum)
- -> Lrc<FxHashSet<DefId>>,
- [] fn is_dllimport_foreign_item: IsDllimportForeignItem(DefId) -> bool,
- [] fn is_statically_included_foreign_item: IsStaticallyIncludedForeignItem(DefId) -> bool,
- [] fn native_library_kind: NativeLibraryKind(DefId)
- -> Option<NativeLibraryKind>,
- [] fn link_args: link_args_node(CrateNum) -> Lrc<Vec<String>>,
-
- // Lifetime resolution. See `middle::resolve_lifetimes`.
- [] fn resolve_lifetimes: ResolveLifetimes(CrateNum) -> Lrc<ResolveLifetimes>,
- [] fn named_region_map: NamedRegion(DefIndex) ->
- Option<Lrc<FxHashMap<ItemLocalId, Region>>>,
- [] fn is_late_bound_map: IsLateBound(DefIndex) ->
- Option<Lrc<FxHashSet<ItemLocalId>>>,
- [] fn object_lifetime_defaults_map: ObjectLifetimeDefaults(DefIndex)
- -> Option<Lrc<FxHashMap<ItemLocalId, Lrc<Vec<ObjectLifetimeDefault>>>>>,
-
- [] fn visibility: Visibility(DefId) -> ty::Visibility,
- [] fn dep_kind: DepKind(CrateNum) -> DepKind,
- [] fn crate_name: CrateName(CrateNum) -> Symbol,
- [] fn item_children: ItemChildren(DefId) -> Lrc<Vec<Export>>,
- [] fn extern_mod_stmt_cnum: ExternModStmtCnum(DefId) -> Option<CrateNum>,
-
- [] fn get_lang_items: get_lang_items_node(CrateNum) -> Lrc<LanguageItems>,
- [] fn defined_lang_items: DefinedLangItems(CrateNum) -> Lrc<Vec<(DefId, usize)>>,
- [] fn missing_lang_items: MissingLangItems(CrateNum) -> Lrc<Vec<LangItem>>,
- [] fn visible_parent_map: visible_parent_map_node(CrateNum)
- -> Lrc<DefIdMap<DefId>>,
- [] fn missing_extern_crate_item: MissingExternCrateItem(CrateNum) -> bool,
- [] fn used_crate_source: UsedCrateSource(CrateNum) -> Lrc<CrateSource>,
- [] fn postorder_cnums: postorder_cnums_node(CrateNum) -> Lrc<Vec<CrateNum>>,
-
- [] fn freevars: Freevars(DefId) -> Option<Lrc<Vec<hir::Freevar>>>,
- [] fn maybe_unused_trait_import: MaybeUnusedTraitImport(DefId) -> bool,
- [] fn maybe_unused_extern_crates: maybe_unused_extern_crates_node(CrateNum)
- -> Lrc<Vec<(DefId, Span)>>,
-
- [] fn stability_index: stability_index_node(CrateNum) -> Lrc<stability::Index<'tcx>>,
- [] fn all_crate_nums: all_crate_nums_node(CrateNum) -> Lrc<Vec<CrateNum>>,
-
- /// A vector of every trait accessible in the whole crate
- /// (i.e. including those from subcrates). This is used only for
- /// error reporting.
- [] fn all_traits: all_traits_node(CrateNum) -> Lrc<Vec<DefId>>,
-
- [] fn exported_symbols: ExportedSymbols(CrateNum)
- -> Arc<Vec<(ExportedSymbol<'tcx>, SymbolExportLevel)>>,
- [] fn collect_and_partition_mono_items:
- collect_and_partition_mono_items_node(CrateNum)
- -> (Arc<DefIdSet>, Arc<Vec<Arc<CodegenUnit<'tcx>>>>),
- [] fn is_codegened_item: IsCodegenedItem(DefId) -> bool,
- [] fn codegen_unit: CodegenUnit(InternedString) -> Arc<CodegenUnit<'tcx>>,
- [] fn compile_codegen_unit: CompileCodegenUnit(InternedString) -> Stats,
- [] fn output_filenames: output_filenames_node(CrateNum)
- -> Arc<OutputFilenames>,
-
- // Erases regions from `ty` to yield a new type.
- // Normally you would just use `tcx.erase_regions(&value)`,
- // however, which uses this query as a kind of cache.
- [] fn erase_regions_ty: erase_regions_ty(Ty<'tcx>) -> Ty<'tcx>,
-
- /// Do not call this query directly: invoke `normalize` instead.
- [] fn normalize_projection_ty: NormalizeProjectionTy(
- CanonicalProjectionGoal<'tcx>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, NormalizationResult<'tcx>>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: invoke `normalize_erasing_regions` instead.
- [] fn normalize_ty_after_erasing_regions: NormalizeTyAfterErasingRegions(
- ParamEnvAnd<'tcx, Ty<'tcx>>
- ) -> Ty<'tcx>,
-
- /// Do not call this query directly: invoke `infcx.at().dropck_outlives()` instead.
- [] fn dropck_outlives: DropckOutlives(
- CanonicalTyGoal<'tcx>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, DropckOutlivesResult<'tcx>>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: invoke `infcx.predicate_may_hold()` or
- /// `infcx.predicate_must_hold()` instead.
- [] fn evaluate_obligation: EvaluateObligation(
- CanonicalPredicateGoal<'tcx>
- ) -> Result<traits::EvaluationResult, traits::OverflowError>,
-
- /// Do not call this query directly: part of the `Eq` type-op
- [] fn type_op_eq: TypeOpEq(
- CanonicalTypeOpEqGoal<'tcx>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ()>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: part of the `Subtype` type-op
- [] fn type_op_subtype: TypeOpSubtype(
- CanonicalTypeOpSubtypeGoal<'tcx>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ()>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: part of the `ProvePredicate` type-op
- [] fn type_op_prove_predicate: TypeOpProvePredicate(
- CanonicalTypeOpProvePredicateGoal<'tcx>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ()>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: part of the `Normalize` type-op
- [] fn type_op_normalize_ty: TypeOpNormalizeTy(
- CanonicalTypeOpNormalizeGoal<'tcx, Ty<'tcx>>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, Ty<'tcx>>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: part of the `Normalize` type-op
- [] fn type_op_normalize_predicate: TypeOpNormalizePredicate(
- CanonicalTypeOpNormalizeGoal<'tcx, ty::Predicate<'tcx>>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ty::Predicate<'tcx>>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: part of the `Normalize` type-op
- [] fn type_op_normalize_poly_fn_sig: TypeOpNormalizePolyFnSig(
- CanonicalTypeOpNormalizeGoal<'tcx, ty::PolyFnSig<'tcx>>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ty::PolyFnSig<'tcx>>>>,
- NoSolution,
- >,
-
- /// Do not call this query directly: part of the `Normalize` type-op
- [] fn type_op_normalize_fn_sig: TypeOpNormalizeFnSig(
- CanonicalTypeOpNormalizeGoal<'tcx, ty::FnSig<'tcx>>
- ) -> Result<
- Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ty::FnSig<'tcx>>>>,
- NoSolution,
- >,
-
- [] fn substitute_normalize_and_test_predicates:
- substitute_normalize_and_test_predicates_node((DefId, &'tcx Substs<'tcx>)) -> bool,
-
- [] fn target_features_whitelist:
- target_features_whitelist_node(CrateNum) -> Lrc<FxHashMap<String, Option<String>>>,
-
- // Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning.
- [] fn instance_def_size_estimate: instance_def_size_estimate_dep_node(ty::InstanceDef<'tcx>)
- -> usize,
-
- [] fn features_query: features_node(CrateNum) -> Lrc<feature_gate::Features>,
-
- [] fn program_clauses_for: ProgramClausesFor(DefId) -> Clauses<'tcx>,
-
- [] fn program_clauses_for_env: ProgramClausesForEnv(
- ty::ParamEnv<'tcx>
- ) -> Clauses<'tcx>,
-
- [] fn wasm_import_module_map: WasmImportModuleMap(CrateNum)
- -> Lrc<FxHashMap<DefId, String>>,
+ Other {
+ /// Records the type of every item.
+ [] fn type_of: TypeOfItem(DefId) -> Ty<'tcx>,
+
+ /// Maps from the def-id of an item (trait/struct/enum/fn) to its
+ /// associated generics.
+ [] fn generics_of: GenericsOfItem(DefId) -> &'tcx ty::Generics,
+
+ /// Maps from the def-id of an item (trait/struct/enum/fn) to the
+ /// predicates (where clauses) that must be proven true in order
+ /// to reference it. This is almost always the "predicates query"
+ /// that you want.
+ ///
+ /// `predicates_of` builds on `predicates_defined_on` -- in fact,
+ /// it is almost always the same as that query, except for the
+ /// case of traits. For traits, `predicates_of` contains
+ /// an additional `Self: Trait<...>` predicate that users don't
+ /// actually write. This reflects the fact that to invoke the
+ /// trait (e.g., via `Default::default`) you must supply types
+ /// that actually implement the trait. (However, this extra
+ /// predicate gets in the way of some checks, which are intended
+ /// to operate over only the actual where-clauses written by the
+ /// user.)
+ [] fn predicates_of: PredicatesOfItem(DefId) -> ty::GenericPredicates<'tcx>,
+
+ /// Maps from the def-id of an item (trait/struct/enum/fn) to the
+ /// predicates (where clauses) directly defined on it. This is
+ /// equal to the `explicit_predicates_of` predicates plus the
+ /// `inferred_outlives_of` predicates.
+ [] fn predicates_defined_on: PredicatesDefinedOnItem(DefId) -> ty::GenericPredicates<'tcx>,
+
+ /// Returns the predicates written explicit by the user.
+ [] fn explicit_predicates_of: ExplicitPredicatesOfItem(DefId)
+ -> ty::GenericPredicates<'tcx>,
+
+ /// Returns the inferred outlives predicates (e.g., for `struct
+ /// Foo<'a, T> { x: &'a T }`, this would return `T: 'a`).
+ [] fn inferred_outlives_of: InferredOutlivesOf(DefId) -> Lrc<Vec<ty::Predicate<'tcx>>>,
+
+ /// Maps from the def-id of a trait to the list of
+ /// super-predicates. This is a subset of the full list of
+ /// predicates. We store these in a separate map because we must
+ /// evaluate them even during type conversion, often before the
+ /// full predicates are available (note that supertraits have
+ /// additional acyclicity requirements).
+ [] fn super_predicates_of: SuperPredicatesOfItem(DefId) -> ty::GenericPredicates<'tcx>,
+
+ /// To avoid cycles within the predicates of a single item we compute
+ /// per-type-parameter predicates for resolving `T::AssocTy`.
+ [] fn type_param_predicates: type_param_predicates((DefId, DefId))
+ -> ty::GenericPredicates<'tcx>,
+
+ [] fn trait_def: TraitDefOfItem(DefId) -> &'tcx ty::TraitDef,
+ [] fn adt_def: AdtDefOfItem(DefId) -> &'tcx ty::AdtDef,
+ [] fn adt_destructor: AdtDestructor(DefId) -> Option<ty::Destructor>,
+ [] fn adt_sized_constraint: SizedConstraint(DefId) -> &'tcx [Ty<'tcx>],
+ [] fn adt_dtorck_constraint: DtorckConstraint(
+ DefId
+ ) -> Result<DtorckConstraint<'tcx>, NoSolution>,
+
+ /// True if this is a const fn
+ [] fn is_const_fn: IsConstFn(DefId) -> bool,
+
+ /// True if this is a foreign item (i.e., linked via `extern { ... }`).
+ [] fn is_foreign_item: IsForeignItem(DefId) -> bool,
+
+ /// Get a map with the variance of every item; use `item_variance`
+ /// instead.
+ [] fn crate_variances: crate_variances(CrateNum) -> Lrc<ty::CrateVariancesMap>,
+
+ /// Maps from def-id of a type or region parameter to its
+ /// (inferred) variance.
+ [] fn variances_of: ItemVariances(DefId) -> Lrc<Vec<ty::Variance>>,
+ },
+
+ TypeChecking {
+ /// Maps from def-id of a type to its (inferred) outlives.
+ [] fn inferred_outlives_crate: InferredOutlivesCrate(CrateNum)
+ -> Lrc<ty::CratePredicatesMap<'tcx>>,
+ },
+
+ Other {
+ /// Maps from an impl/trait def-id to a list of the def-ids of its items
+ [] fn associated_item_def_ids: AssociatedItemDefIds(DefId) -> Lrc<Vec<DefId>>,
+
+ /// Maps from a trait item to the trait item "descriptor"
+ [] fn associated_item: AssociatedItems(DefId) -> ty::AssociatedItem,
+
+ [] fn impl_trait_ref: ImplTraitRef(DefId) -> Option<ty::TraitRef<'tcx>>,
+ [] fn impl_polarity: ImplPolarity(DefId) -> hir::ImplPolarity,
+ },
+
+ TypeChecking {
+ /// Maps a DefId of a type to a list of its inherent impls.
+ /// Contains implementations of methods that are inherent to a type.
+ /// Methods in these implementations don't need to be exported.
+ [] fn inherent_impls: InherentImpls(DefId) -> Lrc<Vec<DefId>>,
+ },
+
+ Codegen {
+ /// Set of all the def-ids in this crate that have MIR associated with
+ /// them. This includes all the body owners, but also things like struct
+ /// constructors.
+ [] fn mir_keys: mir_keys(CrateNum) -> Lrc<DefIdSet>,
+
+ /// Maps DefId's that have an associated Mir to the result
+ /// of the MIR qualify_consts pass. The actual meaning of
+ /// the value isn't known except to the pass itself.
+ [] fn mir_const_qualif: MirConstQualif(DefId) -> (u8, Lrc<IdxSetBuf<mir::Local>>),
+
+ /// Fetch the MIR for a given def-id right after it's built - this includes
+ /// unreachable code.
+ [] fn mir_built: MirBuilt(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
+
+ /// Fetch the MIR for a given def-id up till the point where it is
+ /// ready for const evaluation.
+ ///
+ /// See the README for the `mir` module for details.
+ [] fn mir_const: MirConst(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
+
+ [] fn mir_validated: MirValidated(DefId) -> &'tcx Steal<mir::Mir<'tcx>>,
+
+ /// MIR after our optimization passes have run. This is MIR that is ready
+ /// for codegen. This is also the only query that can fetch non-local MIR, at present.
+ [] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>,
+ },
+
+ TypeChecking {
+ /// The result of unsafety-checking this def-id.
+ [] fn unsafety_check_result: UnsafetyCheckResult(DefId) -> mir::UnsafetyCheckResult,
+
+ /// HACK: when evaluated, this reports a "unsafe derive on repr(packed)" error
+ [] fn unsafe_derive_on_repr_packed: UnsafeDeriveOnReprPacked(DefId) -> (),
+
+ /// The signature of functions and closures.
+ [] fn fn_sig: FnSignature(DefId) -> ty::PolyFnSig<'tcx>,
+ },
+
+ Other {
+ /// Caches CoerceUnsized kinds for impls on custom types.
+ [] fn coerce_unsized_info: CoerceUnsizedInfo(DefId)
+ -> ty::adjustment::CoerceUnsizedInfo,
+ },
+
+ TypeChecking {
+ [] fn typeck_item_bodies: typeck_item_bodies_dep_node(CrateNum) -> CompileResult,
+
+ [] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>,
+ },
+
+ Other {
+ [] fn used_trait_imports: UsedTraitImports(DefId) -> Lrc<DefIdSet>,
+ },
+
+ TypeChecking {
+ [] fn has_typeck_tables: HasTypeckTables(DefId) -> bool,
+
+ [] fn coherent_trait: CoherenceCheckTrait(DefId) -> (),
+ },
+
+ BorrowChecking {
+ [] fn borrowck: BorrowCheck(DefId) -> Lrc<BorrowCheckResult>,
+
+ /// Borrow checks the function body. If this is a closure, returns
+ /// additional requirements that the closure's creator must verify.
+ [] fn mir_borrowck: MirBorrowCheck(DefId) -> mir::BorrowCheckResult<'tcx>,
+ },
+
+ TypeChecking {
+ /// Gets a complete map from all types to their inherent impls.
+ /// Not meant to be used directly outside of coherence.
+ /// (Defined only for LOCAL_CRATE)
+ [] fn crate_inherent_impls: crate_inherent_impls_dep_node(CrateNum) -> CrateInherentImpls,
+
+ /// Checks all types in the krate for overlap in their inherent impls. Reports errors.
+ /// Not meant to be used directly outside of coherence.
+ /// (Defined only for LOCAL_CRATE)
+ [] fn crate_inherent_impls_overlap_check: inherent_impls_overlap_check_dep_node(CrateNum)
+ -> (),
+ },
+
+ Other {
+ /// Results of evaluating const items or constants embedded in
+ /// other items (such as enum variant explicit discriminants).
+ [] fn const_eval: const_eval_dep_node(ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
+ -> ConstEvalResult<'tcx>,
+
+ /// Converts a constant value to an constant allocation
+ [] fn const_value_to_allocation: const_value_to_allocation(
+ &'tcx ty::Const<'tcx>
+ ) -> &'tcx Allocation,
+ },
+
+ TypeChecking {
+ [] fn check_match: CheckMatch(DefId)
+ -> Result<(), ErrorReported>,
+
+ /// Performs the privacy check and computes "access levels".
+ [] fn privacy_access_levels: PrivacyAccessLevels(CrateNum) -> Lrc<AccessLevels>,
+ },
+
+ Other {
+ [] fn reachable_set: reachability_dep_node(CrateNum) -> ReachableSet,
+
+ /// Per-body `region::ScopeTree`. The `DefId` should be the owner-def-id for the body;
+ /// in the case of closures, this will be redirected to the enclosing function.
+ [] fn region_scope_tree: RegionScopeTree(DefId) -> Lrc<region::ScopeTree>,
+
+ [] fn mir_shims: mir_shim_dep_node(ty::InstanceDef<'tcx>) -> &'tcx mir::Mir<'tcx>,
+
+ [] fn def_symbol_name: SymbolName(DefId) -> ty::SymbolName,
+ [] fn symbol_name: symbol_name_dep_node(ty::Instance<'tcx>) -> ty::SymbolName,
+
+ [] fn describe_def: DescribeDef(DefId) -> Option<Def>,
+ [] fn def_span: DefSpan(DefId) -> Span,
+ [] fn lookup_stability: LookupStability(DefId) -> Option<&'tcx attr::Stability>,
+ [] fn lookup_deprecation_entry: LookupDeprecationEntry(DefId) -> Option<DeprecationEntry>,
+ [] fn item_attrs: ItemAttrs(DefId) -> Lrc<[ast::Attribute]>,
+ },
+
+ Codegen {
+ [] fn codegen_fn_attrs: codegen_fn_attrs(DefId) -> CodegenFnAttrs,
+ },
+
+ Other {
+ [] fn fn_arg_names: FnArgNames(DefId) -> Vec<ast::Name>,
+ /// Gets the rendered value of the specified constant or associated constant.
+ /// Used by rustdoc.
+ [] fn rendered_const: RenderedConst(DefId) -> String,
+ [] fn impl_parent: ImplParent(DefId) -> Option<DefId>,
+ },
+
+ TypeChecking {
+ [] fn trait_of_item: TraitOfItem(DefId) -> Option<DefId>,
+ [] fn const_is_rvalue_promotable_to_static: ConstIsRvaluePromotableToStatic(DefId) -> bool,
+ [] fn rvalue_promotable_map: RvaluePromotableMap(DefId) -> Lrc<ItemLocalSet>,
+ },
+
+ Codegen {
+ [] fn is_mir_available: IsMirAvailable(DefId) -> bool,
+ },
+
+ Other {
+ [] fn vtable_methods: vtable_methods_node(ty::PolyTraitRef<'tcx>)
+ -> Lrc<Vec<Option<(DefId, &'tcx Substs<'tcx>)>>>,
+ },
+
+ Codegen {
+ [] fn codegen_fulfill_obligation: fulfill_obligation_dep_node(
+ (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>)) -> Vtable<'tcx, ()>,
+ },
+
+ TypeChecking {
+ [] fn trait_impls_of: TraitImpls(DefId) -> Lrc<ty::trait_def::TraitImpls>,
+ [] fn specialization_graph_of: SpecializationGraph(DefId)
+ -> Lrc<specialization_graph::Graph>,
+ [] fn is_object_safe: ObjectSafety(DefId) -> bool,
+
+ // Get the ParameterEnvironment for a given item; this environment
+ // will be in "user-facing" mode, meaning that it is suitabe for
+ // type-checking etc, and it does not normalize specializable
+ // associated types. This is almost always what you want,
+ // unless you are doing MIR optimizations, in which case you
+ // might want to use `reveal_all()` method to change modes.
+ [] fn param_env: ParamEnv(DefId) -> ty::ParamEnv<'tcx>,
+
+ // Trait selection queries. These are best used by invoking `ty.moves_by_default()`,
+ // `ty.is_copy()`, etc, since that will prune the environment where possible.
+ [] fn is_copy_raw: is_copy_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
+ [] fn is_sized_raw: is_sized_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
+ [] fn is_freeze_raw: is_freeze_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
+ [] fn needs_drop_raw: needs_drop_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool,
+ [] fn layout_raw: layout_dep_node(ty::ParamEnvAnd<'tcx, Ty<'tcx>>)
+ -> Result<&'tcx ty::layout::LayoutDetails,
+ ty::layout::LayoutError<'tcx>>,
+ },
+
+ Other {
+ [] fn dylib_dependency_formats: DylibDepFormats(CrateNum)
+ -> Lrc<Vec<(CrateNum, LinkagePreference)>>,
+ },
+
+ Codegen {
+ [fatal_cycle] fn is_panic_runtime: IsPanicRuntime(CrateNum) -> bool,
+ [fatal_cycle] fn is_compiler_builtins: IsCompilerBuiltins(CrateNum) -> bool,
+ [fatal_cycle] fn has_global_allocator: HasGlobalAllocator(CrateNum) -> bool,
+ [fatal_cycle] fn is_sanitizer_runtime: IsSanitizerRuntime(CrateNum) -> bool,
+ [fatal_cycle] fn is_profiler_runtime: IsProfilerRuntime(CrateNum) -> bool,
+ [fatal_cycle] fn panic_strategy: GetPanicStrategy(CrateNum) -> PanicStrategy,
+ [fatal_cycle] fn is_no_builtins: IsNoBuiltins(CrateNum) -> bool,
+
+ [] fn extern_crate: ExternCrate(DefId) -> Lrc<Option<ExternCrate>>,
+ },
+
+ TypeChecking {
+ [] fn specializes: specializes_node((DefId, DefId)) -> bool,
+ [] fn in_scope_traits_map: InScopeTraits(DefIndex)
+ -> Option<Lrc<FxHashMap<ItemLocalId, Lrc<StableVec<TraitCandidate>>>>>,
+ },
+
+ Other {
+ [] fn module_exports: ModuleExports(DefId) -> Option<Lrc<Vec<Export>>>,
+ [] fn lint_levels: lint_levels_node(CrateNum) -> Lrc<lint::LintLevelMap>,
+ },
+
+ TypeChecking {
+ [] fn impl_defaultness: ImplDefaultness(DefId) -> hir::Defaultness,
+
+ [] fn check_item_well_formed: CheckItemWellFormed(DefId) -> (),
+ [] fn check_trait_item_well_formed: CheckTraitItemWellFormed(DefId) -> (),
+ [] fn check_impl_item_well_formed: CheckImplItemWellFormed(DefId) -> (),
+ },
+
+ Linking {
+ // The DefIds of all non-generic functions and statics in the given crate
+ // that can be reached from outside the crate.
+ //
+ // We expect this items to be available for being linked to.
+ //
+ // This query can also be called for LOCAL_CRATE. In this case it will
+ // compute which items will be reachable to other crates, taking into account
+ // the kind of crate that is currently compiled. Crates with only a
+ // C interface have fewer reachable things.
+ //
+ // Does not include external symbols that don't have a corresponding DefId,
+ // like the compiler-generated `main` function and so on.
+ [] fn reachable_non_generics: ReachableNonGenerics(CrateNum)
+ -> Lrc<DefIdMap<SymbolExportLevel>>,
+ [] fn is_reachable_non_generic: IsReachableNonGeneric(DefId) -> bool,
+ [] fn is_unreachable_local_definition: IsUnreachableLocalDefinition(DefId) -> bool,
+ },
+
+ Codegen {
+ [] fn upstream_monomorphizations: UpstreamMonomorphizations(CrateNum)
+ -> Lrc<DefIdMap<Lrc<FxHashMap<&'tcx Substs<'tcx>, CrateNum>>>>,
+ [] fn upstream_monomorphizations_for: UpstreamMonomorphizationsFor(DefId)
+ -> Option<Lrc<FxHashMap<&'tcx Substs<'tcx>, CrateNum>>>,
+ },
+
+ Other {
+ [] fn native_libraries: NativeLibraries(CrateNum) -> Lrc<Vec<NativeLibrary>>,
+
+ [] fn foreign_modules: ForeignModules(CrateNum) -> Lrc<Vec<ForeignModule>>,
+
+ [] fn plugin_registrar_fn: PluginRegistrarFn(CrateNum) -> Option<DefId>,
+ [] fn derive_registrar_fn: DeriveRegistrarFn(CrateNum) -> Option<DefId>,
+ [] fn crate_disambiguator: CrateDisambiguator(CrateNum) -> CrateDisambiguator,
+ [] fn crate_hash: CrateHash(CrateNum) -> Svh,
+ [] fn original_crate_name: OriginalCrateName(CrateNum) -> Symbol,
+ [] fn extra_filename: ExtraFileName(CrateNum) -> String,
+ },
+
+ TypeChecking {
+ [] fn implementations_of_trait: implementations_of_trait_node((CrateNum, DefId))
+ -> Lrc<Vec<DefId>>,
+ [] fn all_trait_implementations: AllTraitImplementations(CrateNum)
+ -> Lrc<Vec<DefId>>,
+ },
+
+ Other {
+ [] fn dllimport_foreign_items: DllimportForeignItems(CrateNum)
+ -> Lrc<FxHashSet<DefId>>,
+ [] fn is_dllimport_foreign_item: IsDllimportForeignItem(DefId) -> bool,
+ [] fn is_statically_included_foreign_item: IsStaticallyIncludedForeignItem(DefId) -> bool,
+ [] fn native_library_kind: NativeLibraryKind(DefId)
+ -> Option<NativeLibraryKind>,
+ },
+
+ Linking {
+ [] fn link_args: link_args_node(CrateNum) -> Lrc<Vec<String>>,
+ },
+
+ BorrowChecking {
+ // Lifetime resolution. See `middle::resolve_lifetimes`.
+ [] fn resolve_lifetimes: ResolveLifetimes(CrateNum) -> Lrc<ResolveLifetimes>,
+ [] fn named_region_map: NamedRegion(DefIndex) ->
+ Option<Lrc<FxHashMap<ItemLocalId, Region>>>,
+ [] fn is_late_bound_map: IsLateBound(DefIndex) ->
+ Option<Lrc<FxHashSet<ItemLocalId>>>,
+ [] fn object_lifetime_defaults_map: ObjectLifetimeDefaults(DefIndex)
+ -> Option<Lrc<FxHashMap<ItemLocalId, Lrc<Vec<ObjectLifetimeDefault>>>>>,
+ },
+
+ TypeChecking {
+ [] fn visibility: Visibility(DefId) -> ty::Visibility,
+ },
+
+ Other {
+ [] fn dep_kind: DepKind(CrateNum) -> DepKind,
+ [] fn crate_name: CrateName(CrateNum) -> Symbol,
+ [] fn item_children: ItemChildren(DefId) -> Lrc<Vec<Export>>,
+ [] fn extern_mod_stmt_cnum: ExternModStmtCnum(DefId) -> Option<CrateNum>,
+
+ [] fn get_lang_items: get_lang_items_node(CrateNum) -> Lrc<LanguageItems>,
+ [] fn defined_lang_items: DefinedLangItems(CrateNum) -> Lrc<Vec<(DefId, usize)>>,
+ [] fn missing_lang_items: MissingLangItems(CrateNum) -> Lrc<Vec<LangItem>>,
+ [] fn visible_parent_map: visible_parent_map_node(CrateNum)
+ -> Lrc<DefIdMap<DefId>>,
+ [] fn missing_extern_crate_item: MissingExternCrateItem(CrateNum) -> bool,
+ [] fn used_crate_source: UsedCrateSource(CrateNum) -> Lrc<CrateSource>,
+ [] fn postorder_cnums: postorder_cnums_node(CrateNum) -> Lrc<Vec<CrateNum>>,
+
+ [] fn freevars: Freevars(DefId) -> Option<Lrc<Vec<hir::Freevar>>>,
+ [] fn maybe_unused_trait_import: MaybeUnusedTraitImport(DefId) -> bool,
+ [] fn maybe_unused_extern_crates: maybe_unused_extern_crates_node(CrateNum)
+ -> Lrc<Vec<(DefId, Span)>>,
+
+ [] fn stability_index: stability_index_node(CrateNum) -> Lrc<stability::Index<'tcx>>,
+ [] fn all_crate_nums: all_crate_nums_node(CrateNum) -> Lrc<Vec<CrateNum>>,
+
+ /// A vector of every trait accessible in the whole crate
+ /// (i.e. including those from subcrates). This is used only for
+ /// error reporting.
+ [] fn all_traits: all_traits_node(CrateNum) -> Lrc<Vec<DefId>>,
+ },
+
+ Linking {
+ [] fn exported_symbols: ExportedSymbols(CrateNum)
+ -> Arc<Vec<(ExportedSymbol<'tcx>, SymbolExportLevel)>>,
+ },
+
+ Codegen {
+ [] fn collect_and_partition_mono_items:
+ collect_and_partition_mono_items_node(CrateNum)
+ -> (Arc<DefIdSet>, Arc<Vec<Arc<CodegenUnit<'tcx>>>>),
+ [] fn is_codegened_item: IsCodegenedItem(DefId) -> bool,
+ [] fn codegen_unit: CodegenUnit(InternedString) -> Arc<CodegenUnit<'tcx>>,
+ [] fn compile_codegen_unit: CompileCodegenUnit(InternedString) -> Stats,
+ },
+
+ Other {
+ [] fn output_filenames: output_filenames_node(CrateNum)
+ -> Arc<OutputFilenames>,
+ },
+
+ TypeChecking {
+ // Erases regions from `ty` to yield a new type.
+ // Normally you would just use `tcx.erase_regions(&value)`,
+ // however, which uses this query as a kind of cache.
+ [] fn erase_regions_ty: erase_regions_ty(Ty<'tcx>) -> Ty<'tcx>,
+
+ /// Do not call this query directly: invoke `normalize` instead.
+ [] fn normalize_projection_ty: NormalizeProjectionTy(
+ CanonicalProjectionGoal<'tcx>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, NormalizationResult<'tcx>>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: invoke `normalize_erasing_regions` instead.
+ [] fn normalize_ty_after_erasing_regions: NormalizeTyAfterErasingRegions(
+ ParamEnvAnd<'tcx, Ty<'tcx>>
+ ) -> Ty<'tcx>,
+
+ /// Do not call this query directly: invoke `infcx.at().dropck_outlives()` instead.
+ [] fn dropck_outlives: DropckOutlives(
+ CanonicalTyGoal<'tcx>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, DropckOutlivesResult<'tcx>>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: invoke `infcx.predicate_may_hold()` or
+ /// `infcx.predicate_must_hold()` instead.
+ [] fn evaluate_obligation: EvaluateObligation(
+ CanonicalPredicateGoal<'tcx>
+ ) -> Result<traits::EvaluationResult, traits::OverflowError>,
+
+ /// Do not call this query directly: part of the `Eq` type-op
+ [] fn type_op_eq: TypeOpEq(
+ CanonicalTypeOpEqGoal<'tcx>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ()>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: part of the `Subtype` type-op
+ [] fn type_op_subtype: TypeOpSubtype(
+ CanonicalTypeOpSubtypeGoal<'tcx>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ()>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: part of the `ProvePredicate` type-op
+ [] fn type_op_prove_predicate: TypeOpProvePredicate(
+ CanonicalTypeOpProvePredicateGoal<'tcx>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ()>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: part of the `Normalize` type-op
+ [] fn type_op_normalize_ty: TypeOpNormalizeTy(
+ CanonicalTypeOpNormalizeGoal<'tcx, Ty<'tcx>>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, Ty<'tcx>>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: part of the `Normalize` type-op
+ [] fn type_op_normalize_predicate: TypeOpNormalizePredicate(
+ CanonicalTypeOpNormalizeGoal<'tcx, ty::Predicate<'tcx>>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ty::Predicate<'tcx>>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: part of the `Normalize` type-op
+ [] fn type_op_normalize_poly_fn_sig: TypeOpNormalizePolyFnSig(
+ CanonicalTypeOpNormalizeGoal<'tcx, ty::PolyFnSig<'tcx>>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ty::PolyFnSig<'tcx>>>>,
+ NoSolution,
+ >,
+
+ /// Do not call this query directly: part of the `Normalize` type-op
+ [] fn type_op_normalize_fn_sig: TypeOpNormalizeFnSig(
+ CanonicalTypeOpNormalizeGoal<'tcx, ty::FnSig<'tcx>>
+ ) -> Result<
+ Lrc<Canonical<'tcx, canonical::QueryResult<'tcx, ty::FnSig<'tcx>>>>,
+ NoSolution,
+ >,
+
+ [] fn substitute_normalize_and_test_predicates:
+ substitute_normalize_and_test_predicates_node((DefId, &'tcx Substs<'tcx>)) -> bool,
+ },
+
+ Other {
+ [] fn target_features_whitelist:
+ target_features_whitelist_node(CrateNum) -> Lrc<FxHashMap<String, Option<String>>>,
+
+ // Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning.
+ [] fn instance_def_size_estimate: instance_def_size_estimate_dep_node(ty::InstanceDef<'tcx>)
+ -> usize,
+
+ [] fn features_query: features_node(CrateNum) -> Lrc<feature_gate::Features>,
+ },
+
+ TypeChecking {
+ [] fn program_clauses_for: ProgramClausesFor(DefId) -> Clauses<'tcx>,
+
+ [] fn program_clauses_for_env: ProgramClausesForEnv(
+ ty::ParamEnv<'tcx>
+ ) -> Clauses<'tcx>,
+ },
+
+ Linking {
+ [] fn wasm_import_module_map: WasmImportModuleMap(CrateNum)
+ -> Lrc<FxHashMap<DefId, String>>,
+ },
}
// `try_get_query` can't be public because it uses the private query
}
macro_rules! define_queries {
+ (<$tcx:tt> $($category:tt {
+ $($(#[$attr:meta])* [$($modifiers:tt)*] fn $name:ident: $node:ident($K:ty) -> $V:ty,)*
+ },)*) => {
+ define_queries_inner! { <$tcx>
+ $($( $(#[$attr])* category<$category> [$($modifiers)*] fn $name: $node($K) -> $V,)*)*
+ }
+ }
+}
+
+macro_rules! define_queries_inner {
(<$tcx:tt>
- $($(#[$attr:meta])*
- [$($modifiers:tt)*] fn $name:ident: $node:ident($K:ty) -> $V:ty,)*) => {
+ $($(#[$attr:meta])* category<$category:tt>
+ [$($modifiers:tt)*] fn $name:ident: $node:ident($K:ty) -> $V:ty,)*) => {
use std::mem;
#[cfg(parallel_queries)]
TyProjection(ProjectionTy<'tcx>),
/// Anonymized (`impl Trait`) type found in a return type.
- /// The DefId comes from the `impl Trait` ast::Ty node, and the
- /// substitutions are for the generics of the function in question.
+ /// The DefId comes either from
+ /// * the `impl Trait` ast::Ty node,
+ /// * or the `existential type` declaration
+ /// The substitutions are for the generics of the function in question.
/// After typeck, the concrete type can be found in the `types` map.
TyAnon(DefId, &'tcx Substs<'tcx>),
// types appearing in the fn signature
}
- ty::TyAnon(..) => {
+ ty::TyAnon(did, substs) => {
// all of the requirements on type parameters
// should've been checked by the instantiation
// of whatever returned this exact `impl Trait`.
+
+ // for named existential types we still need to check them
+ if super::is_impl_trait_defn(self.infcx.tcx, did).is_none() {
+ let obligations = self.nominal_obligations(did, substs);
+ self.out.extend(obligations);
+ }
}
ty::TyDynamic(data, r) => {
match key.disambiguated_data.data {
DefPathData::AssocTypeInTrait(_) |
DefPathData::AssocTypeInImpl(_) |
+ DefPathData::AssocExistentialInImpl(_) |
DefPathData::Trait(_) |
DefPathData::TypeNs(_) => {
break;
}
ty::tls::with(|tcx| {
+ let def_key = tcx.def_key(def_id);
+ if let Some(name) = def_key.disambiguated_data.data.get_opt_name() {
+ write!(f, "{}", name)?;
+ let mut substs = substs.iter();
+ if let Some(first) = substs.next() {
+ write!(f, "::<")?;
+ write!(f, "{}", first)?;
+ for subst in substs {
+ write!(f, ", {}", subst)?;
+ }
+ write!(f, ">")?;
+ }
+ return Ok(());
+ }
// Grab the "TraitA + TraitB" from `impl TraitA + TraitB`,
// by looking up the projections associated with the def_id.
let predicates_of = tcx.predicates_of(def_id);
}
fn llvm_type(&self, cx: &CodegenCx<'a, 'tcx>) -> Type {
- let mut llargument_tys = Vec::new();
+ let args_capacity: usize = self.args.iter().map(|arg|
+ if arg.pad.is_some() { 1 } else { 0 } +
+ if let PassMode::Pair(_, _) = arg.mode { 2 } else { 1 }
+ ).sum();
+ let mut llargument_tys = Vec::with_capacity(
+ if let PassMode::Indirect(_) = self.ret.mode { 1 } else { 0 } + args_capacity
+ );
let llreturn_ty = match self.ret.mode {
PassMode::Ignore => Type::void(cx),
pub fn provide_extern(providers: &mut Providers) {
providers.wasm_import_module_map = |tcx, cnum| {
+ // Build up a map from DefId to a `NativeLibrary` structure, where
+ // `NativeLibrary` internally contains information about
+ // `#[link(wasm_import_module = "...")]` for example.
+ let native_libs = tcx.native_libraries(cnum);
+ let mut def_id_to_native_lib = FxHashMap();
+ for lib in native_libs.iter() {
+ if let Some(id) = lib.foreign_module {
+ def_id_to_native_lib.insert(id, lib);
+ }
+ }
+
let mut ret = FxHashMap();
for lib in tcx.foreign_modules(cnum).iter() {
- let attrs = tcx.get_attrs(lib.def_id);
- let mut module = None;
- for attr in attrs.iter().filter(|a| a.check_name("wasm_import_module")) {
- module = attr.value_str();
- }
+ let module = def_id_to_native_lib
+ .get(&lib.def_id)
+ .and_then(|s| s.wasm_import_module);
let module = match module {
Some(s) => s,
None => continue,
}
Lrc::new(ret)
- }
+ };
}
fn wasm_import_module(tcx: TyCtxt, id: DefId) -> Option<CString> {
NativeLibraryKind::NativeFramework |
NativeLibraryKind::NativeUnknown => continue,
}
- ab.add_native_library(&lib.name.as_str());
+ if let Some(name) = lib.name {
+ ab.add_native_library(&name.as_str());
+ }
}
// After adding all files to the archive, we need to update the
fn print_native_static_libs(sess: &Session, all_native_libs: &[NativeLibrary]) {
let lib_args: Vec<_> = all_native_libs.iter()
.filter(|l| relevant_lib(sess, l))
- .filter_map(|lib| match lib.kind {
- NativeLibraryKind::NativeStaticNobundle |
- NativeLibraryKind::NativeUnknown => {
- if sess.target.target.options.is_like_msvc {
- Some(format!("{}.lib", lib.name))
- } else {
- Some(format!("-l{}", lib.name))
- }
- },
- NativeLibraryKind::NativeFramework => {
- // ld-only syntax, since there are no frameworks in MSVC
- Some(format!("-framework {}", lib.name))
- },
- // These are included, no need to print them
- NativeLibraryKind::NativeStatic => None,
+ .filter_map(|lib| {
+ let name = lib.name?;
+ match lib.kind {
+ NativeLibraryKind::NativeStaticNobundle |
+ NativeLibraryKind::NativeUnknown => {
+ if sess.target.target.options.is_like_msvc {
+ Some(format!("{}.lib", name))
+ } else {
+ Some(format!("-l{}", name))
+ }
+ },
+ NativeLibraryKind::NativeFramework => {
+ // ld-only syntax, since there are no frameworks in MSVC
+ Some(format!("-framework {}", name))
+ },
+ // These are included, no need to print them
+ NativeLibraryKind::NativeStatic => None,
+ }
})
.collect();
if !lib_args.is_empty() {
let search_path = archive_search_paths(sess);
for lib in relevant_libs {
+ let name = match lib.name {
+ Some(ref l) => l,
+ None => continue,
+ };
match lib.kind {
- NativeLibraryKind::NativeUnknown => cmd.link_dylib(&lib.name.as_str()),
- NativeLibraryKind::NativeFramework => cmd.link_framework(&lib.name.as_str()),
- NativeLibraryKind::NativeStaticNobundle => cmd.link_staticlib(&lib.name.as_str()),
- NativeLibraryKind::NativeStatic => cmd.link_whole_staticlib(&lib.name.as_str(),
+ NativeLibraryKind::NativeUnknown => cmd.link_dylib(&name.as_str()),
+ NativeLibraryKind::NativeFramework => cmd.link_framework(&name.as_str()),
+ NativeLibraryKind::NativeStaticNobundle => cmd.link_staticlib(&name.as_str()),
+ NativeLibraryKind::NativeStatic => cmd.link_whole_staticlib(&name.as_str(),
&search_path)
}
}
let crates = &codegen_results.crate_info.used_crates_static;
for &(cnum, _) in crates {
for lib in codegen_results.crate_info.native_libraries[&cnum].iter() {
+ let name = match lib.name {
+ Some(ref l) => l,
+ None => continue,
+ };
if !relevant_lib(sess, &lib) {
continue
}
match lib.kind {
- NativeLibraryKind::NativeUnknown => cmd.link_dylib(&lib.name.as_str()),
- NativeLibraryKind::NativeFramework => cmd.link_framework(&lib.name.as_str()),
+ NativeLibraryKind::NativeUnknown => cmd.link_dylib(&name.as_str()),
+ NativeLibraryKind::NativeFramework => cmd.link_framework(&name.as_str()),
NativeLibraryKind::NativeStaticNobundle => {
// Link "static-nobundle" native libs only if the crate they originate from
// is being linked statically to the current crate. If it's linked dynamically
// or is an rlib already included via some other dylib crate, the symbols from
// native libs will have already been included in that dylib.
if data[cnum.as_usize() - 1] == Linkage::Static {
- cmd.link_staticlib(&lib.name.as_str())
+ cmd.link_staticlib(&name.as_str())
}
},
// ignore statically included native libraries here as we've
cgcx.save_temp_bitcode(&module, "thin-lto-after-pm");
timeline.record("thin-done");
- // FIXME: this is a hack around a bug in LLVM right now. Discovered in
- // #46910 it was found out that on 32-bit MSVC LLVM will hit a codegen
- // error if there's an available_externally function in the LLVM module.
- // Typically we don't actually use these functions but ThinLTO makes
- // heavy use of them when inlining across modules.
- //
- // Tracked upstream at https://bugs.llvm.org/show_bug.cgi?id=35736 this
- // function call (and its definition on the C++ side of things)
- // shouldn't be necessary eventually and we can safetly delete these few
- // lines.
- llvm::LLVMRustThinLTORemoveAvailableExternally(llmod);
- cgcx.save_temp_bitcode(&module, "thin-lto-after-rm-ae");
- timeline.record("no-ae");
-
Ok(module)
}
}
///
/// This function is intended as a hack for now where we manually rewrite the
/// wasm output by LLVM to have the correct import modules listed. The
-/// `#[wasm_import_module]` attribute in Rust translates to the module that each
-/// symbol is imported from, so here we manually go through the wasm file,
-/// decode it, rewrite imports, and then rewrite the wasm module.
+/// `#[link(wasm_import_module = "...")]` attribute in Rust translates to the
+/// module that each symbol is imported from, so here we manually go through the
+/// wasm file, decode it, rewrite imports, and then rewrite the wasm module.
///
/// Support for this was added to LLVM in
/// https://github.com/llvm-mirror/llvm/commit/0f32e1365, although support still
use llvm;
use llvm::{AtomicRmwBinOp, AtomicOrdering, SynchronizationScope, AsmDialect};
use llvm::{Opcode, IntPredicate, RealPredicate, False, OperandBundleDef};
-use llvm::{ValueRef, BasicBlockRef, BuilderRef, ModuleRef};
+use llvm::{ValueRef, BasicBlockRef, BuilderRef};
use common::*;
use type_::Type;
use value::Value;
}
}
- pub fn trap(&self) {
- unsafe {
- let bb: BasicBlockRef = llvm::LLVMGetInsertBlock(self.llbuilder);
- let fn_: ValueRef = llvm::LLVMGetBasicBlockParent(bb);
- let m: ModuleRef = llvm::LLVMGetGlobalParent(fn_);
- let p = "llvm.trap\0".as_ptr();
- let t: ValueRef = llvm::LLVMGetNamedFunction(m, p as *const _);
- assert!((t as isize != 0));
- let args: &[ValueRef] = &[];
- self.count_insn("trap");
- llvm::LLVMRustBuildCall(self.llbuilder, t,
- args.as_ptr(), args.len() as c_uint,
- ptr::null_mut(),
- noname());
- }
- }
-
pub fn landing_pad(&self, ty: Type, pers_fn: ValueRef,
num_clauses: usize) -> ValueRef {
self.count_insn("landingpad");
use std::default::Default;
use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
use std::env;
+use std::error::Error;
use std::ffi::OsString;
+use std::fmt::{self, Display};
use std::io::{self, Read, Write};
use std::iter::repeat;
use std::mem;
}
}
+/// Exit status code used for successful compilation and help output.
+pub const EXIT_SUCCESS: isize = 0;
+
+/// Exit status code used for compilation failures and invalid flags.
+pub const EXIT_FAILURE: isize = 1;
+
const BUG_REPORT_URL: &'static str = "https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.\
md#bug-reports";
pub fn run<F>(run_compiler: F) -> isize
where F: FnOnce() -> (CompileResult, Option<Session>) + Send + 'static
{
- monitor(move || {
+ let result = monitor(move || {
let (result, session) = run_compiler();
if let Err(CompileIncomplete::Errored(_)) = result {
match session {
}
}
});
- 0
+
+ match result {
+ Ok(()) => EXIT_SUCCESS,
+ Err(_) => EXIT_FAILURE,
+ }
}
fn load_backend_from_dylib(path: &Path) -> fn() -> Box<dyn CodegenBackend> {
}
}
+#[derive(Debug)]
+pub struct CompilationFailure;
+
+impl Error for CompilationFailure {}
+
+impl Display for CompilationFailure {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "compilation had errors")
+ }
+}
+
/// Run a procedure which will detect panics in the compiler and print nicer
/// error messages rather than just failing the test.
///
/// The diagnostic emitter yielded to the procedure should be used for reporting
/// errors of the compiler.
-pub fn monitor<F: FnOnce() + Send + 'static>(f: F) {
- let result = in_rustc_thread(move || {
+pub fn monitor<F: FnOnce() + Send + 'static>(f: F) -> Result<(), CompilationFailure> {
+ in_rustc_thread(move || {
f()
- });
-
- if let Err(value) = result {
- // Thread panicked without emitting a fatal diagnostic
- if !value.is::<errors::FatalErrorMarker>() {
- // Emit a newline
+ }).map_err(|value| {
+ if value.is::<errors::FatalErrorMarker>() {
+ CompilationFailure
+ } else {
+ // Thread panicked without emitting a fatal diagnostic
eprintln!("");
let emitter =
¬e,
errors::Level::Note);
}
- }
- panic::resume_unwind(Box::new(errors::FatalErrorMarker));
- }
+ panic::resume_unwind(Box::new(errors::FatalErrorMarker));
+ }
+ })
}
pub fn diagnostics_registry() -> errors::registry::Registry {
ImplItemKind::Method(..) => ("NodeImplItem", LABELS_FN_IN_IMPL),
ImplItemKind::Const(..) => ("NodeImplConst", LABELS_CONST_IN_IMPL),
ImplItemKind::Type(..) => ("NodeImplType", LABELS_CONST_IN_IMPL),
+ ImplItemKind::Existential(..) => ("NodeImplType", LABELS_CONST_IN_IMPL),
}
},
_ => self.tcx.sess.span_fatal(
hir::ImplItemKind::Const(..) => "an associated constant",
hir::ImplItemKind::Method(..) => "a method",
hir::ImplItemKind::Type(_) => "an associated type",
+ hir::ImplItemKind::Existential(_) => "an associated existential type",
};
self.check_missing_docs_attrs(cx,
Some(impl_item.id),
CU1: *mut *mut c_void,
CU2: *mut *mut c_void);
pub fn LLVMRustThinLTOPatchDICompileUnit(M: ModuleRef, CU: *mut c_void);
- pub fn LLVMRustThinLTORemoveAvailableExternally(M: ModuleRef);
pub fn LLVMRustLinkerNew(M: ModuleRef) -> LinkerRef;
pub fn LLVMRustLinkerAdd(linker: LinkerRef,
EntryKind::Type => Def::TyAlias(did),
EntryKind::Existential => Def::Existential(did),
EntryKind::AssociatedType(_) => Def::AssociatedTy(did),
+ EntryKind::AssociatedExistential(_) => Def::AssociatedExistential(did),
EntryKind::Mod(_) => Def::Mod(did),
EntryKind::Variant(_) => Def::Variant(did),
EntryKind::Trait(_) => Def::Trait(did),
}))
}
ty::AssociatedKind::Type => EntryKind::AssociatedType(container),
+ ty::AssociatedKind::Existential =>
+ span_bug!(ast_item.span, "existential type in trait"),
};
Entry {
None
}
}
+ ty::AssociatedKind::Existential => unreachable!(),
},
inherent_impls: LazySeq::empty(),
variances: if trait_item.kind == ty::AssociatedKind::Method {
has_self: impl_item.method_has_self_argument,
}))
}
+ ty::AssociatedKind::Existential => EntryKind::AssociatedExistential(container),
ty::AssociatedKind::Type => EntryKind::AssociatedType(container)
};
let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir;
needs_inline || is_const_fn || always_encode_mir
},
+ hir::ImplItemKind::Existential(..) |
hir::ImplItemKind::Type(..) => false,
};
Some(item) => item,
None => continue,
};
- let kind = items.iter().find(|k| {
- k.check_name("kind")
- }).and_then(|a| a.value_str()).map(Symbol::as_str);
- let kind = match kind.as_ref().map(|s| &s[..]) {
- Some("static") => cstore::NativeStatic,
- Some("static-nobundle") => cstore::NativeStaticNobundle,
- Some("dylib") => cstore::NativeUnknown,
- Some("framework") => cstore::NativeFramework,
- Some(k) => {
- struct_span_err!(self.tcx.sess, m.span, E0458,
- "unknown kind: `{}`", k)
- .span_label(m.span, "unknown kind").emit();
- cstore::NativeUnknown
- }
- None => cstore::NativeUnknown
- };
- let n = items.iter().find(|n| {
- n.check_name("name")
- }).and_then(|a| a.value_str());
- let n = match n {
- Some(n) => n,
- None => {
- struct_span_err!(self.tcx.sess, m.span, E0459,
- "#[link(...)] specified without `name = \"foo\"`")
- .span_label(m.span, "missing `name` argument").emit();
- Symbol::intern("foo")
- }
+ let mut lib = NativeLibrary {
+ name: None,
+ kind: cstore::NativeUnknown,
+ cfg: None,
+ foreign_module: Some(self.tcx.hir.local_def_id(it.id)),
+ wasm_import_module: None,
};
- let cfg = items.iter().find(|k| {
- k.check_name("cfg")
- }).and_then(|a| a.meta_item_list());
- let cfg = if let Some(list) = cfg {
- if list.is_empty() {
- self.tcx.sess.span_err(m.span(), "`cfg()` must have an argument");
- return;
- } else if let cfg @ Some(..) = list[0].meta_item() {
- cfg.cloned()
+ let mut kind_specified = false;
+
+ for item in items.iter() {
+ if item.check_name("kind") {
+ kind_specified = true;
+ let kind = match item.value_str() {
+ Some(name) => name,
+ None => continue, // skip like historical compilers
+ };
+ lib.kind = match &kind.as_str()[..] {
+ "static" => cstore::NativeStatic,
+ "static-nobundle" => cstore::NativeStaticNobundle,
+ "dylib" => cstore::NativeUnknown,
+ "framework" => cstore::NativeFramework,
+ k => {
+ struct_span_err!(self.tcx.sess, m.span, E0458,
+ "unknown kind: `{}`", k)
+ .span_label(item.span, "unknown kind").emit();
+ cstore::NativeUnknown
+ }
+ };
+ } else if item.check_name("name") {
+ lib.name = item.value_str();
+ } else if item.check_name("cfg") {
+ let cfg = match item.meta_item_list() {
+ Some(list) => list,
+ None => continue, // skip like historical compilers
+ };
+ if cfg.is_empty() {
+ self.tcx.sess.span_err(
+ item.span(),
+ "`cfg()` must have an argument",
+ );
+ } else if let cfg @ Some(..) = cfg[0].meta_item() {
+ lib.cfg = cfg.cloned();
+ } else {
+ self.tcx.sess.span_err(cfg[0].span(), "invalid argument for `cfg(..)`");
+ }
+ } else if item.check_name("wasm_import_module") {
+ match item.value_str() {
+ Some(s) => lib.wasm_import_module = Some(s),
+ None => {
+ let msg = "must be of the form #[link(wasm_import_module = \"...\")]";
+ self.tcx.sess.span_err(item.span(), msg);
+ }
+ }
} else {
- self.tcx.sess.span_err(list[0].span(), "invalid argument for `cfg(..)`");
- return;
+ // currently, like past compilers, ignore unknown
+ // directives here.
}
- } else {
- None
- };
- let lib = NativeLibrary {
- name: n,
- kind,
- cfg,
- foreign_module: Some(self.tcx.hir.local_def_id(it.id)),
- };
+ }
+
+ // In general we require #[link(name = "...")] but we allow
+ // #[link(wasm_import_module = "...")] without the `name`.
+ let requires_name = kind_specified || lib.wasm_import_module.is_none();
+ if lib.name.is_none() && requires_name {
+ struct_span_err!(self.tcx.sess, m.span, E0459,
+ "#[link(...)] specified without \
+ `name = \"foo\"`")
+ .span_label(m.span, "missing `name` argument")
+ .emit();
+ }
self.register_native_lib(Some(m.span), lib);
}
}
impl<'a, 'tcx> Collector<'a, 'tcx> {
fn register_native_lib(&mut self, span: Option<Span>, lib: NativeLibrary) {
- if lib.name.as_str().is_empty() {
+ if lib.name.as_ref().map(|s| s.as_str().is_empty()).unwrap_or(false) {
match span {
Some(span) => {
struct_span_err!(self.tcx.sess, span, E0454,
let mut renames = FxHashSet();
for &(ref name, ref new_name, _) in &self.tcx.sess.opts.libs {
if let &Some(ref new_name) = new_name {
+ let any_duplicate = self.libs
+ .iter()
+ .filter_map(|lib| lib.name.as_ref())
+ .any(|n| n == name);
if new_name.is_empty() {
self.tcx.sess.err(
&format!("an empty renaming target was specified for library `{}`",name));
- } else if !self.libs.iter().any(|lib| lib.name == name as &str) {
+ } else if !any_duplicate {
self.tcx.sess.err(&format!("renaming of the library `{}` was specified, \
however this crate contains no #[link(...)] \
attributes referencing this library.", name));
for &(ref name, ref new_name, kind) in &self.tcx.sess.opts.libs {
let mut found = false;
for lib in self.libs.iter_mut() {
- if lib.name == name as &str {
+ let lib_name = match lib.name {
+ Some(n) => n,
+ None => continue,
+ };
+ if lib_name == name as &str {
let mut changed = false;
if let Some(k) = kind {
lib.kind = k;
changed = true;
}
if let &Some(ref new_name) = new_name {
- lib.name = Symbol::intern(new_name);
+ lib.name = Some(Symbol::intern(new_name));
changed = true;
}
if !changed {
// Add if not found
let new_name = new_name.as_ref().map(|s| &**s); // &Option<String> -> Option<&str>
let lib = NativeLibrary {
- name: Symbol::intern(new_name.unwrap_or(name)),
+ name: Some(Symbol::intern(new_name.unwrap_or(name))),
kind: if let Some(k) = kind { k } else { cstore::NativeUnknown },
cfg: None,
foreign_module: None,
+ wasm_import_module: None,
};
self.register_native_lib(None, lib);
}
Impl(Lazy<ImplData<'tcx>>),
Method(Lazy<MethodData<'tcx>>),
AssociatedType(AssociatedContainer),
+ AssociatedExistential(AssociatedContainer),
AssociatedConst(AssociatedContainer, ConstQualif, Lazy<RenderedConst>),
}
EntryKind::Method(ref method_data) => {
method_data.hash_stable(hcx, hasher);
}
+ EntryKind::AssociatedExistential(associated_container) |
EntryKind::AssociatedType(associated_container) => {
associated_container.hash_stable(hcx, hasher);
}
-use rustc::ty::Ty;
-use rustc::ty::layout::LayoutOf;
+use rustc::ty::{self, Ty};
+use rustc::ty::layout::{self, LayoutOf};
use syntax::ast::{FloatTy, IntTy, UintTy};
use rustc_apfloat::ieee::{Single, Double};
use super::{EvalContext, Machine};
-use rustc::mir::interpret::{Scalar, EvalResult, Pointer, PointerArithmetic};
+use rustc::mir::interpret::{Scalar, EvalResult, Pointer, PointerArithmetic, Value, EvalErrorKind};
+use rustc::mir::CastKind;
use rustc_apfloat::Float;
+use interpret::eval_context::ValTy;
+use interpret::Place;
impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
+ crate fn cast(
+ &mut self,
+ src: ValTy<'tcx>,
+ kind: CastKind,
+ dest_ty: Ty<'tcx>,
+ dest: Place,
+ ) -> EvalResult<'tcx> {
+ use rustc::mir::CastKind::*;
+ match kind {
+ Unsize => {
+ let src_layout = self.layout_of(src.ty)?;
+ let dst_layout = self.layout_of(dest_ty)?;
+ self.unsize_into(src.value, src_layout, dest, dst_layout)?;
+ }
+
+ Misc => {
+ if self.type_is_fat_ptr(src.ty) {
+ match (src.value, self.type_is_fat_ptr(dest_ty)) {
+ (Value::ByRef { .. }, _) |
+ // pointers to extern types
+ (Value::Scalar(_),_) |
+ // slices and trait objects to other slices/trait objects
+ (Value::ScalarPair(..), true) => {
+ let valty = ValTy {
+ value: src.value,
+ ty: dest_ty,
+ };
+ self.write_value(valty, dest)?;
+ }
+ // slices and trait objects to thin pointers (dropping the metadata)
+ (Value::ScalarPair(data, _), false) => {
+ let valty = ValTy {
+ value: Value::Scalar(data),
+ ty: dest_ty,
+ };
+ self.write_value(valty, dest)?;
+ }
+ }
+ } else {
+ let src_layout = self.layout_of(src.ty)?;
+ match src_layout.variants {
+ layout::Variants::Single { index } => {
+ if let Some(def) = src.ty.ty_adt_def() {
+ let discr_val = def
+ .discriminant_for_variant(*self.tcx, index)
+ .val;
+ let defined = self
+ .layout_of(dest_ty)
+ .unwrap()
+ .size
+ .bits() as u8;
+ return self.write_scalar(
+ dest,
+ Scalar::Bits {
+ bits: discr_val,
+ defined,
+ },
+ dest_ty);
+ }
+ }
+ layout::Variants::Tagged { .. } |
+ layout::Variants::NicheFilling { .. } => {},
+ }
+
+ let src_val = self.value_to_scalar(src)?;
+ let dest_val = self.cast_scalar(src_val, src.ty, dest_ty)?;
+ let valty = ValTy {
+ value: Value::Scalar(dest_val),
+ ty: dest_ty,
+ };
+ self.write_value(valty, dest)?;
+ }
+ }
+
+ ReifyFnPointer => {
+ match src.ty.sty {
+ ty::TyFnDef(def_id, substs) => {
+ if self.tcx.has_attr(def_id, "rustc_args_required_const") {
+ bug!("reifying a fn ptr that requires \
+ const arguments");
+ }
+ let instance: EvalResult<'tcx, _> = ty::Instance::resolve(
+ *self.tcx,
+ self.param_env,
+ def_id,
+ substs,
+ ).ok_or_else(|| EvalErrorKind::TooGeneric.into());
+ let fn_ptr = self.memory.create_fn_alloc(instance?);
+ let valty = ValTy {
+ value: Value::Scalar(fn_ptr.into()),
+ ty: dest_ty,
+ };
+ self.write_value(valty, dest)?;
+ }
+ ref other => bug!("reify fn pointer on {:?}", other),
+ }
+ }
+
+ UnsafeFnPointer => {
+ match dest_ty.sty {
+ ty::TyFnPtr(_) => {
+ let mut src = src;
+ src.ty = dest_ty;
+ self.write_value(src, dest)?;
+ }
+ ref other => bug!("fn to unsafe fn cast on {:?}", other),
+ }
+ }
+
+ ClosureFnPointer => {
+ match src.ty.sty {
+ ty::TyClosure(def_id, substs) => {
+ let substs = self.tcx.subst_and_normalize_erasing_regions(
+ self.substs(),
+ ty::ParamEnv::reveal_all(),
+ &substs,
+ );
+ let instance = ty::Instance::resolve_closure(
+ *self.tcx,
+ def_id,
+ substs,
+ ty::ClosureKind::FnOnce,
+ );
+ let fn_ptr = self.memory.create_fn_alloc(instance);
+ let valty = ValTy {
+ value: Value::Scalar(fn_ptr.into()),
+ ty: dest_ty,
+ };
+ self.write_value(valty, dest)?;
+ }
+ ref other => bug!("closure fn pointer on {:?}", other),
+ }
+ }
+ }
+ Ok(())
+ }
+
pub(super) fn cast_scalar(
&self,
val: Scalar,
Cast(kind, ref operand, cast_ty) => {
debug_assert_eq!(self.monomorphize(cast_ty, self.substs()), dest_ty);
- use rustc::mir::CastKind::*;
- match kind {
- Unsize => {
- let src = self.eval_operand(operand)?;
- let src_layout = self.layout_of(src.ty)?;
- let dst_layout = self.layout_of(dest_ty)?;
- self.unsize_into(src.value, src_layout, dest, dst_layout)?;
- }
-
- Misc => {
- let src = self.eval_operand(operand)?;
- if self.type_is_fat_ptr(src.ty) {
- match (src.value, self.type_is_fat_ptr(dest_ty)) {
- (Value::ByRef { .. }, _) |
- // pointers to extern types
- (Value::Scalar(_),_) |
- // slices and trait objects to other slices/trait objects
- (Value::ScalarPair(..), true) => {
- let valty = ValTy {
- value: src.value,
- ty: dest_ty,
- };
- self.write_value(valty, dest)?;
- }
- // slices and trait objects to thin pointers (dropping the metadata)
- (Value::ScalarPair(data, _), false) => {
- let valty = ValTy {
- value: Value::Scalar(data),
- ty: dest_ty,
- };
- self.write_value(valty, dest)?;
- }
- }
- } else {
- let src_layout = self.layout_of(src.ty)?;
- match src_layout.variants {
- layout::Variants::Single { index } => {
- if let Some(def) = src.ty.ty_adt_def() {
- let discr_val = def
- .discriminant_for_variant(*self.tcx, index)
- .val;
- let defined = self
- .layout_of(dest_ty)
- .unwrap()
- .size
- .bits() as u8;
- return self.write_scalar(
- dest,
- Scalar::Bits {
- bits: discr_val,
- defined,
- },
- dest_ty);
- }
- }
- layout::Variants::Tagged { .. } |
- layout::Variants::NicheFilling { .. } => {},
- }
-
- let src_val = self.value_to_scalar(src)?;
- let dest_val = self.cast_scalar(src_val, src.ty, dest_ty)?;
- let valty = ValTy {
- value: Value::Scalar(dest_val),
- ty: dest_ty,
- };
- self.write_value(valty, dest)?;
- }
- }
-
- ReifyFnPointer => {
- match self.eval_operand(operand)?.ty.sty {
- ty::TyFnDef(def_id, substs) => {
- if self.tcx.has_attr(def_id, "rustc_args_required_const") {
- bug!("reifying a fn ptr that requires \
- const arguments");
- }
- let instance: EvalResult<'tcx, _> = ty::Instance::resolve(
- *self.tcx,
- self.param_env,
- def_id,
- substs,
- ).ok_or_else(|| EvalErrorKind::TooGeneric.into());
- let fn_ptr = self.memory.create_fn_alloc(instance?);
- let valty = ValTy {
- value: Value::Scalar(fn_ptr.into()),
- ty: dest_ty,
- };
- self.write_value(valty, dest)?;
- }
- ref other => bug!("reify fn pointer on {:?}", other),
- }
- }
-
- UnsafeFnPointer => {
- match dest_ty.sty {
- ty::TyFnPtr(_) => {
- let mut src = self.eval_operand(operand)?;
- src.ty = dest_ty;
- self.write_value(src, dest)?;
- }
- ref other => bug!("fn to unsafe fn cast on {:?}", other),
- }
- }
-
- ClosureFnPointer => {
- match self.eval_operand(operand)?.ty.sty {
- ty::TyClosure(def_id, substs) => {
- let substs = self.tcx.subst_and_normalize_erasing_regions(
- self.substs(),
- ty::ParamEnv::reveal_all(),
- &substs,
- );
- let instance = ty::Instance::resolve_closure(
- *self.tcx,
- def_id,
- substs,
- ty::ClosureKind::FnOnce,
- );
- let fn_ptr = self.memory.create_fn_alloc(instance);
- let valty = ValTy {
- value: Value::Scalar(fn_ptr.into()),
- ty: dest_ty,
- };
- self.write_value(valty, dest)?;
- }
- ref other => bug!("closure fn pointer on {:?}", other),
- }
- }
- }
+ let src = self.eval_operand(operand)?;
+ self.cast(src, kind, dest_ty, dest)?;
}
Discriminant(ref place) => {
}
}
- fn unsize_into(
+ crate fn unsize_into(
&mut self,
src: Value,
src_layout: TyLayout<'tcx>,
use rustc::mir::{NullOp, StatementKind, Statement, BasicBlock, LocalKind};
use rustc::mir::{TerminatorKind, ClearCrossCrate, SourceInfo, BinOp, ProjectionElem};
use rustc::mir::visit::{Visitor, PlaceContext};
-use rustc::mir::interpret::ConstEvalErr;
+use rustc::mir::interpret::{ConstEvalErr, EvalErrorKind};
use rustc::ty::{TyCtxt, self, Instance};
use rustc::mir::interpret::{Value, Scalar, GlobalId, EvalResult};
use interpret::EvalContext;
let r = match f(self) {
Ok(val) => Some(val),
Err(err) => {
- let (frames, span) = self.ecx.generate_stacktrace(None);
- let err = ConstEvalErr {
- span,
- error: err,
- stacktrace: frames,
- };
- err.report_as_lint(
- self.ecx.tcx,
- "this expression will panic at runtime",
- lint_root,
- );
+ match err.kind {
+ // don't report these, they make no sense in a const prop context
+ EvalErrorKind::MachineError(_) => {},
+ _ => {
+ let (frames, span) = self.ecx.generate_stacktrace(None);
+ let err = ConstEvalErr {
+ span,
+ error: err,
+ stacktrace: frames,
+ };
+ err.report_as_lint(
+ self.ecx.tcx,
+ "this expression will panic at runtime",
+ lint_root,
+ );
+ }
+ }
None
},
};
},
Rvalue::Repeat(..) |
Rvalue::Ref(..) |
- Rvalue::Cast(..) |
Rvalue::Aggregate(..) |
Rvalue::NullaryOp(NullOp::Box, _) |
Rvalue::Discriminant(..) => None,
+
+ Rvalue::Cast(kind, ref operand, _) => {
+ let (value, ty, span) = self.eval_operand(operand, source_info)?;
+ self.use_ecx(source_info, |this| {
+ let dest_ptr = this.ecx.alloc_ptr(place_ty)?;
+ let place_align = this.ecx.layout_of(place_ty)?.align;
+ let dest = ::interpret::Place::from_ptr(dest_ptr, place_align);
+ this.ecx.cast(ValTy { value, ty }, kind, place_ty, dest)?;
+ Ok((
+ Value::ByRef(dest_ptr.into(), place_align),
+ place_ty,
+ span,
+ ))
+ })
+ }
+
// FIXME(oli-obk): evaluate static/constant slice lengths
Rvalue::Len(_) => None,
Rvalue::NullaryOp(NullOp::SizeOf, ty) => {
)
} else {
if overflow {
- use rustc::mir::interpret::EvalErrorKind;
let err = EvalErrorKind::Overflow(op).into();
let _: Option<()> = self.use_ecx(source_info, |_| Err(err));
return None;
hir::ItemKind::Use(..) => {}
// The interface is empty
hir::ItemKind::GlobalAsm(..) => {}
- hir::ItemKind::Existential(..) => {
+ hir::ItemKind::Existential(hir::ExistTy { impl_trait_fn: Some(_), .. }) => {
if item_level.is_some() {
// Reach the (potentially private) type and the API being exposed
self.reach(item.id).ty().predicates();
}
// Visit everything
hir::ItemKind::Const(..) | hir::ItemKind::Static(..) |
+ hir::ItemKind::Existential(..) |
hir::ItemKind::Fn(..) | hir::ItemKind::Ty(..) => {
if item_level.is_some() {
self.reach(item.id).generics().predicates().ty();
hir::ImplItemKind::Method(..) => {
self.access_levels.is_reachable(impl_item.id)
}
+ hir::ImplItemKind::Existential(..) |
hir::ImplItemKind::Type(_) => false,
}
});
hir::ItemKind::Use(..) => {}
// No subitems
hir::ItemKind::GlobalAsm(..) => {}
- hir::ItemKind::Existential(..) => {
+ hir::ItemKind::Existential(hir::ExistTy { impl_trait_fn: Some(_), .. }) => {
// Check the traits being exposed, as they're separate,
// e.g. `impl Iterator<Item=T>` has two predicates,
// `X: Iterator` and `<X as Iterator>::Item == T`,
}
// Subitems of these items have inherited publicity
hir::ItemKind::Const(..) | hir::ItemKind::Static(..) | hir::ItemKind::Fn(..) |
+ hir::ItemKind::Existential(..) |
hir::ItemKind::Ty(..) => {
self.check(item.id, item_visibility).generics().predicates().ty();
self.define(parent, ident, TypeNS, (def, vis, sp, expansion));
}
+ ItemKind::Existential(_, _) => {
+ let def = Def::Existential(self.definitions.local_def_id(item.id));
+ self.define(parent, ident, TypeNS, (def, vis, sp, expansion));
+ }
+
ItemKind::Enum(ref enum_definition, _) => {
let def = Def::Enum(self.definitions.local_def_id(item.id));
let module_kind = ModuleKind::Def(def, ident.name);
Def::AssociatedTy(..) | Def::PrimTy(..) | Def::Fn(..) | Def::Const(..) |
Def::Static(..) | Def::StructCtor(..) | Def::VariantCtor(..) | Def::Method(..) |
Def::AssociatedConst(..) | Def::Local(..) | Def::Upvar(..) | Def::Label(..) |
- Def::Existential(..) |
+ Def::Existential(..) | Def::AssociatedExistential(..) |
Def::Macro(..) | Def::GlobalAsm(..) | Def::Err =>
bug!("TypeParametersFromOuterFunction should only be used with Def::SelfTy or \
Def::TyParam")
Def::Struct(..) | Def::Union(..) | Def::Enum(..) |
Def::Trait(..) | Def::TyAlias(..) | Def::AssociatedTy(..) |
Def::PrimTy(..) | Def::TyParam(..) | Def::SelfTy(..) |
+ Def::Existential(..) |
Def::TyForeign(..) => true,
_ => false,
},
match item.node {
ItemKind::Enum(_, ref generics) |
ItemKind::Ty(_, ref generics) |
+ ItemKind::Existential(_, ref generics) |
ItemKind::Struct(_, ref generics) |
ItemKind::Union(_, ref generics) |
ItemKind::Fn(_, _, ref generics, _) => {
this.visit_ty(ty);
}
+ ImplItemKind::Existential(ref bounds) => {
+ // If this is a trait impl, ensure the type
+ // exists in trait
+ this.check_trait_item(impl_item.ident,
+ TypeNS,
+ impl_item.span,
+ |n, s| TypeNotMemberOfTrait(n, s));
+
+ for bound in bounds {
+ this.visit_param_bound(bound);
+ }
+ }
ImplItemKind::Macro(_) =>
panic!("unexpanded macro in resolve!"),
}
// trait.
self.visit_ty(ty)
}
+ ast::ImplItemKind::Existential(ref bounds) => {
+ // FIXME uses of the assoc type should ideally point to this
+ // 'def' and the name here should be a ref to the def in the
+ // trait.
+ for bound in bounds.iter() {
+ if let ast::GenericBound::Trait(trait_ref, _) = bound {
+ self.process_path(trait_ref.trait_ref.ref_id, &trait_ref.trait_ref.path)
+ }
+ }
+ }
ast::ImplItemKind::Macro(_) => {}
}
}
self.visit_ty(&ty);
self.process_generic_params(ty_params, item.span, &qualname, item.id);
}
+ Existential(ref _bounds, ref ty_params) => {
+ let qualname = format!("::{}", self.tcx.node_path_str(item.id));
+ // FIXME do something with _bounds
+ let value = String::new();
+ let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Type);
+ if !self.span.filter_generated(sub_span, item.span) {
+ let span = self.span_from_span(sub_span.expect("No span found for typedef"));
+ let id = ::id_from_node_id(item.id, &self.save_ctxt);
+
+ self.dumper.dump_def(
+ &access_from!(self.save_ctxt, item),
+ Def {
+ kind: DefKind::Type,
+ id,
+ span,
+ name: item.ident.to_string(),
+ qualname: qualname.clone(),
+ value,
+ parent: None,
+ children: vec![],
+ decl_id: None,
+ docs: self.save_ctxt.docs_for_attrs(&item.attrs),
+ sig: sig::item_signature(item, &self.save_ctxt),
+ attributes: lower_attributes(item.attrs.clone(), &self.save_ctxt),
+ },
+ );
+ }
+
+ self.process_generic_params(ty_params, item.span, &qualname, item.id);
+ }
Mac(_) => (),
_ => visit::walk_item(self, item),
}
HirDef::TyAlias(def_id) |
HirDef::TyForeign(def_id) |
HirDef::TraitAlias(def_id) |
+ HirDef::AssociatedExistential(def_id) |
HirDef::AssociatedTy(def_id) |
HirDef::Trait(def_id) |
HirDef::Existential(def_id) |
refs: vec![],
})
}
+ ast::ItemKind::Existential(ref bounds, ref generics) => {
+ let text = "existential type ".to_owned();
+ let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
+
+ if !bounds.is_empty() {
+ sig.text.push_str(": ");
+ sig.text.push_str(&pprust::bounds_to_string(bounds));
+ }
+ sig.text.push(';');
+
+ Ok(sig)
+ }
ast::ItemKind::Ty(ref ty, ref generics) => {
let text = "type ".to_owned();
let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
let span = path.span;
match path.def {
+ Def::Existential(did) => {
+ // check for desugared impl trait
+ if ty::is_impl_trait_defn(tcx, did).is_some() {
+ let lifetimes = &path.segments[0].args.as_ref().unwrap().args;
+ return self.impl_trait_ty_to_ty(did, lifetimes);
+ }
+ let item_segment = path.segments.split_last().unwrap();
+ self.prohibit_generics(item_segment.1);
+ let substs = self.ast_path_substs_for_ty(span, did, item_segment.0);
+ self.normalize_ty(
+ span,
+ tcx.mk_anon(did, substs),
+ )
+ }
Def::Enum(did) | Def::TyAlias(did) | Def::Struct(did) |
Def::Union(did) | Def::TyForeign(did) => {
assert_eq!(opt_self_ty, None);
hir::TyStr => tcx.mk_str()
}
}
- Def::Existential(exist_ty_did) => {
- assert!(exist_ty_did.is_local());
- let lifetimes = &path.segments[0].args.as_ref().unwrap().args;
- self.impl_trait_ty_to_ty(exist_ty_did, lifetimes)
- }
Def::Err => {
self.set_tainted_by_errors();
return self.tcx().types.err;
pub fn predicates(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, param_ty: Ty<'tcx>)
-> Vec<ty::Predicate<'tcx>>
{
- let mut vec = Vec::new();
-
// If it could be sized, and is, add the sized predicate
- if self.implicitly_sized {
- if let Some(sized) = tcx.lang_items().sized_trait() {
+ let sized_predicate = if self.implicitly_sized {
+ tcx.lang_items().sized_trait().map(|sized| {
let trait_ref = ty::TraitRef {
def_id: sized,
substs: tcx.mk_substs_trait(param_ty, &[])
};
- vec.push(trait_ref.to_predicate());
- }
- }
-
- for ®ion_bound in &self.region_bounds {
- // account for the binder being introduced below; no need to shift `param_ty`
- // because, at present at least, it can only refer to early-bound regions
- let region_bound = tcx.mk_region(ty::fold::shift_region(*region_bound, 1));
- vec.push(
- ty::Binder::dummy(ty::OutlivesPredicate(param_ty, region_bound)).to_predicate());
- }
-
- for bound_trait_ref in &self.trait_bounds {
- vec.push(bound_trait_ref.to_predicate());
- }
-
- for projection in &self.projection_bounds {
- vec.push(projection.to_predicate());
- }
+ trait_ref.to_predicate()
+ })
+ } else {
+ None
+ };
- vec
+ sized_predicate.into_iter().chain(
+ self.region_bounds.iter().map(|®ion_bound| {
+ // account for the binder being introduced below; no need to shift `param_ty`
+ // because, at present at least, it can only refer to early-bound regions
+ let region_bound = tcx.mk_region(ty::fold::shift_region(*region_bound, 1));
+ ty::Binder::dummy(ty::OutlivesPredicate(param_ty, region_bound)).to_predicate()
+ }).chain(
+ self.trait_bounds.iter().map(|bound_trait_ref| {
+ bound_trait_ref.to_predicate()
+ })
+ ).chain(
+ self.projection_bounds.iter().map(|projection| {
+ projection.to_predicate()
+ })
+ )
+ ).collect()
}
}
match self.mode {
Mode::MethodCall => item.method_has_self_argument,
Mode::Path => match item.kind {
+ ty::AssociatedKind::Existential |
ty::AssociatedKind::Type => false,
ty::AssociatedKind::Method | ty::AssociatedKind::Const => true
},
hir::ItemKind::Union(..) => {
check_union(tcx, it.id, it.span);
}
+ hir::ItemKind::Existential(..) |
hir::ItemKind::Ty(..) => {
let def_id = tcx.hir.local_def_id(it.id);
let pty_ty = tcx.type_of(def_id);
let kind = match impl_item.node {
hir::ImplItemKind::Const(..) => ty::AssociatedKind::Const,
hir::ImplItemKind::Method(..) => ty::AssociatedKind::Method,
+ hir::ImplItemKind::Existential(..) => ty::AssociatedKind::Existential,
hir::ImplItemKind::Type(_) => ty::AssociatedKind::Type
};
err.emit()
}
}
+ hir::ImplItemKind::Existential(..) |
hir::ImplItemKind::Type(_) => {
if ty_trait_item.kind == ty::AssociatedKind::Type {
if ty_trait_item.defaultness.has_value() {
use hir::def_id::DefId;
use rustc::traits::{self, ObligationCauseCode};
-use rustc::ty::{self, Lift, Ty, TyCtxt, GenericParamDefKind};
-use rustc::ty::subst::Substs;
+use rustc::ty::{self, Lift, Ty, TyCtxt, GenericParamDefKind, TypeFoldable};
+use rustc::ty::subst::{Subst, Substs};
use rustc::ty::util::ExplicitSelf;
use rustc::util::nodemap::{FxHashSet, FxHashMap};
use rustc::middle::lang_items;
+use rustc::infer::anon_types::may_define_existential_type;
use syntax::ast;
use syntax::feature_gate::{self, GateIssue};
fcx.register_wf_obligation(ty, span, code.clone());
}
}
+ ty::AssociatedKind::Existential => {
+ // FIXME(oli-obk) implement existential types in trait impls
+ unimplemented!()
+ }
}
implied_bounds
}
}
- check_where_clauses(tcx, fcx, item.span, def_id);
+ check_where_clauses(tcx, fcx, item.span, def_id, None);
vec![] // no implied bounds in a struct def'n
});
fn check_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item: &hir::Item) {
let trait_def_id = tcx.hir.local_def_id(item.id);
for_item(tcx, item).with_fcx(|fcx, _| {
- check_where_clauses(tcx, fcx, item.span, trait_def_id);
+ check_where_clauses(tcx, fcx, item.span, trait_def_id, None);
vec![]
});
}
}
}
- check_where_clauses(tcx, fcx, item.span, item_def_id);
+ check_where_clauses(tcx, fcx, item.span, item_def_id, None);
fcx.impl_implied_bounds(item_def_id, item.span)
});
fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
span: Span,
def_id: DefId,
+ return_ty: Option<Ty<'tcx>>,
) {
use ty::subst::Subst;
use rustc::ty::TypeFoldable;
traits::Obligation::new(cause, fcx.param_env, pred)
});
- let predicates = predicates.instantiate_identity(fcx.tcx);
+ let mut predicates = predicates.instantiate_identity(fcx.tcx);
+
+ if let Some(return_ty) = return_ty {
+ predicates.predicates.extend(check_existential_types(tcx, fcx, def_id, span, return_ty));
+ }
+
let predicates = fcx.normalize_associated_types_in(span, &predicates);
debug!("check_where_clauses: predicates={:?}", predicates.predicates);
// FIXME(#25759) return types should not be implied bounds
implied_bounds.push(sig.output());
- check_where_clauses(tcx, fcx, span, def_id);
+ check_where_clauses(tcx, fcx, span, def_id, Some(sig.output()));
+}
+
+/// Checks "defining uses" of existential types to ensure that they meet the restrictions laid for
+/// "higher-order pattern unification".
+/// This ensures that inference is tractable.
+/// In particular, definitions of existential types can only use other generics as arguments,
+/// and they cannot repeat an argument. Example:
+///
+/// ```rust
+/// existential type Foo<A, B>;
+///
+/// // ok -- `Foo` is applied to two distinct, generic types.
+/// fn a<T, U>() -> Foo<T, U> { .. }
+///
+/// // not ok -- `Foo` is applied to `T` twice.
+/// fn b<T>() -> Foo<T, T> { .. }
+///
+///
+/// // not ok -- `Foo` is applied to a non-generic type.
+/// fn b<T>() -> Foo<T, u32> { .. }
+/// ```
+///
+fn check_existential_types<'a, 'fcx, 'gcx, 'tcx>(
+ tcx: TyCtxt<'a, 'gcx, 'gcx>,
+ fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
+ fn_def_id: DefId,
+ span: Span,
+ ty: Ty<'tcx>,
+) -> Vec<ty::Predicate<'tcx>> {
+ trace!("check_existential_types: {:?}, {:?}", ty, ty.sty);
+ let mut substituted_predicates = Vec::new();
+ ty.fold_with(&mut ty::fold::BottomUpFolder {
+ tcx: fcx.tcx,
+ fldop: |ty| {
+ if let ty::TyAnon(def_id, substs) = ty.sty {
+ trace!("check_existential_types: anon_ty, {:?}, {:?}", def_id, substs);
+ let generics = tcx.generics_of(def_id);
+ // only check named existential types
+ if generics.parent.is_none() {
+ let anon_node_id = tcx.hir.as_local_node_id(def_id).unwrap();
+ if may_define_existential_type(tcx, fn_def_id, anon_node_id) {
+ trace!("check_existential_types may define. Generics: {:#?}", generics);
+ let mut seen: FxHashMap<_, Vec<_>> = FxHashMap();
+ for (subst, param) in substs.iter().zip(&generics.params) {
+ match subst.unpack() {
+ ty::subst::UnpackedKind::Type(ty) => match ty.sty {
+ ty::TyParam(..) => {},
+ // prevent `fn foo() -> Foo<u32>` from being defining
+ _ => {
+ tcx
+ .sess
+ .struct_span_err(
+ span,
+ "non-defining existential type use \
+ in defining scope",
+ )
+ .span_note(
+ tcx.def_span(param.def_id),
+ &format!(
+ "used non-generic type {} for \
+ generic parameter",
+ ty,
+ ),
+ )
+ .emit();
+ },
+ }, // match ty
+ ty::subst::UnpackedKind::Lifetime(region) => {
+ let param_span = tcx.def_span(param.def_id);
+ if let ty::ReStatic = region {
+ tcx
+ .sess
+ .struct_span_err(
+ span,
+ "non-defining existential type use \
+ in defining scope",
+ )
+ .span_label(
+ param_span,
+ "cannot use static lifetime, use a bound lifetime \
+ instead or remove the lifetime parameter from the \
+ existential type",
+ )
+ .emit();
+ } else {
+ seen.entry(region).or_default().push(param_span);
+ }
+ },
+ } // match subst
+ } // for (subst, param)
+ for (_, spans) in seen {
+ if spans.len() > 1 {
+ tcx
+ .sess
+ .struct_span_err(
+ span,
+ "non-defining existential type use \
+ in defining scope",
+ ).
+ span_note(
+ spans,
+ "lifetime used multiple times",
+ )
+ .emit();
+ }
+ }
+ } // if may_define_existential_type
+
+ // now register the bounds on the parameters of the existential type
+ // so the parameters given by the function need to fulfil them
+ // ```rust
+ // existential type Foo<T: Bar>: 'static;
+ // fn foo<U>() -> Foo<U> { .. *}
+ // ```
+ // becomes
+ // ```rust
+ // existential type Foo<T: Bar>: 'static;
+ // fn foo<U: Bar>() -> Foo<U> { .. *}
+ // ```
+ let predicates = tcx.predicates_of(def_id);
+ trace!(
+ "check_existential_types may define. adding predicates: {:#?}",
+ predicates,
+ );
+ for &pred in predicates.predicates.iter() {
+ let substituted_pred = pred.subst(fcx.tcx, substs);
+ // Avoid duplication of predicates that contain no parameters, for example.
+ if !predicates.predicates.contains(&substituted_pred) {
+ substituted_predicates.push(substituted_pred);
+ }
+ }
+ } // if is_named_existential_type
+ } // if let TyAnon
+ ty
+ },
+ reg_op: |reg| reg,
+ });
+ substituted_predicates
}
fn check_method_receiver<'fcx, 'gcx, 'tcx>(fcx: &FnCtxt<'fcx, 'gcx, 'tcx>,
use rustc::hir::def_id::{DefId, DefIndex};
use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
use rustc::infer::InferCtxt;
+use rustc::ty::subst::UnpackedKind;
use rustc::ty::{self, Ty, TyCtxt};
use rustc::ty::adjustment::{Adjust, Adjustment};
-use rustc::ty::fold::{TypeFoldable, TypeFolder};
+use rustc::ty::fold::{TypeFoldable, TypeFolder, BottomUpFolder};
use rustc::util::nodemap::DefIdSet;
use syntax::ast;
use syntax_pos::Span;
for (&def_id, anon_defn) in self.fcx.anon_types.borrow().iter() {
let node_id = self.tcx().hir.as_local_node_id(def_id).unwrap();
let instantiated_ty = self.resolve(&anon_defn.concrete_ty, &node_id);
- let definition_ty = self.fcx.infer_anon_definition_from_instantiation(
- def_id,
- anon_defn,
- instantiated_ty,
- );
+
+ let generics = self.tcx().generics_of(def_id);
+
+ let definition_ty = if generics.parent.is_some() {
+ // impl trait
+ self.fcx.infer_anon_definition_from_instantiation(
+ def_id,
+ anon_defn,
+ instantiated_ty,
+ )
+ } else {
+ // prevent
+ // * `fn foo<T>() -> Foo<T>`
+ // * `fn foo<T: Bound + Other>() -> Foo<T>`
+ // from being defining
+
+ // Also replace all generic params with the ones from the existential type
+ // definition so
+ // ```rust
+ // existential type Foo<T>: 'static;
+ // fn foo<U>() -> Foo<U> { .. }
+ // ```
+ // figures out the concrete type with `U`, but the stored type is with `T`
+ instantiated_ty.fold_with(&mut BottomUpFolder {
+ tcx: self.tcx().global_tcx(),
+ fldop: |ty| {
+ trace!("checking type {:?}: {:#?}", ty, ty.sty);
+ // find a type parameter
+ if let ty::TyParam(..) = ty.sty {
+ // look it up in the substitution list
+ assert_eq!(anon_defn.substs.len(), generics.params.len());
+ for (subst, param) in anon_defn.substs.iter().zip(&generics.params) {
+ if let UnpackedKind::Type(subst) = subst.unpack() {
+ if subst == ty {
+ // found it in the substitution list, replace with the
+ // parameter from the existential type
+ return self
+ .tcx()
+ .global_tcx()
+ .mk_ty_param(param.index, param.name);
+ }
+ }
+ }
+ self.tcx()
+ .sess
+ .struct_span_err(
+ span,
+ &format!(
+ "type parameter `{}` is part of concrete type but not used \
+ in parameter list for existential type",
+ ty,
+ ),
+ )
+ .emit();
+ return self.tcx().types.err;
+ }
+ ty
+ },
+ reg_op: |region| {
+ match region {
+ // ignore static regions
+ ty::ReStatic => region,
+ _ => {
+ trace!("checking {:?}", region);
+ for (subst, p) in anon_defn.substs.iter().zip(&generics.params) {
+ if let UnpackedKind::Lifetime(subst) = subst.unpack() {
+ if subst == region {
+ // found it in the substitution list, replace with the
+ // parameter from the existential type
+ let reg = ty::EarlyBoundRegion {
+ def_id: p.def_id,
+ index: p.index,
+ name: p.name,
+ };
+ trace!("replace {:?} with {:?}", region, reg);
+ return self.tcx().global_tcx()
+ .mk_region(ty::ReEarlyBound(reg));
+ }
+ }
+ }
+ trace!("anon_defn: {:#?}", anon_defn);
+ trace!("generics: {:#?}", generics);
+ self.tcx().sess
+ .struct_span_err(
+ span,
+ "non-defining existential type use in defining scope",
+ )
+ .span_label(
+ span,
+ format!(
+ "lifetime `{}` is part of concrete type but not used \
+ in parameter list of existential type",
+ region,
+ ),
+ )
+ .emit();
+ self.tcx().global_tcx().mk_region(ty::ReStatic)
+ }
+ }
+ }
+ })
+ };
+
let old = self.tables.concrete_existential_types.insert(def_id, definition_ty);
if let Some(old) = old {
if old != definition_ty {
ItemKind::Fn(.., ref generics, _) |
ItemKind::Impl(_, _, _, ref generics, ..) |
ItemKind::Ty(_, ref generics) |
+ ItemKind::Existential(ExistTy { ref generics, impl_trait_fn: None, ..}) |
ItemKind::Enum(_, ref generics) |
ItemKind::Struct(_, ref generics) |
ItemKind::Union(_, ref generics) => generics,
convert_variant_ctor(tcx, struct_def.id());
}
},
- hir::ItemKind::Existential(..) => {}
+
+ // Desugared from `impl Trait` -> visited by the function's return type
+ hir::ItemKind::Existential(hir::ExistTy { impl_trait_fn: Some(_), .. }) => {}
+
+ hir::ItemKind::Existential(..) |
hir::ItemKind::Ty(..) |
hir::ItemKind::Static(..) |
hir::ItemKind::Const(..) |
})
}
+fn report_assoc_ty_on_inherent_impl<'a, 'tcx>(
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ span: Span,
+) {
+ span_err!(tcx.sess, span, E0202, "associated types are not allowed in inherent impls");
+}
+
fn type_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
-> Ty<'tcx> {
tcx.mk_fn_def(def_id, substs)
}
ImplItemKind::Const(ref ty, _) => icx.to_ty(ty),
+ ImplItemKind::Existential(ref _bounds) => {
+ if tcx.impl_trait_ref(tcx.hir.get_parent_did(node_id)).is_none() {
+ report_assoc_ty_on_inherent_impl(tcx, item.span);
+ }
+ // FIXME(oli-obk) implement existential types in trait impls
+ unimplemented!()
+ }
ImplItemKind::Type(ref ty) => {
if tcx.impl_trait_ref(tcx.hir.get_parent_did(node_id)).is_none() {
- span_err!(tcx.sess, item.span, E0202,
- "associated types are not allowed in inherent impls");
+ report_assoc_ty_on_inherent_impl(tcx, item.span);
}
icx.to_ty(ty)
let substs = Substs::identity_for_item(tcx, def_id);
tcx.mk_adt(def, substs)
}
- // this is only reachable once we have named existential types
- ItemKind::Existential(hir::ExistTy { impl_trait_fn: None, .. }) => unimplemented!(),
+ ItemKind::Existential(hir::ExistTy { impl_trait_fn: None, .. }) => {
+ find_existential_constraints(tcx, def_id)
+ },
// existential types desugared from impl Trait
ItemKind::Existential(hir::ExistTy { impl_trait_fn: Some(owner), .. }) => {
tcx.typeck_tables_of(owner).concrete_existential_types[&def_id]
}
}
+fn find_existential_constraints<'a, 'tcx>(
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ def_id: DefId,
+) -> ty::Ty<'tcx> {
+ use rustc::hir::map::*;
+ use rustc::hir::*;
+
+ struct ConstraintLocator<'a, 'tcx: 'a> {
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ def_id: DefId,
+ found: Option<(Span, ty::Ty<'tcx>)>,
+ }
+ impl<'a, 'tcx> ConstraintLocator<'a, 'tcx> {
+ fn check(&mut self, def_id: DefId) {
+ // don't try to check items that cannot possibly constrain the type
+ if !self.tcx.has_typeck_tables(def_id) {
+ return;
+ }
+ let ty = self
+ .tcx
+ .typeck_tables_of(def_id)
+ .concrete_existential_types
+ .get(&self.def_id)
+ .cloned();
+ if let Some(ty) = ty {
+ // FIXME(oli-obk): trace the actual span from inference to improve errors
+ let span = self.tcx.def_span(def_id);
+ if let Some((prev_span, prev_ty)) = self.found {
+ if ty != prev_ty {
+ // found different concrete types for the existential type
+ let mut err = self.tcx.sess.struct_span_err(
+ span,
+ "defining existential type use differs from previous",
+ );
+ err.span_note(prev_span, "previous use here");
+ err.emit();
+ }
+ } else {
+ self.found = Some((span, ty));
+ }
+ }
+ }
+ }
+ impl<'a, 'tcx> intravisit::Visitor<'tcx> for ConstraintLocator<'a, 'tcx> {
+ fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> {
+ intravisit::NestedVisitorMap::All(&self.tcx.hir)
+ }
+ fn visit_item(&mut self, it: &'tcx Item) {
+ let def_id = self.tcx.hir.local_def_id(it.id);
+ // the existential type itself or its children are not within its reveal scope
+ if def_id != self.def_id {
+ self.check(def_id);
+ intravisit::walk_item(self, it);
+ }
+ }
+ fn visit_impl_item(&mut self, it: &'tcx ImplItem) {
+ let def_id = self.tcx.hir.local_def_id(it.id);
+ // the existential type itself or its children are not within its reveal scope
+ if def_id != self.def_id {
+ self.check(def_id);
+ intravisit::walk_impl_item(self, it);
+ }
+ }
+ fn visit_trait_item(&mut self, it: &'tcx TraitItem) {
+ let def_id = self.tcx.hir.local_def_id(it.id);
+ self.check(def_id);
+ intravisit::walk_trait_item(self, it);
+ }
+ }
+ let mut locator = ConstraintLocator { def_id, tcx, found: None };
+ let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
+ let parent = tcx.hir.get_parent(node_id);
+ if parent == ast::CRATE_NODE_ID {
+ intravisit::walk_crate(&mut locator, tcx.hir.krate());
+ } else {
+ match tcx.hir.get(parent) {
+ NodeItem(ref it) => intravisit::walk_item(&mut locator, it),
+ NodeImplItem(ref it) => intravisit::walk_impl_item(&mut locator, it),
+ NodeTraitItem(ref it) => intravisit::walk_trait_item(&mut locator, it),
+ other => bug!("{:?} is not a valid parent of an existential type item", other),
+ }
+ }
+ match locator.found {
+ Some((_, ty)) => ty,
+ None => {
+ let span = tcx.def_span(def_id);
+ tcx.sess.span_err(span, "could not find defining uses");
+ tcx.types.err
+ }
+ }
+}
+
fn fn_sig<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
def_id: DefId)
-> ty::PolyFnSig<'tcx> {
let icx = ItemCtxt::new(tcx, def_id);
let no_generics = hir::Generics::empty();
+
+ let mut predicates = vec![];
+
let ast_generics = match node {
NodeTraitItem(item) => {
&item.generics
is_trait = Some((ty::TraitRef::identity(tcx, def_id), items));
generics
}
- ItemKind::Existential(ref exist_ty) => {
+ ItemKind::Existential(ExistTy { ref bounds, impl_trait_fn, ref generics }) => {
let substs = Substs::identity_for_item(tcx, def_id);
let anon_ty = tcx.mk_anon(def_id, substs);
// Collect the bounds, i.e. the `A+B+'c` in `impl A+B+'c`.
let bounds = compute_bounds(&icx,
anon_ty,
- &exist_ty.bounds,
+ bounds,
SizedByDefault::Yes,
tcx.def_span(def_id));
- let predicates = bounds.predicates(tcx, anon_ty);
-
- return ty::GenericPredicates {
- parent: None,
- predicates: predicates
- };
+ if impl_trait_fn.is_some() {
+ // impl Trait
+ return ty::GenericPredicates {
+ parent: None,
+ predicates: bounds.predicates(tcx, anon_ty),
+ };
+ } else {
+ // named existential types
+ predicates.extend(bounds.predicates(tcx, anon_ty));
+ generics
+ }
}
_ => &no_generics,
let parent_count = generics.parent_count as u32;
let has_own_self = generics.has_self && parent_count == 0;
- let mut predicates = vec![];
-
// Below we'll consider the bounds on the type parameters (including `Self`)
// and the explicit where-clauses, but to get the full set of predicates
// on a trait we need to add in the supertrait bounds and bounds found on
impl From<ty::AssociatedKind> for Namespace {
fn from(a_kind: ty::AssociatedKind) -> Self {
match a_kind {
+ ty::AssociatedKind::Existential |
ty::AssociatedKind::Type => Namespace::Type,
ty::AssociatedKind::Const |
ty::AssociatedKind::Method => Namespace::Value,
impl<'a> From <&'a hir::ImplItemKind> for Namespace {
fn from(impl_kind: &'a hir::ImplItemKind) -> Self {
match *impl_kind {
+ hir::ImplItemKind::Existential(..) |
hir::ImplItemKind::Type(..) => Namespace::Type,
hir::ImplItemKind::Const(..) |
hir::ImplItemKind::Method(..) => Namespace::Value,
self.stability.as_ref().map(|s| &s.since[..])
}
+ pub fn is_non_exhaustive(&self) -> bool {
+ self.attrs.other_attrs.iter()
+ .any(|a| a.name().as_str() == "non_exhaustive")
+ }
+
/// Returns a documentation-level item type from the item.
pub fn type_(&self) -> ItemType {
ItemType::from(self)
FunctionItem(Function),
ModuleItem(Module),
TypedefItem(Typedef, bool /* is associated type */),
+ ExistentialItem(Existential, bool /* is associated type */),
StaticItem(Static),
ConstantItem(Constant),
TraitItem(Trait),
ItemEnum::EnumItem(ref e) => &e.generics,
ItemEnum::FunctionItem(ref f) => &f.generics,
ItemEnum::TypedefItem(ref t, _) => &t.generics,
+ ItemEnum::ExistentialItem(ref t, _) => &t.generics,
ItemEnum::TraitItem(ref t) => &t.generics,
ItemEnum::ImplItem(ref i) => &i.generics,
ItemEnum::TyMethodItem(ref i) => &i.generics,
items.extend(self.foreigns.iter().flat_map(|x| x.clean(cx)));
items.extend(self.mods.iter().map(|x| x.clean(cx)));
items.extend(self.typedefs.iter().map(|x| x.clean(cx)));
+ items.extend(self.existentials.iter().map(|x| x.clean(cx)));
items.extend(self.statics.iter().map(|x| x.clean(cx)));
items.extend(self.constants.iter().map(|x| x.clean(cx)));
items.extend(self.traits.iter().map(|x| x.clean(cx)));
type_: ty.clean(cx),
generics: Generics::default(),
}, true),
+ hir::ImplItemKind::Existential(ref bounds) => ExistentialItem(Existential {
+ bounds: bounds.clean(cx),
+ generics: Generics::default(),
+ }, true),
};
Item {
name: Some(self.ident.name.clean(cx)),
}, true)
}
}
+ ty::AssociatedKind::Existential => unimplemented!(),
};
let visibility = match self.container {
}
}
+#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
+pub struct Existential {
+ pub bounds: Vec<GenericBound>,
+ pub generics: Generics,
+}
+
+impl Clean<Item> for doctree::Existential {
+ fn clean(&self, cx: &DocContext) -> Item {
+ Item {
+ name: Some(self.name.clean(cx)),
+ attrs: self.attrs.clean(cx),
+ source: self.whence.clean(cx),
+ def_id: cx.tcx.hir.local_def_id(self.id.clone()),
+ visibility: self.vis.clean(cx),
+ stability: self.stab.clean(cx),
+ deprecation: self.depr.clean(cx),
+ inner: ExistentialItem(Existential {
+ bounds: self.exist_ty.bounds.clean(cx),
+ generics: self.exist_ty.generics.clean(cx),
+ }, false),
+ }
+ }
+}
+
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]
pub struct BareFunctionDecl {
pub unsafety: hir::Unsafety,
pub mods: Vec<Module>,
pub id: NodeId,
pub typedefs: Vec<Typedef>,
+ pub existentials: Vec<Existential>,
pub statics: Vec<Static>,
pub constants: Vec<Constant>,
pub traits: Vec<Trait>,
fns : Vec::new(),
mods : Vec::new(),
typedefs : Vec::new(),
+ existentials: Vec::new(),
statics : Vec::new(),
constants : Vec::new(),
traits : Vec::new(),
pub depr: Option<attr::Deprecation>,
}
+pub struct Existential {
+ pub exist_ty: hir::ExistTy,
+ pub name: Name,
+ pub id: ast::NodeId,
+ pub attrs: hir::HirVec<ast::Attribute>,
+ pub whence: Span,
+ pub vis: hir::Visibility,
+ pub stab: Option<attr::Stability>,
+ pub depr: Option<attr::Deprecation>,
+}
+
#[derive(Debug)]
pub struct Static {
pub type_: P<hir::Ty>,
/// don't override!
fn fold_item_recur(&mut self, item: Item) -> Option<Item> {
- let Item { attrs, name, source, visibility, def_id, inner, stability, deprecation } = item;
+ let Item {
+ attrs,
+ name,
+ source,
+ visibility,
+ def_id,
+ inner,
+ stability,
+ deprecation,
+ } = item;
let inner = match inner {
StrippedItem(box i) => StrippedItem(box self.fold_inner_recur(i)),
Union = 19,
ForeignType = 20,
Keyword = 21,
+ Existential = 22,
}
clean::EnumItem(..) => ItemType::Enum,
clean::FunctionItem(..) => ItemType::Function,
clean::TypedefItem(..) => ItemType::Typedef,
+ clean::ExistentialItem(..) => ItemType::Existential,
clean::StaticItem(..) => ItemType::Static,
clean::ConstantItem(..) => ItemType::Constant,
clean::TraitItem(..) => ItemType::Trait,
ItemType::AssociatedConst => "associatedconstant",
ItemType::ForeignType => "foreigntype",
ItemType::Keyword => "keyword",
+ ItemType::Existential => "existential",
}
}
ItemType::Trait |
ItemType::Primitive |
ItemType::AssociatedType |
+ ItemType::Existential |
ItemType::ForeignType => NameSpace::Type,
ItemType::ExternCrate |
macros: HashSet<ItemEntry>,
functions: HashSet<ItemEntry>,
typedefs: HashSet<ItemEntry>,
+ existentials: HashSet<ItemEntry>,
statics: HashSet<ItemEntry>,
constants: HashSet<ItemEntry>,
keywords: HashSet<ItemEntry>,
macros: HashSet::with_capacity(100),
functions: HashSet::with_capacity(100),
typedefs: HashSet::with_capacity(100),
+ existentials: HashSet::with_capacity(100),
statics: HashSet::with_capacity(100),
constants: HashSet::with_capacity(100),
keywords: HashSet::with_capacity(100),
ItemType::Macro => self.macros.insert(ItemEntry::new(new_url, name)),
ItemType::Function => self.functions.insert(ItemEntry::new(new_url, name)),
ItemType::Typedef => self.typedefs.insert(ItemEntry::new(new_url, name)),
+ ItemType::Existential => self.existentials.insert(ItemEntry::new(new_url, name)),
ItemType::Static => self.statics.insert(ItemEntry::new(new_url, name)),
ItemType::Constant => self.constants.insert(ItemEntry::new(new_url, name)),
_ => true,
print_entries(f, &self.macros, "Macros", "macros")?;
print_entries(f, &self.functions, "Functions", "functions")?;
print_entries(f, &self.typedefs, "Typedefs", "typedefs")?;
+ print_entries(f, &self.existentials, "Existentials", "existentials")?;
print_entries(f, &self.statics, "Statics", "statics")?;
print_entries(f, &self.constants, "Constants", "constants")
}
clean::ConstantItem(..) => write!(fmt, "Constant ")?,
clean::ForeignTypeItem => write!(fmt, "Foreign Type ")?,
clean::KeywordItem(..) => write!(fmt, "Keyword ")?,
+ clean::ExistentialItem(..) => write!(fmt, "Existential Type ")?,
_ => {
// We don't generate pages for any other type.
unreachable!();
clean::ConstantItem(ref c) => item_constant(fmt, self.cx, self.item, c),
clean::ForeignTypeItem => item_foreign_type(fmt, self.cx, self.item),
clean::KeywordItem(ref k) => item_keyword(fmt, self.cx, self.item, k),
+ clean::ExistentialItem(ref e, _) => item_existential(fmt, self.cx, self.item, e),
_ => {
// We don't generate pages for any other type.
unreachable!();
Ok(())
}
+fn document_non_exhaustive_header(item: &clean::Item) -> &str {
+ if item.is_non_exhaustive() { " (Non-exhaustive)" } else { "" }
+}
+
+fn document_non_exhaustive(w: &mut fmt::Formatter, item: &clean::Item) -> fmt::Result {
+ if item.is_non_exhaustive() {
+ write!(w, "<div class='docblock non-exhaustive non-exhaustive-{}'>", {
+ if item.is_struct() { "struct" } else if item.is_enum() { "enum" } else { "type" }
+ })?;
+
+ if item.is_struct() {
+ write!(w, "Non-exhaustive structs could have additional fields added in future. \
+ Therefore, non-exhaustive structs cannot be constructed in external crates \
+ using the traditional <code>Struct {{ .. }}</code> syntax; cannot be \
+ matched against without a wildcard <code>..</code>; and \
+ struct update syntax will not work.")?;
+ } else if item.is_enum() {
+ write!(w, "Non-exhaustive enums could have additional variants added in future. \
+ Therefore, when matching against variants of non-exhaustive enums, an \
+ extra wildcard arm must be added to account for any future variants.")?;
+ } else {
+ write!(w, "This type will require a wildcard arm in any match statements or \
+ constructors.")?;
+ }
+
+ write!(w, "</div>")?;
+ }
+
+ Ok(())
+}
+
fn name_key(name: &str) -> (&str, u64, usize) {
// find number at end
let split = name.bytes().rposition(|b| b < b'0' || b'9' < b).map_or(0, |s| s + 1);
Ok(())
}
-fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
- t: &clean::Trait) -> fmt::Result {
+fn bounds(t_bounds: &[clean::GenericBound]) -> String {
let mut bounds = String::new();
let mut bounds_plain = String::new();
- if !t.bounds.is_empty() {
+ if !t_bounds.is_empty() {
if !bounds.is_empty() {
bounds.push(' ');
bounds_plain.push(' ');
}
bounds.push_str(": ");
bounds_plain.push_str(": ");
- for (i, p) in t.bounds.iter().enumerate() {
+ for (i, p) in t_bounds.iter().enumerate() {
if i > 0 {
bounds.push_str(" + ");
bounds_plain.push_str(" + ");
bounds_plain.push_str(&format!("{:#}", *p));
}
}
+ bounds
+}
+fn item_trait(
+ w: &mut fmt::Formatter,
+ cx: &Context,
+ it: &clean::Item,
+ t: &clean::Trait,
+) -> fmt::Result {
+ let bounds = bounds(&t.bounds);
let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
let required = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>();
if let doctree::Plain = s.struct_type {
if fields.peek().is_some() {
write!(w, "<h2 id='fields' class='fields small-section-header'>
- Fields<a href='#fields' class='anchor'></a></h2>")?;
+ Fields{}<a href='#fields' class='anchor'></a></h2>",
+ document_non_exhaustive_header(it))?;
+ document_non_exhaustive(w, it)?;
for (field, ty) in fields {
let id = derive_id(format!("{}.{}",
ItemType::StructField,
document(w, cx, it)?;
if !e.variants.is_empty() {
write!(w, "<h2 id='variants' class='variants small-section-header'>
- Variants<a href='#variants' class='anchor'></a></h2>\n")?;
+ Variants{}<a href='#variants' class='anchor'></a></h2>\n",
+ document_non_exhaustive_header(it))?;
+ document_non_exhaustive(w, it)?;
for variant in &e.variants {
let id = derive_id(format!("{}.{}",
ItemType::Variant,
"must_use",
"no_mangle",
"repr",
- "unsafe_destructor_blind_to_params"
+ "unsafe_destructor_blind_to_params",
+ "non_exhaustive"
];
fn render_attributes(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result {
Ok(())
}
+fn item_existential(
+ w: &mut fmt::Formatter,
+ cx: &Context,
+ it: &clean::Item,
+ t: &clean::Existential,
+) -> fmt::Result {
+ write!(w, "<pre class='rust existential'>")?;
+ render_attributes(w, it)?;
+ write!(w, "existential type {}{}{where_clause}: {bounds};</pre>",
+ it.name.as_ref().unwrap(),
+ t.generics,
+ where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
+ bounds = bounds(&t.bounds))?;
+
+ document(w, cx, it)?;
+
+ // Render any items associated directly to this alias, as otherwise they
+ // won't be visible anywhere in the docs. It would be nice to also show
+ // associated items from the aliased type (see discussion in #32077), but
+ // we need #14072 to make sense of the generics.
+ render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+}
+
fn item_typedef(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Typedef) -> fmt::Result {
write!(w, "<pre class='rust typedef'>")?;
ItemType::AssociatedConst => ("associated-consts", "Associated Constants"),
ItemType::ForeignType => ("foreign-types", "Foreign Types"),
ItemType::Keyword => ("keywords", "Keywords"),
+ ItemType::Existential => ("existentials", "Existentials"),
}
}
onEach(e.getElementsByClassName('associatedconstant'), func);
});
- function createToggle(otherMessage, extraClass) {
+ function createToggle(otherMessage, fontSize, extraClass) {
var span = document.createElement('span');
span.className = 'toggle-label';
span.style.display = 'none';
span.innerHTML = ' Expand description';
} else {
span.innerHTML = otherMessage;
- span.style.fontSize = '20px';
+ }
+
+ if (fontSize) {
+ span.style.fontSize = fontSize;
}
var mainToggle = toggle.cloneNode(true);
}
if (e.parentNode.id === "main") {
var otherMessage;
+ var fontSize;
var extraClass;
+
if (hasClass(e, "type-decl")) {
+ fontSize = "20px";
otherMessage = ' Show declaration';
+ } else if (hasClass(e, "non-exhaustive")) {
+ otherMessage = ' This ';
+ if (hasClass(e, "non-exhaustive-struct")) {
+ otherMessage += 'struct';
+ } else if (hasClass(e, "non-exhaustive-enum")) {
+ otherMessage += 'enum';
+ } else if (hasClass(e, "non-exhaustive-type")) {
+ otherMessage += 'type';
+ }
+ otherMessage += ' is marked as non-exhaustive';
} else if (hasClass(e.childNodes[0], "impl-items")) {
extraClass = "marg-left";
}
- e.parentNode.insertBefore(createToggle(otherMessage, extraClass), e);
+
+ e.parentNode.insertBefore(createToggle(otherMessage, fontSize, extraClass), e);
if (otherMessage && getCurrentValue('rustdoc-item-declarations') !== "false") {
collapseDocs(e.previousSibling.childNodes[0], "toggle");
}
}
#all-types > p {
margin: 5px 0;
-}
\ No newline at end of file
+}
+
+.non-exhaustive {
+ margin-bottom: 1em;
+}
}
.search-results td span.grey {
color: #ccc;
-}
\ No newline at end of file
+}
}
.search-results td span.grey {
color: #999;
-}
\ No newline at end of file
+}
use std::collections::{BTreeMap, BTreeSet};
use std::default::Default;
use std::env;
+use std::panic;
use std::path::{Path, PathBuf};
use std::process;
use std::sync::mpsc::channel;
syntax::with_globals(move || {
get_args().map(|args| main_args(&args)).unwrap_or(1)
})
- }).unwrap().join().unwrap_or(101);
+ }).unwrap().join().unwrap_or(rustc_driver::EXIT_FAILURE);
process::exit(res as i32);
}
"disable-minification",
"Disable minification applied on JS files")
}),
- unstable("warn", |o| {
+ stable("warn", |o| {
o.optmulti("W", "warn", "Set lint warnings", "OPT")
}),
- unstable("allow", |o| {
+ stable("allow", |o| {
o.optmulti("A", "allow", "Set lint allowed", "OPT")
}),
- unstable("deny", |o| {
+ stable("deny", |o| {
o.optmulti("D", "deny", "Set lint denied", "OPT")
}),
- unstable("forbid", |o| {
+ stable("forbid", |o| {
o.optmulti("F", "forbid", "Set lint forbidden", "OPT")
}),
- unstable("cap-lints", |o| {
+ stable("cap-lints", |o| {
o.optmulti(
"",
"cap-lints",
let (tx, rx) = channel();
- rustc_driver::monitor(move || syntax::with_globals(move || {
+ let result = rustc_driver::monitor(move || syntax::with_globals(move || {
use rustc::session::config::Input;
let (mut krate, renderinfo) =
tx.send(f(Output { krate: krate, renderinfo: renderinfo, passes: passes })).unwrap();
}));
- rx.recv().unwrap()
+
+ match result {
+ Ok(()) => rx.recv().unwrap(),
+ Err(_) => panic::resume_unwind(Box::new(errors::FatalErrorMarker)),
+ }
}
/// Prints deprecation warnings for deprecated options
return ret;
}
// These items can all get re-exported
+ clean::ExistentialItem(..) |
clean::TypedefItem(..) | clean::StaticItem(..) |
clean::StructItem(..) | clean::EnumItem(..) |
clean::TraitItem(..) | clean::FunctionItem(..) |
};
om.typedefs.push(t);
},
+ hir::ItemKind::Existential(ref exist_ty) => {
+ let t = Existential {
+ exist_ty: exist_ty.clone(),
+ name,
+ id: item.id,
+ attrs: item.attrs.clone(),
+ whence: item.span,
+ vis: item.vis.clone(),
+ stab: self.stability(item.id),
+ depr: self.deprecation(item.id),
+ };
+ om.existentials.push(t);
+ },
hir::ItemKind::Static(ref ty, ref mut_, ref exp) => {
let s = Static {
type_: ty.clone(),
om.impls.push(i);
}
},
- hir::ItemKind::Existential(_) => {
- // FIXME(oli-obk): actually generate docs for real existential items
- }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
pub fn call_once<F>(&self, f: F) where F: FnOnce() {
// Fast path, just see if we've completed initialization.
- if self.state.load(Ordering::SeqCst) == COMPLETE {
+ // An `Acquire` load is enough because that makes all the initialization
+ // operations visible to us. The cold path uses SeqCst consistently
+ // because the performance difference really does not matter there,
+ // and SeqCst minimizes the chances of something going wrong.
+ if self.state.load(Ordering::Acquire) == COMPLETE {
return
}
#[unstable(feature = "once_poison", issue = "33577")]
pub fn call_once_force<F>(&self, f: F) where F: FnOnce(&OnceState) {
// same as above, just with a different parameter to `call_inner`.
- if self.state.load(Ordering::SeqCst) == COMPLETE {
+ // An `Acquire` load is enough because that makes all the initialization
+ // operations visible to us. The cold path uses SeqCst consistently
+ // because the performance difference really does not matter there,
+ // and SeqCst minimizes the chances of something going wrong.
+ if self.state.load(Ordering::Acquire) == COMPLETE {
return
}
Const(P<Ty>, P<Expr>),
Method(MethodSig, P<Block>),
Type(P<Ty>),
+ Existential(GenericBounds),
Macro(Mac),
}
///
/// E.g. `type Foo = Bar<u8>;`
Ty(P<Ty>, Generics),
+ /// An existential type declaration (`existential type`).
+ ///
+ /// E.g. `existential type Foo: Bar + Boo;`
+ Existential(GenericBounds, Generics),
/// An enum definition (`enum` or `pub enum`).
///
/// E.g. `enum Foo<A, B> { C<A>, D<B> }`
ItemKind::ForeignMod(..) => "foreign module",
ItemKind::GlobalAsm(..) => "global asm",
ItemKind::Ty(..) => "type alias",
+ ItemKind::Existential(..) => "existential type",
ItemKind::Enum(..) => "enum",
ItemKind::Struct(..) => "struct",
ItemKind::Union(..) => "union",
InvocationKind::Derive { ref path, .. } => path.span,
}
}
+
+ pub fn attr_id(&self) -> Option<ast::AttrId> {
+ match self.kind {
+ InvocationKind::Attr { attr: Some(ref attr), .. } => Some(attr.id),
+ _ => None,
+ }
+ }
}
pub struct MacroExpander<'a, 'b:'a> {
let scope =
if self.monotonic { invoc.expansion_data.mark } else { orig_expansion_data.mark };
+ let attr_id_before = invoc.attr_id();
let ext = match self.cx.resolver.resolve_invoc(&mut invoc, scope, force) {
Ok(ext) => Some(ext),
Err(Determinacy::Determined) => None,
Err(Determinacy::Undetermined) => {
+ // Sometimes attributes which we thought were invocations
+ // end up being custom attributes for custom derives. If
+ // that's the case our `invoc` will have changed out from
+ // under us. If this is the case we're making progress so we
+ // want to flag it as such, and we test this by looking if
+ // the `attr_id()` method has been changing over time.
+ if invoc.attr_id() != attr_id_before {
+ progress = true;
+ }
undetermined_invocations.push(invoc);
continue
}
// `use path as _;` and `extern crate c as _;`
(active, underscore_imports, "1.26.0", Some(48216), None),
- // The #![wasm_import_module] attribute
- (active, wasm_import_module, "1.26.0", Some(52090), None),
-
// Allows keywords to be escaped for use as identifiers
(active, raw_identifiers, "1.26.0", Some(48589), None),
// Allows macro invocations in `extern {}` blocks
(active, macros_in_extern, "1.27.0", Some(49476), None),
+ // `existential type`
+ (active, existential_type, "1.28.0", Some(34511), None),
+
// unstable #[target_feature] directives
(active, arm_target_feature, "1.27.0", Some(44839), None),
(active, aarch64_target_feature, "1.27.0", Some(44839), None),
"the `#[no_debug]` attribute was an experimental feature that has been \
deprecated due to lack of demand",
cfg_fn!(no_debug))),
- ("wasm_import_module", Normal, Gated(Stability::Unstable,
- "wasm_import_module",
- "experimental attribute",
- cfg_fn!(wasm_import_module))),
("omit_gdb_pretty_printer_section", Whitelisted, Gated(Stability::Unstable,
"omit_gdb_pretty_printer_section",
"the `#[omit_gdb_pretty_printer_section]` \
gate_feature_post!(&self, decl_macro, i.span, msg);
}
+ ast::ItemKind::Existential(..) => {
+ gate_feature_post!(
+ &self,
+ existential_type,
+ i.span,
+ "existential types are unstable"
+ );
+ }
+
_ => {}
}
gate_feature_post!(&self, const_fn, ii.span, "const fn is unstable");
}
}
+ ast::ImplItemKind::Existential(..) => {
+ gate_feature_post!(
+ &self,
+ existential_type,
+ ii.span,
+ "existential types are unstable"
+ );
+ }
+
ast::ImplItemKind::Type(_) if !ii.generics.params.is_empty() => {
gate_feature_post!(&self, generic_associated_types, ii.span,
"generic associated types are unstable");
ItemKind::Ty(t, generics) => {
ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics))
}
+ ItemKind::Existential(bounds, generics) => ItemKind::Existential(
+ folder.fold_bounds(bounds),
+ folder.fold_generics(generics),
+ ),
ItemKind::Enum(enum_definition, generics) => {
let generics = folder.fold_generics(generics);
let variants = enum_definition.variants.move_map(|x| folder.fold_variant(x));
folder.fold_block(body))
}
ast::ImplItemKind::Type(ty) => ast::ImplItemKind::Type(folder.fold_ty(ty)),
+ ast::ImplItemKind::Existential(bounds) => {
+ ast::ImplItemKind::Existential(folder.fold_bounds(bounds))
+ },
ast::ImplItemKind::Macro(mac) => ast::ImplItemKind::Macro(folder.fold_mac(mac))
},
span: folder.new_span(i.span),
use std::path::{self, Path, PathBuf};
use std::slice;
+#[derive(Debug)]
+/// Whether the type alias or associated type is a concrete type or an existential type
+pub enum AliasKind {
+ /// Just a new name for the same type
+ Weak(P<Ty>),
+ /// Only trait impls of the type will be usable, not the actual type itself
+ Existential(GenericBounds),
+}
+
bitflags! {
struct Restrictions: u8 {
const STMT_EXPR = 1 << 0;
let lo = self.span;
let vis = self.parse_visibility(false)?;
let defaultness = self.parse_defaultness();
- let (name, node, generics) = if self.eat_keyword(keywords::Type) {
- // This parses the grammar:
- // ImplItemAssocTy = Ident ["<"...">"] ["where" ...] "=" Ty ";"
- let name = self.parse_ident()?;
- let mut generics = self.parse_generics()?;
- generics.where_clause = self.parse_where_clause()?;
- self.expect(&token::Eq)?;
- let typ = self.parse_ty()?;
- self.expect(&token::Semi)?;
- (name, ast::ImplItemKind::Type(typ), generics)
+ let (name, node, generics) = if let Some(type_) = self.eat_type() {
+ let (name, alias, generics) = type_?;
+ let kind = match alias {
+ AliasKind::Weak(typ) => ast::ImplItemKind::Type(typ),
+ AliasKind::Existential(bounds) => ast::ImplItemKind::Existential(bounds),
+ };
+ (name, kind, generics)
} else if self.is_const_item() {
// This parses the grammar:
// ImplItemConst = "const" Ident ":" Ty "=" Expr ";"
}
/// Parse type Foo = Bar;
- fn parse_item_type(&mut self) -> PResult<'a, ItemInfo> {
+ /// or
+ /// existential type Foo: Bar;
+ /// or
+ /// return None without modifying the parser state
+ fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, ast::Generics)>> {
+ // This parses the grammar:
+ // Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";"
+ if self.check_keyword(keywords::Type) ||
+ self.check_keyword(keywords::Existential) &&
+ self.look_ahead(1, |t| t.is_keyword(keywords::Type)) {
+ let existential = self.eat_keyword(keywords::Existential);
+ assert!(self.eat_keyword(keywords::Type));
+ Some(self.parse_existential_or_alias(existential))
+ } else {
+ None
+ }
+ }
+
+ /// Parse type alias or existential type
+ fn parse_existential_or_alias(
+ &mut self,
+ existential: bool,
+ ) -> PResult<'a, (Ident, AliasKind, ast::Generics)> {
let ident = self.parse_ident()?;
let mut tps = self.parse_generics()?;
tps.where_clause = self.parse_where_clause()?;
- self.expect(&token::Eq)?;
- let ty = self.parse_ty()?;
+ let alias = if existential {
+ self.expect(&token::Colon)?;
+ let bounds = self.parse_generic_bounds()?;
+ AliasKind::Existential(bounds)
+ } else {
+ self.expect(&token::Eq)?;
+ let ty = self.parse_ty()?;
+ AliasKind::Weak(ty)
+ };
self.expect(&token::Semi)?;
- Ok((ident, ItemKind::Ty(ty, tps), None))
+ Ok((ident, alias, tps))
}
/// Parse the part of an "enum" decl following the '{'
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.eat_keyword(keywords::Type) {
+ if let Some(type_) = self.eat_type() {
+ let (ident, alias, generics) = type_?;
// TYPE ITEM
- let (ident, item_, extra_attrs) = self.parse_item_type()?;
+ let item_ = match alias {
+ AliasKind::Weak(ty) => ItemKind::Ty(ty, generics),
+ AliasKind::Existential(bounds) => ItemKind::Existential(bounds, generics),
+ };
let prev_span = self.prev_span;
let item = self.mk_item(lo.to(prev_span),
ident,
item_,
visibility,
- maybe_append(attrs, extra_attrs));
+ attrs);
return Ok(Some(item));
}
if self.eat_keyword(keywords::Enum) {
self.end()?;
}
ast::ItemKind::Ty(ref ty, ref generics) => {
- self.ibox(INDENT_UNIT)?;
- self.ibox(0)?;
- self.word_nbsp(&visibility_qualified(&item.vis, "type"))?;
+ self.head(&visibility_qualified(&item.vis, "type"))?;
self.print_ident(item.ident)?;
self.print_generic_params(&generics.params)?;
self.end()?; // end the inner ibox
self.s.word(";")?;
self.end()?; // end the outer ibox
}
+ ast::ItemKind::Existential(ref bounds, ref generics) => {
+ self.head(&visibility_qualified(&item.vis, "existential type"))?;
+ self.print_ident(item.ident)?;
+ self.print_generic_params(&generics.params)?;
+ self.end()?; // end the inner ibox
+
+ self.print_where_clause(&generics.where_clause)?;
+ self.s.space()?;
+ self.print_type_bounds(":", bounds)?;
+ self.s.word(";")?;
+ self.end()?; // end the outer ibox
+ }
ast::ItemKind::Enum(ref enum_definition, ref params) => {
self.print_enum_def(
enum_definition,
}
}
- pub fn print_defaultness(&mut self, defatulness: ast::Defaultness) -> io::Result<()> {
- if let ast::Defaultness::Default = defatulness {
+ pub fn print_defaultness(&mut self, defaultness: ast::Defaultness) -> io::Result<()> {
+ if let ast::Defaultness::Default = defaultness {
try!(self.word_nbsp("default"));
}
Ok(())
ast::ImplItemKind::Type(ref ty) => {
self.print_associated_type(ii.ident, None, Some(ty))?;
}
+ ast::ImplItemKind::Existential(ref bounds) => {
+ self.word_space("existential")?;
+ self.print_associated_type(ii.ident, Some(bounds), None)?;
+ }
ast::ImplItemKind::Macro(ref mac) => {
self.print_mac(mac)?;
match mac.node.delim {
visitor.visit_ty(typ);
visitor.visit_generics(type_parameters)
}
+ ItemKind::Existential(ref bounds, ref type_parameters) => {
+ walk_list!(visitor, visit_param_bound, bounds);
+ visitor.visit_generics(type_parameters)
+ }
ItemKind::Enum(ref enum_definition, ref type_parameters) => {
visitor.visit_generics(type_parameters);
visitor.visit_enum_def(enum_definition, type_parameters, item.id, item.span)
ImplItemKind::Type(ref ty) => {
visitor.visit_ty(ty);
}
+ ImplItemKind::Existential(ref bounds) => {
+ walk_list!(visitor, visit_param_bound, bounds);
+ }
ImplItemKind::Macro(ref mac) => {
visitor.visit_mac(mac);
}
(56, Default, "default")
(57, Dyn, "dyn")
(58, Union, "union")
+ (59, Existential, "existential")
}
impl Symbol {
MD->addOperand(Unit);
}
-extern "C" void
-LLVMRustThinLTORemoveAvailableExternally(LLVMModuleRef Mod) {
- Module *M = unwrap(Mod);
- for (Function &F : M->functions()) {
- if (F.hasAvailableExternallyLinkage())
- F.deleteBody();
- }
-}
-
#else
extern "C" bool
report_fatal_error("ThinLTO not available");
}
-extern "C" void
-LLVMRustThinLTORemoveAvailableExternally(LLVMModuleRef Mod) {
- report_fatal_error("ThinLTO not available");
-}
-
#endif // LLVM_VERSION_GE(4, 0)
// except according to those terms.
// compile-flags: -Z parse-only
+// ignore-tidy-linelength
struct Foo;
fn foo() {}
#[stable(feature = "rust1", since = "1.0.0")]
-} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, or
+} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, or
fn main() {}
// except according to those terms.
// compile-flags: -Z parse-only
+// ignore-tidy-linelength
struct Foo;
impl Foo {
#[stable(feature = "rust1", since = "1.0.0")]
-} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`, or
+} //~ ERROR expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`, or
fn main() {}
// except according to those terms.
// compile-flags: -Z parse-only
+// ignore-tidy-linelength
struct S;
impl S {
static fn f() {}
}
-//~^^ ERROR expected one of `async`, `const`, `crate`, `default`, `extern`, `fn`, `pub`, `type`,
+//~^^ ERROR expected one of `async`, `const`, `crate`, `default`, `existential`, `extern`, `fn`, `pub`, `type`,
--- /dev/null
+-include ../tools.mk
+
+all:
+ $(RUSTC) success.rs; [ $$? -eq 0 ]
+ $(RUSTC) --invalid-arg-foo; [ $$? -eq 1 ]
+ $(RUSTC) compile-error.rs; [ $$? -eq 1 ]
+ $(RUSTC) -Ztreat-err-as-bug compile-error.rs; [ $$? -eq 101 ]
+ $(RUSTDOC) -o $(TMPDIR)/exit-code success.rs; [ $$? -eq 0 ]
+ $(RUSTDOC) --invalid-arg-foo; [ $$? -eq 1 ]
+ $(RUSTDOC) compile-error.rs; [ $$? -eq 1 ]
+ $(RUSTDOC) lint-failure.rs; [ $$? -eq 1 ]
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ compile_error!("kaboom");
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(intra_doc_link_resolution_failure)]
+
+/// [intradoc::failure]
+fn main() {
+ println!("Hello, world!");
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// Main function
+fn main() {
+ println!("Hello, world!");
+}
// except according to those terms.
#![crate_type = "cdylib"]
-#![feature(wasm_import_module)]
#![deny(warnings)]
extern crate foo;
-#[wasm_import_module = "./me"]
+#[link(wasm_import_module = "./me")]
extern {
#[link_name = "me_in_dep"]
fn dep();
// except according to those terms.
#![crate_type = "rlib"]
-#![feature(wasm_import_module)]
#![deny(warnings)]
-#[wasm_import_module = "./dep"]
+#[link(wasm_import_module = "./dep")]
extern {
pub fn dep();
}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+
+use proc_macro::*;
+
+#[proc_macro_derive(A, attributes(b))]
+pub fn foo(_x: TokenStream) -> TokenStream {
+ TokenStream::new()
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:derive-two-attrs.rs
+
+#![feature(use_extern_macros)]
+
+extern crate derive_two_attrs as foo;
+
+use foo::A;
+
+#[derive(A)]
+#[b]
+#[b]
+struct B;
+
+fn main() {}
assert!(foo as usize != bar as usize);
- assert_eq!(foo as i16, foo as usize as i16);
+ // Taking a few bits of a function's address is totally pointless and we detect that
+ // Disabling the lint to ensure that the assertion can still be run
+ #[allow(const_err)]
+ {
+ assert_eq!(foo as i16, foo as usize as i16);
+ }
// fptr-ptr-cast
static BLOCK_ENUM_CONSTRUCTOR: fn(usize) -> Option<usize> = { Some };
-// FIXME #13972
-// static BLOCK_UNSAFE_SAFE_PTR: &'static isize = unsafe { &*(0xdeadbeef as *const isize) };
-// static BLOCK_UNSAFE_SAFE_PTR_2: &'static isize = unsafe {
-// const X: *const isize = 0xdeadbeef as *const isize;
-// &*X
-// };
-
pub fn main() {
assert_eq!(BLOCK_INTEGRAL, 1);
assert_eq!(BLOCK_EXPLICIT_UNIT, ());
assert_eq!(BLOCK_FN_INFERRED(300), 300);
assert_eq!(BLOCK_FN(300), 300);
assert_eq!(BLOCK_ENUM_CONSTRUCTOR(200), Some(200));
- // FIXME #13972
- // assert_eq!(BLOCK_UNSAFE_SAFE_PTR as *const isize as usize, 0xdeadbeef);
- // assert_eq!(BLOCK_UNSAFE_SAFE_PTR_2 as *const isize as usize, 0xdeadbeef);
}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(existential_type)]
+
+fn main() {
+ assert_eq!(foo().to_string(), "foo");
+ assert_eq!(bar1().to_string(), "bar1");
+ assert_eq!(bar2().to_string(), "bar2");
+ let mut x = bar1();
+ x = bar2();
+ assert_eq!(boo::boo().to_string(), "boo");
+ assert_eq!(my_iter(42u8).collect::<Vec<u8>>(), vec![42u8]);
+}
+
+// single definition
+existential type Foo: std::fmt::Display;
+
+fn foo() -> Foo {
+ "foo"
+}
+
+// two definitions
+existential type Bar: std::fmt::Display;
+
+fn bar1() -> Bar {
+ "bar1"
+}
+
+fn bar2() -> Bar {
+ "bar2"
+}
+
+// definition in submodule
+existential type Boo: std::fmt::Display;
+
+mod boo {
+ pub fn boo() -> super::Boo {
+ "boo"
+ }
+}
+
+existential type MyIter<T>: Iterator<Item = T>;
+
+fn my_iter<T>(t: T) -> MyIter<T> {
+ std::iter::once(t)
+}
+
+fn my_iter2<T>(t: T) -> MyIter<T> {
+ std::iter::once(t)
+}
+
+// param names should not have an effect!
+fn my_iter3<U>(u: U) -> MyIter<U> {
+ std::iter::once(u)
+}
+
+// param position should not have an effect!
+fn my_iter4<U, V>(_: U, v: V) -> MyIter<V> {
+ std::iter::once(v)
+}
+
+// param names should not have an effect!
+existential type MyOtherIter<T>: Iterator<Item = T>;
+
+fn my_other_iter<U>(u: U) -> MyOtherIter<U> {
+ std::iter::once(u)
+}
+
+trait Trait {}
+existential type GenericBound<'a, T: Trait>: 'a;
+
+fn generic_bound<'a, T: Trait + 'a>(t: T) -> GenericBound<'a, T> {
+ t
+}
+
+mod pass_through {
+ pub existential type Passthrough<T>: 'static;
+
+ fn define_passthrough<T: 'static>(t: T) -> Passthrough<T> {
+ t
+ }
+}
+
+fn use_passthrough(x: pass_through::Passthrough<u32>) -> pass_through::Passthrough<u32> {
+ x
+}
// aux-build:sepcomp_lib.rs
// compile-flags: -C lto -g
// no-prefer-dynamic
-// ignore-android FIXME #18800
extern crate sepcomp_lib;
use sepcomp_lib::a::one;
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Foo;
+fn takes_ref(_: &Foo) {}
+
+fn main() {
+ let ref opt = Some(Foo);
+ opt.map(|arg| takes_ref(arg));
+ //~^ ERROR mismatched types [E0308]
+ opt.and_then(|arg| Some(takes_ref(arg)));
+ //~^ ERROR mismatched types [E0308]
+ let ref opt: Result<_, ()> = Ok(Foo);
+ opt.map(|arg| takes_ref(arg));
+ //~^ ERROR mismatched types [E0308]
+ opt.and_then(|arg| Ok(takes_ref(arg)));
+ //~^ ERROR mismatched types [E0308]
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/as-ref.rs:16:27
+ |
+LL | opt.map(|arg| takes_ref(arg));
+ | - ^^^ expected &Foo, found struct `Foo`
+ | |
+ | help: consider using `as_ref` instead: `as_ref().`
+ |
+ = note: expected type `&Foo`
+ found type `Foo`
+
+error[E0308]: mismatched types
+ --> $DIR/as-ref.rs:18:37
+ |
+LL | opt.and_then(|arg| Some(takes_ref(arg)));
+ | - ^^^ expected &Foo, found struct `Foo`
+ | |
+ | help: consider using `as_ref` instead: `as_ref().`
+ |
+ = note: expected type `&Foo`
+ found type `Foo`
+
+error[E0308]: mismatched types
+ --> $DIR/as-ref.rs:21:27
+ |
+LL | opt.map(|arg| takes_ref(arg));
+ | - ^^^ expected &Foo, found struct `Foo`
+ | |
+ | help: consider using `as_ref` instead: `as_ref().`
+ |
+ = note: expected type `&Foo`
+ found type `Foo`
+
+error[E0308]: mismatched types
+ --> $DIR/as-ref.rs:23:35
+ |
+LL | opt.and_then(|arg| Ok(takes_ref(arg)));
+ | - ^^^ expected &Foo, found struct `Foo`
+ | |
+ | help: consider using `as_ref` instead: `as_ref().`
+ |
+ = note: expected type `&Foo`
+ found type `Foo`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn foo() {}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn bar() {}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_export]
+macro_rules! mac {
+ ($ident:ident) => { let $ident = 42; }
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// intentionally blank
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+// Point at the captured immutable outer variable
+
+fn foo(mut f: Box<FnMut()>) {
+ f();
+}
+
+fn main() {
+ let mut y = true;
+ foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
+}
--- /dev/null
+error[E0594]: cannot assign to immutable item `y`
+ --> $DIR/closure-immutable-outer-variable.rs:21:26
+ |
+LL | foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
+ | ^^^^^^^^^ cannot assign
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0594`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+// Point at the captured immutable outer variable
+
+fn foo(mut f: Box<FnMut()>) {
+ f();
+}
+
+fn main() {
+ let y = true;
+ foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Point at the captured immutable outer variable
+
+fn foo(mut f: Box<FnMut()>) {
+ f();
+}
+
+fn main() {
+ let mut y = true;
+ foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
+}
--- /dev/null
+error[E0594]: cannot assign to captured outer variable in an `FnMut` closure
+ --> $DIR/closure-immutable-outer-variable.rs:21:26
+ |
+LL | let y = true;
+ | - help: consider making `y` mutable: `mut y`
+LL | foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
+ | ^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0594`.
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Obj<F> where F: FnMut() -> u32 {
+ closure: F,
+}
+
+fn main() {
+ let o = Obj { closure: || 42 };
+ o.closure();
+ //~^ ERROR no method named `closure` found
+}
--- /dev/null
+error[E0599]: no method named `closure` found for type `Obj<[closure@$DIR/issue-18343.rs:16:28: 16:33]>` in the current scope
+ --> $DIR/issue-18343.rs:17:7
+ |
+LL | struct Obj<F> where F: FnMut() -> u32 {
+ | ------------------------------------- method `closure` not found for this
+...
+LL | o.closure();
+ | ^^^^^^^ field, not a method
+ |
+ = help: use `(o.closure)(...)` if you meant to call the function stored in the `closure` field
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0599`.
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(core, fnbox)]
+
+use std::boxed::FnBox;
+
+struct FuncContainer {
+ f1: fn(data: u8),
+ f2: extern "C" fn(data: u8),
+ f3: unsafe fn(data: u8),
+}
+
+struct FuncContainerOuter {
+ container: Box<FuncContainer>
+}
+
+struct Obj<F> where F: FnOnce() -> u32 {
+ closure: F,
+ not_closure: usize,
+}
+
+struct BoxedObj {
+ boxed_closure: Box<FnBox() -> u32>,
+}
+
+struct Wrapper<F> where F: FnMut() -> u32 {
+ wrap: Obj<F>,
+}
+
+fn func() -> u32 {
+ 0
+}
+
+fn check_expression() -> Obj<Box<FnBox() -> u32>> {
+ Obj { closure: Box::new(|| 42_u32) as Box<FnBox() -> u32>, not_closure: 42 }
+}
+
+fn main() {
+ // test variations of function
+
+ let o_closure = Obj { closure: || 42, not_closure: 42 };
+ o_closure.closure(); //~ ERROR no method named `closure` found
+
+ o_closure.not_closure();
+ //~^ ERROR no method named `not_closure` found
+
+ let o_func = Obj { closure: func, not_closure: 5 };
+ o_func.closure(); //~ ERROR no method named `closure` found
+
+ let boxed_fn = BoxedObj { boxed_closure: Box::new(func) };
+ boxed_fn.boxed_closure();//~ ERROR no method named `boxed_closure` found
+
+ let boxed_closure = BoxedObj { boxed_closure: Box::new(|| 42_u32) as Box<FnBox() -> u32> };
+ boxed_closure.boxed_closure();//~ ERROR no method named `boxed_closure` found
+
+ // test expression writing in the notes
+
+ let w = Wrapper { wrap: o_func };
+ w.wrap.closure();//~ ERROR no method named `closure` found
+
+ w.wrap.not_closure();
+ //~^ ERROR no method named `not_closure` found
+
+ check_expression().closure();//~ ERROR no method named `closure` found
+}
+
+impl FuncContainerOuter {
+ fn run(&self) {
+ unsafe {
+ (*self.container).f1(1); //~ ERROR no method named `f1` found
+ (*self.container).f2(1); //~ ERROR no method named `f2` found
+ (*self.container).f3(1); //~ ERROR no method named `f3` found
+ }
+ }
+}
--- /dev/null
+error[E0599]: no method named `closure` found for type `Obj<[closure@$DIR/issue-2392.rs:49:36: 49:41]>` in the current scope
+ --> $DIR/issue-2392.rs:50:15
+ |
+LL | struct Obj<F> where F: FnOnce() -> u32 {
+ | -------------------------------------- method `closure` not found for this
+...
+LL | o_closure.closure(); //~ ERROR no method named `closure` found
+ | ^^^^^^^ field, not a method
+ |
+ = help: use `(o_closure.closure)(...)` if you meant to call the function stored in the `closure` field
+
+error[E0599]: no method named `not_closure` found for type `Obj<[closure@$DIR/issue-2392.rs:49:36: 49:41]>` in the current scope
+ --> $DIR/issue-2392.rs:52:15
+ |
+LL | struct Obj<F> where F: FnOnce() -> u32 {
+ | -------------------------------------- method `not_closure` not found for this
+...
+LL | o_closure.not_closure();
+ | ^^^^^^^^^^^ field, not a method
+ |
+ = help: did you mean to write `o_closure.not_closure` instead of `o_closure.not_closure(...)`?
+
+error[E0599]: no method named `closure` found for type `Obj<fn() -> u32 {func}>` in the current scope
+ --> $DIR/issue-2392.rs:56:12
+ |
+LL | struct Obj<F> where F: FnOnce() -> u32 {
+ | -------------------------------------- method `closure` not found for this
+...
+LL | o_func.closure(); //~ ERROR no method named `closure` found
+ | ^^^^^^^ field, not a method
+ |
+ = help: use `(o_func.closure)(...)` if you meant to call the function stored in the `closure` field
+
+error[E0599]: no method named `boxed_closure` found for type `BoxedObj` in the current scope
+ --> $DIR/issue-2392.rs:59:14
+ |
+LL | struct BoxedObj {
+ | --------------- method `boxed_closure` not found for this
+...
+LL | boxed_fn.boxed_closure();//~ ERROR no method named `boxed_closure` found
+ | ^^^^^^^^^^^^^ field, not a method
+ |
+ = help: use `(boxed_fn.boxed_closure)(...)` if you meant to call the function stored in the `boxed_closure` field
+
+error[E0599]: no method named `boxed_closure` found for type `BoxedObj` in the current scope
+ --> $DIR/issue-2392.rs:62:19
+ |
+LL | struct BoxedObj {
+ | --------------- method `boxed_closure` not found for this
+...
+LL | boxed_closure.boxed_closure();//~ ERROR no method named `boxed_closure` found
+ | ^^^^^^^^^^^^^ field, not a method
+ |
+ = help: use `(boxed_closure.boxed_closure)(...)` if you meant to call the function stored in the `boxed_closure` field
+
+error[E0599]: no method named `closure` found for type `Obj<fn() -> u32 {func}>` in the current scope
+ --> $DIR/issue-2392.rs:67:12
+ |
+LL | struct Obj<F> where F: FnOnce() -> u32 {
+ | -------------------------------------- method `closure` not found for this
+...
+LL | w.wrap.closure();//~ ERROR no method named `closure` found
+ | ^^^^^^^ field, not a method
+ |
+ = help: use `(w.wrap.closure)(...)` if you meant to call the function stored in the `closure` field
+
+error[E0599]: no method named `not_closure` found for type `Obj<fn() -> u32 {func}>` in the current scope
+ --> $DIR/issue-2392.rs:69:12
+ |
+LL | struct Obj<F> where F: FnOnce() -> u32 {
+ | -------------------------------------- method `not_closure` not found for this
+...
+LL | w.wrap.not_closure();
+ | ^^^^^^^^^^^ field, not a method
+ |
+ = help: did you mean to write `w.wrap.not_closure` instead of `w.wrap.not_closure(...)`?
+
+error[E0599]: no method named `closure` found for type `Obj<std::boxed::Box<(dyn std::boxed::FnBox<(), Output=u32> + 'static)>>` in the current scope
+ --> $DIR/issue-2392.rs:72:24
+ |
+LL | struct Obj<F> where F: FnOnce() -> u32 {
+ | -------------------------------------- method `closure` not found for this
+...
+LL | check_expression().closure();//~ ERROR no method named `closure` found
+ | ^^^^^^^ field, not a method
+ |
+ = help: use `(check_expression().closure)(...)` if you meant to call the function stored in the `closure` field
+
+error[E0599]: no method named `f1` found for type `FuncContainer` in the current scope
+ --> $DIR/issue-2392.rs:78:31
+ |
+LL | struct FuncContainer {
+ | -------------------- method `f1` not found for this
+...
+LL | (*self.container).f1(1); //~ ERROR no method named `f1` found
+ | ^^ field, not a method
+ |
+ = help: use `((*self.container).f1)(...)` if you meant to call the function stored in the `f1` field
+
+error[E0599]: no method named `f2` found for type `FuncContainer` in the current scope
+ --> $DIR/issue-2392.rs:79:31
+ |
+LL | struct FuncContainer {
+ | -------------------- method `f2` not found for this
+...
+LL | (*self.container).f2(1); //~ ERROR no method named `f2` found
+ | ^^ field, not a method
+ |
+ = help: use `((*self.container).f2)(...)` if you meant to call the function stored in the `f2` field
+
+error[E0599]: no method named `f3` found for type `FuncContainer` in the current scope
+ --> $DIR/issue-2392.rs:80:31
+ |
+LL | struct FuncContainer {
+ | -------------------- method `f3` not found for this
+...
+LL | (*self.container).f3(1); //~ ERROR no method named `f3` found
+ | ^^ field, not a method
+ |
+ = help: use `((*self.container).f3)(...)` if you meant to call the function stored in the `f3` field
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0599`.
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Example {
+ example: Box<Fn(i32) -> i32>
+}
+
+fn main() {
+ let demo = Example {
+ example: Box::new(|x| {
+ x + 1
+ })
+ };
+
+ demo.example(1);
+ //~^ ERROR no method named `example`
+ // (demo.example)(1);
+}
--- /dev/null
+error[E0599]: no method named `example` found for type `Example` in the current scope
+ --> $DIR/issue-32128.rs:22:10
+ |
+LL | struct Example {
+ | -------------- method `example` not found for this
+...
+LL | demo.example(1);
+ | ^^^^^^^ field, not a method
+ |
+ = help: use `(demo.example)(...)` if you meant to call the function stored in the `example` field
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0599`.
--- /dev/null
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::ops::Deref;
+
+struct Obj<F> where F: FnMut() -> u32 {
+ fn_ptr: fn() -> (),
+ closure: F,
+}
+
+struct C {
+ c_fn_ptr: fn() -> (),
+}
+
+struct D(C);
+
+impl Deref for D {
+ type Target = C;
+ fn deref(&self) -> &C {
+ &self.0
+ }
+}
+
+
+fn empty() {}
+
+fn main() {
+ let o = Obj { fn_ptr: empty, closure: || 42 };
+ let p = &o;
+ p.closure(); //~ ERROR no method named `closure` found
+ let q = &p;
+ q.fn_ptr(); //~ ERROR no method named `fn_ptr` found
+ let r = D(C { c_fn_ptr: empty });
+ let s = &r;
+ s.c_fn_ptr(); //~ ERROR no method named `c_fn_ptr` found
+}
--- /dev/null
+error[E0599]: no method named `closure` found for type `&Obj<[closure@$DIR/issue-33784.rs:35:43: 35:48]>` in the current scope
+ --> $DIR/issue-33784.rs:37:7
+ |
+LL | p.closure(); //~ ERROR no method named `closure` found
+ | ^^^^^^^ field, not a method
+ |
+ = help: use `(p.closure)(...)` if you meant to call the function stored in the `closure` field
+
+error[E0599]: no method named `fn_ptr` found for type `&&Obj<[closure@$DIR/issue-33784.rs:35:43: 35:48]>` in the current scope
+ --> $DIR/issue-33784.rs:39:7
+ |
+LL | q.fn_ptr(); //~ ERROR no method named `fn_ptr` found
+ | ^^^^^^ field, not a method
+ |
+ = help: use `(q.fn_ptr)(...)` if you meant to call the function stored in the `fn_ptr` field
+
+error[E0599]: no method named `c_fn_ptr` found for type `&D` in the current scope
+ --> $DIR/issue-33784.rs:42:7
+ |
+LL | s.c_fn_ptr(); //~ ERROR no method named `c_fn_ptr` found
+ | ^^^^^^^^ field, not a method
+ |
+ = help: use `(s.c_fn_ptr)(...)` if you meant to call the function stored in the `c_fn_ptr` field
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0599`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub mod animal {
+ pub struct Dog {
+ pub age: usize,
+ dog_age: usize,
+ }
+
+ impl Dog {
+ pub fn new(age: usize) -> Dog {
+ Dog { age: age, dog_age: age * 7 }
+ }
+ }
+}
+
+fn main() {
+ let dog = animal::Dog::new(3);
+ let dog_age = dog.dog_age(); //~ ERROR no method
+ //let dog_age = dog.dog_age;
+ println!("{}", dog_age);
+}
--- /dev/null
+error[E0599]: no method named `dog_age` found for type `animal::Dog` in the current scope
+ --> $DIR/private-field.rs:26:23
+ |
+LL | pub struct Dog {
+ | -------------- method `dog_age` not found for this
+...
+LL | let dog_age = dog.dog_age(); //~ ERROR no method
+ | ^^^^^^^ private field, not a method
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0599`.
//~| WARN const_err
println!("{}", 1/(false as u32));
//~^ WARN const_err
+ //~| WARN const_err
let _x = 1/(false as u32);
+ //~^ WARN const_err
+ //~| WARN const_err
}
LL | let _x = 1/(1-1);
| ^^^^^^^ attempt to divide by zero
+warning: attempt to divide by zero
+ --> $DIR/promoted_errors.rs:25:20
+ |
+LL | println!("{}", 1/(false as u32));
+ | ^^^^^^^^^^^^^^^^
+
warning: this expression will panic at runtime
--> $DIR/promoted_errors.rs:25:20
|
LL | println!("{}", 1/(false as u32));
| ^^^^^^^^^^^^^^^^ attempt to divide by zero
+warning: attempt to divide by zero
+ --> $DIR/promoted_errors.rs:28:14
+ |
+LL | let _x = 1/(false as u32);
+ | ^^^^^^^^^^^^^^^^
+
+warning: this expression will panic at runtime
+ --> $DIR/promoted_errors.rs:28:14
+ |
+LL | let _x = 1/(false as u32);
+ | ^^^^^^^^^^^^^^^^ attempt to divide by zero
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// `const`s shouldn't suggest `.into()`
+
+const TEN: u8 = 10;
+const TWELVE: u16 = TEN + 2;
+//~^ ERROR mismatched types [E0308]
+
+fn main() {
+ const TEN: u8 = 10;
+ const ALSO_TEN: u16 = TEN;
+ //~^ ERROR mismatched types [E0308]
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/const-type-mismatch.rs:14:21
+ |
+LL | const TWELVE: u16 = TEN + 2;
+ | ^^^^^^^ expected u16, found u8
+
+error[E0308]: mismatched types
+ --> $DIR/const-type-mismatch.rs:19:27
+ |
+LL | const ALSO_TEN: u16 = TEN;
+ | ^^^ expected u16, found u8
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::path::{Path, PathBuf};
+
+
+fn main() {
+ let _tis_an_instants_play: String = "'Tis a fond Ambush—"; //~ ERROR mismatched types
+ let _just_to_make_bliss: PathBuf = Path::new("/ern/her/own/surprise");
+ //~^ ERROR mismatched types
+
+ let _but_should_the_play: String = 2; // Perhaps surprisingly, we suggest .to_string() here
+ //~^ ERROR mismatched types
+
+ let _prove_piercing_earnest: Vec<usize> = &[1, 2, 3]; //~ ERROR mismatched types
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/conversion-methods.rs:15:41
+ |
+LL | let _tis_an_instants_play: String = "'Tis a fond Ambush—"; //~ ERROR mismatched types
+ | ^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | expected struct `std::string::String`, found reference
+ | help: try using a conversion method: `"'Tis a fond Ambush—".to_string()`
+ |
+ = note: expected type `std::string::String`
+ found type `&'static str`
+
+error[E0308]: mismatched types
+ --> $DIR/conversion-methods.rs:16:40
+ |
+LL | let _just_to_make_bliss: PathBuf = Path::new("/ern/her/own/surprise");
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | expected struct `std::path::PathBuf`, found reference
+ | help: try using a conversion method: `Path::new("/ern/her/own/surprise").to_path_buf()`
+ |
+ = note: expected type `std::path::PathBuf`
+ found type `&std::path::Path`
+
+error[E0308]: mismatched types
+ --> $DIR/conversion-methods.rs:19:40
+ |
+LL | let _but_should_the_play: String = 2; // Perhaps surprisingly, we suggest .to_string() here
+ | ^
+ | |
+ | expected struct `std::string::String`, found integral variable
+ | help: try using a conversion method: `2.to_string()`
+ |
+ = note: expected type `std::string::String`
+ found type `{integer}`
+
+error[E0308]: mismatched types
+ --> $DIR/conversion-methods.rs:22:47
+ |
+LL | let _prove_piercing_earnest: Vec<usize> = &[1, 2, 3]; //~ ERROR mismatched types
+ | ^^^^^^^^^^
+ | |
+ | expected struct `std::vec::Vec`, found reference
+ | help: try using a conversion method: `&[1, 2, 3].to_vec()`
+ |
+ = note: expected type `std::vec::Vec<usize>`
+ found type `&[{integer}; 3]`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct T;
+
+fn main() {
+ T::new();
+ //~^ ERROR no function or associated item named `new` found for type `T` in the current scope
+}
--- /dev/null
+error[E0599]: no function or associated item named `new` found for type `T` in the current scope
+ --> $DIR/dont-suggest-private-trait-method.rs:14:5
+ |
+LL | struct T;
+ | --------- function or associated item `new` not found for this
+...
+LL | T::new();
+ | ^^^^^^ function or associated item not found in `T`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0599`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let _redemptive = 1...21;
+ //~^ ERROR unexpected token
+}
--- /dev/null
+error: unexpected token: `...`
+ --> $DIR/dotdotdot-expr.rs:12:24
+ |
+LL | let _redemptive = 1...21;
+ | ^^^
+help: use `..` for an exclusive range
+ |
+LL | let _redemptive = 1..21;
+ | ^^
+help: or `..=` for an inclusive range
+ |
+LL | let _redemptive = 1..=21;
+ | ^^^
+
+error: aborting due to previous error
+
--> $DIR/E0458.rs:11:1
|
LL | #[link(kind = "wonderful_unicorn")] extern {} //~ ERROR E0458
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unknown kind
+ | ^^^^^^^--------------------------^^
+ | |
+ | unknown kind
error[E0459]: #[link(...)] specified without `name = "foo"`
--> $DIR/E0458.rs:11:1
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-pass
+
+#![allow(warnings)]
+
+#![feature(existential_type)]
+
+fn main() {
+}
+
+existential type Foo<V>: std::fmt::Debug;
+
+trait Trait<U> {}
+
+fn foo_desugared<T: Trait<[u32; {
+ #[no_mangle]
+ static FOO: usize = 42;
+ 3
+}]>>(_: T) -> Foo<T> {
+ (42, std::marker::PhantomData::<T>)
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(existential_type)]
+
+fn main() {
+}
+
+trait TraitWithAssoc {
+ type Assoc;
+}
+
+existential type Foo<V>: Trait<V>;
+
+trait Trait<U> {}
+
+impl<W> Trait<W> for () {}
+
+fn foo_desugared<T: TraitWithAssoc>(_: T) -> Foo<T::Assoc> { //~ ERROR non-defining
+ ()
+}
--- /dev/null
+error: non-defining existential type use in defining scope
+ --> $DIR/bound_reduction2.rs:26:1
+ |
+LL | / fn foo_desugared<T: TraitWithAssoc>(_: T) -> Foo<T::Assoc> { //~ ERROR non-defining
+LL | | ()
+LL | | }
+ | |_^
+ |
+note: used non-generic type <T as TraitWithAssoc>::Assoc for generic parameter
+ --> $DIR/bound_reduction2.rs:20:22
+ |
+LL | existential type Foo<V>: Trait<V>;
+ | ^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+// declared but never defined
+existential type Bar: std::fmt::Debug; //~ ERROR could not find defining uses
--- /dev/null
+error: could not find defining uses
+ --> $DIR/declared_but_never_defined.rs:17:1
+ |
+LL | existential type Bar: std::fmt::Debug; //~ ERROR could not find defining uses
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+mod boo {
+ // declared in module but not defined inside of it
+ pub existential type Boo: ::std::fmt::Debug; //~ ERROR could not find defining uses
+}
+
+fn bomp() -> boo::Boo {
+ ""
+}
--- /dev/null
+error: could not find defining uses
+ --> $DIR/declared_but_not_defined_in_scope.rs:18:5
+ |
+LL | pub existential type Boo: ::std::fmt::Debug; //~ ERROR could not find defining uses
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+// two definitions with different types
+existential type Foo: std::fmt::Debug;
+
+fn foo() -> Foo {
+ ""
+}
+
+fn bar() -> Foo { //~ ERROR defining existential type use differs from previous
+ 42i32
+}
--- /dev/null
+error: defining existential type use differs from previous
+ --> $DIR/different_defining_uses.rs:23:1
+ |
+LL | / fn bar() -> Foo { //~ ERROR defining existential type use differs from previous
+LL | | 42i32
+LL | | }
+ | |_^
+ |
+note: previous use here
+ --> $DIR/different_defining_uses.rs:19:1
+ |
+LL | / fn foo() -> Foo {
+LL | | ""
+LL | | }
+ | |_^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+// two definitions with different types
+existential type Foo: std::fmt::Debug;
+
+fn foo() -> Foo {
+ ""
+}
+
+fn bar() -> Foo { //~ ERROR defining existential type use differs from previous
+ panic!()
+}
+
+fn boo() -> Foo { //~ ERROR defining existential type use differs from previous
+ loop {}
+}
--- /dev/null
+error: defining existential type use differs from previous
+ --> $DIR/different_defining_uses_never_type.rs:23:1
+ |
+LL | / fn bar() -> Foo { //~ ERROR defining existential type use differs from previous
+LL | | panic!()
+LL | | }
+ | |_^
+ |
+note: previous use here
+ --> $DIR/different_defining_uses_never_type.rs:19:1
+ |
+LL | / fn foo() -> Foo {
+LL | | ""
+LL | | }
+ | |_^
+
+error: defining existential type use differs from previous
+ --> $DIR/different_defining_uses_never_type.rs:27:1
+ |
+LL | / fn boo() -> Foo { //~ ERROR defining existential type use differs from previous
+LL | | loop {}
+LL | | }
+ | |_^
+ |
+note: previous use here
+ --> $DIR/different_defining_uses_never_type.rs:19:1
+ |
+LL | / fn foo() -> Foo {
+LL | | ""
+LL | | }
+ | |_^
+
+error: aborting due to 2 previous errors
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-pass
+
+#![feature(existential_type)]
+
+fn main() {}
+
+// two definitions with different types
+existential type Foo: std::fmt::Debug;
+
+fn foo() -> Foo {
+ ""
+}
+
+fn bar(arg: bool) -> Foo {
+ if arg {
+ panic!()
+ } else {
+ "bar"
+ }
+}
+
+fn boo(arg: bool) -> Foo {
+ if arg {
+ loop {}
+ } else {
+ "boo"
+ }
+}
+
+fn bar2(arg: bool) -> Foo {
+ if arg {
+ "bar2"
+ } else {
+ panic!()
+ }
+}
+
+fn boo2(arg: bool) -> Foo {
+ if arg {
+ "boo2"
+ } else {
+ loop {}
+ }
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(existential_type)]
+// compile-pass
+
+trait Bar {}
+struct Dummy;
+impl Bar for Dummy {}
+
+trait Foo {
+ type Assoc: Bar;
+ fn foo() -> Self::Assoc;
+ fn bar() -> Self::Assoc;
+}
+
+existential type Helper: Bar;
+
+impl Foo for i32 {
+ type Assoc = Helper;
+ fn foo() -> Helper {
+ Dummy
+ }
+ fn bar() -> Helper {
+ Dummy
+ }
+}
+
+fn main() {}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+existential type MyIter<T>: Iterator<Item = T>;
+
+fn my_iter<T>(t: T) -> MyIter<T> {
+ std::iter::once(t)
+}
+
+fn my_iter2<T>(t: T) -> MyIter<T> { //~ ERROR defining existential type use differs from previous
+ Some(t).into_iter()
+}
--- /dev/null
+error: defining existential type use differs from previous
+ --> $DIR/generic_different_defining_uses.rs:22:1
+ |
+LL | / fn my_iter2<T>(t: T) -> MyIter<T> { //~ ERROR defining existential type use differs from previous
+LL | | Some(t).into_iter()
+LL | | }
+ | |_^
+ |
+note: previous use here
+ --> $DIR/generic_different_defining_uses.rs:18:1
+ |
+LL | / fn my_iter<T>(t: T) -> MyIter<T> {
+LL | | std::iter::once(t)
+LL | | }
+ | |_^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+existential type Two<'a, 'b>: std::fmt::Debug;
+
+fn one<'a>(t: &'a ()) -> Two<'a, 'a> { //~ ERROR non-defining existential type use
+ t
+}
--- /dev/null
+error: non-defining existential type use in defining scope
+ --> $DIR/generic_duplicate_lifetime_param.rs:18:1
+ |
+LL | / fn one<'a>(t: &'a ()) -> Two<'a, 'a> { //~ ERROR non-defining existential type use
+LL | | t
+LL | | }
+ | |_^
+ |
+note: lifetime used multiple times
+ --> $DIR/generic_duplicate_lifetime_param.rs:16:22
+ |
+LL | existential type Two<'a, 'b>: std::fmt::Debug;
+ | ^^ ^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+existential type Two<T, U>: 'static; //~ ERROR type parameter `U` is unused
+
+fn one<T: 'static>(t: T) -> Two<T, T> {
+ t
+}
--- /dev/null
+error[E0091]: type parameter `U` is unused
+ --> $DIR/generic_duplicate_param_use.rs:16:25
+ |
+LL | existential type Two<T, U>: 'static; //~ ERROR type parameter `U` is unused
+ | ^ unused type parameter
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0091`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-pass
+
+#![feature(existential_type)]
+
+fn main() {}
+
+existential type Region<'a>: std::fmt::Debug;
+
+fn region<'b>(a: &'b ()) -> Region<'b> {
+ a
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+existential type Cmp<T>: 'static;
+
+// not a defining use, because it doesn't define *all* possible generics
+fn cmp() -> Cmp<u32> { //~ ERROR non-defining existential type use in defining scope
+ 5u32
+}
--- /dev/null
+error: non-defining existential type use in defining scope
+ --> $DIR/generic_nondefining_use.rs:19:1
+ |
+LL | / fn cmp() -> Cmp<u32> { //~ ERROR non-defining existential type use in defining scope
+LL | | 5u32
+LL | | }
+ | |_^
+ |
+note: used non-generic type u32 for generic parameter
+ --> $DIR/generic_nondefining_use.rs:16:22
+ |
+LL | existential type Cmp<T>: 'static;
+ | ^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+existential type WrongGeneric<T: 'static>: 'static;
+
+fn wrong_generic<U: 'static, V: 'static>(_: U, v: V) -> WrongGeneric<U> {
+//~^ ERROR type parameter `V` is part of concrete type but not used in parameter list
+ v
+}
--- /dev/null
+error: type parameter `V` is part of concrete type but not used in parameter list for existential type
+ --> $DIR/generic_not_used.rs:18:73
+ |
+LL | fn wrong_generic<U: 'static, V: 'static>(_: U, v: V) -> WrongGeneric<U> {
+ | _________________________________________________________________________^
+LL | | //~^ ERROR type parameter `V` is part of concrete type but not used in parameter list
+LL | | v
+LL | | }
+ | |_^
+
+error: aborting due to previous error
+
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/generic_type_does_not_live_long_enough.rs:16:18
+ |
+LL | let z: i32 = x; //~ ERROR mismatched types
+ | ^ expected i32, found anonymized type
+ |
+ = note: expected type `i32`
+ found type `WrongGeneric::<&{integer}>`
+
+warning: not reporting region error due to nll
+ --> $DIR/generic_type_does_not_live_long_enough.rs:19:1
+ |
+LL | existential type WrongGeneric<T>: 'static;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(existential_type)]
+
+fn main() {
+ let y = 42;
+ let x = wrong_generic(&y);
+ let z: i32 = x; //~ ERROR mismatched types
+}
+
+existential type WrongGeneric<T>: 'static;
+//~^ ERROR the parameter type `T` may not live long enough
+
+fn wrong_generic<T>(t: T) -> WrongGeneric<T> {
+ t
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/generic_type_does_not_live_long_enough.rs:16:18
+ |
+LL | let z: i32 = x; //~ ERROR mismatched types
+ | ^ expected i32, found anonymized type
+ |
+ = note: expected type `i32`
+ found type `WrongGeneric::<&{integer}>`
+
+error[E0310]: the parameter type `T` may not live long enough
+ --> $DIR/generic_type_does_not_live_long_enough.rs:19:1
+ |
+LL | existential type WrongGeneric<T>: 'static;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn wrong_generic<T>(t: T) -> WrongGeneric<T> {
+ | - help: consider adding an explicit lifetime bound `T: 'static`...
+ |
+note: ...so that the type `T` will meet its required lifetime bounds
+ --> $DIR/generic_type_does_not_live_long_enough.rs:19:1
+ |
+LL | existential type WrongGeneric<T>: 'static;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+Some errors occurred: E0308, E0310.
+For more information about an error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+trait Trait {}
+existential type Underconstrained<T: Trait>: 'static; //~ ERROR the trait bound `T: Trait`
+
+// no `Trait` bound
+fn underconstrain<T>(_: T) -> Underconstrained<T> {
+ unimplemented!()
+}
--- /dev/null
+error[E0277]: the trait bound `T: Trait` is not satisfied
+ --> $DIR/generic_underconstrained.rs:17:1
+ |
+LL | existential type Underconstrained<T: Trait>: 'static; //~ ERROR the trait bound `T: Trait`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `T`
+ |
+ = help: consider adding a `where T: Trait` bound
+ = note: the return type of a function must have a statically known size
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+existential type Underconstrained<T: std::fmt::Debug>: 'static;
+//~^ ERROR `U` doesn't implement `std::fmt::Debug`
+
+// not a defining use, because it doesn't define *all* possible generics
+fn underconstrained<U>(_: U) -> Underconstrained<U> {
+ 5u32
+}
+
+existential type Underconstrained2<T: std::fmt::Debug>: 'static;
+//~^ ERROR `V` doesn't implement `std::fmt::Debug`
+
+// not a defining use, because it doesn't define *all* possible generics
+fn underconstrained2<U, V>(_: U, _: V) -> Underconstrained2<V> {
+ 5u32
+}
--- /dev/null
+error[E0277]: `U` doesn't implement `std::fmt::Debug`
+ --> $DIR/generic_underconstrained2.rs:16:1
+ |
+LL | existential type Underconstrained<T: std::fmt::Debug>: 'static;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `U` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+ |
+ = help: the trait `std::fmt::Debug` is not implemented for `U`
+ = help: consider adding a `where U: std::fmt::Debug` bound
+ = note: the return type of a function must have a statically known size
+
+error[E0277]: `V` doesn't implement `std::fmt::Debug`
+ --> $DIR/generic_underconstrained2.rs:24:1
+ |
+LL | existential type Underconstrained2<T: std::fmt::Debug>: 'static;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `V` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+ |
+ = help: the trait `std::fmt::Debug` is not implemented for `V`
+ = help: consider adding a `where V: std::fmt::Debug` bound
+ = note: the return type of a function must have a statically known size
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+// don't reveal the concrete type
+existential type NoReveal: std::fmt::Debug;
+
+fn define_no_reveal() -> NoReveal {
+ ""
+}
+
+fn no_reveal(x: NoReveal) {
+ let _: &'static str = x; //~ mismatched types
+ let _ = x as &'static str; //~ non-primitive cast
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/never_reveal_concrete_type.rs:24:27
+ |
+LL | let _: &'static str = x; //~ mismatched types
+ | ^ expected reference, found anonymized type
+ |
+ = note: expected type `&'static str`
+ found type `NoReveal`
+
+error[E0605]: non-primitive cast: `NoReveal` as `&'static str`
+ --> $DIR/never_reveal_concrete_type.rs:25:13
+ |
+LL | let _ = x as &'static str; //~ non-primitive cast
+ | ^^^^^^^^^^^^^^^^^
+ |
+ = note: an `as` expression can only be used to convert between primitive types. Consider using the `From` trait
+
+error: aborting due to 2 previous errors
+
+Some errors occurred: E0308, E0605.
+For more information about an error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+#![feature(existential_type)]
+
+fn main() {}
+
+mod boo {
+ pub existential type Boo: ::std::fmt::Debug;
+ fn bomp() -> Boo {
+ ""
+ }
+}
+
+// don't actually know the type here
+
+fn bomp2() {
+ let _: &str = bomp(); //~ ERROR mismatched types
+}
+
+fn bomp() -> boo::Boo {
+ "" //~ ERROR mismatched types
+}
+
+fn bomp_loop() -> boo::Boo {
+ loop {}
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/no_revealing_outside_defining_module.rs:26:19
+ |
+LL | let _: &str = bomp(); //~ ERROR mismatched types
+ | ^^^^^^ expected &str, found anonymized type
+ |
+ = note: expected type `&str`
+ found type `Boo`
+
+error[E0308]: mismatched types
+ --> $DIR/no_revealing_outside_defining_module.rs:30:5
+ |
+LL | fn bomp() -> boo::Boo {
+ | -------- expected `Boo` because of return type
+LL | "" //~ ERROR mismatched types
+ | ^^ expected anonymized type, found reference
+ |
+ = note: expected type `Boo`
+ found type `&'static str`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(existential_type)]
+
+fn main() {
+}
+
+trait TraitWithAssoc {
+ type Assoc;
+}
+
+existential type Foo<V>: Trait<V::Assoc>; //~ associated type `Assoc` not found for `V`
+
+trait Trait<U> {}
+
+impl<W> Trait<W> for () {}
+
+fn foo_desugared<T: TraitWithAssoc>(_: T) -> Foo<T> {
+ ()
+}
--- /dev/null
+error[E0220]: associated type `Assoc` not found for `V`
+ --> $DIR/not_well_formed.rs:20:32
+ |
+LL | existential type Foo<V>: Trait<V::Assoc>; //~ associated type `Assoc` not found for `V`
+ | ^^^^^^^^ associated type `Assoc` not found
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0220`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(existential_type)]
+
+fn main() {
+}
+
+existential type PartiallyDefined<T>: 'static; //~ `T` is unused
+
+fn partially_defined<T: std::fmt::Debug>(_: T) -> PartiallyDefined<T> {
+ 4u32
+}
+
+existential type PartiallyDefined2<T>: 'static; //~ `T` is unused
+
+fn partially_defined2<T: std::fmt::Debug>(_: T) -> PartiallyDefined2<T> {
+ 4u32
+}
+
+fn partially_defined22<T>(_: T) -> PartiallyDefined2<T> {
+ 4u32
+}
--- /dev/null
+error[E0091]: type parameter `T` is unused
+ --> $DIR/unused_generic_param.rs:16:35
+ |
+LL | existential type PartiallyDefined<T>: 'static; //~ `T` is unused
+ | ^ unused type parameter
+
+error[E0091]: type parameter `T` is unused
+ --> $DIR/unused_generic_param.rs:22:36
+ |
+LL | existential type PartiallyDefined2<T>: 'static; //~ `T` is unused
+ | ^ unused type parameter
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0091`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:m1.rs
+// aux-build:m2.rs
+
+
+extern crate m1;
+extern crate m2 as m1; //~ ERROR is defined multiple times
+
+fn main() {}
--- /dev/null
+error[E0259]: the name `m1` is defined multiple times
+ --> $DIR/extern-crate-rename.rs:16:1
+ |
+LL | extern crate m1;
+ | ---------------- previous import of the extern crate `m1` here
+LL | extern crate m2 as m1; //~ ERROR is defined multiple times
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | `m1` reimported here
+ | You can use `as` to change the binding name of the import
+ |
+ = note: `m1` must be defined only once in the type namespace of this module
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0259`.
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Check that existential types must be ungated to use the `existential` keyword
+
+
+
+existential type Foo: std::fmt::Debug; //~ ERROR existential types are unstable
+
+trait Bar {
+ type Baa: std::fmt::Debug;
+}
+
+impl Bar for () {
+ existential type Baa: std::fmt::Debug; //~ ERROR existential types are unstable
+}
+
+fn main() {}
--- /dev/null
+error[E0658]: existential types are unstable (see issue #34511)
+ --> $DIR/feature-gate-existential-type.rs:15:1
+ |
+LL | existential type Foo: std::fmt::Debug; //~ ERROR existential types are unstable
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(existential_type)] to the crate attributes to enable
+
+error[E0658]: existential types are unstable (see issue #34511)
+ --> $DIR/feature-gate-existential-type.rs:22:5
+ |
+LL | existential type Baa: std::fmt::Debug; //~ ERROR existential types are unstable
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: add #![feature(existential_type)] to the crate attributes to enable
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[wasm_import_module = "test"] //~ ERROR: experimental
-extern {
-}
-
-fn main() {}
+++ /dev/null
-error[E0658]: experimental attribute (see issue #52090)
- --> $DIR/feature-gate-wasm_import_module.rs:11:1
- |
-LL | #[wasm_import_module = "test"] //~ ERROR: experimental
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(wasm_import_module)] to the crate attributes to enable
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0658`.
--- /dev/null
+error[E0594]: cannot assign to `x` which is behind a `&` reference
+ --> $DIR/fn-closure-mutable-capture.rs:15:17
+ |
+LL | bar(move || x = 1);
+ | ^^^^^ cannot assign
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0594`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn bar<F: Fn()>(_f: F) {}
+
+pub fn foo() {
+ let mut x = 0;
+ bar(move || x = 1);
+ //~^ ERROR cannot assign to captured outer variable in an `Fn` closure
+ //~| NOTE `Fn` closures cannot capture their enclosing environment for modifications
+}
+
+fn main() {}
--- /dev/null
+error[E0594]: cannot assign to captured outer variable in an `Fn` closure
+ --> $DIR/fn-closure-mutable-capture.rs:15:17
+ |
+LL | bar(move || x = 1);
+ | ^^^^^
+ |
+ = note: `Fn` closures cannot capture their enclosing environment for modifications
+help: consider changing this closure to take self by mutable reference
+ --> $DIR/fn-closure-mutable-capture.rs:15:9
+ |
+LL | bar(move || x = 1);
+ | ^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0594`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// E0277 should point exclusively at line 14, not the entire for loop span
+
+fn main() {
+ for c in "asdf" {
+ //~^ ERROR the trait bound `&str: std::iter::Iterator` is not satisfied
+ //~| NOTE `&str` is not an iterator
+ //~| HELP the trait `std::iter::Iterator` is not implemented for `&str`
+ //~| NOTE required by `std::iter::IntoIterator::into_iter`
+ println!("");
+ }
+}
--- /dev/null
+error[E0277]: the trait bound `&str: std::iter::Iterator` is not satisfied
+ --> $DIR/for-c-in-str.rs:14:14
+ |
+LL | for c in "asdf" {
+ | ^^^^^^ `&str` is not an iterator; try calling `.chars()` or `.bytes()`
+ |
+ = help: the trait `std::iter::Iterator` is not implemented for `&str`
+ = note: required by `std::iter::IntoIterator::into_iter`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
// return type, which can't depend on the obligation.
fn cycle1() -> impl Clone {
//~^ ERROR cycle detected
+ //~| ERROR cycle detected
send(cycle2().clone());
+ //~^ ERROR cannot be sent between threads safely
Rc::new(Cell::new(5))
}
-error[E0391]: cycle detected when processing `cycle1`
+error[E0391]: cycle detected when processing `cycle1::{{impl-Trait}}`
+ --> $DIR/auto-trait-leak.rs:24:16
+ |
+LL | fn cycle1() -> impl Clone {
+ | ^^^^^^^^^^
+ |
+note: ...which requires processing `cycle1`...
--> $DIR/auto-trait-leak.rs:24:1
|
LL | fn cycle1() -> impl Clone {
| ^^^^^^^^^^^^^^^^^^^^^^^^^
- |
note: ...which requires evaluating trait selection obligation `impl std::clone::Clone: std::marker::Send`...
note: ...which requires processing `cycle2::{{impl-Trait}}`...
- --> $DIR/auto-trait-leak.rs:31:16
+ --> $DIR/auto-trait-leak.rs:33:16
|
LL | fn cycle2() -> impl Clone {
| ^^^^^^^^^^
note: ...which requires processing `cycle2`...
- --> $DIR/auto-trait-leak.rs:31:1
+ --> $DIR/auto-trait-leak.rs:33:1
|
LL | fn cycle2() -> impl Clone {
| ^^^^^^^^^^^^^^^^^^^^^^^^^
note: ...which requires evaluating trait selection obligation `impl std::clone::Clone: std::marker::Send`...
-note: ...which requires processing `cycle1::{{impl-Trait}}`...
+ = note: ...which again requires processing `cycle1::{{impl-Trait}}`, completing the cycle
+
+error[E0391]: cycle detected when processing `cycle1::{{impl-Trait}}`
--> $DIR/auto-trait-leak.rs:24:16
|
LL | fn cycle1() -> impl Clone {
| ^^^^^^^^^^
- = note: ...which again requires processing `cycle1`, completing the cycle
-note: cycle used when type-checking all item bodies
+ |
+note: ...which requires processing `cycle1`...
+ --> $DIR/auto-trait-leak.rs:24:1
+ |
+LL | fn cycle1() -> impl Clone {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: ...which requires evaluating trait selection obligation `impl std::clone::Clone: std::marker::Send`...
+note: ...which requires processing `cycle2::{{impl-Trait}}`...
+ --> $DIR/auto-trait-leak.rs:33:16
+ |
+LL | fn cycle2() -> impl Clone {
+ | ^^^^^^^^^^
+note: ...which requires processing `cycle2`...
+ --> $DIR/auto-trait-leak.rs:33:1
+ |
+LL | fn cycle2() -> impl Clone {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+ = note: ...which again requires processing `cycle1::{{impl-Trait}}`, completing the cycle
+
+error[E0277]: `std::rc::Rc<std::string::String>` cannot be sent between threads safely
+ --> $DIR/auto-trait-leak.rs:27:5
+ |
+LL | send(cycle2().clone());
+ | ^^^^ `std::rc::Rc<std::string::String>` cannot be sent between threads safely
+ |
+ = help: within `impl std::clone::Clone`, the trait `std::marker::Send` is not implemented for `std::rc::Rc<std::string::String>`
+ = note: required because it appears within the type `impl std::clone::Clone`
+note: required by `send`
+ --> $DIR/auto-trait-leak.rs:16:1
+ |
+LL | fn send<T: Send>(_: T) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^
-error: aborting due to previous error
+error: aborting due to 3 previous errors
-For more information about this error, try `rustc --explain E0391`.
+Some errors occurred: E0277, E0391.
+For more information about an error, try `rustc --explain E0277`.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// ignore-test currently ICEs when using NLL (#52416)
+
// We used to ICE when moving out of a `*mut T` or `*const T`.
struct T(u8);
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(unused_imports)]
+
+pub mod extension1 {
+ pub trait ConstructorExtension {}
+}
+
+pub mod extension2 {
+ pub trait ConstructorExtension {}
+}
+
+use extension1::ConstructorExtension;
+use extension2::ConstructorExtension as OtherConstructorExtension; //~ ERROR is defined multiple times
+
+fn main() {}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(unused_imports)]
+
+pub mod extension1 {
+ pub trait ConstructorExtension {}
+}
+
+pub mod extension2 {
+ pub trait ConstructorExtension {}
+}
+
+use extension1::ConstructorExtension;
+use extension2::ConstructorExtension; //~ ERROR is defined multiple times
+
+fn main() {}
--- /dev/null
+error[E0252]: the name `ConstructorExtension` is defined multiple times
+ --> $DIR/issue-32354-suggest-import-rename.rs:24:5
+ |
+LL | use extension1::ConstructorExtension;
+ | -------------------------------- previous import of the trait `ConstructorExtension` here
+LL | use extension2::ConstructorExtension; //~ ERROR is defined multiple times
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ConstructorExtension` reimported here
+ |
+ = note: `ConstructorExtension` must be defined only once in the type namespace of this module
+help: You can use `as` to change the binding name of the import
+ |
+LL | use extension2::ConstructorExtension as OtherConstructorExtension; //~ ERROR is defined multiple times
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0252`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// check that we substitute type parameters before we suggest anything - otherwise
+// we would suggest function such as `as_slice` for the `&[u16]`.
+
+fn foo(b: &[u16]) {}
+
+fn main() {
+ let a: Vec<u8> = Vec::new();
+ foo(&a); //~ ERROR mismatched types
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/issue-43420-no-over-suggest.rs:18:9
+ |
+LL | foo(&a); //~ ERROR mismatched types
+ | ^^ expected slice, found struct `std::vec::Vec`
+ |
+ = note: expected type `&[u16]`
+ found type `&std::vec::Vec<u8>`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
error: `cfg()` must have an argument
- --> $DIR/issue-43926.rs:11:1
+ --> $DIR/issue-43926.rs:11:20
|
LL | #[link(name="foo", cfg())] //~ ERROR `cfg()` must have an argument
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^
error: aborting due to previous error
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#[no_mangle] pub static RAH: usize = 5;
+//~^ ERROR const items should never be #[no_mangle]
+
+fn main() {}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#[no_mangle] pub const RAH: usize = 5;
+//~^ ERROR const items should never be #[no_mangle]
+
+fn main() {}
--- /dev/null
+error: const items should never be #[no_mangle]
+ --> $DIR/issue-45562.rs:13:14
+ |
+LL | #[no_mangle] pub const RAH: usize = 5;
+ | ---------^^^^^^^^^^^^^^^^
+ | |
+ | help: try a static value: `pub static`
+ |
+ = note: #[deny(no_mangle_const_items)] on by default
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+extern crate std as other_std;
+fn main() {}
+//~^^ ERROR the name `std` is defined multiple times [E0259]
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+extern crate std;
+fn main() {}
+//~^^ ERROR the name `std` is defined multiple times [E0259]
--- /dev/null
+error[E0259]: the name `std` is defined multiple times
+ --> $DIR/issue-45799-bad-extern-crate-rename-suggestion-formatting.rs:13:1
+ |
+LL | extern crate std;
+ | ^^^^^^^^^^^^^^^^^ `std` reimported here
+ |
+ = note: `std` must be defined only once in the type namespace of this module
+help: You can use `as` to change the binding name of the import
+ |
+LL | extern crate std as other_std;
+ |
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0259`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo() {
+ let s = "abc";
+ let u: &str = if true { s[..2] } else { s };
+ //~^ ERROR mismatched types
+}
+
+fn main() {
+ foo();
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/issue-46302.rs:13:27
+ |
+LL | let u: &str = if true { s[..2] } else { s };
+ | ^^^^^^
+ | |
+ | expected &str, found str
+ | help: consider borrowing here: `&s[..2]`
+ |
+ = note: expected type `&str`
+ found type `str`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(unused)]
+
+fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
+ and_yet + 1
+}
+
+fn main() {
+ let behold: isize = 2;
+ let with_tears: usize = 3;
+ light_flows_our_war_of_mocking_words(&(behold as usize));
+ //~^ ERROR mismatched types [E0308]
+ light_flows_our_war_of_mocking_words(&(with_tears + 4));
+ //~^ ERROR mismatched types [E0308]
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+#![allow(unused)]
+
+fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
+ and_yet + 1
+}
+
+fn main() {
+ let behold: isize = 2;
+ let with_tears: usize = 3;
+ light_flows_our_war_of_mocking_words(behold as usize);
+ //~^ ERROR mismatched types [E0308]
+ light_flows_our_war_of_mocking_words(with_tears + 4);
+ //~^ ERROR mismatched types [E0308]
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:22:42
+ |
+LL | light_flows_our_war_of_mocking_words(behold as usize);
+ | ^^^^^^^^^^^^^^^
+ | |
+ | expected &usize, found usize
+ | help: consider borrowing here: `&(behold as usize)`
+ |
+ = note: expected type `&usize`
+ found type `usize`
+
+error[E0308]: mismatched types
+ --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:24:42
+ |
+LL | light_flows_our_war_of_mocking_words(with_tears + 4);
+ | ^^^^^^^^^^^^^^
+ | |
+ | expected &usize, found usize
+ | help: consider borrowing here: `&(with_tears + 4)`
+ |
+ = note: expected type `&usize`
+ found type `usize`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo() -> bool {
+ b"".starts_with(stringify!(foo))
+ //~^ ERROR mismatched types
+}
+
+fn main() {}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/issue-48364.rs:12:21
+ |
+LL | b"".starts_with(stringify!(foo))
+ | ^^^^^^^^^^^^^^^ expected slice, found str
+ |
+ = note: expected type `&[u8]`
+ found type `&'static str`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+error[E0594]: cannot assign to `*my_ref` which is behind a `&` reference
+ --> $DIR/issue-51244.rs:13:5
+ |
+LL | let ref my_ref @ _ = 0;
+ | -------------- help: consider changing this to be a mutable reference: `ref mut my_ref @ _`
+LL | *my_ref = 0; //~ ERROR cannot assign to immutable borrowed content `*my_ref` [E0594]
+ | ^^^^^^^^^^^ `my_ref` is a `&` reference, so the data it refers to cannot be written
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0594`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let ref my_ref @ _ = 0;
+ *my_ref = 0; //~ ERROR cannot assign to immutable borrowed content `*my_ref` [E0594]
+}
--- /dev/null
+error[E0594]: cannot assign to immutable borrowed content `*my_ref`
+ --> $DIR/issue-51244.rs:13:5
+ |
+LL | let ref my_ref @ _ = 0;
+ | -------------- help: use a mutable reference instead: `ref mut my_ref @ _`
+LL | *my_ref = 0; //~ ERROR cannot assign to immutable borrowed content `*my_ref` [E0594]
+ | ^^^^^^^^^^^ cannot borrow as mutable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0594`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(nll)]
+
+fn main() {
+ let foo = &16;
+ //~^ HELP consider changing this to be a mutable reference
+ //~| SUGGESTION &mut 16
+ *foo = 32;
+ //~^ ERROR cannot assign to `*foo` which is behind a `&` reference
+ let bar = foo;
+ //~^ HELP consider changing this to be a mutable reference
+ //~| SUGGESTION &mut i32
+ *bar = 64;
+ //~^ ERROR cannot assign to `*bar` which is behind a `&` reference
+}
--- /dev/null
+error[E0594]: cannot assign to `*foo` which is behind a `&` reference
+ --> $DIR/issue-51515.rs:17:5
+ |
+LL | let foo = &16;
+ | --- help: consider changing this to be a mutable reference: `&mut 16`
+...
+LL | *foo = 32;
+ | ^^^^^^^^^ `foo` is a `&` reference, so the data it refers to cannot be written
+
+error[E0594]: cannot assign to `*bar` which is behind a `&` reference
+ --> $DIR/issue-51515.rs:22:5
+ |
+LL | let bar = foo;
+ | --- help: consider changing this to be a mutable reference: `&mut i32`
+...
+LL | *bar = 64;
+ | ^^^^^^^^^ `bar` is a `&` reference, so the data it refers to cannot be written
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0594`.
--- /dev/null
+error[E0597]: borrowed value does not live long enough
+ --> $DIR/issue-52049.rs:16:10
+ |
+LL | foo(&unpromotable(5u32));
+ | ^^^^^^^^^^^^^^^^^^ temporary value does not live long enough
+LL | }
+ | - temporary value only lives until here
+ |
+ = note: borrowed value must be valid for the static lifetime...
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0597`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo(_: &'static u32) {}
+
+fn unpromotable<T>(t: T) -> T { t }
+
+fn main() {
+ foo(&unpromotable(5u32));
+}
+//~^^ ERROR borrowed value does not live long enough
--- /dev/null
+error[E0597]: borrowed value does not live long enough
+ --> $DIR/issue-52049.rs:16:10
+ |
+LL | foo(&unpromotable(5u32));
+ | ^^^^^^^^^^^^^^^^^^ - temporary value only lives until here
+ | |
+ | temporary value does not live long enough
+ |
+ = note: borrowed value must be valid for the static lifetime...
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0597`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_export]
+macro_rules! bar {
+ () => {use std::string::ToString;}
+}
+
+#[macro_export]
+macro_rules! baz {
+ ($i:item) => ($i)
+}
+
+#[macro_export]
+macro_rules! baz2 {
+ ($($i:tt)*) => ($($i)*)
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:lints-in-foreign-macros.rs
+// compile-pass
+
+#![warn(unused_imports)]
+
+#[macro_use]
+extern crate lints_in_foreign_macros;
+
+macro_rules! foo {
+ () => {use std::string::ToString;} //~ WARN: unused import
+}
+
+mod a { foo!(); }
+mod b { bar!(); }
+mod c { baz!(use std::string::ToString;); } //~ WARN: unused import
+mod d { baz2!(use std::string::ToString;); } //~ WARN: unused import
+
+fn main() {}
--- /dev/null
+warning: unused import: `std::string::ToString`
+ --> $DIR/lints-in-foreign-macros.rs:20:16
+ |
+LL | () => {use std::string::ToString;} //~ WARN: unused import
+ | ^^^^^^^^^^^^^^^^^^^^^
+...
+LL | mod a { foo!(); }
+ | ------- in this macro invocation
+ |
+note: lint level defined here
+ --> $DIR/lints-in-foreign-macros.rs:14:9
+ |
+LL | #![warn(unused_imports)]
+ | ^^^^^^^^^^^^^^
+
+warning: unused import: `std::string::ToString`
+ --> $DIR/lints-in-foreign-macros.rs:25:18
+ |
+LL | mod c { baz!(use std::string::ToString;); } //~ WARN: unused import
+ | ^^^^^^^^^^^^^^^^^^^^^
+
+warning: unused import: `std::string::ToString`
+ --> $DIR/lints-in-foreign-macros.rs:26:19
+ |
+LL | mod d { baz2!(use std::string::ToString;); } //~ WARN: unused import
+ | ^^^^^^^^^^^^^^^^^^^^^
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:macro-in-other-crate.rs
+
+#[macro_use] extern crate macro_in_other_crate;
+
+macro_rules! local_mac {
+ ($ident:ident) => { let $ident = 42; }
+}
+
+fn main() {
+ let x = 2.0.neg();
+ //~^ ERROR can't call method `neg` on ambiguous numeric type `{float}`
+
+ let y = 2.0;
+ let x = y.neg();
+ //~^ ERROR can't call method `neg` on ambiguous numeric type `{float}`
+ println!("{:?}", x);
+
+ for i in 0..100 {
+ println!("{}", i.pow(2));
+ //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
+ }
+
+ local_mac!(local_bar);
+ local_bar.pow(2);
+ //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
+}
+
+fn qux() {
+ mac!(bar);
+ bar.pow(2);
+ //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
+}
--- /dev/null
+error[E0689]: can't call method `neg` on ambiguous numeric type `{float}`
+ --> $DIR/method-on-ambiguous-numeric-type.rs:20:17
+ |
+LL | let x = 2.0.neg();
+ | ^^^
+help: you must specify a concrete type for this numeric value, like `f32`
+ |
+LL | let x = 2.0_f32.neg();
+ | ^^^^^^^
+
+error[E0689]: can't call method `neg` on ambiguous numeric type `{float}`
+ --> $DIR/method-on-ambiguous-numeric-type.rs:24:15
+ |
+LL | let x = y.neg();
+ | ^^^
+help: you must specify a type for this binding, like `f32`
+ |
+LL | let y: f32 = 2.0;
+ | ^^^^^^
+
+error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
+ --> $DIR/method-on-ambiguous-numeric-type.rs:29:26
+ |
+LL | for i in 0..100 {
+ | - you must specify a type for this binding, like `i32`
+LL | println!("{}", i.pow(2));
+ | ^^^
+
+error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
+ --> $DIR/method-on-ambiguous-numeric-type.rs:34:15
+ |
+LL | local_bar.pow(2);
+ | ^^^
+help: you must specify a type for this binding, like `i32`
+ |
+LL | ($ident:ident) => { let $ident: i32 = 42; }
+ | ^^^^^^^^^^^
+
+error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
+ --> $DIR/method-on-ambiguous-numeric-type.rs:40:9
+ |
+LL | mac!(bar);
+ | ---------- you must specify a type for this binding, like `i32`
+LL | bar.pow(2);
+ | ^^^
+ |
+ = 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: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0689`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+fn main() {
+ match &Some(3) {
+ &None => 1,
+ &Some(2) => { 3 }
+ //~^ ERROR expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`
+ //~| NOTE expected one of `,`, `.`, `?`, `}`, or an operator here
+ _ => 2
+ };
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+fn main() {
+ match &Some(3) {
+ &None => 1
+ &Some(2) => { 3 }
+ //~^ ERROR expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`
+ //~| NOTE expected one of `,`, `.`, `?`, `}`, or an operator here
+ _ => 2
+ };
+}
--- /dev/null
+error: expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`
+ --> $DIR/missing-comma-in-match.rs:16:18
+ |
+LL | &None => 1
+ | - help: missing a comma here to end this `match` arm
+LL | &Some(2) => { 3 }
+ | ^^ expected one of `,`, `.`, `?`, `}`, or an operator here
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo() -> i32 {
+ 4
+}
+fn main() {
+ let x: u16 = foo();
+ //~^ ERROR mismatched types
+ let y: i64 = x + x;
+ //~^ ERROR mismatched types
+ let z: i32 = x + x;
+ //~^ ERROR mismatched types
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast-2.rs:15:18
+ |
+LL | let x: u16 = foo();
+ | ^^^^^ expected u16, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast-2.rs:17:18
+ |
+LL | let y: i64 = x + x;
+ | ^^^^^ expected i64, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast-2.rs:19:18
+ |
+LL | let z: i32 = x + x;
+ | ^^^^^ expected i32, found u16
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+fn foo<N>(_x: N) {}
+
+fn main() {
+ let x_usize: usize = 1;
+ let x_u64: u64 = 2;
+ let x_u32: u32 = 3;
+ let x_u16: u16 = 4;
+ let x_u8: u8 = 5;
+ let x_isize: isize = 6;
+ let x_i64: i64 = 7;
+ let x_i32: i32 = 8;
+ let x_i16: i16 = 9;
+ let x_i8: i8 = 10;
+ let x_f64: f64 = 11.0;
+ let x_f32: f32 = 12.0;
+
+ foo::<usize>(x_usize);
+ foo::<usize>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<usize>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<isize>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_isize);
+ foo::<isize>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<isize>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<u64>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_u64);
+ foo::<u64>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<u64>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<i64>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_i64);
+ foo::<i64>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<i64>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<u32>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_u32);
+ foo::<u32>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<u32>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<i32>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_i32);
+ foo::<i32>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<i32>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<u16>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_u16);
+ foo::<u16>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<u16>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<i16>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_i16);
+ foo::<i16>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<i16>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<u8>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_u8);
+ foo::<u8>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<u8>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<i8>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_i8);
+ foo::<i8>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<i8>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<f64>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<f64>(x_f64);
+ foo::<f64>(x_f32);
+ //~^ ERROR mismatched types
+
+ foo::<f32>(x_usize);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_u64);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_u32);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_u16);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_u8);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_isize);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_i64);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_i32);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_i16);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_i8);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_f64);
+ //~^ ERROR mismatched types
+ foo::<f32>(x_f32);
+
+ foo::<u32>(x_u8 as u16);
+ //~^ ERROR mismatched types
+ foo::<i32>(-x_i8);
+ //~^ ERROR mismatched types
+}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:29:18
+ |
+LL | foo::<usize>(x_u64);
+ | ^^^^^ expected usize, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:31:18
+ |
+LL | foo::<usize>(x_u32);
+ | ^^^^^ expected usize, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:33:18
+ |
+LL | foo::<usize>(x_u16);
+ | ^^^^^ expected usize, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:35:18
+ |
+LL | foo::<usize>(x_u8);
+ | ^^^^ expected usize, found u8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:37:18
+ |
+LL | foo::<usize>(x_isize);
+ | ^^^^^^^ expected usize, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:39:18
+ |
+LL | foo::<usize>(x_i64);
+ | ^^^^^ expected usize, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:41:18
+ |
+LL | foo::<usize>(x_i32);
+ | ^^^^^ expected usize, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:43:18
+ |
+LL | foo::<usize>(x_i16);
+ | ^^^^^ expected usize, found i16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:45:18
+ |
+LL | foo::<usize>(x_i8);
+ | ^^^^ expected usize, found i8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:47:18
+ |
+LL | foo::<usize>(x_f64);
+ | ^^^^^ expected usize, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:49:18
+ |
+LL | foo::<usize>(x_f32);
+ | ^^^^^ expected usize, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:52:18
+ |
+LL | foo::<isize>(x_usize);
+ | ^^^^^^^ expected isize, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:54:18
+ |
+LL | foo::<isize>(x_u64);
+ | ^^^^^ expected isize, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:56:18
+ |
+LL | foo::<isize>(x_u32);
+ | ^^^^^ expected isize, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:58:18
+ |
+LL | foo::<isize>(x_u16);
+ | ^^^^^ expected isize, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:60:18
+ |
+LL | foo::<isize>(x_u8);
+ | ^^^^ expected isize, found u8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:63:18
+ |
+LL | foo::<isize>(x_i64);
+ | ^^^^^ expected isize, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:65:18
+ |
+LL | foo::<isize>(x_i32);
+ | ^^^^^ expected isize, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:67:18
+ |
+LL | foo::<isize>(x_i16);
+ | ^^^^^ expected isize, found i16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:69:18
+ |
+LL | foo::<isize>(x_i8);
+ | ^^^^ expected isize, found i8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:71:18
+ |
+LL | foo::<isize>(x_f64);
+ | ^^^^^ expected isize, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:73:18
+ |
+LL | foo::<isize>(x_f32);
+ | ^^^^^ expected isize, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:76:16
+ |
+LL | foo::<u64>(x_usize);
+ | ^^^^^^^ expected u64, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:79:16
+ |
+LL | foo::<u64>(x_u32);
+ | ^^^^^ expected u64, found u32
+help: you can cast an `u32` to `u64`, which will zero-extend the source value
+ |
+LL | foo::<u64>(x_u32.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:81:16
+ |
+LL | foo::<u64>(x_u16);
+ | ^^^^^ expected u64, found u16
+help: you can cast an `u16` to `u64`, which will zero-extend the source value
+ |
+LL | foo::<u64>(x_u16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:83:16
+ |
+LL | foo::<u64>(x_u8);
+ | ^^^^ expected u64, found u8
+help: you can cast an `u8` to `u64`, which will zero-extend the source value
+ |
+LL | foo::<u64>(x_u8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:85:16
+ |
+LL | foo::<u64>(x_isize);
+ | ^^^^^^^ expected u64, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:87:16
+ |
+LL | foo::<u64>(x_i64);
+ | ^^^^^ expected u64, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:89:16
+ |
+LL | foo::<u64>(x_i32);
+ | ^^^^^ expected u64, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:91:16
+ |
+LL | foo::<u64>(x_i16);
+ | ^^^^^ expected u64, found i16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:93:16
+ |
+LL | foo::<u64>(x_i8);
+ | ^^^^ expected u64, found i8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:95:16
+ |
+LL | foo::<u64>(x_f64);
+ | ^^^^^ expected u64, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:97:16
+ |
+LL | foo::<u64>(x_f32);
+ | ^^^^^ expected u64, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:100:16
+ |
+LL | foo::<i64>(x_usize);
+ | ^^^^^^^ expected i64, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:102:16
+ |
+LL | foo::<i64>(x_u64);
+ | ^^^^^ expected i64, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:104:16
+ |
+LL | foo::<i64>(x_u32);
+ | ^^^^^ expected i64, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:106:16
+ |
+LL | foo::<i64>(x_u16);
+ | ^^^^^ expected i64, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:108:16
+ |
+LL | foo::<i64>(x_u8);
+ | ^^^^ expected i64, found u8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:110:16
+ |
+LL | foo::<i64>(x_isize);
+ | ^^^^^^^ expected i64, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:113:16
+ |
+LL | foo::<i64>(x_i32);
+ | ^^^^^ expected i64, found i32
+help: you can cast an `i32` to `i64`, which will sign-extend the source value
+ |
+LL | foo::<i64>(x_i32.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:115:16
+ |
+LL | foo::<i64>(x_i16);
+ | ^^^^^ expected i64, found i16
+help: you can cast an `i16` to `i64`, which will sign-extend the source value
+ |
+LL | foo::<i64>(x_i16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:117:16
+ |
+LL | foo::<i64>(x_i8);
+ | ^^^^ expected i64, found i8
+help: you can cast an `i8` to `i64`, which will sign-extend the source value
+ |
+LL | foo::<i64>(x_i8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:119:16
+ |
+LL | foo::<i64>(x_f64);
+ | ^^^^^ expected i64, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:121:16
+ |
+LL | foo::<i64>(x_f32);
+ | ^^^^^ expected i64, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:124:16
+ |
+LL | foo::<u32>(x_usize);
+ | ^^^^^^^ expected u32, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:126:16
+ |
+LL | foo::<u32>(x_u64);
+ | ^^^^^ expected u32, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:129:16
+ |
+LL | foo::<u32>(x_u16);
+ | ^^^^^ expected u32, found u16
+help: you can cast an `u16` to `u32`, which will zero-extend the source value
+ |
+LL | foo::<u32>(x_u16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:131:16
+ |
+LL | foo::<u32>(x_u8);
+ | ^^^^ expected u32, found u8
+help: you can cast an `u8` to `u32`, which will zero-extend the source value
+ |
+LL | foo::<u32>(x_u8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:133:16
+ |
+LL | foo::<u32>(x_isize);
+ | ^^^^^^^ expected u32, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:135:16
+ |
+LL | foo::<u32>(x_i64);
+ | ^^^^^ expected u32, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:137:16
+ |
+LL | foo::<u32>(x_i32);
+ | ^^^^^ expected u32, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:139:16
+ |
+LL | foo::<u32>(x_i16);
+ | ^^^^^ expected u32, found i16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:141:16
+ |
+LL | foo::<u32>(x_i8);
+ | ^^^^ expected u32, found i8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:143:16
+ |
+LL | foo::<u32>(x_f64);
+ | ^^^^^ expected u32, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:145:16
+ |
+LL | foo::<u32>(x_f32);
+ | ^^^^^ expected u32, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:148:16
+ |
+LL | foo::<i32>(x_usize);
+ | ^^^^^^^ expected i32, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:150:16
+ |
+LL | foo::<i32>(x_u64);
+ | ^^^^^ expected i32, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:152:16
+ |
+LL | foo::<i32>(x_u32);
+ | ^^^^^ expected i32, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:154:16
+ |
+LL | foo::<i32>(x_u16);
+ | ^^^^^ expected i32, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:156:16
+ |
+LL | foo::<i32>(x_u8);
+ | ^^^^ expected i32, found u8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:158:16
+ |
+LL | foo::<i32>(x_isize);
+ | ^^^^^^^ expected i32, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:160:16
+ |
+LL | foo::<i32>(x_i64);
+ | ^^^^^ expected i32, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:163:16
+ |
+LL | foo::<i32>(x_i16);
+ | ^^^^^ expected i32, found i16
+help: you can cast an `i16` to `i32`, which will sign-extend the source value
+ |
+LL | foo::<i32>(x_i16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:165:16
+ |
+LL | foo::<i32>(x_i8);
+ | ^^^^ expected i32, found i8
+help: you can cast an `i8` to `i32`, which will sign-extend the source value
+ |
+LL | foo::<i32>(x_i8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:167:16
+ |
+LL | foo::<i32>(x_f64);
+ | ^^^^^ expected i32, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:169:16
+ |
+LL | foo::<i32>(x_f32);
+ | ^^^^^ expected i32, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:172:16
+ |
+LL | foo::<u16>(x_usize);
+ | ^^^^^^^ expected u16, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:174:16
+ |
+LL | foo::<u16>(x_u64);
+ | ^^^^^ expected u16, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:176:16
+ |
+LL | foo::<u16>(x_u32);
+ | ^^^^^ expected u16, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:179:16
+ |
+LL | foo::<u16>(x_u8);
+ | ^^^^ expected u16, found u8
+help: you can cast an `u8` to `u16`, which will zero-extend the source value
+ |
+LL | foo::<u16>(x_u8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:181:16
+ |
+LL | foo::<u16>(x_isize);
+ | ^^^^^^^ expected u16, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:183:16
+ |
+LL | foo::<u16>(x_i64);
+ | ^^^^^ expected u16, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:185:16
+ |
+LL | foo::<u16>(x_i32);
+ | ^^^^^ expected u16, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:187:16
+ |
+LL | foo::<u16>(x_i16);
+ | ^^^^^ expected u16, found i16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:189:16
+ |
+LL | foo::<u16>(x_i8);
+ | ^^^^ expected u16, found i8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:191:16
+ |
+LL | foo::<u16>(x_f64);
+ | ^^^^^ expected u16, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:193:16
+ |
+LL | foo::<u16>(x_f32);
+ | ^^^^^ expected u16, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:196:16
+ |
+LL | foo::<i16>(x_usize);
+ | ^^^^^^^ expected i16, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:198:16
+ |
+LL | foo::<i16>(x_u64);
+ | ^^^^^ expected i16, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:200:16
+ |
+LL | foo::<i16>(x_u32);
+ | ^^^^^ expected i16, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:202:16
+ |
+LL | foo::<i16>(x_u16);
+ | ^^^^^ expected i16, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:204:16
+ |
+LL | foo::<i16>(x_u8);
+ | ^^^^ expected i16, found u8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:206:16
+ |
+LL | foo::<i16>(x_isize);
+ | ^^^^^^^ expected i16, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:208:16
+ |
+LL | foo::<i16>(x_i64);
+ | ^^^^^ expected i16, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:210:16
+ |
+LL | foo::<i16>(x_i32);
+ | ^^^^^ expected i16, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:213:16
+ |
+LL | foo::<i16>(x_i8);
+ | ^^^^ expected i16, found i8
+help: you can cast an `i8` to `i16`, which will sign-extend the source value
+ |
+LL | foo::<i16>(x_i8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:215:16
+ |
+LL | foo::<i16>(x_f64);
+ | ^^^^^ expected i16, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:217:16
+ |
+LL | foo::<i16>(x_f32);
+ | ^^^^^ expected i16, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:220:15
+ |
+LL | foo::<u8>(x_usize);
+ | ^^^^^^^ expected u8, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:222:15
+ |
+LL | foo::<u8>(x_u64);
+ | ^^^^^ expected u8, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:224:15
+ |
+LL | foo::<u8>(x_u32);
+ | ^^^^^ expected u8, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:226:15
+ |
+LL | foo::<u8>(x_u16);
+ | ^^^^^ expected u8, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:229:15
+ |
+LL | foo::<u8>(x_isize);
+ | ^^^^^^^ expected u8, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:231:15
+ |
+LL | foo::<u8>(x_i64);
+ | ^^^^^ expected u8, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:233:15
+ |
+LL | foo::<u8>(x_i32);
+ | ^^^^^ expected u8, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:235:15
+ |
+LL | foo::<u8>(x_i16);
+ | ^^^^^ expected u8, found i16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:237:15
+ |
+LL | foo::<u8>(x_i8);
+ | ^^^^ expected u8, found i8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:239:15
+ |
+LL | foo::<u8>(x_f64);
+ | ^^^^^ expected u8, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:241:15
+ |
+LL | foo::<u8>(x_f32);
+ | ^^^^^ expected u8, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:244:15
+ |
+LL | foo::<i8>(x_usize);
+ | ^^^^^^^ expected i8, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:246:15
+ |
+LL | foo::<i8>(x_u64);
+ | ^^^^^ expected i8, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:248:15
+ |
+LL | foo::<i8>(x_u32);
+ | ^^^^^ expected i8, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:250:15
+ |
+LL | foo::<i8>(x_u16);
+ | ^^^^^ expected i8, found u16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:252:15
+ |
+LL | foo::<i8>(x_u8);
+ | ^^^^ expected i8, found u8
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:254:15
+ |
+LL | foo::<i8>(x_isize);
+ | ^^^^^^^ expected i8, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:256:15
+ |
+LL | foo::<i8>(x_i64);
+ | ^^^^^ expected i8, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:258:15
+ |
+LL | foo::<i8>(x_i32);
+ | ^^^^^ expected i8, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:260:15
+ |
+LL | foo::<i8>(x_i16);
+ | ^^^^^ expected i8, found i16
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:263:15
+ |
+LL | foo::<i8>(x_f64);
+ | ^^^^^ expected i8, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:265:15
+ |
+LL | foo::<i8>(x_f32);
+ | ^^^^^ expected i8, found f32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:268:16
+ |
+LL | foo::<f64>(x_usize);
+ | ^^^^^^^ expected f64, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:270:16
+ |
+LL | foo::<f64>(x_u64);
+ | ^^^^^ expected f64, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:272:16
+ |
+LL | foo::<f64>(x_u32);
+ | ^^^^^ expected f64, found u32
+help: you can cast an `u32` to `f64`, producing the floating point representation of the integer
+ |
+LL | foo::<f64>(x_u32.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:274:16
+ |
+LL | foo::<f64>(x_u16);
+ | ^^^^^ expected f64, found u16
+help: you can cast an `u16` to `f64`, producing the floating point representation of the integer
+ |
+LL | foo::<f64>(x_u16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:276:16
+ |
+LL | foo::<f64>(x_u8);
+ | ^^^^ expected f64, found u8
+help: you can cast an `u8` to `f64`, producing the floating point representation of the integer
+ |
+LL | foo::<f64>(x_u8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:278:16
+ |
+LL | foo::<f64>(x_isize);
+ | ^^^^^^^ expected f64, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:280:16
+ |
+LL | foo::<f64>(x_i64);
+ | ^^^^^ expected f64, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:282:16
+ |
+LL | foo::<f64>(x_i32);
+ | ^^^^^ expected f64, found i32
+help: you can cast an `i32` to `f64`, producing the floating point representation of the integer
+ |
+LL | foo::<f64>(x_i32.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:284:16
+ |
+LL | foo::<f64>(x_i16);
+ | ^^^^^ expected f64, found i16
+help: you can cast an `i16` to `f64`, producing the floating point representation of the integer
+ |
+LL | foo::<f64>(x_i16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:286:16
+ |
+LL | foo::<f64>(x_i8);
+ | ^^^^ expected f64, found i8
+help: you can cast an `i8` to `f64`, producing the floating point representation of the integer
+ |
+LL | foo::<f64>(x_i8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:289:16
+ |
+LL | foo::<f64>(x_f32);
+ | ^^^^^ expected f64, found f32
+help: you can cast an `f32` to `f64` in a lossless way
+ |
+LL | foo::<f64>(x_f32.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:292:16
+ |
+LL | foo::<f32>(x_usize);
+ | ^^^^^^^ expected f32, found usize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:294:16
+ |
+LL | foo::<f32>(x_u64);
+ | ^^^^^ expected f32, found u64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:296:16
+ |
+LL | foo::<f32>(x_u32);
+ | ^^^^^ expected f32, found u32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:298:16
+ |
+LL | foo::<f32>(x_u16);
+ | ^^^^^ expected f32, found u16
+help: you can cast an `u16` to `f32`, producing the floating point representation of the integer
+ |
+LL | foo::<f32>(x_u16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:300:16
+ |
+LL | foo::<f32>(x_u8);
+ | ^^^^ expected f32, found u8
+help: you can cast an `u8` to `f32`, producing the floating point representation of the integer
+ |
+LL | foo::<f32>(x_u8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:302:16
+ |
+LL | foo::<f32>(x_isize);
+ | ^^^^^^^ expected f32, found isize
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:304:16
+ |
+LL | foo::<f32>(x_i64);
+ | ^^^^^ expected f32, found i64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:306:16
+ |
+LL | foo::<f32>(x_i32);
+ | ^^^^^ expected f32, found i32
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:308:16
+ |
+LL | foo::<f32>(x_i16);
+ | ^^^^^ expected f32, found i16
+help: you can cast an `i16` to `f32`, producing the floating point representation of the integer
+ |
+LL | foo::<f32>(x_i16.into());
+ | ^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:310:16
+ |
+LL | foo::<f32>(x_i8);
+ | ^^^^ expected f32, found i8
+help: you can cast an `i8` to `f32`, producing the floating point representation of the integer
+ |
+LL | foo::<f32>(x_i8.into());
+ | ^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:312:16
+ |
+LL | foo::<f32>(x_f64);
+ | ^^^^^ expected f32, found f64
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:316:16
+ |
+LL | foo::<u32>(x_u8 as u16);
+ | ^^^^^^^^^^^ expected u32, found u16
+help: you can cast an `u16` to `u32`, which will zero-extend the source value
+ |
+LL | foo::<u32>((x_u8 as u16).into());
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/numeric-cast.rs:318:16
+ |
+LL | foo::<i32>(-x_i8);
+ | ^^^^^ expected i32, found i8
+help: you can cast an `i8` to `i32`, which will sign-extend the source value
+ |
+LL | foo::<i32>((-x_i8).into());
+ | ^^^^^^^^^^^^^^
+
+error: aborting due to 134 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let x = -5;
+ if x<-1 {
+ //~^ ERROR emplacement syntax is obsolete
+ println!("ok");
+ }
+}
--- /dev/null
+error: emplacement syntax is obsolete (for now, anyway)
+ --> $DIR/placement-syntax.rs:13:8
+ |
+LL | if x<-1 {
+ | ^^^^
+ |
+ = note: for more information, see <https://github.com/rust-lang/rust/issues/27779#issuecomment-378416911>
+help: if you meant to write a comparison against a negative value, add a space in between `<` and `-`
+ |
+LL | if x< -1 {
+ | ^^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub foo(s: usize) { bar() }
+//~^ ERROR missing `fn` for method definition
+
+fn main() {
+ foo(2);
+}
--- /dev/null
+error: missing `fn` for method definition
+ --> $DIR/pub-ident-fn-2.rs:11:4
+ |
+LL | pub foo(s: usize) { bar() }
+ | ^
+help: add `fn` here to parse `foo` as a public method
+ |
+LL | pub fn foo(s: usize) { bar() }
+ | ^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub S();
+//~^ ERROR missing `fn` or `struct` for method or struct definition
+
+fn main() {}
--- /dev/null
+error: missing `fn` or `struct` for method or struct definition
+ --> $DIR/pub-ident-fn-or-struct-2.rs:11:4
+ |
+LL | pub S();
+ | ---^- help: if you meant to call a macro, try: `S!`
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub S (foo) bar
+//~^ ERROR missing `fn` or `struct` for method or struct definition
+
+fn main() {}
--- /dev/null
+error: missing `fn` or `struct` for method or struct definition
+ --> $DIR/pub-ident-fn-or-struct.rs:11:4
+ |
+LL | pub S (foo) bar
+ | ---^- help: if you meant to call a macro, try: `S!`
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+pub fn foo(_s: usize) -> bool { true }
+//~^ ERROR missing `fn` for method definition
+
+fn main() {
+ foo(2);
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+pub foo(_s: usize) -> bool { true }
+//~^ ERROR missing `fn` for method definition
+
+fn main() {
+ foo(2);
+}
--- /dev/null
+error: missing `fn` for method definition
+ --> $DIR/pub-ident-fn.rs:13:4
+ |
+LL | pub foo(_s: usize) -> bool { true }
+ | ^^^
+help: add `fn` here to parse `foo` as a public method
+ |
+LL | pub fn foo(_s: usize) -> bool { true }
+ | ^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub S {
+//~^ ERROR missing `struct` for struct definition
+}
+fn main() {}
--- /dev/null
+error: missing `struct` for struct definition
+ --> $DIR/pub-ident-struct.rs:11:4
+ |
+LL | pub S {
+ | ^
+help: add `struct` here to parse `S` as a public struct
+ |
+LL | pub struct S {
+ | ^^^^^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: --edition 2018
+// aux-build:removing-extern-crate.rs
+// run-rustfix
+// compile-pass
+
+#![warn(rust_2018_idioms)]
+#![allow(unused_imports)]
+
+
+
+
+mod another {
+
+
+}
+
+fn main() {}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-flags: --edition 2018
+// aux-build:removing-extern-crate.rs
+// run-rustfix
+// compile-pass
+
+#![warn(rust_2018_idioms)]
+#![allow(unused_imports)]
+
+extern crate std as foo;
+extern crate core;
+
+mod another {
+ extern crate std as foo;
+ extern crate std;
+}
+
+fn main() {}
--- /dev/null
+warning: unused extern crate
+ --> $DIR/removing-extern-crate.rs:19:1
+ |
+LL | extern crate std as foo;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove it
+ |
+note: lint level defined here
+ --> $DIR/removing-extern-crate.rs:16:9
+ |
+LL | #![warn(rust_2018_idioms)]
+ | ^^^^^^^^^^^^^^^^
+ = note: #[warn(unused_extern_crates)] implied by #[warn(rust_2018_idioms)]
+
+warning: unused extern crate
+ --> $DIR/removing-extern-crate.rs:20:1
+ |
+LL | extern crate core;
+ | ^^^^^^^^^^^^^^^^^^ help: remove it
+
+warning: unused extern crate
+ --> $DIR/removing-extern-crate.rs:23:5
+ |
+LL | extern crate std as foo;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove it
+
+warning: unused extern crate
+ --> $DIR/removing-extern-crate.rs:24:5
+ |
+LL | extern crate std;
+ | ^^^^^^^^^^^^^^^^^ help: remove it
+
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// compile-pass
+
+#[repr]
+//^ WARN `repr` attribute must have a hint
+struct _A {}
+
+#[repr = "B"]
+//^ WARN `repr` attribute isn't configurable with a literal
+struct _B {}
+
+#[repr = "C"]
+//^ WARN `repr` attribute isn't configurable with a literal
+struct _C {}
+
+#[repr(C)]
+struct _D {}
+
+fn main() {}
--- /dev/null
+warning: `repr` attribute must have a hint
+ --> $DIR/repr.rs:13:1
+ |
+LL | #[repr]
+ | ^^^^^^^ needs a hint
+ |
+ = note: #[warn(bad_repr)] on by default
+ = help: valid hints include `#[repr(C)]`, `#[repr(packed)]`, `#[repr(rust)]` and `#[repr(transparent)]`
+ = note: for more information, visit <https://doc.rust-lang.org/reference/type-layout.html>
+
+warning: `repr` attribute isn't configurable with a literal
+ --> $DIR/repr.rs:17:1
+ |
+LL | #[repr = "B"]
+ | ^^^^^^^^^^^^^ needs a hint
+ |
+ = help: valid hints include `#[repr(C)]`, `#[repr(packed)]`, `#[repr(rust)]` and `#[repr(transparent)]`
+ = note: for more information, visit <https://doc.rust-lang.org/reference/type-layout.html>
+
+warning: `repr` attribute isn't configurable with a literal
+ --> $DIR/repr.rs:21:1
+ |
+LL | #[repr = "C"]
+ | ^^^^^^^^^^^^^ help: give `repr` a hint: `#[repr(C)]`
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct S<T> {
+ t: T,
+}
+
+fn foo<T>(x: T) -> S<T> {
+ S { t: x }
+}
+
+fn bar() {
+ foo(4 as usize)
+ //~^ ERROR mismatched types
+}
+
+fn main() {}
--- /dev/null
+error[E0308]: mismatched types
+ --> $DIR/return-type.rs:20:5
+ |
+LL | foo(4 as usize)
+ | ^^^^^^^^^^^^^^^ expected (), found struct `S`
+ |
+ = note: expected type `()`
+ found type `S<usize>`
+help: try adding a semicolon
+ |
+LL | foo(4 as usize);
+ | ^
+help: try adding a return type
+ |
+LL | fn bar() -> S<usize> {
+ | ^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
-error: lifetime parameter `'b` only used once
- --> $DIR/one-use-in-fn-argument-in-band.rs:19:22
+error: lifetime parameter `'a` only used once
+ --> $DIR/one-use-in-fn-argument-in-band.rs:19:10
|
LL | fn a(x: &'a u32, y: &'b u32) {
- | ^^
- | |
- | this lifetime...
- | ...is used only here
+ | ^^
+ | |
+ | this lifetime...
+ | ...is used only here
|
note: lint level defined here
--> $DIR/one-use-in-fn-argument-in-band.rs:12:9
LL | #![deny(single_use_lifetimes)]
| ^^^^^^^^^^^^^^^^^^^^
-error: lifetime parameter `'a` only used once
- --> $DIR/one-use-in-fn-argument-in-band.rs:19:10
+error: lifetime parameter `'b` only used once
+ --> $DIR/one-use-in-fn-argument-in-band.rs:19:22
|
LL | fn a(x: &'a u32, y: &'b u32) {
- | ^^
- | |
- | this lifetime...
- | ...is used only here
+ | ^^
+ | |
+ | this lifetime...
+ | ...is used only here
error: aborting due to 2 previous errors
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let s = "abc";
+ let t = if true { s[..2] } else { s };
+ //~^ ERROR if and else have incompatible types
+ let u: &str = if true { s[..2] } else { s };
+ //~^ ERROR mismatched types
+ let v = s[..2];
+ //~^ ERROR the size for values of type
+ let w: &str = s[..2];
+ //~^ ERROR mismatched types
+}
--- /dev/null
+error[E0308]: if and else have incompatible types
+ --> $DIR/str-array-assignment.rs:13:11
+ |
+LL | let t = if true { s[..2] } else { s };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected str, found &str
+ |
+ = note: expected type `str`
+ found type `&str`
+
+error[E0308]: mismatched types
+ --> $DIR/str-array-assignment.rs:15:27
+ |
+LL | let u: &str = if true { s[..2] } else { s };
+ | ^^^^^^
+ | |
+ | expected &str, found str
+ | help: consider borrowing here: `&s[..2]`
+ |
+ = note: expected type `&str`
+ found type `str`
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> $DIR/str-array-assignment.rs:17:7
+ |
+LL | let v = s[..2];
+ | ^ ------ help: consider borrowing here: `&s[..2]`
+ | |
+ | doesn't have a size known at compile-time
+ |
+ = help: the trait `std::marker::Sized` is not implemented for `str`
+ = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types-and-sized>
+ = note: all local variables must have a statically known size
+
+error[E0308]: mismatched types
+ --> $DIR/str-array-assignment.rs:19:17
+ |
+LL | let w: &str = s[..2];
+ | ^^^^^^
+ | |
+ | expected &str, found str
+ | help: consider borrowing here: `&s[..2]`
+ |
+ = note: expected type `&str`
+ found type `str`
+
+error: aborting due to 4 previous errors
+
+Some errors occurred: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+fn main() {
+ println!("●●");
+ //~^ ERROR character literal may only contain one codepoint
+}
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+
+fn main() {
+ println!('●●');
+ //~^ ERROR character literal may only contain one codepoint
+}
--- /dev/null
+error: character literal may only contain one codepoint
+ --> $DIR/str-as-char.rs:14:14
+ |
+LL | println!('●●');
+ | ^^^^
+help: if you meant to write a `str` literal, use double quotes
+ |
+LL | println!("●●");
+ | ^^^^
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[allow(unreachable_code, unused_labels)]
+fn main() {
+ 'foo: loop {
+ break 'fo; //~ ERROR use of undeclared label
+ }
+
+ 'bar: loop {
+ continue 'bor; //~ ERROR use of undeclared label
+ }
+
+ 'longlabel: loop {
+ 'longlabel1: loop {
+ break 'longlable; //~ ERROR use of undeclared label
+ }
+ }
+}
--- /dev/null
+error[E0426]: use of undeclared label `'fo`
+ --> $DIR/suggest-labels.rs:14:15
+ |
+LL | break 'fo; //~ ERROR use of undeclared label
+ | ^^^ did you mean `'foo`?
+
+error[E0426]: use of undeclared label `'bor`
+ --> $DIR/suggest-labels.rs:18:18
+ |
+LL | continue 'bor; //~ ERROR use of undeclared label
+ | ^^^^ did you mean `'bar`?
+
+error[E0426]: use of undeclared label `'longlable`
+ --> $DIR/suggest-labels.rs:23:19
+ |
+LL | break 'longlable; //~ ERROR use of undeclared label
+ | ^^^^^^^^^^ did you mean `'longlabel1`?
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0426`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Foo;
+
+impl Foo {
+ fn bar(self) {}
+ fn baz(&self, x: f64) {}
+}
+
+trait FooT {
+ fn bag(&self);
+}
+
+impl FooT for Foo {
+ fn bag(&self) {}
+}
+
+fn main() {
+ let f = Foo;
+ f.bat(1.0); //~ ERROR no method named
+
+ let s = "foo".to_string();
+ let _ = s.is_emtpy(); //~ ERROR no method named
+
+ // Generates a warning for `count_zeros()`. `count_ones()` is also a close
+ // match, but the former is closer.
+ let _ = 63u32.count_eos(); //~ ERROR no method named
+
+ // Does not generate a warning
+ let _ = 63u32.count_o(); //~ ERROR no method named
+
+}
--- /dev/null
+error[E0599]: no method named `bat` found for type `Foo` in the current scope
+ --> $DIR/suggest-methods.rs:28:7
+ |
+LL | struct Foo;
+ | ----------- method `bat` not found for this
+...
+LL | f.bat(1.0); //~ ERROR no method named
+ | ^^^
+ |
+ = help: did you mean `bar`?
+
+error[E0599]: no method named `is_emtpy` found for type `std::string::String` in the current scope
+ --> $DIR/suggest-methods.rs:31:15
+ |
+LL | let _ = s.is_emtpy(); //~ ERROR no method named
+ | ^^^^^^^^
+ |
+ = help: did you mean `is_empty`?
+
+error[E0599]: no method named `count_eos` found for type `u32` in the current scope
+ --> $DIR/suggest-methods.rs:35:19
+ |
+LL | let _ = 63u32.count_eos(); //~ ERROR no method named
+ | ^^^^^^^^^
+ |
+ = help: did you mean `count_zeros`?
+
+error[E0599]: no method named `count_o` found for type `u32` in the current scope
+ --> $DIR/suggest-methods.rs:38:19
+ |
+LL | let _ = 63u32.count_o(); //~ ERROR no method named
+ | ^^^^^^^
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0599`.
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(nll)]
+
+struct X(usize);
+
+impl X {
+ fn zap(&self) {
+ //~^ HELP
+ //~| SUGGESTION &mut self
+ self.0 = 32;
+ //~^ ERROR
+ }
+}
+
+fn main() {
+ let ref foo = 16;
+ //~^ HELP
+ //~| SUGGESTION ref mut foo
+ *foo = 32;
+ //~^ ERROR
+ if let Some(ref bar) = Some(16) {
+ //~^ HELP
+ //~| SUGGESTION ref mut bar
+ *bar = 32;
+ //~^ ERROR
+ }
+ match 16 {
+ ref quo => { *quo = 32; },
+ //~^ ERROR
+ //~| HELP
+ //~| SUGGESTION ref mut quo
+ }
+}
--- /dev/null
+error[E0594]: cannot assign to `self.0` which is behind a `&` reference
+ --> $DIR/suggest-ref-mut.rs:19:9
+ |
+LL | fn zap(&self) {
+ | ----- help: consider changing this to be a mutable reference: `&mut self`
+...
+LL | self.0 = 32;
+ | ^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be written
+
+error[E0594]: cannot assign to `*foo` which is behind a `&` reference
+ --> $DIR/suggest-ref-mut.rs:28:5
+ |
+LL | let ref foo = 16;
+ | ------- help: consider changing this to be a mutable reference: `ref mut foo`
+...
+LL | *foo = 32;
+ | ^^^^^^^^^ `foo` is a `&` reference, so the data it refers to cannot be written
+
+error[E0594]: cannot assign to `*bar` which is behind a `&` reference
+ --> $DIR/suggest-ref-mut.rs:33:9
+ |
+LL | if let Some(ref bar) = Some(16) {
+ | ------- help: consider changing this to be a mutable reference: `ref mut bar`
+...
+LL | *bar = 32;
+ | ^^^^^^^^^ `bar` is a `&` reference, so the data it refers to cannot be written
+
+error[E0594]: cannot assign to `*quo` which is behind a `&` reference
+ --> $DIR/suggest-ref-mut.rs:37:22
+ |
+LL | ref quo => { *quo = 32; },
+ | ------- ^^^^^^^^^ `quo` is a `&` reference, so the data it refers to cannot be written
+ | |
+ | help: consider changing this to be a mutable reference: `ref mut quo`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct Foo;
-fn takes_ref(_: &Foo) {}
-
-fn main() {
- let ref opt = Some(Foo);
- opt.map(|arg| takes_ref(arg));
- //~^ ERROR mismatched types [E0308]
- opt.and_then(|arg| Some(takes_ref(arg)));
- //~^ ERROR mismatched types [E0308]
- let ref opt: Result<_, ()> = Ok(Foo);
- opt.map(|arg| takes_ref(arg));
- //~^ ERROR mismatched types [E0308]
- opt.and_then(|arg| Ok(takes_ref(arg)));
- //~^ ERROR mismatched types [E0308]
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/as-ref.rs:16:27
- |
-LL | opt.map(|arg| takes_ref(arg));
- | - ^^^ expected &Foo, found struct `Foo`
- | |
- | help: consider using `as_ref` instead: `as_ref().`
- |
- = note: expected type `&Foo`
- found type `Foo`
-
-error[E0308]: mismatched types
- --> $DIR/as-ref.rs:18:37
- |
-LL | opt.and_then(|arg| Some(takes_ref(arg)));
- | - ^^^ expected &Foo, found struct `Foo`
- | |
- | help: consider using `as_ref` instead: `as_ref().`
- |
- = note: expected type `&Foo`
- found type `Foo`
-
-error[E0308]: mismatched types
- --> $DIR/as-ref.rs:21:27
- |
-LL | opt.map(|arg| takes_ref(arg));
- | - ^^^ expected &Foo, found struct `Foo`
- | |
- | help: consider using `as_ref` instead: `as_ref().`
- |
- = note: expected type `&Foo`
- found type `Foo`
-
-error[E0308]: mismatched types
- --> $DIR/as-ref.rs:23:35
- |
-LL | opt.and_then(|arg| Ok(takes_ref(arg)));
- | - ^^^ expected &Foo, found struct `Foo`
- | |
- | help: consider using `as_ref` instead: `as_ref().`
- |
- = note: expected type `&Foo`
- found type `Foo`
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub fn foo() {}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub fn bar() {}
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_export]
-macro_rules! mac {
- ($ident:ident) => { let $ident = 42; }
-}
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// intentionally blank
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-// Point at the captured immutable outer variable
-
-fn foo(mut f: Box<FnMut()>) {
- f();
-}
-
-fn main() {
- let mut y = true;
- foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
-}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-// Point at the captured immutable outer variable
-
-fn foo(mut f: Box<FnMut()>) {
- f();
-}
-
-fn main() {
- let y = true;
- foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
-}
+++ /dev/null
-error[E0594]: cannot assign to immutable item `y`
- --> $DIR/closure-immutable-outer-variable.rs:21:26
- |
-LL | foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
- | ^^^^^^^^^ cannot assign
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-// Point at the captured immutable outer variable
-
-fn foo(mut f: Box<FnMut()>) {
- f();
-}
-
-fn main() {
- let y = true;
- foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
-}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Point at the captured immutable outer variable
-
-fn foo(mut f: Box<FnMut()>) {
- f();
-}
-
-fn main() {
- let mut y = true;
- foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
-}
+++ /dev/null
-error[E0594]: cannot assign to captured outer variable in an `FnMut` closure
- --> $DIR/closure-immutable-outer-variable.rs:21:26
- |
-LL | let y = true;
- | - help: consider making `y` mutable: `mut y`
-LL | foo(Box::new(move || y = false) as Box<_>); //~ ERROR cannot assign to captured outer variable
- | ^^^^^^^^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct Obj<F> where F: FnMut() -> u32 {
- closure: F,
-}
-
-fn main() {
- let o = Obj { closure: || 42 };
- o.closure();
- //~^ ERROR no method named `closure` found
-}
+++ /dev/null
-error[E0599]: no method named `closure` found for type `Obj<[closure@$DIR/issue-18343.rs:16:28: 16:33]>` in the current scope
- --> $DIR/issue-18343.rs:17:7
- |
-LL | struct Obj<F> where F: FnMut() -> u32 {
- | ------------------------------------- method `closure` not found for this
-...
-LL | o.closure();
- | ^^^^^^^ field, not a method
- |
- = help: use `(o.closure)(...)` if you meant to call the function stored in the `closure` field
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0599`.
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(core, fnbox)]
-
-use std::boxed::FnBox;
-
-struct FuncContainer {
- f1: fn(data: u8),
- f2: extern "C" fn(data: u8),
- f3: unsafe fn(data: u8),
-}
-
-struct FuncContainerOuter {
- container: Box<FuncContainer>
-}
-
-struct Obj<F> where F: FnOnce() -> u32 {
- closure: F,
- not_closure: usize,
-}
-
-struct BoxedObj {
- boxed_closure: Box<FnBox() -> u32>,
-}
-
-struct Wrapper<F> where F: FnMut() -> u32 {
- wrap: Obj<F>,
-}
-
-fn func() -> u32 {
- 0
-}
-
-fn check_expression() -> Obj<Box<FnBox() -> u32>> {
- Obj { closure: Box::new(|| 42_u32) as Box<FnBox() -> u32>, not_closure: 42 }
-}
-
-fn main() {
- // test variations of function
-
- let o_closure = Obj { closure: || 42, not_closure: 42 };
- o_closure.closure(); //~ ERROR no method named `closure` found
-
- o_closure.not_closure();
- //~^ ERROR no method named `not_closure` found
-
- let o_func = Obj { closure: func, not_closure: 5 };
- o_func.closure(); //~ ERROR no method named `closure` found
-
- let boxed_fn = BoxedObj { boxed_closure: Box::new(func) };
- boxed_fn.boxed_closure();//~ ERROR no method named `boxed_closure` found
-
- let boxed_closure = BoxedObj { boxed_closure: Box::new(|| 42_u32) as Box<FnBox() -> u32> };
- boxed_closure.boxed_closure();//~ ERROR no method named `boxed_closure` found
-
- // test expression writing in the notes
-
- let w = Wrapper { wrap: o_func };
- w.wrap.closure();//~ ERROR no method named `closure` found
-
- w.wrap.not_closure();
- //~^ ERROR no method named `not_closure` found
-
- check_expression().closure();//~ ERROR no method named `closure` found
-}
-
-impl FuncContainerOuter {
- fn run(&self) {
- unsafe {
- (*self.container).f1(1); //~ ERROR no method named `f1` found
- (*self.container).f2(1); //~ ERROR no method named `f2` found
- (*self.container).f3(1); //~ ERROR no method named `f3` found
- }
- }
-}
+++ /dev/null
-error[E0599]: no method named `closure` found for type `Obj<[closure@$DIR/issue-2392.rs:49:36: 49:41]>` in the current scope
- --> $DIR/issue-2392.rs:50:15
- |
-LL | struct Obj<F> where F: FnOnce() -> u32 {
- | -------------------------------------- method `closure` not found for this
-...
-LL | o_closure.closure(); //~ ERROR no method named `closure` found
- | ^^^^^^^ field, not a method
- |
- = help: use `(o_closure.closure)(...)` if you meant to call the function stored in the `closure` field
-
-error[E0599]: no method named `not_closure` found for type `Obj<[closure@$DIR/issue-2392.rs:49:36: 49:41]>` in the current scope
- --> $DIR/issue-2392.rs:52:15
- |
-LL | struct Obj<F> where F: FnOnce() -> u32 {
- | -------------------------------------- method `not_closure` not found for this
-...
-LL | o_closure.not_closure();
- | ^^^^^^^^^^^ field, not a method
- |
- = help: did you mean to write `o_closure.not_closure` instead of `o_closure.not_closure(...)`?
-
-error[E0599]: no method named `closure` found for type `Obj<fn() -> u32 {func}>` in the current scope
- --> $DIR/issue-2392.rs:56:12
- |
-LL | struct Obj<F> where F: FnOnce() -> u32 {
- | -------------------------------------- method `closure` not found for this
-...
-LL | o_func.closure(); //~ ERROR no method named `closure` found
- | ^^^^^^^ field, not a method
- |
- = help: use `(o_func.closure)(...)` if you meant to call the function stored in the `closure` field
-
-error[E0599]: no method named `boxed_closure` found for type `BoxedObj` in the current scope
- --> $DIR/issue-2392.rs:59:14
- |
-LL | struct BoxedObj {
- | --------------- method `boxed_closure` not found for this
-...
-LL | boxed_fn.boxed_closure();//~ ERROR no method named `boxed_closure` found
- | ^^^^^^^^^^^^^ field, not a method
- |
- = help: use `(boxed_fn.boxed_closure)(...)` if you meant to call the function stored in the `boxed_closure` field
-
-error[E0599]: no method named `boxed_closure` found for type `BoxedObj` in the current scope
- --> $DIR/issue-2392.rs:62:19
- |
-LL | struct BoxedObj {
- | --------------- method `boxed_closure` not found for this
-...
-LL | boxed_closure.boxed_closure();//~ ERROR no method named `boxed_closure` found
- | ^^^^^^^^^^^^^ field, not a method
- |
- = help: use `(boxed_closure.boxed_closure)(...)` if you meant to call the function stored in the `boxed_closure` field
-
-error[E0599]: no method named `closure` found for type `Obj<fn() -> u32 {func}>` in the current scope
- --> $DIR/issue-2392.rs:67:12
- |
-LL | struct Obj<F> where F: FnOnce() -> u32 {
- | -------------------------------------- method `closure` not found for this
-...
-LL | w.wrap.closure();//~ ERROR no method named `closure` found
- | ^^^^^^^ field, not a method
- |
- = help: use `(w.wrap.closure)(...)` if you meant to call the function stored in the `closure` field
-
-error[E0599]: no method named `not_closure` found for type `Obj<fn() -> u32 {func}>` in the current scope
- --> $DIR/issue-2392.rs:69:12
- |
-LL | struct Obj<F> where F: FnOnce() -> u32 {
- | -------------------------------------- method `not_closure` not found for this
-...
-LL | w.wrap.not_closure();
- | ^^^^^^^^^^^ field, not a method
- |
- = help: did you mean to write `w.wrap.not_closure` instead of `w.wrap.not_closure(...)`?
-
-error[E0599]: no method named `closure` found for type `Obj<std::boxed::Box<(dyn std::boxed::FnBox<(), Output=u32> + 'static)>>` in the current scope
- --> $DIR/issue-2392.rs:72:24
- |
-LL | struct Obj<F> where F: FnOnce() -> u32 {
- | -------------------------------------- method `closure` not found for this
-...
-LL | check_expression().closure();//~ ERROR no method named `closure` found
- | ^^^^^^^ field, not a method
- |
- = help: use `(check_expression().closure)(...)` if you meant to call the function stored in the `closure` field
-
-error[E0599]: no method named `f1` found for type `FuncContainer` in the current scope
- --> $DIR/issue-2392.rs:78:31
- |
-LL | struct FuncContainer {
- | -------------------- method `f1` not found for this
-...
-LL | (*self.container).f1(1); //~ ERROR no method named `f1` found
- | ^^ field, not a method
- |
- = help: use `((*self.container).f1)(...)` if you meant to call the function stored in the `f1` field
-
-error[E0599]: no method named `f2` found for type `FuncContainer` in the current scope
- --> $DIR/issue-2392.rs:79:31
- |
-LL | struct FuncContainer {
- | -------------------- method `f2` not found for this
-...
-LL | (*self.container).f2(1); //~ ERROR no method named `f2` found
- | ^^ field, not a method
- |
- = help: use `((*self.container).f2)(...)` if you meant to call the function stored in the `f2` field
-
-error[E0599]: no method named `f3` found for type `FuncContainer` in the current scope
- --> $DIR/issue-2392.rs:80:31
- |
-LL | struct FuncContainer {
- | -------------------- method `f3` not found for this
-...
-LL | (*self.container).f3(1); //~ ERROR no method named `f3` found
- | ^^ field, not a method
- |
- = help: use `((*self.container).f3)(...)` if you meant to call the function stored in the `f3` field
-
-error: aborting due to 11 previous errors
-
-For more information about this error, try `rustc --explain E0599`.
+++ /dev/null
-// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct Example {
- example: Box<Fn(i32) -> i32>
-}
-
-fn main() {
- let demo = Example {
- example: Box::new(|x| {
- x + 1
- })
- };
-
- demo.example(1);
- //~^ ERROR no method named `example`
- // (demo.example)(1);
-}
+++ /dev/null
-error[E0599]: no method named `example` found for type `Example` in the current scope
- --> $DIR/issue-32128.rs:22:10
- |
-LL | struct Example {
- | -------------- method `example` not found for this
-...
-LL | demo.example(1);
- | ^^^^^^^ field, not a method
- |
- = help: use `(demo.example)(...)` if you meant to call the function stored in the `example` field
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0599`.
+++ /dev/null
-// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::ops::Deref;
-
-struct Obj<F> where F: FnMut() -> u32 {
- fn_ptr: fn() -> (),
- closure: F,
-}
-
-struct C {
- c_fn_ptr: fn() -> (),
-}
-
-struct D(C);
-
-impl Deref for D {
- type Target = C;
- fn deref(&self) -> &C {
- &self.0
- }
-}
-
-
-fn empty() {}
-
-fn main() {
- let o = Obj { fn_ptr: empty, closure: || 42 };
- let p = &o;
- p.closure(); //~ ERROR no method named `closure` found
- let q = &p;
- q.fn_ptr(); //~ ERROR no method named `fn_ptr` found
- let r = D(C { c_fn_ptr: empty });
- let s = &r;
- s.c_fn_ptr(); //~ ERROR no method named `c_fn_ptr` found
-}
+++ /dev/null
-error[E0599]: no method named `closure` found for type `&Obj<[closure@$DIR/issue-33784.rs:35:43: 35:48]>` in the current scope
- --> $DIR/issue-33784.rs:37:7
- |
-LL | p.closure(); //~ ERROR no method named `closure` found
- | ^^^^^^^ field, not a method
- |
- = help: use `(p.closure)(...)` if you meant to call the function stored in the `closure` field
-
-error[E0599]: no method named `fn_ptr` found for type `&&Obj<[closure@$DIR/issue-33784.rs:35:43: 35:48]>` in the current scope
- --> $DIR/issue-33784.rs:39:7
- |
-LL | q.fn_ptr(); //~ ERROR no method named `fn_ptr` found
- | ^^^^^^ field, not a method
- |
- = help: use `(q.fn_ptr)(...)` if you meant to call the function stored in the `fn_ptr` field
-
-error[E0599]: no method named `c_fn_ptr` found for type `&D` in the current scope
- --> $DIR/issue-33784.rs:42:7
- |
-LL | s.c_fn_ptr(); //~ ERROR no method named `c_fn_ptr` found
- | ^^^^^^^^ field, not a method
- |
- = help: use `(s.c_fn_ptr)(...)` if you meant to call the function stored in the `c_fn_ptr` field
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0599`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub mod animal {
- pub struct Dog {
- pub age: usize,
- dog_age: usize,
- }
-
- impl Dog {
- pub fn new(age: usize) -> Dog {
- Dog { age: age, dog_age: age * 7 }
- }
- }
-}
-
-fn main() {
- let dog = animal::Dog::new(3);
- let dog_age = dog.dog_age(); //~ ERROR no method
- //let dog_age = dog.dog_age;
- println!("{}", dog_age);
-}
+++ /dev/null
-error[E0599]: no method named `dog_age` found for type `animal::Dog` in the current scope
- --> $DIR/private-field.rs:26:23
- |
-LL | pub struct Dog {
- | -------------- method `dog_age` not found for this
-...
-LL | let dog_age = dog.dog_age(); //~ ERROR no method
- | ^^^^^^^ private field, not a method
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0599`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// `const`s shouldn't suggest `.into()`
-
-const TEN: u8 = 10;
-const TWELVE: u16 = TEN + 2;
-//~^ ERROR mismatched types [E0308]
-
-fn main() {
- const TEN: u8 = 10;
- const ALSO_TEN: u16 = TEN;
- //~^ ERROR mismatched types [E0308]
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/const-type-mismatch.rs:14:21
- |
-LL | const TWELVE: u16 = TEN + 2;
- | ^^^^^^^ expected u16, found u8
-
-error[E0308]: mismatched types
- --> $DIR/const-type-mismatch.rs:19:27
- |
-LL | const ALSO_TEN: u16 = TEN;
- | ^^^ expected u16, found u8
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::path::{Path, PathBuf};
-
-
-fn main() {
- let _tis_an_instants_play: String = "'Tis a fond Ambush—"; //~ ERROR mismatched types
- let _just_to_make_bliss: PathBuf = Path::new("/ern/her/own/surprise");
- //~^ ERROR mismatched types
-
- let _but_should_the_play: String = 2; // Perhaps surprisingly, we suggest .to_string() here
- //~^ ERROR mismatched types
-
- let _prove_piercing_earnest: Vec<usize> = &[1, 2, 3]; //~ ERROR mismatched types
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/conversion-methods.rs:15:41
- |
-LL | let _tis_an_instants_play: String = "'Tis a fond Ambush—"; //~ ERROR mismatched types
- | ^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected struct `std::string::String`, found reference
- | help: try using a conversion method: `"'Tis a fond Ambush—".to_string()`
- |
- = note: expected type `std::string::String`
- found type `&'static str`
-
-error[E0308]: mismatched types
- --> $DIR/conversion-methods.rs:16:40
- |
-LL | let _just_to_make_bliss: PathBuf = Path::new("/ern/her/own/surprise");
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | expected struct `std::path::PathBuf`, found reference
- | help: try using a conversion method: `Path::new("/ern/her/own/surprise").to_path_buf()`
- |
- = note: expected type `std::path::PathBuf`
- found type `&std::path::Path`
-
-error[E0308]: mismatched types
- --> $DIR/conversion-methods.rs:19:40
- |
-LL | let _but_should_the_play: String = 2; // Perhaps surprisingly, we suggest .to_string() here
- | ^
- | |
- | expected struct `std::string::String`, found integral variable
- | help: try using a conversion method: `2.to_string()`
- |
- = note: expected type `std::string::String`
- found type `{integer}`
-
-error[E0308]: mismatched types
- --> $DIR/conversion-methods.rs:22:47
- |
-LL | let _prove_piercing_earnest: Vec<usize> = &[1, 2, 3]; //~ ERROR mismatched types
- | ^^^^^^^^^^
- | |
- | expected struct `std::vec::Vec`, found reference
- | help: try using a conversion method: `&[1, 2, 3].to_vec()`
- |
- = note: expected type `std::vec::Vec<usize>`
- found type `&[{integer}; 3]`
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct T;
-
-fn main() {
- T::new();
- //~^ ERROR no function or associated item named `new` found for type `T` in the current scope
-}
+++ /dev/null
-error[E0599]: no function or associated item named `new` found for type `T` in the current scope
- --> $DIR/dont-suggest-private-trait-method.rs:14:5
- |
-LL | struct T;
- | --------- function or associated item `new` not found for this
-...
-LL | T::new();
- | ^^^^^^ function or associated item not found in `T`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0599`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let _redemptive = 1...21;
- //~^ ERROR unexpected token
-}
+++ /dev/null
-error: unexpected token: `...`
- --> $DIR/dotdotdot-expr.rs:12:24
- |
-LL | let _redemptive = 1...21;
- | ^^^
-help: use `..` for an exclusive range
- |
-LL | let _redemptive = 1..21;
- | ^^
-help: or `..=` for an inclusive range
- |
-LL | let _redemptive = 1..=21;
- | ^^^
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:m1.rs
-// aux-build:m2.rs
-
-
-extern crate m1;
-extern crate m2 as m1; //~ ERROR is defined multiple times
-
-fn main() {}
+++ /dev/null
-error[E0259]: the name `m1` is defined multiple times
- --> $DIR/extern-crate-rename.rs:16:1
- |
-LL | extern crate m1;
- | ---------------- previous import of the extern crate `m1` here
-LL | extern crate m2 as m1; //~ ERROR is defined multiple times
- | ^^^^^^^^^^^^^^^^^^^^^^
- | |
- | `m1` reimported here
- | You can use `as` to change the binding name of the import
- |
- = note: `m1` must be defined only once in the type namespace of this module
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0259`.
+++ /dev/null
-error[E0594]: cannot assign to `x` which is behind a `&` reference
- --> $DIR/fn-closure-mutable-capture.rs:15:17
- |
-LL | bar(move || x = 1);
- | ^^^^^ cannot assign
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub fn bar<F: Fn()>(_f: F) {}
-
-pub fn foo() {
- let mut x = 0;
- bar(move || x = 1);
- //~^ ERROR cannot assign to captured outer variable in an `Fn` closure
- //~| NOTE `Fn` closures cannot capture their enclosing environment for modifications
-}
-
-fn main() {}
+++ /dev/null
-error[E0594]: cannot assign to captured outer variable in an `Fn` closure
- --> $DIR/fn-closure-mutable-capture.rs:15:17
- |
-LL | bar(move || x = 1);
- | ^^^^^
- |
- = note: `Fn` closures cannot capture their enclosing environment for modifications
-help: consider changing this closure to take self by mutable reference
- --> $DIR/fn-closure-mutable-capture.rs:15:9
- |
-LL | bar(move || x = 1);
- | ^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// E0277 should point exclusively at line 14, not the entire for loop span
-
-fn main() {
- for c in "asdf" {
- //~^ ERROR the trait bound `&str: std::iter::Iterator` is not satisfied
- //~| NOTE `&str` is not an iterator
- //~| HELP the trait `std::iter::Iterator` is not implemented for `&str`
- //~| NOTE required by `std::iter::IntoIterator::into_iter`
- println!("");
- }
-}
+++ /dev/null
-error[E0277]: the trait bound `&str: std::iter::Iterator` is not satisfied
- --> $DIR/for-c-in-str.rs:14:14
- |
-LL | for c in "asdf" {
- | ^^^^^^ `&str` is not an iterator; try calling `.chars()` or `.bytes()`
- |
- = help: the trait `std::iter::Iterator` is not implemented for `&str`
- = note: required by `std::iter::IntoIterator::into_iter`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0277`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-#![allow(unused_imports)]
-
-pub mod extension1 {
- pub trait ConstructorExtension {}
-}
-
-pub mod extension2 {
- pub trait ConstructorExtension {}
-}
-
-use extension1::ConstructorExtension;
-use extension2::ConstructorExtension as OtherConstructorExtension; //~ ERROR is defined multiple times
-
-fn main() {}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-#![allow(unused_imports)]
-
-pub mod extension1 {
- pub trait ConstructorExtension {}
-}
-
-pub mod extension2 {
- pub trait ConstructorExtension {}
-}
-
-use extension1::ConstructorExtension;
-use extension2::ConstructorExtension; //~ ERROR is defined multiple times
-
-fn main() {}
+++ /dev/null
-error[E0252]: the name `ConstructorExtension` is defined multiple times
- --> $DIR/issue-32354-suggest-import-rename.rs:24:5
- |
-LL | use extension1::ConstructorExtension;
- | -------------------------------- previous import of the trait `ConstructorExtension` here
-LL | use extension2::ConstructorExtension; //~ ERROR is defined multiple times
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ConstructorExtension` reimported here
- |
- = note: `ConstructorExtension` must be defined only once in the type namespace of this module
-help: You can use `as` to change the binding name of the import
- |
-LL | use extension2::ConstructorExtension as OtherConstructorExtension; //~ ERROR is defined multiple times
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0252`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// check that we substitute type parameters before we suggest anything - otherwise
-// we would suggest function such as `as_slice` for the `&[u16]`.
-
-fn foo(b: &[u16]) {}
-
-fn main() {
- let a: Vec<u8> = Vec::new();
- foo(&a); //~ ERROR mismatched types
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/issue-43420-no-over-suggest.rs:18:9
- |
-LL | foo(&a); //~ ERROR mismatched types
- | ^^ expected slice, found struct `std::vec::Vec`
- |
- = note: expected type `&[u16]`
- found type `&std::vec::Vec<u8>`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-#[no_mangle] pub static RAH: usize = 5;
-//~^ ERROR const items should never be #[no_mangle]
-
-fn main() {}
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-#[no_mangle] pub const RAH: usize = 5;
-//~^ ERROR const items should never be #[no_mangle]
-
-fn main() {}
+++ /dev/null
-error: const items should never be #[no_mangle]
- --> $DIR/issue-45562.rs:13:14
- |
-LL | #[no_mangle] pub const RAH: usize = 5;
- | ---------^^^^^^^^^^^^^^^^
- | |
- | help: try a static value: `pub static`
- |
- = note: #[deny(no_mangle_const_items)] on by default
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-extern crate std as other_std;
-fn main() {}
-//~^^ ERROR the name `std` is defined multiple times [E0259]
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-extern crate std;
-fn main() {}
-//~^^ ERROR the name `std` is defined multiple times [E0259]
+++ /dev/null
-error[E0259]: the name `std` is defined multiple times
- --> $DIR/issue-45799-bad-extern-crate-rename-suggestion-formatting.rs:13:1
- |
-LL | extern crate std;
- | ^^^^^^^^^^^^^^^^^ `std` reimported here
- |
- = note: `std` must be defined only once in the type namespace of this module
-help: You can use `as` to change the binding name of the import
- |
-LL | extern crate std as other_std;
- |
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0259`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn foo() {
- let s = "abc";
- let u: &str = if true { s[..2] } else { s };
- //~^ ERROR mismatched types
-}
-
-fn main() {
- foo();
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/issue-46302.rs:13:27
- |
-LL | let u: &str = if true { s[..2] } else { s };
- | ^^^^^^
- | |
- | expected &str, found str
- | help: consider borrowing here: `&s[..2]`
- |
- = note: expected type `&str`
- found type `str`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-#![allow(unused)]
-
-fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
- and_yet + 1
-}
-
-fn main() {
- let behold: isize = 2;
- let with_tears: usize = 3;
- light_flows_our_war_of_mocking_words(&(behold as usize));
- //~^ ERROR mismatched types [E0308]
- light_flows_our_war_of_mocking_words(&(with_tears + 4));
- //~^ ERROR mismatched types [E0308]
-}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-#![allow(unused)]
-
-fn light_flows_our_war_of_mocking_words(and_yet: &usize) -> usize {
- and_yet + 1
-}
-
-fn main() {
- let behold: isize = 2;
- let with_tears: usize = 3;
- light_flows_our_war_of_mocking_words(behold as usize);
- //~^ ERROR mismatched types [E0308]
- light_flows_our_war_of_mocking_words(with_tears + 4);
- //~^ ERROR mismatched types [E0308]
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:22:42
- |
-LL | light_flows_our_war_of_mocking_words(behold as usize);
- | ^^^^^^^^^^^^^^^
- | |
- | expected &usize, found usize
- | help: consider borrowing here: `&(behold as usize)`
- |
- = note: expected type `&usize`
- found type `usize`
-
-error[E0308]: mismatched types
- --> $DIR/issue-46756-consider-borrowing-cast-or-binexpr.rs:24:42
- |
-LL | light_flows_our_war_of_mocking_words(with_tears + 4);
- | ^^^^^^^^^^^^^^
- | |
- | expected &usize, found usize
- | help: consider borrowing here: `&(with_tears + 4)`
- |
- = note: expected type `&usize`
- found type `usize`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn foo() -> bool {
- b"".starts_with(stringify!(foo))
- //~^ ERROR mismatched types
-}
-
-fn main() {}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/issue-48364.rs:12:21
- |
-LL | b"".starts_with(stringify!(foo))
- | ^^^^^^^^^^^^^^^ expected slice, found str
- |
- = note: expected type `&[u8]`
- found type `&'static str`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-error[E0594]: cannot assign to `*my_ref` which is behind a `&` reference
- --> $DIR/issue-51244.rs:13:5
- |
-LL | let ref my_ref @ _ = 0;
- | -------------- help: consider changing this to be a mutable reference: `ref mut my_ref @ _`
-LL | *my_ref = 0; //~ ERROR cannot assign to immutable borrowed content `*my_ref` [E0594]
- | ^^^^^^^^^^^ `my_ref` is a `&` reference, so the data it refers to cannot be written
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let ref my_ref @ _ = 0;
- *my_ref = 0; //~ ERROR cannot assign to immutable borrowed content `*my_ref` [E0594]
-}
+++ /dev/null
-error[E0594]: cannot assign to immutable borrowed content `*my_ref`
- --> $DIR/issue-51244.rs:13:5
- |
-LL | let ref my_ref @ _ = 0;
- | -------------- help: use a mutable reference instead: `ref mut my_ref @ _`
-LL | *my_ref = 0; //~ ERROR cannot assign to immutable borrowed content `*my_ref` [E0594]
- | ^^^^^^^^^^^ cannot borrow as mutable
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(nll)]
-
-fn main() {
- let foo = &16;
- //~^ HELP consider changing this to be a mutable reference
- //~| SUGGESTION &mut 16
- *foo = 32;
- //~^ ERROR cannot assign to `*foo` which is behind a `&` reference
- let bar = foo;
- //~^ HELP consider changing this to be a mutable reference
- //~| SUGGESTION &mut i32
- *bar = 64;
- //~^ ERROR cannot assign to `*bar` which is behind a `&` reference
-}
+++ /dev/null
-error[E0594]: cannot assign to `*foo` which is behind a `&` reference
- --> $DIR/issue-51515.rs:17:5
- |
-LL | let foo = &16;
- | --- help: consider changing this to be a mutable reference: `&mut 16`
-...
-LL | *foo = 32;
- | ^^^^^^^^^ `foo` is a `&` reference, so the data it refers to cannot be written
-
-error[E0594]: cannot assign to `*bar` which is behind a `&` reference
- --> $DIR/issue-51515.rs:22:5
- |
-LL | let bar = foo;
- | --- help: consider changing this to be a mutable reference: `&mut i32`
-...
-LL | *bar = 64;
- | ^^^^^^^^^ `bar` is a `&` reference, so the data it refers to cannot be written
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-error[E0597]: borrowed value does not live long enough
- --> $DIR/issue-52049.rs:16:10
- |
-LL | foo(&unpromotable(5u32));
- | ^^^^^^^^^^^^^^^^^^ temporary value does not live long enough
-LL | }
- | - temporary value only lives until here
- |
- = note: borrowed value must be valid for the static lifetime...
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0597`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn foo(_: &'static u32) {}
-
-fn unpromotable<T>(t: T) -> T { t }
-
-fn main() {
- foo(&unpromotable(5u32));
-}
-//~^^ ERROR borrowed value does not live long enough
+++ /dev/null
-error[E0597]: borrowed value does not live long enough
- --> $DIR/issue-52049.rs:16:10
- |
-LL | foo(&unpromotable(5u32));
- | ^^^^^^^^^^^^^^^^^^ - temporary value only lives until here
- | |
- | temporary value does not live long enough
- |
- = note: borrowed value must be valid for the static lifetime...
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0597`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:macro-in-other-crate.rs
-
-#[macro_use] extern crate macro_in_other_crate;
-
-macro_rules! local_mac {
- ($ident:ident) => { let $ident = 42; }
-}
-
-fn main() {
- let x = 2.0.neg();
- //~^ ERROR can't call method `neg` on ambiguous numeric type `{float}`
-
- let y = 2.0;
- let x = y.neg();
- //~^ ERROR can't call method `neg` on ambiguous numeric type `{float}`
- println!("{:?}", x);
-
- for i in 0..100 {
- println!("{}", i.pow(2));
- //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
- }
-
- local_mac!(local_bar);
- local_bar.pow(2);
- //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
-}
-
-fn qux() {
- mac!(bar);
- bar.pow(2);
- //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
-}
+++ /dev/null
-error[E0689]: can't call method `neg` on ambiguous numeric type `{float}`
- --> $DIR/method-on-ambiguous-numeric-type.rs:20:17
- |
-LL | let x = 2.0.neg();
- | ^^^
-help: you must specify a concrete type for this numeric value, like `f32`
- |
-LL | let x = 2.0_f32.neg();
- | ^^^^^^^
-
-error[E0689]: can't call method `neg` on ambiguous numeric type `{float}`
- --> $DIR/method-on-ambiguous-numeric-type.rs:24:15
- |
-LL | let x = y.neg();
- | ^^^
-help: you must specify a type for this binding, like `f32`
- |
-LL | let y: f32 = 2.0;
- | ^^^^^^
-
-error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
- --> $DIR/method-on-ambiguous-numeric-type.rs:29:26
- |
-LL | for i in 0..100 {
- | - you must specify a type for this binding, like `i32`
-LL | println!("{}", i.pow(2));
- | ^^^
-
-error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
- --> $DIR/method-on-ambiguous-numeric-type.rs:34:15
- |
-LL | local_bar.pow(2);
- | ^^^
-help: you must specify a type for this binding, like `i32`
- |
-LL | ($ident:ident) => { let $ident: i32 = 42; }
- | ^^^^^^^^^^^
-
-error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
- --> $DIR/method-on-ambiguous-numeric-type.rs:40:9
- |
-LL | mac!(bar);
- | ---------- you must specify a type for this binding, like `i32`
-LL | bar.pow(2);
- | ^^^
- |
- = 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: aborting due to 5 previous errors
-
-For more information about this error, try `rustc --explain E0689`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-fn main() {
- match &Some(3) {
- &None => 1,
- &Some(2) => { 3 }
- //~^ ERROR expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`
- //~| NOTE expected one of `,`, `.`, `?`, `}`, or an operator here
- _ => 2
- };
-}
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-fn main() {
- match &Some(3) {
- &None => 1
- &Some(2) => { 3 }
- //~^ ERROR expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`
- //~| NOTE expected one of `,`, `.`, `?`, `}`, or an operator here
- _ => 2
- };
-}
+++ /dev/null
-error: expected one of `,`, `.`, `?`, `}`, or an operator, found `=>`
- --> $DIR/missing-comma-in-match.rs:16:18
- |
-LL | &None => 1
- | - help: missing a comma here to end this `match` arm
-LL | &Some(2) => { 3 }
- | ^^ expected one of `,`, `.`, `?`, `}`, or an operator here
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn foo() -> i32 {
- 4
-}
-fn main() {
- let x: u16 = foo();
- //~^ ERROR mismatched types
- let y: i64 = x + x;
- //~^ ERROR mismatched types
- let z: i32 = x + x;
- //~^ ERROR mismatched types
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/numeric-cast-2.rs:15:18
- |
-LL | let x: u16 = foo();
- | ^^^^^ expected u16, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast-2.rs:17:18
- |
-LL | let y: i64 = x + x;
- | ^^^^^ expected i64, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast-2.rs:19:18
- |
-LL | let z: i32 = x + x;
- | ^^^^^ expected i32, found u16
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-
-fn foo<N>(_x: N) {}
-
-fn main() {
- let x_usize: usize = 1;
- let x_u64: u64 = 2;
- let x_u32: u32 = 3;
- let x_u16: u16 = 4;
- let x_u8: u8 = 5;
- let x_isize: isize = 6;
- let x_i64: i64 = 7;
- let x_i32: i32 = 8;
- let x_i16: i16 = 9;
- let x_i8: i8 = 10;
- let x_f64: f64 = 11.0;
- let x_f32: f32 = 12.0;
-
- foo::<usize>(x_usize);
- foo::<usize>(x_u64);
- //~^ ERROR mismatched types
- foo::<usize>(x_u32);
- //~^ ERROR mismatched types
- foo::<usize>(x_u16);
- //~^ ERROR mismatched types
- foo::<usize>(x_u8);
- //~^ ERROR mismatched types
- foo::<usize>(x_isize);
- //~^ ERROR mismatched types
- foo::<usize>(x_i64);
- //~^ ERROR mismatched types
- foo::<usize>(x_i32);
- //~^ ERROR mismatched types
- foo::<usize>(x_i16);
- //~^ ERROR mismatched types
- foo::<usize>(x_i8);
- //~^ ERROR mismatched types
- foo::<usize>(x_f64);
- //~^ ERROR mismatched types
- foo::<usize>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<isize>(x_usize);
- //~^ ERROR mismatched types
- foo::<isize>(x_u64);
- //~^ ERROR mismatched types
- foo::<isize>(x_u32);
- //~^ ERROR mismatched types
- foo::<isize>(x_u16);
- //~^ ERROR mismatched types
- foo::<isize>(x_u8);
- //~^ ERROR mismatched types
- foo::<isize>(x_isize);
- foo::<isize>(x_i64);
- //~^ ERROR mismatched types
- foo::<isize>(x_i32);
- //~^ ERROR mismatched types
- foo::<isize>(x_i16);
- //~^ ERROR mismatched types
- foo::<isize>(x_i8);
- //~^ ERROR mismatched types
- foo::<isize>(x_f64);
- //~^ ERROR mismatched types
- foo::<isize>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<u64>(x_usize);
- //~^ ERROR mismatched types
- foo::<u64>(x_u64);
- foo::<u64>(x_u32);
- //~^ ERROR mismatched types
- foo::<u64>(x_u16);
- //~^ ERROR mismatched types
- foo::<u64>(x_u8);
- //~^ ERROR mismatched types
- foo::<u64>(x_isize);
- //~^ ERROR mismatched types
- foo::<u64>(x_i64);
- //~^ ERROR mismatched types
- foo::<u64>(x_i32);
- //~^ ERROR mismatched types
- foo::<u64>(x_i16);
- //~^ ERROR mismatched types
- foo::<u64>(x_i8);
- //~^ ERROR mismatched types
- foo::<u64>(x_f64);
- //~^ ERROR mismatched types
- foo::<u64>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<i64>(x_usize);
- //~^ ERROR mismatched types
- foo::<i64>(x_u64);
- //~^ ERROR mismatched types
- foo::<i64>(x_u32);
- //~^ ERROR mismatched types
- foo::<i64>(x_u16);
- //~^ ERROR mismatched types
- foo::<i64>(x_u8);
- //~^ ERROR mismatched types
- foo::<i64>(x_isize);
- //~^ ERROR mismatched types
- foo::<i64>(x_i64);
- foo::<i64>(x_i32);
- //~^ ERROR mismatched types
- foo::<i64>(x_i16);
- //~^ ERROR mismatched types
- foo::<i64>(x_i8);
- //~^ ERROR mismatched types
- foo::<i64>(x_f64);
- //~^ ERROR mismatched types
- foo::<i64>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<u32>(x_usize);
- //~^ ERROR mismatched types
- foo::<u32>(x_u64);
- //~^ ERROR mismatched types
- foo::<u32>(x_u32);
- foo::<u32>(x_u16);
- //~^ ERROR mismatched types
- foo::<u32>(x_u8);
- //~^ ERROR mismatched types
- foo::<u32>(x_isize);
- //~^ ERROR mismatched types
- foo::<u32>(x_i64);
- //~^ ERROR mismatched types
- foo::<u32>(x_i32);
- //~^ ERROR mismatched types
- foo::<u32>(x_i16);
- //~^ ERROR mismatched types
- foo::<u32>(x_i8);
- //~^ ERROR mismatched types
- foo::<u32>(x_f64);
- //~^ ERROR mismatched types
- foo::<u32>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<i32>(x_usize);
- //~^ ERROR mismatched types
- foo::<i32>(x_u64);
- //~^ ERROR mismatched types
- foo::<i32>(x_u32);
- //~^ ERROR mismatched types
- foo::<i32>(x_u16);
- //~^ ERROR mismatched types
- foo::<i32>(x_u8);
- //~^ ERROR mismatched types
- foo::<i32>(x_isize);
- //~^ ERROR mismatched types
- foo::<i32>(x_i64);
- //~^ ERROR mismatched types
- foo::<i32>(x_i32);
- foo::<i32>(x_i16);
- //~^ ERROR mismatched types
- foo::<i32>(x_i8);
- //~^ ERROR mismatched types
- foo::<i32>(x_f64);
- //~^ ERROR mismatched types
- foo::<i32>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<u16>(x_usize);
- //~^ ERROR mismatched types
- foo::<u16>(x_u64);
- //~^ ERROR mismatched types
- foo::<u16>(x_u32);
- //~^ ERROR mismatched types
- foo::<u16>(x_u16);
- foo::<u16>(x_u8);
- //~^ ERROR mismatched types
- foo::<u16>(x_isize);
- //~^ ERROR mismatched types
- foo::<u16>(x_i64);
- //~^ ERROR mismatched types
- foo::<u16>(x_i32);
- //~^ ERROR mismatched types
- foo::<u16>(x_i16);
- //~^ ERROR mismatched types
- foo::<u16>(x_i8);
- //~^ ERROR mismatched types
- foo::<u16>(x_f64);
- //~^ ERROR mismatched types
- foo::<u16>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<i16>(x_usize);
- //~^ ERROR mismatched types
- foo::<i16>(x_u64);
- //~^ ERROR mismatched types
- foo::<i16>(x_u32);
- //~^ ERROR mismatched types
- foo::<i16>(x_u16);
- //~^ ERROR mismatched types
- foo::<i16>(x_u8);
- //~^ ERROR mismatched types
- foo::<i16>(x_isize);
- //~^ ERROR mismatched types
- foo::<i16>(x_i64);
- //~^ ERROR mismatched types
- foo::<i16>(x_i32);
- //~^ ERROR mismatched types
- foo::<i16>(x_i16);
- foo::<i16>(x_i8);
- //~^ ERROR mismatched types
- foo::<i16>(x_f64);
- //~^ ERROR mismatched types
- foo::<i16>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<u8>(x_usize);
- //~^ ERROR mismatched types
- foo::<u8>(x_u64);
- //~^ ERROR mismatched types
- foo::<u8>(x_u32);
- //~^ ERROR mismatched types
- foo::<u8>(x_u16);
- //~^ ERROR mismatched types
- foo::<u8>(x_u8);
- foo::<u8>(x_isize);
- //~^ ERROR mismatched types
- foo::<u8>(x_i64);
- //~^ ERROR mismatched types
- foo::<u8>(x_i32);
- //~^ ERROR mismatched types
- foo::<u8>(x_i16);
- //~^ ERROR mismatched types
- foo::<u8>(x_i8);
- //~^ ERROR mismatched types
- foo::<u8>(x_f64);
- //~^ ERROR mismatched types
- foo::<u8>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<i8>(x_usize);
- //~^ ERROR mismatched types
- foo::<i8>(x_u64);
- //~^ ERROR mismatched types
- foo::<i8>(x_u32);
- //~^ ERROR mismatched types
- foo::<i8>(x_u16);
- //~^ ERROR mismatched types
- foo::<i8>(x_u8);
- //~^ ERROR mismatched types
- foo::<i8>(x_isize);
- //~^ ERROR mismatched types
- foo::<i8>(x_i64);
- //~^ ERROR mismatched types
- foo::<i8>(x_i32);
- //~^ ERROR mismatched types
- foo::<i8>(x_i16);
- //~^ ERROR mismatched types
- foo::<i8>(x_i8);
- foo::<i8>(x_f64);
- //~^ ERROR mismatched types
- foo::<i8>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<f64>(x_usize);
- //~^ ERROR mismatched types
- foo::<f64>(x_u64);
- //~^ ERROR mismatched types
- foo::<f64>(x_u32);
- //~^ ERROR mismatched types
- foo::<f64>(x_u16);
- //~^ ERROR mismatched types
- foo::<f64>(x_u8);
- //~^ ERROR mismatched types
- foo::<f64>(x_isize);
- //~^ ERROR mismatched types
- foo::<f64>(x_i64);
- //~^ ERROR mismatched types
- foo::<f64>(x_i32);
- //~^ ERROR mismatched types
- foo::<f64>(x_i16);
- //~^ ERROR mismatched types
- foo::<f64>(x_i8);
- //~^ ERROR mismatched types
- foo::<f64>(x_f64);
- foo::<f64>(x_f32);
- //~^ ERROR mismatched types
-
- foo::<f32>(x_usize);
- //~^ ERROR mismatched types
- foo::<f32>(x_u64);
- //~^ ERROR mismatched types
- foo::<f32>(x_u32);
- //~^ ERROR mismatched types
- foo::<f32>(x_u16);
- //~^ ERROR mismatched types
- foo::<f32>(x_u8);
- //~^ ERROR mismatched types
- foo::<f32>(x_isize);
- //~^ ERROR mismatched types
- foo::<f32>(x_i64);
- //~^ ERROR mismatched types
- foo::<f32>(x_i32);
- //~^ ERROR mismatched types
- foo::<f32>(x_i16);
- //~^ ERROR mismatched types
- foo::<f32>(x_i8);
- //~^ ERROR mismatched types
- foo::<f32>(x_f64);
- //~^ ERROR mismatched types
- foo::<f32>(x_f32);
-
- foo::<u32>(x_u8 as u16);
- //~^ ERROR mismatched types
- foo::<i32>(-x_i8);
- //~^ ERROR mismatched types
-}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:29:18
- |
-LL | foo::<usize>(x_u64);
- | ^^^^^ expected usize, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:31:18
- |
-LL | foo::<usize>(x_u32);
- | ^^^^^ expected usize, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:33:18
- |
-LL | foo::<usize>(x_u16);
- | ^^^^^ expected usize, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:35:18
- |
-LL | foo::<usize>(x_u8);
- | ^^^^ expected usize, found u8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:37:18
- |
-LL | foo::<usize>(x_isize);
- | ^^^^^^^ expected usize, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:39:18
- |
-LL | foo::<usize>(x_i64);
- | ^^^^^ expected usize, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:41:18
- |
-LL | foo::<usize>(x_i32);
- | ^^^^^ expected usize, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:43:18
- |
-LL | foo::<usize>(x_i16);
- | ^^^^^ expected usize, found i16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:45:18
- |
-LL | foo::<usize>(x_i8);
- | ^^^^ expected usize, found i8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:47:18
- |
-LL | foo::<usize>(x_f64);
- | ^^^^^ expected usize, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:49:18
- |
-LL | foo::<usize>(x_f32);
- | ^^^^^ expected usize, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:52:18
- |
-LL | foo::<isize>(x_usize);
- | ^^^^^^^ expected isize, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:54:18
- |
-LL | foo::<isize>(x_u64);
- | ^^^^^ expected isize, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:56:18
- |
-LL | foo::<isize>(x_u32);
- | ^^^^^ expected isize, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:58:18
- |
-LL | foo::<isize>(x_u16);
- | ^^^^^ expected isize, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:60:18
- |
-LL | foo::<isize>(x_u8);
- | ^^^^ expected isize, found u8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:63:18
- |
-LL | foo::<isize>(x_i64);
- | ^^^^^ expected isize, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:65:18
- |
-LL | foo::<isize>(x_i32);
- | ^^^^^ expected isize, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:67:18
- |
-LL | foo::<isize>(x_i16);
- | ^^^^^ expected isize, found i16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:69:18
- |
-LL | foo::<isize>(x_i8);
- | ^^^^ expected isize, found i8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:71:18
- |
-LL | foo::<isize>(x_f64);
- | ^^^^^ expected isize, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:73:18
- |
-LL | foo::<isize>(x_f32);
- | ^^^^^ expected isize, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:76:16
- |
-LL | foo::<u64>(x_usize);
- | ^^^^^^^ expected u64, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:79:16
- |
-LL | foo::<u64>(x_u32);
- | ^^^^^ expected u64, found u32
-help: you can cast an `u32` to `u64`, which will zero-extend the source value
- |
-LL | foo::<u64>(x_u32.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:81:16
- |
-LL | foo::<u64>(x_u16);
- | ^^^^^ expected u64, found u16
-help: you can cast an `u16` to `u64`, which will zero-extend the source value
- |
-LL | foo::<u64>(x_u16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:83:16
- |
-LL | foo::<u64>(x_u8);
- | ^^^^ expected u64, found u8
-help: you can cast an `u8` to `u64`, which will zero-extend the source value
- |
-LL | foo::<u64>(x_u8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:85:16
- |
-LL | foo::<u64>(x_isize);
- | ^^^^^^^ expected u64, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:87:16
- |
-LL | foo::<u64>(x_i64);
- | ^^^^^ expected u64, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:89:16
- |
-LL | foo::<u64>(x_i32);
- | ^^^^^ expected u64, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:91:16
- |
-LL | foo::<u64>(x_i16);
- | ^^^^^ expected u64, found i16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:93:16
- |
-LL | foo::<u64>(x_i8);
- | ^^^^ expected u64, found i8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:95:16
- |
-LL | foo::<u64>(x_f64);
- | ^^^^^ expected u64, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:97:16
- |
-LL | foo::<u64>(x_f32);
- | ^^^^^ expected u64, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:100:16
- |
-LL | foo::<i64>(x_usize);
- | ^^^^^^^ expected i64, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:102:16
- |
-LL | foo::<i64>(x_u64);
- | ^^^^^ expected i64, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:104:16
- |
-LL | foo::<i64>(x_u32);
- | ^^^^^ expected i64, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:106:16
- |
-LL | foo::<i64>(x_u16);
- | ^^^^^ expected i64, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:108:16
- |
-LL | foo::<i64>(x_u8);
- | ^^^^ expected i64, found u8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:110:16
- |
-LL | foo::<i64>(x_isize);
- | ^^^^^^^ expected i64, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:113:16
- |
-LL | foo::<i64>(x_i32);
- | ^^^^^ expected i64, found i32
-help: you can cast an `i32` to `i64`, which will sign-extend the source value
- |
-LL | foo::<i64>(x_i32.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:115:16
- |
-LL | foo::<i64>(x_i16);
- | ^^^^^ expected i64, found i16
-help: you can cast an `i16` to `i64`, which will sign-extend the source value
- |
-LL | foo::<i64>(x_i16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:117:16
- |
-LL | foo::<i64>(x_i8);
- | ^^^^ expected i64, found i8
-help: you can cast an `i8` to `i64`, which will sign-extend the source value
- |
-LL | foo::<i64>(x_i8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:119:16
- |
-LL | foo::<i64>(x_f64);
- | ^^^^^ expected i64, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:121:16
- |
-LL | foo::<i64>(x_f32);
- | ^^^^^ expected i64, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:124:16
- |
-LL | foo::<u32>(x_usize);
- | ^^^^^^^ expected u32, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:126:16
- |
-LL | foo::<u32>(x_u64);
- | ^^^^^ expected u32, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:129:16
- |
-LL | foo::<u32>(x_u16);
- | ^^^^^ expected u32, found u16
-help: you can cast an `u16` to `u32`, which will zero-extend the source value
- |
-LL | foo::<u32>(x_u16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:131:16
- |
-LL | foo::<u32>(x_u8);
- | ^^^^ expected u32, found u8
-help: you can cast an `u8` to `u32`, which will zero-extend the source value
- |
-LL | foo::<u32>(x_u8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:133:16
- |
-LL | foo::<u32>(x_isize);
- | ^^^^^^^ expected u32, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:135:16
- |
-LL | foo::<u32>(x_i64);
- | ^^^^^ expected u32, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:137:16
- |
-LL | foo::<u32>(x_i32);
- | ^^^^^ expected u32, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:139:16
- |
-LL | foo::<u32>(x_i16);
- | ^^^^^ expected u32, found i16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:141:16
- |
-LL | foo::<u32>(x_i8);
- | ^^^^ expected u32, found i8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:143:16
- |
-LL | foo::<u32>(x_f64);
- | ^^^^^ expected u32, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:145:16
- |
-LL | foo::<u32>(x_f32);
- | ^^^^^ expected u32, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:148:16
- |
-LL | foo::<i32>(x_usize);
- | ^^^^^^^ expected i32, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:150:16
- |
-LL | foo::<i32>(x_u64);
- | ^^^^^ expected i32, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:152:16
- |
-LL | foo::<i32>(x_u32);
- | ^^^^^ expected i32, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:154:16
- |
-LL | foo::<i32>(x_u16);
- | ^^^^^ expected i32, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:156:16
- |
-LL | foo::<i32>(x_u8);
- | ^^^^ expected i32, found u8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:158:16
- |
-LL | foo::<i32>(x_isize);
- | ^^^^^^^ expected i32, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:160:16
- |
-LL | foo::<i32>(x_i64);
- | ^^^^^ expected i32, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:163:16
- |
-LL | foo::<i32>(x_i16);
- | ^^^^^ expected i32, found i16
-help: you can cast an `i16` to `i32`, which will sign-extend the source value
- |
-LL | foo::<i32>(x_i16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:165:16
- |
-LL | foo::<i32>(x_i8);
- | ^^^^ expected i32, found i8
-help: you can cast an `i8` to `i32`, which will sign-extend the source value
- |
-LL | foo::<i32>(x_i8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:167:16
- |
-LL | foo::<i32>(x_f64);
- | ^^^^^ expected i32, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:169:16
- |
-LL | foo::<i32>(x_f32);
- | ^^^^^ expected i32, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:172:16
- |
-LL | foo::<u16>(x_usize);
- | ^^^^^^^ expected u16, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:174:16
- |
-LL | foo::<u16>(x_u64);
- | ^^^^^ expected u16, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:176:16
- |
-LL | foo::<u16>(x_u32);
- | ^^^^^ expected u16, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:179:16
- |
-LL | foo::<u16>(x_u8);
- | ^^^^ expected u16, found u8
-help: you can cast an `u8` to `u16`, which will zero-extend the source value
- |
-LL | foo::<u16>(x_u8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:181:16
- |
-LL | foo::<u16>(x_isize);
- | ^^^^^^^ expected u16, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:183:16
- |
-LL | foo::<u16>(x_i64);
- | ^^^^^ expected u16, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:185:16
- |
-LL | foo::<u16>(x_i32);
- | ^^^^^ expected u16, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:187:16
- |
-LL | foo::<u16>(x_i16);
- | ^^^^^ expected u16, found i16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:189:16
- |
-LL | foo::<u16>(x_i8);
- | ^^^^ expected u16, found i8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:191:16
- |
-LL | foo::<u16>(x_f64);
- | ^^^^^ expected u16, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:193:16
- |
-LL | foo::<u16>(x_f32);
- | ^^^^^ expected u16, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:196:16
- |
-LL | foo::<i16>(x_usize);
- | ^^^^^^^ expected i16, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:198:16
- |
-LL | foo::<i16>(x_u64);
- | ^^^^^ expected i16, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:200:16
- |
-LL | foo::<i16>(x_u32);
- | ^^^^^ expected i16, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:202:16
- |
-LL | foo::<i16>(x_u16);
- | ^^^^^ expected i16, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:204:16
- |
-LL | foo::<i16>(x_u8);
- | ^^^^ expected i16, found u8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:206:16
- |
-LL | foo::<i16>(x_isize);
- | ^^^^^^^ expected i16, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:208:16
- |
-LL | foo::<i16>(x_i64);
- | ^^^^^ expected i16, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:210:16
- |
-LL | foo::<i16>(x_i32);
- | ^^^^^ expected i16, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:213:16
- |
-LL | foo::<i16>(x_i8);
- | ^^^^ expected i16, found i8
-help: you can cast an `i8` to `i16`, which will sign-extend the source value
- |
-LL | foo::<i16>(x_i8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:215:16
- |
-LL | foo::<i16>(x_f64);
- | ^^^^^ expected i16, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:217:16
- |
-LL | foo::<i16>(x_f32);
- | ^^^^^ expected i16, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:220:15
- |
-LL | foo::<u8>(x_usize);
- | ^^^^^^^ expected u8, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:222:15
- |
-LL | foo::<u8>(x_u64);
- | ^^^^^ expected u8, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:224:15
- |
-LL | foo::<u8>(x_u32);
- | ^^^^^ expected u8, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:226:15
- |
-LL | foo::<u8>(x_u16);
- | ^^^^^ expected u8, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:229:15
- |
-LL | foo::<u8>(x_isize);
- | ^^^^^^^ expected u8, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:231:15
- |
-LL | foo::<u8>(x_i64);
- | ^^^^^ expected u8, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:233:15
- |
-LL | foo::<u8>(x_i32);
- | ^^^^^ expected u8, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:235:15
- |
-LL | foo::<u8>(x_i16);
- | ^^^^^ expected u8, found i16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:237:15
- |
-LL | foo::<u8>(x_i8);
- | ^^^^ expected u8, found i8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:239:15
- |
-LL | foo::<u8>(x_f64);
- | ^^^^^ expected u8, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:241:15
- |
-LL | foo::<u8>(x_f32);
- | ^^^^^ expected u8, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:244:15
- |
-LL | foo::<i8>(x_usize);
- | ^^^^^^^ expected i8, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:246:15
- |
-LL | foo::<i8>(x_u64);
- | ^^^^^ expected i8, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:248:15
- |
-LL | foo::<i8>(x_u32);
- | ^^^^^ expected i8, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:250:15
- |
-LL | foo::<i8>(x_u16);
- | ^^^^^ expected i8, found u16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:252:15
- |
-LL | foo::<i8>(x_u8);
- | ^^^^ expected i8, found u8
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:254:15
- |
-LL | foo::<i8>(x_isize);
- | ^^^^^^^ expected i8, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:256:15
- |
-LL | foo::<i8>(x_i64);
- | ^^^^^ expected i8, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:258:15
- |
-LL | foo::<i8>(x_i32);
- | ^^^^^ expected i8, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:260:15
- |
-LL | foo::<i8>(x_i16);
- | ^^^^^ expected i8, found i16
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:263:15
- |
-LL | foo::<i8>(x_f64);
- | ^^^^^ expected i8, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:265:15
- |
-LL | foo::<i8>(x_f32);
- | ^^^^^ expected i8, found f32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:268:16
- |
-LL | foo::<f64>(x_usize);
- | ^^^^^^^ expected f64, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:270:16
- |
-LL | foo::<f64>(x_u64);
- | ^^^^^ expected f64, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:272:16
- |
-LL | foo::<f64>(x_u32);
- | ^^^^^ expected f64, found u32
-help: you can cast an `u32` to `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(x_u32.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:274:16
- |
-LL | foo::<f64>(x_u16);
- | ^^^^^ expected f64, found u16
-help: you can cast an `u16` to `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(x_u16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:276:16
- |
-LL | foo::<f64>(x_u8);
- | ^^^^ expected f64, found u8
-help: you can cast an `u8` to `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(x_u8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:278:16
- |
-LL | foo::<f64>(x_isize);
- | ^^^^^^^ expected f64, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:280:16
- |
-LL | foo::<f64>(x_i64);
- | ^^^^^ expected f64, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:282:16
- |
-LL | foo::<f64>(x_i32);
- | ^^^^^ expected f64, found i32
-help: you can cast an `i32` to `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(x_i32.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:284:16
- |
-LL | foo::<f64>(x_i16);
- | ^^^^^ expected f64, found i16
-help: you can cast an `i16` to `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(x_i16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:286:16
- |
-LL | foo::<f64>(x_i8);
- | ^^^^ expected f64, found i8
-help: you can cast an `i8` to `f64`, producing the floating point representation of the integer
- |
-LL | foo::<f64>(x_i8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:289:16
- |
-LL | foo::<f64>(x_f32);
- | ^^^^^ expected f64, found f32
-help: you can cast an `f32` to `f64` in a lossless way
- |
-LL | foo::<f64>(x_f32.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:292:16
- |
-LL | foo::<f32>(x_usize);
- | ^^^^^^^ expected f32, found usize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:294:16
- |
-LL | foo::<f32>(x_u64);
- | ^^^^^ expected f32, found u64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:296:16
- |
-LL | foo::<f32>(x_u32);
- | ^^^^^ expected f32, found u32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:298:16
- |
-LL | foo::<f32>(x_u16);
- | ^^^^^ expected f32, found u16
-help: you can cast an `u16` to `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(x_u16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:300:16
- |
-LL | foo::<f32>(x_u8);
- | ^^^^ expected f32, found u8
-help: you can cast an `u8` to `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(x_u8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:302:16
- |
-LL | foo::<f32>(x_isize);
- | ^^^^^^^ expected f32, found isize
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:304:16
- |
-LL | foo::<f32>(x_i64);
- | ^^^^^ expected f32, found i64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:306:16
- |
-LL | foo::<f32>(x_i32);
- | ^^^^^ expected f32, found i32
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:308:16
- |
-LL | foo::<f32>(x_i16);
- | ^^^^^ expected f32, found i16
-help: you can cast an `i16` to `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(x_i16.into());
- | ^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:310:16
- |
-LL | foo::<f32>(x_i8);
- | ^^^^ expected f32, found i8
-help: you can cast an `i8` to `f32`, producing the floating point representation of the integer
- |
-LL | foo::<f32>(x_i8.into());
- | ^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:312:16
- |
-LL | foo::<f32>(x_f64);
- | ^^^^^ expected f32, found f64
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:316:16
- |
-LL | foo::<u32>(x_u8 as u16);
- | ^^^^^^^^^^^ expected u32, found u16
-help: you can cast an `u16` to `u32`, which will zero-extend the source value
- |
-LL | foo::<u32>((x_u8 as u16).into());
- | ^^^^^^^^^^^^^^^^^^^^
-
-error[E0308]: mismatched types
- --> $DIR/numeric-cast.rs:318:16
- |
-LL | foo::<i32>(-x_i8);
- | ^^^^^ expected i32, found i8
-help: you can cast an `i8` to `i32`, which will sign-extend the source value
- |
-LL | foo::<i32>((-x_i8).into());
- | ^^^^^^^^^^^^^^
-
-error: aborting due to 134 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let x = -5;
- if x<-1 {
- //~^ ERROR emplacement syntax is obsolete
- println!("ok");
- }
-}
+++ /dev/null
-error: emplacement syntax is obsolete (for now, anyway)
- --> $DIR/placement-syntax.rs:13:8
- |
-LL | if x<-1 {
- | ^^^^
- |
- = note: for more information, see <https://github.com/rust-lang/rust/issues/27779#issuecomment-378416911>
-help: if you meant to write a comparison against a negative value, add a space in between `<` and `-`
- |
-LL | if x< -1 {
- | ^^^
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub foo(s: usize) { bar() }
-//~^ ERROR missing `fn` for method definition
-
-fn main() {
- foo(2);
-}
+++ /dev/null
-error: missing `fn` for method definition
- --> $DIR/pub-ident-fn-2.rs:11:4
- |
-LL | pub foo(s: usize) { bar() }
- | ^
-help: add `fn` here to parse `foo` as a public method
- |
-LL | pub fn foo(s: usize) { bar() }
- | ^^
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub S();
-//~^ ERROR missing `fn` or `struct` for method or struct definition
-
-fn main() {}
+++ /dev/null
-error: missing `fn` or `struct` for method or struct definition
- --> $DIR/pub-ident-fn-or-struct-2.rs:11:4
- |
-LL | pub S();
- | ---^- help: if you meant to call a macro, try: `S!`
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub S (foo) bar
-//~^ ERROR missing `fn` or `struct` for method or struct definition
-
-fn main() {}
+++ /dev/null
-error: missing `fn` or `struct` for method or struct definition
- --> $DIR/pub-ident-fn-or-struct.rs:11:4
- |
-LL | pub S (foo) bar
- | ---^- help: if you meant to call a macro, try: `S!`
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-pub fn foo(_s: usize) -> bool { true }
-//~^ ERROR missing `fn` for method definition
-
-fn main() {
- foo(2);
-}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-pub foo(_s: usize) -> bool { true }
-//~^ ERROR missing `fn` for method definition
-
-fn main() {
- foo(2);
-}
+++ /dev/null
-error: missing `fn` for method definition
- --> $DIR/pub-ident-fn.rs:13:4
- |
-LL | pub foo(_s: usize) -> bool { true }
- | ^^^
-help: add `fn` here to parse `foo` as a public method
- |
-LL | pub fn foo(_s: usize) -> bool { true }
- | ^^
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub S {
-//~^ ERROR missing `struct` for struct definition
-}
-fn main() {}
+++ /dev/null
-error: missing `struct` for struct definition
- --> $DIR/pub-ident-struct.rs:11:4
- |
-LL | pub S {
- | ^
-help: add `struct` here to parse `S` as a public struct
- |
-LL | pub struct S {
- | ^^^^^^
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// compile-flags: --edition 2018
-// aux-build:removing-extern-crate.rs
-// run-rustfix
-// compile-pass
-
-#![warn(rust_2018_idioms)]
-#![allow(unused_imports)]
-
-
-
-
-mod another {
-
-
-}
-
-fn main() {}
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// compile-flags: --edition 2018
-// aux-build:removing-extern-crate.rs
-// run-rustfix
-// compile-pass
-
-#![warn(rust_2018_idioms)]
-#![allow(unused_imports)]
-
-extern crate std as foo;
-extern crate core;
-
-mod another {
- extern crate std as foo;
- extern crate std;
-}
-
-fn main() {}
+++ /dev/null
-warning: unused extern crate
- --> $DIR/removing-extern-crate.rs:19:1
- |
-LL | extern crate std as foo;
- | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove it
- |
-note: lint level defined here
- --> $DIR/removing-extern-crate.rs:16:9
- |
-LL | #![warn(rust_2018_idioms)]
- | ^^^^^^^^^^^^^^^^
- = note: #[warn(unused_extern_crates)] implied by #[warn(rust_2018_idioms)]
-
-warning: unused extern crate
- --> $DIR/removing-extern-crate.rs:20:1
- |
-LL | extern crate core;
- | ^^^^^^^^^^^^^^^^^^ help: remove it
-
-warning: unused extern crate
- --> $DIR/removing-extern-crate.rs:23:5
- |
-LL | extern crate std as foo;
- | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove it
-
-warning: unused extern crate
- --> $DIR/removing-extern-crate.rs:24:5
- |
-LL | extern crate std;
- | ^^^^^^^^^^^^^^^^^ help: remove it
-
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// compile-pass
-
-#[repr]
-//^ WARN `repr` attribute must have a hint
-struct _A {}
-
-#[repr = "B"]
-//^ WARN `repr` attribute isn't configurable with a literal
-struct _B {}
-
-#[repr = "C"]
-//^ WARN `repr` attribute isn't configurable with a literal
-struct _C {}
-
-#[repr(C)]
-struct _D {}
-
-fn main() {}
+++ /dev/null
-warning: `repr` attribute must have a hint
- --> $DIR/repr.rs:13:1
- |
-LL | #[repr]
- | ^^^^^^^ needs a hint
- |
- = note: #[warn(bad_repr)] on by default
- = help: valid hints include `#[repr(C)]`, `#[repr(packed)]`, `#[repr(rust)]` and `#[repr(transparent)]`
- = note: for more information, visit <https://doc.rust-lang.org/reference/type-layout.html>
-
-warning: `repr` attribute isn't configurable with a literal
- --> $DIR/repr.rs:17:1
- |
-LL | #[repr = "B"]
- | ^^^^^^^^^^^^^ needs a hint
- |
- = help: valid hints include `#[repr(C)]`, `#[repr(packed)]`, `#[repr(rust)]` and `#[repr(transparent)]`
- = note: for more information, visit <https://doc.rust-lang.org/reference/type-layout.html>
-
-warning: `repr` attribute isn't configurable with a literal
- --> $DIR/repr.rs:21:1
- |
-LL | #[repr = "C"]
- | ^^^^^^^^^^^^^ help: give `repr` a hint: `#[repr(C)]`
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct S<T> {
- t: T,
-}
-
-fn foo<T>(x: T) -> S<T> {
- S { t: x }
-}
-
-fn bar() {
- foo(4 as usize)
- //~^ ERROR mismatched types
-}
-
-fn main() {}
+++ /dev/null
-error[E0308]: mismatched types
- --> $DIR/return-type.rs:20:5
- |
-LL | foo(4 as usize)
- | ^^^^^^^^^^^^^^^ expected (), found struct `S`
- |
- = note: expected type `()`
- found type `S<usize>`
-help: try adding a semicolon
- |
-LL | foo(4 as usize);
- | ^
-help: try adding a return type
- |
-LL | fn bar() -> S<usize> {
- | ^^^^^^^^^^^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0308`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let s = "abc";
- let t = if true { s[..2] } else { s };
- //~^ ERROR if and else have incompatible types
- let u: &str = if true { s[..2] } else { s };
- //~^ ERROR mismatched types
- let v = s[..2];
- //~^ ERROR the size for values of type
- let w: &str = s[..2];
- //~^ ERROR mismatched types
-}
+++ /dev/null
-error[E0308]: if and else have incompatible types
- --> $DIR/str-array-assignment.rs:13:11
- |
-LL | let t = if true { s[..2] } else { s };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected str, found &str
- |
- = note: expected type `str`
- found type `&str`
-
-error[E0308]: mismatched types
- --> $DIR/str-array-assignment.rs:15:27
- |
-LL | let u: &str = if true { s[..2] } else { s };
- | ^^^^^^
- | |
- | expected &str, found str
- | help: consider borrowing here: `&s[..2]`
- |
- = note: expected type `&str`
- found type `str`
-
-error[E0277]: the size for values of type `str` cannot be known at compilation time
- --> $DIR/str-array-assignment.rs:17:7
- |
-LL | let v = s[..2];
- | ^ ------ help: consider borrowing here: `&s[..2]`
- | |
- | doesn't have a size known at compile-time
- |
- = help: the trait `std::marker::Sized` is not implemented for `str`
- = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types-and-sized>
- = note: all local variables must have a statically known size
-
-error[E0308]: mismatched types
- --> $DIR/str-array-assignment.rs:19:17
- |
-LL | let w: &str = s[..2];
- | ^^^^^^
- | |
- | expected &str, found str
- | help: consider borrowing here: `&s[..2]`
- |
- = note: expected type `&str`
- found type `str`
-
-error: aborting due to 4 previous errors
-
-Some errors occurred: E0277, E0308.
-For more information about an error, try `rustc --explain E0277`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-fn main() {
- println!("●●");
- //~^ ERROR character literal may only contain one codepoint
-}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-
-fn main() {
- println!('●●');
- //~^ ERROR character literal may only contain one codepoint
-}
+++ /dev/null
-error: character literal may only contain one codepoint
- --> $DIR/str-as-char.rs:14:14
- |
-LL | println!('●●');
- | ^^^^
-help: if you meant to write a `str` literal, use double quotes
- |
-LL | println!("●●");
- | ^^^^
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[allow(unreachable_code, unused_labels)]
-fn main() {
- 'foo: loop {
- break 'fo; //~ ERROR use of undeclared label
- }
-
- 'bar: loop {
- continue 'bor; //~ ERROR use of undeclared label
- }
-
- 'longlabel: loop {
- 'longlabel1: loop {
- break 'longlable; //~ ERROR use of undeclared label
- }
- }
-}
+++ /dev/null
-error[E0426]: use of undeclared label `'fo`
- --> $DIR/suggest-labels.rs:14:15
- |
-LL | break 'fo; //~ ERROR use of undeclared label
- | ^^^ did you mean `'foo`?
-
-error[E0426]: use of undeclared label `'bor`
- --> $DIR/suggest-labels.rs:18:18
- |
-LL | continue 'bor; //~ ERROR use of undeclared label
- | ^^^^ did you mean `'bar`?
-
-error[E0426]: use of undeclared label `'longlable`
- --> $DIR/suggest-labels.rs:23:19
- |
-LL | break 'longlable; //~ ERROR use of undeclared label
- | ^^^^^^^^^^ did you mean `'longlabel1`?
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0426`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct Foo;
-
-impl Foo {
- fn bar(self) {}
- fn baz(&self, x: f64) {}
-}
-
-trait FooT {
- fn bag(&self);
-}
-
-impl FooT for Foo {
- fn bag(&self) {}
-}
-
-fn main() {
- let f = Foo;
- f.bat(1.0); //~ ERROR no method named
-
- let s = "foo".to_string();
- let _ = s.is_emtpy(); //~ ERROR no method named
-
- // Generates a warning for `count_zeros()`. `count_ones()` is also a close
- // match, but the former is closer.
- let _ = 63u32.count_eos(); //~ ERROR no method named
-
- // Does not generate a warning
- let _ = 63u32.count_o(); //~ ERROR no method named
-
-}
+++ /dev/null
-error[E0599]: no method named `bat` found for type `Foo` in the current scope
- --> $DIR/suggest-methods.rs:28:7
- |
-LL | struct Foo;
- | ----------- method `bat` not found for this
-...
-LL | f.bat(1.0); //~ ERROR no method named
- | ^^^
- |
- = help: did you mean `bar`?
-
-error[E0599]: no method named `is_emtpy` found for type `std::string::String` in the current scope
- --> $DIR/suggest-methods.rs:31:15
- |
-LL | let _ = s.is_emtpy(); //~ ERROR no method named
- | ^^^^^^^^
- |
- = help: did you mean `is_empty`?
-
-error[E0599]: no method named `count_eos` found for type `u32` in the current scope
- --> $DIR/suggest-methods.rs:35:19
- |
-LL | let _ = 63u32.count_eos(); //~ ERROR no method named
- | ^^^^^^^^^
- |
- = help: did you mean `count_zeros`?
-
-error[E0599]: no method named `count_o` found for type `u32` in the current scope
- --> $DIR/suggest-methods.rs:38:19
- |
-LL | let _ = 63u32.count_o(); //~ ERROR no method named
- | ^^^^^^^
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0599`.
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(nll)]
-
-struct X(usize);
-
-impl X {
- fn zap(&self) {
- //~^ HELP
- //~| SUGGESTION &mut self
- self.0 = 32;
- //~^ ERROR
- }
-}
-
-fn main() {
- let ref foo = 16;
- //~^ HELP
- //~| SUGGESTION ref mut foo
- *foo = 32;
- //~^ ERROR
- if let Some(ref bar) = Some(16) {
- //~^ HELP
- //~| SUGGESTION ref mut bar
- *bar = 32;
- //~^ ERROR
- }
- match 16 {
- ref quo => { *quo = 32; },
- //~^ ERROR
- //~| HELP
- //~| SUGGESTION ref mut quo
- }
-}
+++ /dev/null
-error[E0594]: cannot assign to `self.0` which is behind a `&` reference
- --> $DIR/suggest-ref-mut.rs:19:9
- |
-LL | fn zap(&self) {
- | ----- help: consider changing this to be a mutable reference: `&mut self`
-...
-LL | self.0 = 32;
- | ^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be written
-
-error[E0594]: cannot assign to `*foo` which is behind a `&` reference
- --> $DIR/suggest-ref-mut.rs:28:5
- |
-LL | let ref foo = 16;
- | ------- help: consider changing this to be a mutable reference: `ref mut foo`
-...
-LL | *foo = 32;
- | ^^^^^^^^^ `foo` is a `&` reference, so the data it refers to cannot be written
-
-error[E0594]: cannot assign to `*bar` which is behind a `&` reference
- --> $DIR/suggest-ref-mut.rs:33:9
- |
-LL | if let Some(ref bar) = Some(16) {
- | ------- help: consider changing this to be a mutable reference: `ref mut bar`
-...
-LL | *bar = 32;
- | ^^^^^^^^^ `bar` is a `&` reference, so the data it refers to cannot be written
-
-error[E0594]: cannot assign to `*quo` which is behind a `&` reference
- --> $DIR/suggest-ref-mut.rs:37:22
- |
-LL | ref quo => { *quo = 32; },
- | ------- ^^^^^^^^^ `quo` is a `&` reference, so the data it refers to cannot be written
- | |
- | help: consider changing this to be a mutable reference: `ref mut quo`
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0594`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(try_trait)]
-
-fn main() {}
-
-fn foo() -> Result<u32, ()> {
- let x: Option<u32> = None;
- x?; //~ the trait bound
- Ok(22)
-}
-
-fn bar() -> u32 {
- let x: Option<u32> = None;
- x?; //~ the `?` operator
- 22
-}
+++ /dev/null
-error[E0277]: the trait bound `(): std::convert::From<std::option::NoneError>` is not satisfied
- --> $DIR/try-on-option.rs:17:5
- |
-LL | x?; //~ the trait bound
- | ^^ the trait `std::convert::From<std::option::NoneError>` is not implemented for `()`
- |
- = note: required by `std::convert::From::from`
-
-error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
- --> $DIR/try-on-option.rs:23:5
- |
-LL | x?; //~ the `?` operator
- | ^^ cannot use the `?` operator in a function that returns `u32`
- |
- = help: the trait `std::ops::Try` is not implemented for `u32`
- = note: required by `std::ops::Try::from_error`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// ignore-cloudabi no std::fs support
-
-#![feature(try_trait)]
-
-use std::ops::Try;
-
-fn main() {
- // error for a `Try` type on a non-`Try` fn
- std::fs::File::open("foo")?; //~ ERROR the `?` operator can only
-
- // a non-`Try` type on a non-`Try` fn
- ()?; //~ ERROR the `?` operator can only
-
- // an unrelated use of `Try`
- try_trait_generic::<()>(); //~ ERROR the trait bound
-}
-
-
-
-fn try_trait_generic<T: Try>() -> T {
- // and a non-`Try` object on a `Try` fn.
- ()?; //~ ERROR the `?` operator can only
-
- loop {}
-}
+++ /dev/null
-error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
- --> $DIR/try-operator-on-main.rs:19:5
- |
-LL | std::fs::File::open("foo")?; //~ ERROR the `?` operator can only
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
- |
- = help: the trait `std::ops::Try` is not implemented for `()`
- = note: required by `std::ops::Try::from_error`
-
-error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
- --> $DIR/try-operator-on-main.rs:22:5
- |
-LL | ()?; //~ ERROR the `?` operator can only
- | ^^^ the `?` operator cannot be applied to type `()`
- |
- = help: the trait `std::ops::Try` is not implemented for `()`
- = note: required by `std::ops::Try::into_result`
-
-error[E0277]: the trait bound `(): std::ops::Try` is not satisfied
- --> $DIR/try-operator-on-main.rs:25:5
- |
-LL | try_trait_generic::<()>(); //~ ERROR the trait bound
- | ^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::ops::Try` is not implemented for `()`
- |
-note: required by `try_trait_generic`
- --> $DIR/try-operator-on-main.rs:30:1
- |
-LL | fn try_trait_generic<T: Try>() -> T {
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
- --> $DIR/try-operator-on-main.rs:32:5
- |
-LL | ()?; //~ ERROR the `?` operator can only
- | ^^^ the `?` operator cannot be applied to type `()`
- |
- = help: the trait `std::ops::Try` is not implemented for `()`
- = note: required by `std::ops::Try::into_result`
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-// compile-flags: -Z parse-only
-
-fn main () {
- ((1, (2, 3)).1).1; //~ ERROR unexpected token: `1.1`
-}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// run-rustfix
-// compile-flags: -Z parse-only
-
-fn main () {
- (1, (2, 3)).1.1; //~ ERROR unexpected token: `1.1`
-}
+++ /dev/null
-error: unexpected token: `1.1`
- --> $DIR/tuple-float-index.rs:15:17
- |
-LL | (1, (2, 3)).1.1; //~ ERROR unexpected token: `1.1`
- | ------------^^^
- | | |
- | | unexpected token
- | help: try parenthesizing the first index: `((1, (2, 3)).1).1`
-
-error: aborting due to previous error
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let x: Vec::with_capacity(10, 20); //~ ERROR expected type, found `10`
- //~^ ERROR this function takes 1 parameter
-}
+++ /dev/null
-error: expected type, found `10`
- --> $DIR/type-ascription-instead-of-initializer.rs:12:31
- |
-LL | let x: Vec::with_capacity(10, 20); //~ ERROR expected type, found `10`
- | -- ^^
- | ||
- | |help: use `=` if you meant to assign
- | while parsing the type for `x`
-
-error[E0061]: this function takes 1 parameter but 2 parameters were supplied
- --> $DIR/type-ascription-instead-of-initializer.rs:12:12
- |
-LL | let x: Vec::with_capacity(10, 20); //~ ERROR expected type, found `10`
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 1 parameter
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0061`.
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(type_ascription)]
-
-fn main() {
- println!("test"):
- 0; //~ ERROR expected type, found `0`
-}
-
-fn foo() {
- println!("test"): 0; //~ ERROR expected type, found `0`
-}
+++ /dev/null
-error: expected type, found `0`
- --> $DIR/type-ascription-instead-of-statement-end.rs:15:5
- |
-LL | println!("test"):
- | - help: try using a semicolon: `;`
-LL | 0; //~ ERROR expected type, found `0`
- | ^ expecting a type here because of type ascription
-
-error: expected type, found `0`
- --> $DIR/type-ascription-instead-of-statement-end.rs:19:23
- |
-LL | println!("test"): 0; //~ ERROR expected type, found `0`
- | ^ expecting a type here because of type ascription
-
-error: aborting due to 2 previous errors
-
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(type_ascription)]
-
-fn main() {
- f() :
- f(); //~ ERROR expected type, found function
-}
-
-fn f() {}
+++ /dev/null
-error[E0573]: expected type, found function `f`
- --> $DIR/type-ascription-with-fn-call.rs:15:5
- |
-LL | f() :
- | - help: did you mean to use `;` here instead?
-LL | f(); //~ ERROR expected type, found function
- | ^^^
- | |
- | not a type
- | expecting a type here because of type ascription
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0573`.
-error: expected one of `(`, `async`, `const`, `default`, `extern`, `fn`, `type`, or `unsafe`, found `}`
+error: expected one of `(`, `async`, `const`, `default`, `existential`, `extern`, `fn`, `type`, or `unsafe`, found `}`
--> $DIR/issue-41155.rs:13:1
|
LL | pub
- | - expected one of 8 possible tokens here
+ | - expected one of 9 possible tokens here
LL | } //~ ERROR expected one of
| ^ unexpected token
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(try_trait)]
+
+fn main() {}
+
+fn foo() -> Result<u32, ()> {
+ let x: Option<u32> = None;
+ x?; //~ the trait bound
+ Ok(22)
+}
+
+fn bar() -> u32 {
+ let x: Option<u32> = None;
+ x?; //~ the `?` operator
+ 22
+}
--- /dev/null
+error[E0277]: the trait bound `(): std::convert::From<std::option::NoneError>` is not satisfied
+ --> $DIR/try-on-option.rs:17:5
+ |
+LL | x?; //~ the trait bound
+ | ^^ the trait `std::convert::From<std::option::NoneError>` is not implemented for `()`
+ |
+ = note: required by `std::convert::From::from`
+
+error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
+ --> $DIR/try-on-option.rs:23:5
+ |
+LL | x?; //~ the `?` operator
+ | ^^ cannot use the `?` operator in a function that returns `u32`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `u32`
+ = note: required by `std::ops::Try::from_error`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-cloudabi no std::fs support
+
+#![feature(try_trait)]
+
+use std::ops::Try;
+
+fn main() {
+ // error for a `Try` type on a non-`Try` fn
+ std::fs::File::open("foo")?; //~ ERROR the `?` operator can only
+
+ // a non-`Try` type on a non-`Try` fn
+ ()?; //~ ERROR the `?` operator can only
+
+ // an unrelated use of `Try`
+ try_trait_generic::<()>(); //~ ERROR the trait bound
+}
+
+
+
+fn try_trait_generic<T: Try>() -> T {
+ // and a non-`Try` object on a `Try` fn.
+ ()?; //~ ERROR the `?` operator can only
+
+ loop {}
+}
--- /dev/null
+error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `std::ops::Try`)
+ --> $DIR/try-operator-on-main.rs:19:5
+ |
+LL | std::fs::File::open("foo")?; //~ ERROR the `?` operator can only
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `()`
+ = note: required by `std::ops::Try::from_error`
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/try-operator-on-main.rs:22:5
+ |
+LL | ()?; //~ ERROR the `?` operator can only
+ | ^^^ the `?` operator cannot be applied to type `()`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `()`
+ = note: required by `std::ops::Try::into_result`
+
+error[E0277]: the trait bound `(): std::ops::Try` is not satisfied
+ --> $DIR/try-operator-on-main.rs:25:5
+ |
+LL | try_trait_generic::<()>(); //~ ERROR the trait bound
+ | ^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::ops::Try` is not implemented for `()`
+ |
+note: required by `try_trait_generic`
+ --> $DIR/try-operator-on-main.rs:30:1
+ |
+LL | fn try_trait_generic<T: Try>() -> T {
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
+ --> $DIR/try-operator-on-main.rs:32:5
+ |
+LL | ()?; //~ ERROR the `?` operator can only
+ | ^^^ the `?` operator cannot be applied to type `()`
+ |
+ = help: the trait `std::ops::Try` is not implemented for `()`
+ = note: required by `std::ops::Try::into_result`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+// compile-flags: -Z parse-only
+
+fn main () {
+ ((1, (2, 3)).1).1; //~ ERROR unexpected token: `1.1`
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+// compile-flags: -Z parse-only
+
+fn main () {
+ (1, (2, 3)).1.1; //~ ERROR unexpected token: `1.1`
+}
--- /dev/null
+error: unexpected token: `1.1`
+ --> $DIR/tuple-float-index.rs:15:17
+ |
+LL | (1, (2, 3)).1.1; //~ ERROR unexpected token: `1.1`
+ | ------------^^^
+ | | |
+ | | unexpected token
+ | help: try parenthesizing the first index: `((1, (2, 3)).1).1`
+
+error: aborting due to previous error
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ let x: Vec::with_capacity(10, 20); //~ ERROR expected type, found `10`
+ //~^ ERROR this function takes 1 parameter
+}
--- /dev/null
+error: expected type, found `10`
+ --> $DIR/type-ascription-instead-of-initializer.rs:12:31
+ |
+LL | let x: Vec::with_capacity(10, 20); //~ ERROR expected type, found `10`
+ | -- ^^
+ | ||
+ | |help: use `=` if you meant to assign
+ | while parsing the type for `x`
+
+error[E0061]: this function takes 1 parameter but 2 parameters were supplied
+ --> $DIR/type-ascription-instead-of-initializer.rs:12:12
+ |
+LL | let x: Vec::with_capacity(10, 20); //~ ERROR expected type, found `10`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 1 parameter
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0061`.
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(type_ascription)]
+
+fn main() {
+ println!("test"):
+ 0; //~ ERROR expected type, found `0`
+}
+
+fn foo() {
+ println!("test"): 0; //~ ERROR expected type, found `0`
+}
--- /dev/null
+error: expected type, found `0`
+ --> $DIR/type-ascription-instead-of-statement-end.rs:15:5
+ |
+LL | println!("test"):
+ | - help: try using a semicolon: `;`
+LL | 0; //~ ERROR expected type, found `0`
+ | ^ expecting a type here because of type ascription
+
+error: expected type, found `0`
+ --> $DIR/type-ascription-instead-of-statement-end.rs:19:23
+ |
+LL | println!("test"): 0; //~ ERROR expected type, found `0`
+ | ^ expecting a type here because of type ascription
+
+error: aborting due to 2 previous errors
+
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(type_ascription)]
+
+fn main() {
+ f() :
+ f(); //~ ERROR expected type, found function
+}
+
+fn f() {}
--- /dev/null
+error[E0573]: expected type, found function `f`
+ --> $DIR/type-ascription-with-fn-call.rs:15:5
+ |
+LL | f() :
+ | - help: did you mean to use `;` here instead?
+LL | f(); //~ ERROR expected type, found function
+ | ^^^
+ | |
+ | not a type
+ | expecting a type here because of type ascription
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0573`.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(wasm_import_module)]
+#[link(name = "...", wasm_import_module)] //~ ERROR: must be of the form
+extern {}
-#[wasm_import_module] //~ ERROR: must be of the form
+#[link(name = "...", wasm_import_module(x))] //~ ERROR: must be of the form
extern {}
-#[wasm_import_module = "foo"] //~ ERROR: must only be attached to
-fn foo() {}
+#[link(name = "...", wasm_import_module())] //~ ERROR: must be of the form
+extern {}
fn main() {}
-error: must be of the form #[wasm_import_module = "..."]
- --> $DIR/wasm-import-module.rs:13:1
+error: must be of the form #[link(wasm_import_module = "...")]
+ --> $DIR/wasm-import-module.rs:11:22
|
-LL | #[wasm_import_module] //~ ERROR: must be of the form
- | ^^^^^^^^^^^^^^^^^^^^^
+LL | #[link(name = "...", wasm_import_module)] //~ ERROR: must be of the form
+ | ^^^^^^^^^^^^^^^^^^
-error: must only be attached to foreign modules
- --> $DIR/wasm-import-module.rs:16:1
+error: must be of the form #[link(wasm_import_module = "...")]
+ --> $DIR/wasm-import-module.rs:14:22
|
-LL | #[wasm_import_module = "foo"] //~ ERROR: must only be attached to
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[link(name = "...", wasm_import_module(x))] //~ ERROR: must be of the form
+ | ^^^^^^^^^^^^^^^^^^^^^
-error: aborting due to 2 previous errors
+error: must be of the form #[link(wasm_import_module = "...")]
+ --> $DIR/wasm-import-module.rs:17:22
+ |
+LL | #[link(name = "...", wasm_import_module())] //~ ERROR: must be of the form
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
use std::io::BufReader;
use std::path::{Path, PathBuf};
-use common;
-use common::Config;
+use common::{self, Config, Mode};
use util;
use extract_gdb_version;
disable_ui_testing_normalization: false,
normalize_stdout: vec![],
normalize_stderr: vec![],
- failure_status: 101,
+ failure_status: -1,
run_rustfix: false,
}
}
if let Some(code) = config.parse_failure_status(ln) {
self.failure_status = code;
+ } else {
+ self.failure_status = match config.mode {
+ Mode::RunFail => 101,
+ _ => 1,
+ };
}
if !self.run_rustfix {
}
fn check_no_compiler_crash(&self, proc_res: &ProcRes) {
- for line in proc_res.stderr.lines() {
- if line.contains("error: internal compiler error") {
- self.fatal_proc_rec("compiler encountered internal error", proc_res);
- } else if line.contains(" panicked at ") {
- self.fatal_proc_rec("compiler panicked", proc_res);
- }
+ match proc_res.status.code() {
+ Some(101) => self.fatal_proc_rec("compiler encountered internal error", proc_res),
+ None => self.fatal_proc_rec("compiler terminated by signal", proc_res),
+ _ => (),
}
}
projects / rust.git / commitdiff