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,
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))
}
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
});
// ```
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 {
+ // impl trait
hir::ItemKind::Existential(hir::ExistTy {
impl_trait_fn: Some(parent),
..
}) => parent,
+ // named existential types
+ hir::ItemKind::Existential(hir::ExistTy {
+ impl_trait_fn: None,
+ ..
+ }) if may_define_existential_type(
+ tcx,
+ self.parent_def_id,
+ anon_node_id,
+ ) => {
+ return self.fold_anon_ty(ty, def_id, substs);
+ },
_ => {
let anon_parent_node_id = tcx.hir.get_parent(anon_node_id);
tcx.hir.local_def_id(anon_parent_node_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`
+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",
}
}
}
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);
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 {
// 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");
- return param_env(tcx, parent);
+ 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 {
+ if let Some(parent) = exist_ty.impl_trait_fn {
+ return param_env(tcx, parent);
+ }
+ }
+ }
+ }
}
// Compute the bounds on Self and the type parameters.
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>),
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);
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),
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,
};
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);
}
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(ref 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 let Some(node_id) = tcx.hir.as_local_node_id(did) {
+ if let hir::map::NodeItem(item) = tcx.hir.get(node_id) {
+ if let hir::ItemKind::Existential(ref exist_ty) = item.node {
+ if exist_ty.impl_trait_fn.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;
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
},
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()));
+}
+
+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 anon_node_id = tcx.hir.as_local_node_id(def_id).unwrap();
+ if may_define_existential_type(tcx, fn_def_id, anon_node_id) {
+ let generics = tcx.generics_of(def_id);
+ trace!("check_existential_types may define. Generics: {:#?}", generics);
+ for (subst, param) in substs.iter().zip(&generics.params) {
+ if let ty::subst::UnpackedKind::Type(ty) = subst.unpack() {
+ 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();
+ return tcx.types.err;
+ },
+ } // match ty
+ } // if let Type = subst
+ } // for (subst, param)
+ } // 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 let TyAnon
+ ty
+ },
+ });
+ 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(
+ let mut definition_ty = self.fcx.infer_anon_definition_from_instantiation(
def_id,
anon_defn,
instantiated_ty,
);
+
+ let generics = self.tcx().generics_of(def_id);
+
+ // named existential type, not an impl trait
+ if generics.parent.is_none() {
+ // 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`
+ definition_ty = definition_ty.fold_with(&mut BottomUpFolder {
+ tcx: self.tcx().global_tcx(),
+ fldop: |ty| {
+ // 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
+ },
+ });
+ }
+
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, node_id: ast::NodeId) {
+ let def_id = self.tcx.hir.local_def_id(node_id);
+ // 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) {
+ // the existential type itself or its children are not within its reveal scope
+ if self.tcx.hir.local_def_id(it.id) != self.def_id {
+ self.check(it.id);
+ intravisit::walk_item(self, it);
+ }
+ }
+ fn visit_impl_item(&mut self, it: &'tcx ImplItem) {
+ // the existential type itself or its children are not within its reveal scope
+ if self.tcx.hir.local_def_id(it.id) != self.def_id {
+ self.check(it.id);
+ intravisit::walk_impl_item(self, it);
+ }
+ }
+ fn visit_trait_item(&mut self, it: &'tcx TraitItem) {
+ self.check(it.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),
+ 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,
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>,
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")
}
ItemType::AssociatedConst => ("associated-consts", "Associated Constants"),
ItemType::ForeignType => ("foreign-types", "Foreign Types"),
ItemType::Keyword => ("keywords", "Keywords"),
+ ItemType::Existential => ("existentials", "Existentials"),
}
}
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
- }
}
}
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",
// 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),
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 {
// 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
+// 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<T: Trait>: 'static;
+
+fn generic_bound<T: Trait>(_: T) -> GenericBound<T> {
+ unimplemented!()
+}
+
+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
+}
+
+existential type PartiallyDefined<T>: 'static;
+
+// doesn't declare all PartiallyDefined for all possible `T`, but since it's the only
+// function producing the value, noone can ever get a value that is problematic
+fn partially_defined<T: std::fmt::Debug>(_: T) -> PartiallyDefined<T> {
+ 4u32
+}
+
+existential type PartiallyDefined2<T>: 'static;
+
+fn partially_defined2<T: std::fmt::Debug>(_: T) -> PartiallyDefined2<T> {
+ 4u32
+}
+
+// fully defines PartiallyDefine2
+fn partially_defined22<T>(_: T) -> PartiallyDefined2<T> {
+ 4u32
+}
--- /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`.
--- /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
+error: defining existential type use differs from previous
+ --> $DIR/existential_type.rs:23:1
+ |
+LL | / fn bar() -> Foo { //~ ERROR defining existential type use differs from previous
+LL | | 42i32
+LL | | }
+ | |_^
+ |
+note: previous use here
+ --> $DIR/existential_type.rs:19:1
+ |
+LL | / fn foo() -> Foo {
+LL | | ""
+LL | | }
+ | |_^
+
+error[E0308]: mismatched types
+ --> $DIR/existential_type.rs:36: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[E0308]: mismatched types
+ --> $DIR/existential_type.rs:50:23
+ |
+LL | let _: &str = bomp(); //~ ERROR mismatched types
+ | ^^^^^^ expected &str, found anonymized type
+ |
+ = note: expected type `&str`
+ found type `Boo`
+
+error[E0308]: mismatched types
+ --> $DIR/existential_type.rs:54:9
+ |
+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[E0277]: the trait bound `T: Trait` is not satisfied
+ --> $DIR/existential_type.rs:61: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
+
+warning: not reporting region error due to nll
+ --> $DIR/existential_type.rs:78:1
+ |
+LL | existential type WrongGeneric<T>: 'static;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/existential_type.rs:93: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/existential_type.rs:94: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: could not find defining uses
+ --> $DIR/existential_type.rs:28:1
+ |
+LL | existential type Bar: std::fmt::Debug; //~ ERROR could not find defining uses
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: could not find defining uses
+ --> $DIR/existential_type.rs:32:5
+ |
+LL | pub existential type Boo: ::std::fmt::Debug; //~ ERROR could not find defining uses
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: defining existential type use differs from previous
+ --> $DIR/existential_type.rs:74: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/existential_type.rs:70:1
+ |
+LL | / fn my_iter<T>(t: T) -> MyIter<T> {
+LL | | std::iter::once(t)
+LL | | }
+ | |_^
+
+error: aborting due to 10 previous errors
+
+Some errors occurred: E0277, E0308, E0605.
+For more information about an 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() {}
+
+// 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
+}
+
+// declared but never defined
+existential type Bar: std::fmt::Debug; //~ ERROR could not find defining uses
+
+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 {
+ "" //~ ERROR mismatched types
+}
+
+mod boo2 {
+ 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
+ }
+}
+
+// generics
+
+trait Trait {}
+existential type Underconstrained<T: Trait>: 'static; //~ ERROR the trait bound `T: Trait`
+
+// no `Trait` bound
+fn underconstrain<T>(_: T) -> Underconstrained<T> {
+ unimplemented!()
+}
+
+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()
+}
+
+existential type WrongGeneric<T>: 'static;
+//~^ ERROR the parameter type `T` may not live long enough
+
+fn wrong_generic<T>(t: T) -> WrongGeneric<T> {
+ t
+}
+
+// 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: defining existential type use differs from previous
+ --> $DIR/existential_type.rs:23:1
+ |
+LL | / fn bar() -> Foo { //~ ERROR defining existential type use differs from previous
+LL | | 42i32
+LL | | }
+ | |_^
+ |
+note: previous use here
+ --> $DIR/existential_type.rs:19:1
+ |
+LL | / fn foo() -> Foo {
+LL | | ""
+LL | | }
+ | |_^
+
+error[E0308]: mismatched types
+ --> $DIR/existential_type.rs:36: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[E0308]: mismatched types
+ --> $DIR/existential_type.rs:50:23
+ |
+LL | let _: &str = bomp(); //~ ERROR mismatched types
+ | ^^^^^^ expected &str, found anonymized type
+ |
+ = note: expected type `&str`
+ found type `Boo`
+
+error[E0308]: mismatched types
+ --> $DIR/existential_type.rs:54:9
+ |
+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[E0277]: the trait bound `T: Trait` is not satisfied
+ --> $DIR/existential_type.rs:61: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[E0310]: the parameter type `T` may not live long enough
+ --> $DIR/existential_type.rs:78: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/existential_type.rs:78:1
+ |
+LL | existential type WrongGeneric<T>: 'static;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0308]: mismatched types
+ --> $DIR/existential_type.rs:93: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/existential_type.rs:94: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: could not find defining uses
+ --> $DIR/existential_type.rs:28:1
+ |
+LL | existential type Bar: std::fmt::Debug; //~ ERROR could not find defining uses
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: could not find defining uses
+ --> $DIR/existential_type.rs:32:5
+ |
+LL | pub existential type Boo: ::std::fmt::Debug; //~ ERROR could not find defining uses
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: defining existential type use differs from previous
+ --> $DIR/existential_type.rs:74: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/existential_type.rs:70:1
+ |
+LL | / fn my_iter<T>(t: T) -> MyIter<T> {
+LL | | std::iter::once(t)
+LL | | }
+ | |_^
+
+error: aborting due to 11 previous errors
+
+Some errors occurred: E0277, E0308, E0310, E0605.
+For more information about an 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/existential_type2.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/existential_type2.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() {}
+
+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/existential_type3.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
+// 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/existential_type4.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/existential_type4.rs:16:22
+ |
+LL | existential type Cmp<T>: 'static;
+ | ^
+
+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
+// 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
+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`.
-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`.
projects / rust.git / commitdiff