diff options
39 files changed, 365 insertions, 595 deletions
diff --git a/src/librustc/hir/def_id.rs b/src/librustc/hir/def_id.rs index 34b3aa53d6b..7acfe683954 100644 --- a/src/librustc/hir/def_id.rs +++ b/src/librustc/hir/def_id.rs @@ -81,7 +81,7 @@ impl serialize::UseSpecializedDecodable for CrateNum {} /// Since the DefIndex is mostly treated as an opaque ID, you probably /// don't have to care about these address spaces. -#[derive(Clone, Eq, Ord, PartialOrd, PartialEq, Hash, Copy)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)] pub struct DefIndex(u32); /// The crate root is always assigned index 0 by the AST Map code, @@ -150,7 +150,7 @@ impl DefIndex { impl serialize::UseSpecializedEncodable for DefIndex {} impl serialize::UseSpecializedDecodable for DefIndex {} -#[derive(Copy, Clone, Eq, PartialEq, Hash)] +#[derive(Copy, Clone, Hash)] pub enum DefIndexAddressSpace { Low = 0, High = 1, @@ -165,7 +165,7 @@ impl DefIndexAddressSpace { /// A DefId identifies a particular *definition*, by combining a crate /// index and a def index. -#[derive(Clone, Eq, Ord, PartialOrd, PartialEq, Hash, Copy)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)] pub struct DefId { pub krate: CrateNum, pub index: DefIndex, @@ -216,7 +216,7 @@ impl serialize::UseSpecializedDecodable for DefId {} /// few cases where we know that only DefIds from the local crate are expected /// and a DefId from a different crate would signify a bug somewhere. This /// is when LocalDefId comes in handy. -#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)] +#[derive(Clone, Copy, PartialEq, Eq, Hash)] pub struct LocalDefId(DefIndex); impl LocalDefId { diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index a7ed854d016..e2c0020db2f 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -51,7 +51,7 @@ use super::itemlikevisit::DeepVisitor; use std::cmp; use std::u32; -#[derive(Copy, Clone, PartialEq, Eq)] +#[derive(Copy, Clone)] pub enum FnKind<'a> { /// #[xxx] pub async/const/extern "Abi" fn foo() ItemFn(Name, &'a Generics, FnHeader, &'a Visibility, &'a [Attribute]), @@ -1115,7 +1115,7 @@ pub fn walk_defaultness<'v, V: Visitor<'v>>(_: &mut V, _: &'v Defaultness) { // would be to walk it. } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, PartialEq, Eq)] +#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] pub struct IdRange { pub min: NodeId, pub max: NodeId, diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 7dd7954c8f4..cb53f963d41 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -238,7 +238,7 @@ pub fn lower_crate( }.lower_crate(krate) } -#[derive(Copy, Clone, PartialEq, Eq)] +#[derive(Copy, Clone, PartialEq)] enum ParamMode { /// Any path in a type context. Explicit, @@ -1927,7 +1927,7 @@ impl<'a> LoweringContext<'a> { variadic: decl.variadic, has_implicit_self: decl.inputs.get(0).map_or(false, |arg| match arg.ty.node { TyKind::ImplicitSelf => true, - TyKind::Rptr(_, ref mt) => mt.ty.node == TyKind::ImplicitSelf, + TyKind::Rptr(_, ref mt) => mt.ty.node.is_implicit_self(), _ => false, }), }) diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index 49a4a1b78a1..9b1bb3310f2 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -171,7 +171,7 @@ pub struct Definitions { /// A unique identifier that we can use to lookup a definition /// precisely. It combines the index of the definition's parent (if /// any) with a `DisambiguatedDefPathData`. -#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, PartialEq, Debug, Hash, RustcEncodable, RustcDecodable)] pub struct DefKey { /// Parent path. pub parent: Option<DefIndex>, @@ -223,13 +223,13 @@ impl DefKey { /// between them. This introduces some artificial ordering dependency /// but means that if you have (e.g.) two impls for the same type in /// the same module, they do get distinct def-ids. -#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, PartialEq, Debug, Hash, RustcEncodable, RustcDecodable)] pub struct DisambiguatedDefPathData { pub data: DefPathData, pub disambiguator: u32 } -#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, Hash, RustcEncodable, RustcDecodable)] pub struct DefPath { /// the path leading from the crate root to the item pub data: Vec<DisambiguatedDefPathData>, @@ -311,7 +311,7 @@ impl DefPath { } } -#[derive(Clone, Debug, Eq, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] pub enum DefPathData { // Root: these should only be used for the root nodes, because // they are treated specially by the `def_path` function. @@ -668,8 +668,7 @@ macro_rules! define_global_metadata_kind { (pub enum GlobalMetaDataKind { $($variant:ident),* }) => ( - #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, - RustcEncodable, RustcDecodable)] + #[derive(Clone, Copy, Debug, Hash, RustcEncodable, RustcDecodable)] pub enum GlobalMetaDataKind { $($variant),* } diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index bae443bfc58..5984f8ce5b1 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -89,7 +89,7 @@ pub mod svh; /// the local_id part of the HirId changing, which is a very useful property in /// incremental compilation where we have to persist things through changes to /// the code base. -#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub struct HirId { pub owner: DefIndex, pub local_id: ItemLocalId, @@ -138,7 +138,7 @@ impl serialize::UseSpecializedDecodable for HirId { /// integers starting at zero, so a mapping that maps all or most nodes within /// an "item-like" to something else can be implement by a `Vec` instead of a /// tree or hash map. -#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] pub struct ItemLocalId(pub u32); @@ -172,7 +172,7 @@ pub const DUMMY_HIR_ID: HirId = HirId { pub const DUMMY_ITEM_LOCAL_ID: ItemLocalId = ItemLocalId(!0); -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Copy)] pub struct Label { pub ident: Ident, } @@ -183,7 +183,7 @@ impl fmt::Debug for Label { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Copy)] pub struct Lifetime { pub id: NodeId, pub span: Span, @@ -312,7 +312,7 @@ impl Lifetime { /// A "Path" is essentially Rust's notion of a name; for instance: /// `std::cmp::PartialEq`. It's represented as a sequence of identifiers, /// along with a bunch of supporting information. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Path { pub span: Span, /// The definition that the path resolved to. @@ -341,7 +341,7 @@ impl fmt::Display for Path { /// A segment of a path: an identifier, an optional lifetime, and a set of /// types. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct PathSegment { /// The identifier portion of this path segment. pub ident: Ident, @@ -396,7 +396,7 @@ impl PathSegment { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum GenericArg { Lifetime(Lifetime), Type(Ty), @@ -411,7 +411,7 @@ impl GenericArg { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct GenericArgs { /// The generic arguments for this path segment. pub args: HirVec<GenericArg>, @@ -467,7 +467,7 @@ pub enum TraitBoundModifier { /// typeck::collect::compute_bounds matches these against /// the "special" built-in traits (see middle::lang_items) and /// detects Copy, Send and Sync. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum GenericBound { Trait(PolyTraitRef, TraitBoundModifier), Outlives(Lifetime), @@ -484,7 +484,7 @@ impl GenericBound { pub type GenericBounds = HirVec<GenericBound>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum GenericParamKind { /// A lifetime definition, eg `'a: 'b + 'c + 'd`. Lifetime { @@ -499,7 +499,7 @@ pub enum GenericParamKind { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct GenericParam { pub id: NodeId, pub name: ParamName, @@ -518,7 +518,7 @@ pub struct GenericParamCount { /// Represents lifetimes and type parameters attached to a declaration /// of a function, enum, trait, etc. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Generics { pub params: HirVec<GenericParam>, pub where_clause: WhereClause, @@ -574,7 +574,7 @@ pub enum SyntheticTyParamKind { } /// A `where` clause in a definition -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereClause { pub id: NodeId, pub predicates: HirVec<WherePredicate>, @@ -593,7 +593,7 @@ impl WhereClause { } /// A single predicate in a `where` clause -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum WherePredicate { /// A type binding, eg `for<'c> Foo: Send+Clone+'c` BoundPredicate(WhereBoundPredicate), @@ -614,7 +614,7 @@ impl WherePredicate { } /// A type bound, eg `for<'c> Foo: Send+Clone+'c` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereBoundPredicate { pub span: Span, /// Any generics from a `for` binding @@ -626,7 +626,7 @@ pub struct WhereBoundPredicate { } /// A lifetime predicate, e.g. `'a: 'b+'c` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereRegionPredicate { pub span: Span, pub lifetime: Lifetime, @@ -634,7 +634,7 @@ pub struct WhereRegionPredicate { } /// An equality predicate (unsupported), e.g. `T=int` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereEqPredicate { pub id: NodeId, pub span: Span, @@ -650,7 +650,7 @@ pub type CrateConfig = HirVec<P<MetaItem>>; /// For more details, see the [rustc guide]. /// /// [rustc guide]: https://rust-lang-nursery.github.io/rustc-guide/hir.html -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Crate { pub module: Mod, pub attrs: HirVec<Attribute>, @@ -748,7 +748,7 @@ impl Crate { /// A macro definition, in this crate or imported from another. /// /// Not parsed directly, but created on macro import or `macro_rules!` expansion. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct MacroDef { pub name: Name, pub vis: Visibility, @@ -759,7 +759,7 @@ pub struct MacroDef { pub legacy: bool, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Block { /// Statements in a block pub stmts: HirVec<Stmt>, @@ -782,7 +782,7 @@ pub struct Block { pub recovered: bool, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Pat { pub id: NodeId, pub hir_id: HirId, @@ -844,7 +844,7 @@ impl Pat { /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` /// are treated the same as` x: x, y: ref y, z: ref mut z`, /// except is_shorthand is true -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct FieldPat { pub id: NodeId, /// The identifier for the field @@ -857,7 +857,7 @@ pub struct FieldPat { /// Explicit binding annotations given in the HIR for a binding. Note /// that this is not the final binding *mode* that we infer after type /// inference. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum BindingAnnotation { /// No binding annotation given: this means that the final binding mode /// will depend on whether we have skipped through a `&` reference @@ -878,13 +878,13 @@ pub enum BindingAnnotation { RefMut, } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum RangeEnd { Included, Excluded, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum PatKind { /// Represents a wildcard pattern (`_`) Wild, @@ -940,7 +940,7 @@ impl Mutability { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum BinOp_ { /// The `+` operator (addition) BiAdd, @@ -1069,7 +1069,7 @@ impl Into<ast::BinOpKind> for BinOp_ { pub type BinOp = Spanned<BinOp_>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum UnOp { /// The `*` operator for dereferencing UnDeref, @@ -1111,7 +1111,7 @@ impl fmt::Debug for Stmt_ { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub enum Stmt_ { /// Could be an item or a local (let) binding: StmtDecl(P<Decl>, NodeId), @@ -1142,7 +1142,7 @@ impl Stmt_ { } /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Local { pub pat: P<Pat>, pub ty: Option<P<Ty>>, @@ -1157,7 +1157,7 @@ pub struct Local { pub type Decl = Spanned<Decl_>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum Decl_ { /// A local (let) binding: DeclLocal(P<Local>), @@ -1182,7 +1182,7 @@ impl Decl_ { } /// represents one arm of a 'match' -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Arm { pub attrs: HirVec<Attribute>, pub pats: HirVec<P<Pat>>, @@ -1190,7 +1190,7 @@ pub struct Arm { pub body: P<Expr>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Field { pub id: NodeId, pub ident: Ident, @@ -1199,7 +1199,7 @@ pub struct Field { pub is_shorthand: bool, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum BlockCheckMode { DefaultBlock, UnsafeBlock(UnsafeSource), @@ -1207,7 +1207,7 @@ pub enum BlockCheckMode { PopUnsafeBlock(UnsafeSource), } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum UnsafeSource { CompilerGenerated, UserProvided, @@ -1239,7 +1239,7 @@ pub struct BodyId { /// /// All bodies have an **owner**, which can be accessed via the HIR /// map using `body_owner_def_id()`. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Body { pub arguments: HirVec<Arg>, pub value: Expr, @@ -1271,7 +1271,7 @@ pub enum BodyOwnerKind { /// These are usually found nested inside types (e.g. array lengths) /// or expressions (e.g. repeat counts), and also used to define /// explicit discriminant values for enum variants. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)] pub struct AnonConst { pub id: NodeId, pub hir_id: HirId, @@ -1279,7 +1279,7 @@ pub struct AnonConst { } /// An expression -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Expr { pub id: NodeId, pub span: Span, @@ -1330,7 +1330,7 @@ impl fmt::Debug for Expr { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum Expr_ { /// A `box x` expression. ExprBox(P<Expr>), @@ -1432,7 +1432,7 @@ pub enum Expr_ { } /// Optionally `Self`-qualified value/type path or associated extension. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum QPath { /// Path to a definition, optionally "fully-qualified" with a `Self` /// type, if the path points to an associated item in a trait. @@ -1452,7 +1452,7 @@ pub enum QPath { } /// Hints at the original code for a let statement -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum LocalSource { /// A `match _ { .. }` Normal, @@ -1479,7 +1479,7 @@ pub enum MatchSource { } /// The loop type that yielded an ExprLoop -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum LoopSource { /// A `loop { .. }` loop Loop, @@ -1489,7 +1489,7 @@ pub enum LoopSource { ForLoop, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum LoopIdError { OutsideLoopScope, UnlabeledCfInWhileCondition, @@ -1507,7 +1507,7 @@ impl fmt::Display for LoopIdError { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub struct Destination { // This is `Some(_)` iff there is an explicit user-specified `label pub label: Option<Label>, @@ -1523,7 +1523,7 @@ pub enum GeneratorMovability { Movable, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum CaptureClause { CaptureByValue, CaptureByRef, @@ -1531,14 +1531,14 @@ pub enum CaptureClause { // NB: If you change this, you'll probably want to change the corresponding // type structure in middle/ty.rs as well. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct MutTy { pub ty: P<Ty>, pub mutbl: Mutability, } /// Represents a method's signature in a trait declaration or implementation. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct MethodSig { pub header: FnHeader, pub decl: P<FnDecl>, @@ -1547,7 +1547,7 @@ pub struct MethodSig { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the node-id of the item // so it can fetched later. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)] pub struct TraitItemId { pub node_id: NodeId, } @@ -1556,7 +1556,7 @@ pub struct TraitItemId { /// possibly including a default implementation. A trait item is /// either required (meaning it doesn't have an implementation, just a /// signature) or provided (meaning it has a default implementation). -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct TraitItem { pub id: NodeId, pub ident: Ident, @@ -1568,7 +1568,7 @@ pub struct TraitItem { } /// A trait method's body (or just argument names). -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum TraitMethod { /// No default body in the trait, just a signature. Required(HirVec<Ident>), @@ -1578,7 +1578,7 @@ pub enum TraitMethod { } /// Represents a trait method or associated constant or type -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum TraitItemKind { /// An associated constant with an optional value (otherwise `impl`s /// must contain a value) @@ -1593,13 +1593,13 @@ pub enum TraitItemKind { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the node-id of the item // so it can fetched later. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)] pub struct ImplItemId { pub node_id: NodeId, } /// Represents anything within an `impl` block -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ImplItem { pub id: NodeId, pub ident: Ident, @@ -1613,7 +1613,7 @@ pub struct ImplItem { } /// Represents different contents within `impl`s -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ImplItemKind { /// An associated constant of the given type, set to the constant result /// of the expression @@ -1625,7 +1625,7 @@ pub enum ImplItemKind { } // Bind a type to an associated type: `A=Foo`. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct TypeBinding { pub id: NodeId, pub ident: Ident, @@ -1634,7 +1634,7 @@ pub struct TypeBinding { } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Ty { pub id: NodeId, pub node: Ty_, @@ -1660,7 +1660,7 @@ pub enum PrimTy { TyChar, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct BareFnTy { pub unsafety: Unsafety, pub abi: Abi, @@ -1669,14 +1669,14 @@ pub struct BareFnTy { pub arg_names: HirVec<Ident>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ExistTy { pub generics: Generics, pub bounds: GenericBounds, pub impl_trait_fn: Option<DefId>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] /// The different kinds of types recognized by the compiler pub enum Ty_ { /// A variable length slice (`[T]`) @@ -1710,14 +1710,14 @@ pub enum Ty_ { TyErr, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct InlineAsmOutput { pub constraint: Symbol, pub is_rw: bool, pub is_indirect: bool, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct InlineAsm { pub asm: Symbol, pub asm_str_style: StrStyle, @@ -1731,7 +1731,7 @@ pub struct InlineAsm { } /// represents an argument in a function header -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Arg { pub pat: P<Pat>, pub id: NodeId, @@ -1739,7 +1739,7 @@ pub struct Arg { } /// Represents the header (not the body) of a function declaration -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct FnDecl { pub inputs: HirVec<Ty>, pub output: FunctionRetTy, @@ -1750,13 +1750,13 @@ pub struct FnDecl { } /// Is the trait definition an auto trait? -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum IsAuto { Yes, No } -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)] pub enum IsAsync { Async, NotAsync, @@ -1768,13 +1768,13 @@ pub enum Unsafety { Normal, } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum Constness { Const, NotConst, } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum Defaultness { Default { has_value: bool }, Final, @@ -1810,7 +1810,7 @@ impl fmt::Display for Unsafety { } } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)] pub enum ImplPolarity { /// `impl Trait for Type` Positive, @@ -1828,7 +1828,7 @@ impl fmt::Debug for ImplPolarity { } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum FunctionRetTy { /// Return type is not specified. /// @@ -1849,7 +1849,7 @@ impl FunctionRetTy { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Mod { /// A span from the first token past `{` to the last token until `}`. /// For `mod foo;`, the inner span ranges from the first token @@ -1858,24 +1858,24 @@ pub struct Mod { pub item_ids: HirVec<ItemId>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ForeignMod { pub abi: Abi, pub items: HirVec<ForeignItem>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct GlobalAsm { pub asm: Symbol, pub ctxt: SyntaxContext, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct EnumDef { pub variants: HirVec<Variant>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Variant_ { pub name: Name, pub attrs: HirVec<Attribute>, @@ -1886,7 +1886,7 @@ pub struct Variant_ { pub type Variant = Spanned<Variant_>; -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum UseKind { /// One import, e.g. `use foo::bar` or `use foo::bar as baz`. /// Also produced for each element of a list `use`, e.g. @@ -1908,13 +1908,13 @@ pub enum UseKind { /// that the ref_id is for. Note that ref_id's value is not the NodeId of the /// trait being referred to but just a unique NodeId that serves as a key /// within the DefMap. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct TraitRef { pub path: Path, pub ref_id: NodeId, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct PolyTraitRef { /// The `'a` in `<'a> Foo<&'a T>` pub bound_generic_params: HirVec<GenericParam>, @@ -1927,7 +1927,7 @@ pub struct PolyTraitRef { pub type Visibility = Spanned<VisibilityKind>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum VisibilityKind { Public, Crate(CrateSugar), @@ -1953,7 +1953,7 @@ impl VisibilityKind { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct StructField { pub span: Span, pub ident: Ident, @@ -1982,7 +1982,7 @@ impl StructField { /// used for `Struct`-structs (but still presents). Structures don't have an analogue of "Id of /// the variant itself" from enum variants. /// Id of the whole struct lives in `Item`. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum VariantData { Struct(HirVec<StructField>, NodeId), Tuple(HirVec<StructField>, NodeId), @@ -2027,7 +2027,7 @@ impl VariantData { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the node-id of the item // so it can fetched later. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ItemId { pub id: NodeId, } @@ -2035,7 +2035,7 @@ pub struct ItemId { /// An item /// /// The name might be a dummy name in case of anonymous items -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Item { pub name: Name, pub id: NodeId, @@ -2046,7 +2046,7 @@ pub struct Item { pub span: Span, } -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)] pub struct FnHeader { pub unsafety: Unsafety, pub constness: Constness, @@ -2054,7 +2054,7 @@ pub struct FnHeader { pub abi: Abi, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum Item_ { /// An `extern crate` item, with optional *original* crate name if the crate was renamed. /// @@ -2156,7 +2156,7 @@ impl Item_ { /// type or method, and whether it is public). This allows other /// passes to find the impl they want without loading the id (which /// means fewer edges in the incremental compilation graph). -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct TraitItemRef { pub id: TraitItemId, pub ident: Ident, @@ -2171,7 +2171,7 @@ pub struct TraitItemRef { /// type or method, and whether it is public). This allows other /// passes to find the impl they want without loading the id (which /// means fewer edges in the incremental compilation graph). -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ImplItemRef { pub id: ImplItemId, pub ident: Ident, @@ -2181,14 +2181,14 @@ pub struct ImplItemRef { pub defaultness: Defaultness, } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum AssociatedItemKind { Const, Method { has_self: bool }, Type, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ForeignItem { pub name: Name, pub attrs: HirVec<Attribute>, @@ -2199,7 +2199,7 @@ pub struct ForeignItem { } /// An item within an `extern` block -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ForeignItem_ { /// A foreign function ForeignItemFn(P<FnDecl>, HirVec<Ident>, Generics), @@ -2261,7 +2261,7 @@ pub fn provide(providers: &mut Providers) { providers.describe_def = map::describe_def; } -#[derive(Clone, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct CodegenFnAttrs { pub flags: CodegenFnAttrFlags, pub inline: InlineAttr, diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 4d0969d898e..377990ef561 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -1914,7 +1914,9 @@ impl<'a> State<'a> { if !before.is_empty() { self.word_space(",")?; } - if p.node != PatKind::Wild { + if let PatKind::Wild = p.node { + // Print nothing + } else { self.print_pat(&p)?; } self.s.word("..")?; @@ -2033,7 +2035,9 @@ impl<'a> State<'a> { s.ann.nested(s, Nested::BodyArgPat(body_id, i))?; i += 1; - if ty.node != hir::TyInfer { + if let hir::TyInfer = ty.node { + // Print nothing + } else { s.s.word(":")?; s.s.space()?; s.print_type(ty)?; diff --git a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs index a2b89475210..f3f3dcfeea0 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs @@ -111,7 +111,7 @@ impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { let (span_1, span_2, main_label, span_label) = match (sup_is_ret_type, sub_is_ret_type) { (None, None) => { - let (main_label_1, span_label_1) = if ty_sup == ty_sub { + let (main_label_1, span_label_1) = if ty_sup.id == ty_sub.id { ( format!("this type is declared with multiple lifetimes..."), format!( diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs index ed8e1654d5a..12c8d07eb00 100644 --- a/src/librustc/middle/cstore.rs +++ b/src/librustc/middle/cstore.rs @@ -125,7 +125,7 @@ pub enum NativeLibraryKind { NativeUnknown, } -#[derive(Clone, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct NativeLibrary { pub kind: NativeLibraryKind, pub name: Symbol, diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 4a76cc683f6..bbfcfb79890 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -174,7 +174,7 @@ pub struct ImplHeader<'tcx> { pub predicates: Vec<Predicate<'tcx>>, } -#[derive(Copy, Clone, Debug, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, PartialEq)] pub struct AssociatedItem { pub def_id: DefId, pub ident: Ident, diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index d6e5c70b8f7..e48009c16d2 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -397,7 +397,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { hir::ItemUnion(..) => "a union", hir::ItemTrait(.., ref trait_item_refs) => { // Issue #11592, traits are always considered exported, even when private. - if it.vis.node == hir::VisibilityKind::Inherited { + if let hir::VisibilityKind::Inherited = it.vis.node { self.private_traits.insert(it.id); for trait_item_ref in trait_item_refs { self.private_traits.insert(trait_item_ref.id.node_id); @@ -414,7 +414,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { if let Some(node_id) = cx.tcx.hir.as_local_node_id(real_trait) { match cx.tcx.hir.find(node_id) { Some(hir_map::NodeItem(item)) => { - if item.vis.node == hir::VisibilityKind::Inherited { + if let hir::VisibilityKind::Inherited = item.vis.node { for impl_item_ref in impl_item_refs { self.private_traits.insert(impl_item_ref.id.node_id); } diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index ca361be258a..f27ca444672 100644 --- a/src/librustc_passes/ast_validation.rs +++ b/src/librustc_passes/ast_validation.rs @@ -60,19 +60,21 @@ impl<'a> AstValidator<'a> { } fn invalid_visibility(&self, vis: &Visibility, note: Option<&str>) { - if vis.node != VisibilityKind::Inherited { - let mut err = struct_span_err!(self.session, - vis.span, - E0449, - "unnecessary visibility qualifier"); - if vis.node == VisibilityKind::Public { - err.span_label(vis.span, "`pub` not permitted here because it's implied"); - } - if let Some(note) = note { - err.note(note); - } - err.emit(); + if let VisibilityKind::Inherited = vis.node { + return + } + + let mut err = struct_span_err!(self.session, + vis.span, + E0449, + "unnecessary visibility qualifier"); + if vis.node.is_pub() { + err.span_label(vis.span, "`pub` not permitted here because it's implied"); + } + if let Some(note) = note { + err.note(note); } + err.emit(); } fn check_decl_no_pat<ReportFn: Fn(Span, bool)>(&self, decl: &FnDecl, report_err: ReportFn) { @@ -268,7 +270,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> { match item.node { ItemKind::Impl(unsafety, polarity, _, _, Some(..), ref ty, ref impl_items) => { self.invalid_visibility(&item.vis, None); - if ty.node == TyKind::Err { + if let TyKind::Err = ty.node { self.err_handler() .struct_span_err(item.span, "`impl Trait for .. {}` is an obsolete syntax") .help("use `auto trait Trait {}` instead").emit(); diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index ef24a201e0f..ec067a6477b 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -86,7 +86,7 @@ impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> { // because this means that they were generated in some fashion by the // compiler and we don't need to consider them. if let ast::ItemKind::Use(..) = item.node { - if item.vis.node == ast::VisibilityKind::Public || item.span.is_dummy() { + if item.vis.node.is_pub() || item.span.is_dummy() { return; } } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index aed70861e33..f3086d3ab2b 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -456,7 +456,7 @@ enum AliasPossibility { Maybe, } -#[derive(Copy, Clone, PartialEq, Eq, Debug)] +#[derive(Copy, Clone, Debug)] enum PathSource<'a> { // Type paths `Path`. Type, diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 311978ec248..34dcdfb757f 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -65,14 +65,14 @@ macro_rules! down_cast_data { macro_rules! access_from { ($save_ctxt:expr, $vis:expr, $id:expr) => { Access { - public: $vis.node == ast::VisibilityKind::Public, + public: $vis.node.is_pub(), reachable: $save_ctxt.analysis.access_levels.is_reachable($id), } }; ($save_ctxt:expr, $item:expr) => { Access { - public: $item.vis.node == ast::VisibilityKind::Public, + public: $item.vis.node.is_pub(), reachable: $save_ctxt.analysis.access_levels.is_reachable($item.id), } }; @@ -523,7 +523,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { .iter() .enumerate() .filter_map(|(i, f)| { - if include_priv_fields || f.vis.node == ast::VisibilityKind::Public { + if include_priv_fields || f.vis.node.is_pub() { f.ident .map(|i| i.to_string()) .or_else(|| Some(i.to_string())) diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 0aff322a29a..bee866db9e4 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -119,7 +119,7 @@ enum ProbeResult { Match, } -#[derive(Debug, PartialEq, Eq, Clone)] +#[derive(Debug, PartialEq, Clone)] pub struct Pick<'tcx> { pub item: ty::AssociatedItem, pub kind: PickKind<'tcx>, diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index f71d62d5a04..030b36c2212 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -49,6 +49,7 @@ use rustc::lint as lint; use std::collections::hash_map::Entry; use std::fmt; +use std::hash::{Hash, Hasher}; use std::default::Default; use std::{mem, slice, vec}; use std::iter::{FromIterator, once}; @@ -754,7 +755,7 @@ impl<'a> FromIterator<&'a DocFragment> for String { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Default, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Default)] pub struct Attributes { pub doc_strings: Vec<DocFragment>, pub other_attrs: Vec<ast::Attribute>, @@ -974,6 +975,30 @@ impl Attributes { } } +impl PartialEq for Attributes { + fn eq(&self, rhs: &Self) -> bool { + self.doc_strings == rhs.doc_strings && + self.cfg == rhs.cfg && + self.span == rhs.span && + self.links == rhs.links && + self.other_attrs.iter().map(|attr| attr.id).eq(rhs.other_attrs.iter().map(|attr| attr.id)) + } +} + +impl Eq for Attributes {} + +impl Hash for Attributes { + fn hash<H: Hasher>(&self, hasher: &mut H) { + self.doc_strings.hash(hasher); + self.cfg.hash(hasher); + self.span.hash(hasher); + self.links.hash(hasher); + for attr in &self.other_attrs { + attr.id.hash(hasher); + } + } +} + impl AttributesExt for Attributes { fn lists<'a>(&'a self, name: &'a str) -> ListAttributesIter<'a> { self.other_attrs.lists(name) diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs index 3a05cb7187d..da705081ff3 100644 --- a/src/libserialize/collection_impls.rs +++ b/src/libserialize/collection_impls.rs @@ -67,7 +67,7 @@ impl<T:Decodable> Decodable for VecDeque<T> { impl< K: Encodable + PartialEq + Ord, - V: Encodable + PartialEq + V: Encodable > Encodable for BTreeMap<K, V> { fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> { e.emit_map(self.len(), |e| { @@ -84,7 +84,7 @@ impl< impl< K: Decodable + PartialEq + Ord, - V: Decodable + PartialEq + V: Decodable > Decodable for BTreeMap<K, V> { fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> { d.read_map(|d, len| { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 71ff9e8058e..209e0b6d787 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -34,7 +34,7 @@ use std::u32; pub use rustc_target::abi::FloatTy; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Copy)] pub struct Label { pub ident: Ident, } @@ -45,7 +45,7 @@ impl fmt::Debug for Label { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Copy)] pub struct Lifetime { pub id: NodeId, pub ident: Ident, @@ -63,7 +63,7 @@ impl fmt::Debug for Lifetime { /// along with a bunch of supporting information. /// /// E.g. `std::cmp::PartialEq` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Path { pub span: Span, /// The segments in the path: the things separated by `::`. @@ -115,7 +115,7 @@ impl Path { /// A segment of a path: an identifier, an optional lifetime, and a set of types. /// /// E.g. `std`, `String` or `Box<T>` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct PathSegment { /// The identifier portion of this path segment. pub ident: Ident, @@ -141,7 +141,7 @@ impl PathSegment { /// Arguments of a path segment. /// /// E.g. `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum GenericArgs { /// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>` AngleBracketed(AngleBracketedArgs), @@ -158,14 +158,14 @@ impl GenericArgs { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum GenericArg { Lifetime(Lifetime), Type(P<Ty>), } /// A path like `Foo<'a, T>` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Default)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Default)] pub struct AngleBracketedArgs { /// Overall span pub span: Span, @@ -190,7 +190,7 @@ impl Into<Option<P<GenericArgs>>> for ParenthesisedArgs { } /// A path like `Foo(A,B) -> C` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ParenthesisedArgs { /// Overall span pub span: Span, @@ -202,7 +202,7 @@ pub struct ParenthesisedArgs { pub output: Option<P<Ty>>, } -#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] pub struct NodeId(u32); impl NodeId { @@ -270,7 +270,7 @@ pub const DUMMY_NODE_ID: NodeId = NodeId(!0); /// A modifier on a bound, currently this is only used for `?Sized`, where the /// modifier is `Maybe`. Negative bounds should also be handled here. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)] pub enum TraitBoundModifier { None, Maybe, @@ -280,7 +280,7 @@ pub enum TraitBoundModifier { /// typeck::collect::compute_bounds matches these against /// the "special" built-in traits (see middle::lang_items) and /// detects Copy, Send and Sync. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum GenericBound { Trait(PolyTraitRef, TraitBoundModifier), Outlives(Lifetime) @@ -297,7 +297,7 @@ impl GenericBound { pub type GenericBounds = Vec<GenericBound>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum GenericParamKind { /// A lifetime definition, e.g. `'a: 'b+'c+'d`. Lifetime, @@ -306,7 +306,7 @@ pub enum GenericParamKind { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct GenericParam { pub id: NodeId, pub ident: Ident, @@ -318,7 +318,7 @@ pub struct GenericParam { /// Represents lifetime, type and const parameters attached to a declaration of /// a function, enum, trait, etc. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Generics { pub params: Vec<GenericParam>, pub where_clause: WhereClause, @@ -341,7 +341,7 @@ impl Default for Generics { } /// A `where` clause in a definition -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereClause { pub id: NodeId, pub predicates: Vec<WherePredicate>, @@ -349,7 +349,7 @@ pub struct WhereClause { } /// A single predicate in a `where` clause -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum WherePredicate { /// A type binding, e.g. `for<'c> Foo: Send+Clone+'c` BoundPredicate(WhereBoundPredicate), @@ -372,7 +372,7 @@ impl WherePredicate { /// A type bound. /// /// E.g. `for<'c> Foo: Send+Clone+'c` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereBoundPredicate { pub span: Span, /// Any generics from a `for` binding @@ -386,7 +386,7 @@ pub struct WhereBoundPredicate { /// A lifetime predicate. /// /// E.g. `'a: 'b+'c` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereRegionPredicate { pub span: Span, pub lifetime: Lifetime, @@ -396,7 +396,7 @@ pub struct WhereRegionPredicate { /// An equality predicate (unsupported). /// /// E.g. `T=int` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereEqPredicate { pub id: NodeId, pub span: Span, @@ -408,7 +408,7 @@ pub struct WhereEqPredicate { /// used to drive conditional compilation pub type CrateConfig = HashSet<(Name, Option<Symbol>)>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Crate { pub module: Mod, pub attrs: Vec<Attribute>, @@ -421,7 +421,7 @@ pub type NestedMetaItem = Spanned<NestedMetaItemKind>; /// Possible values inside of compile-time attribute lists. /// /// E.g. the '..' in `#[name(..)]`. -#[derive(Clone, Eq, RustcEncodable, RustcDecodable, Hash, Debug, PartialEq)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum NestedMetaItemKind { /// A full MetaItem, for recursive meta items. MetaItem(MetaItem), @@ -434,7 +434,7 @@ pub enum NestedMetaItemKind { /// A spanned compile-time attribute item. /// /// E.g. `#[test]`, `#[derive(..)]`, `#[rustfmt::skip]` or `#[feature = "foo"]` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct MetaItem { pub ident: Path, pub node: MetaItemKind, @@ -444,7 +444,7 @@ pub struct MetaItem { /// A compile-time attribute item. /// /// E.g. `#[test]`, `#[derive(..)]` or `#[feature = "foo"]` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum MetaItemKind { /// Word meta item. /// @@ -463,7 +463,7 @@ pub enum MetaItemKind { /// A Block (`{ .. }`). /// /// E.g. `{ .. }` as in `fn foo() { .. }` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Block { /// Statements in a block pub stmts: Vec<Stmt>, @@ -474,7 +474,7 @@ pub struct Block { pub recovered: bool, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Pat { pub id: NodeId, pub node: PatKind, @@ -552,7 +552,7 @@ impl Pat { /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` /// are treated the same as` x: x, y: ref y, z: ref mut z`, /// except is_shorthand is true -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct FieldPat { /// The identifier for the field pub ident: Ident, @@ -562,25 +562,25 @@ pub struct FieldPat { pub attrs: ThinVec<Attribute>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum BindingMode { ByRef(Mutability), ByValue(Mutability), } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum RangeEnd { Included(RangeSyntax), Excluded, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum RangeSyntax { DotDotDot, DotDotEq, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum PatKind { /// Represents a wildcard pattern (`_`) Wild, @@ -627,13 +627,13 @@ pub enum PatKind { Mac(Mac), } -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum Mutability { Mutable, Immutable, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum BinOpKind { /// The `+` operator (addition) Add, @@ -730,7 +730,7 @@ impl BinOpKind { pub type BinOp = Spanned<BinOpKind>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum UnOp { /// The `*` operator for dereferencing Deref, @@ -759,7 +759,7 @@ impl UnOp { } /// A statement -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Stmt { pub id: NodeId, pub node: StmtKind, @@ -800,7 +800,7 @@ impl fmt::Debug for Stmt { } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub enum StmtKind { /// A local (let) binding. Local(P<Local>), @@ -816,7 +816,7 @@ pub enum StmtKind { Mac(P<(Mac, MacStmtStyle, ThinVec<Attribute>)>), } -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum MacStmtStyle { /// The macro statement had a trailing semicolon, e.g. `foo! { ... };` /// `foo!(...);`, `foo![...];` @@ -830,7 +830,7 @@ pub enum MacStmtStyle { } /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Local { pub pat: P<Pat>, pub ty: Option<P<Ty>>, @@ -851,7 +851,7 @@ pub struct Local { /// _ => { println!("no match!") }, /// } /// ``` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Arm { pub attrs: Vec<Attribute>, pub pats: Vec<P<Pat>>, @@ -859,7 +859,7 @@ pub struct Arm { pub body: P<Expr>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Field { pub ident: Ident, pub expr: P<Expr>, @@ -868,13 +868,15 @@ pub struct Field { pub attrs: ThinVec<Attribute>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +pub type SpannedIdent = Spanned<Ident>; + +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum BlockCheckMode { Default, Unsafe(UnsafeSource), } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum UnsafeSource { CompilerGenerated, UserProvided, @@ -885,7 +887,7 @@ pub enum UnsafeSource { /// These are usually found nested inside types (e.g. array lengths) /// or expressions (e.g. repeat counts), and also used to define /// explicit discriminant values for enum variants. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct AnonConst { pub id: NodeId, pub value: P<Expr>, @@ -893,7 +895,7 @@ pub struct AnonConst { /// An expression -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash,)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Expr { pub id: NodeId, pub node: ExprKind, @@ -1016,7 +1018,7 @@ impl fmt::Debug for Expr { } /// Limit types of a range (inclusive or exclusive) -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum RangeLimits { /// Inclusive at the beginning, exclusive at the end HalfOpen, @@ -1024,7 +1026,7 @@ pub enum RangeLimits { Closed, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ExprKind { /// A `box x` expression. Box(P<Expr>), @@ -1181,7 +1183,7 @@ pub enum ExprKind { /// ^~~~~ ^ /// ty position = 0 /// ``` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct QSelf { pub ty: P<Ty>, @@ -1193,14 +1195,14 @@ pub struct QSelf { } /// A capture clause -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum CaptureBy { Value, Ref, } /// The movability of a generator / closure literal -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum Movability { Static, Movable, @@ -1214,14 +1216,14 @@ pub type Mac = Spanned<Mac_>; /// /// NB: the additional ident for a macro_rules-style macro is actually /// stored in the enclosing item. Oog. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Mac_ { pub path: Path, pub delim: MacDelimiter, pub tts: ThinTokenStream, } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)] pub enum MacDelimiter { Parenthesis, Bracket, @@ -1234,7 +1236,7 @@ impl Mac_ { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct MacroDef { pub tokens: ThinTokenStream, pub legacy: bool, @@ -1246,7 +1248,7 @@ impl MacroDef { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum StrStyle { /// A regular string, like `"foo"` Cooked, @@ -1259,7 +1261,7 @@ pub enum StrStyle { /// A literal pub type Lit = Spanned<LitKind>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum LitIntType { Signed(IntTy), Unsigned(UintTy), @@ -1269,7 +1271,7 @@ pub enum LitIntType { /// Literal kind. /// /// E.g. `"foo"`, `42`, `12.34` or `bool` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum LitKind { /// A string literal (`"foo"`) Str(Symbol, StrStyle), @@ -1335,7 +1337,7 @@ impl LitKind { // NB: If you change this, you'll probably want to change the corresponding // type structure in middle/ty.rs as well. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct MutTy { pub ty: P<Ty>, pub mutbl: Mutability, @@ -1343,7 +1345,7 @@ pub struct MutTy { /// Represents a method's signature in a trait declaration, /// or in an implementation. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct MethodSig { pub header: FnHeader, pub decl: P<FnDecl>, @@ -1353,7 +1355,7 @@ pub struct MethodSig { /// possibly including a default implementation. A trait item is /// either required (meaning it doesn't have an implementation, just a /// signature) or provided (meaning it has a default implementation). -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct TraitItem { pub id: NodeId, pub ident: Ident, @@ -1365,7 +1367,7 @@ pub struct TraitItem { pub tokens: Option<TokenStream>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum TraitItemKind { Const(P<Ty>, Option<P<Expr>>), Method(MethodSig, Option<P<Block>>), @@ -1373,7 +1375,7 @@ pub enum TraitItemKind { Macro(Mac), } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ImplItem { pub id: NodeId, pub ident: Ident, @@ -1387,7 +1389,7 @@ pub struct ImplItem { pub tokens: Option<TokenStream>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ImplItemKind { Const(P<Ty>, P<Expr>), Method(MethodSig, P<Block>), @@ -1395,8 +1397,7 @@ pub enum ImplItemKind { Macro(Mac), } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy, - PartialOrd, Ord)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Copy)] pub enum IntTy { Isize, I8, @@ -1449,8 +1450,7 @@ impl IntTy { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy, - PartialOrd, Ord)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Copy)] pub enum UintTy { Usize, U8, @@ -1501,7 +1501,7 @@ impl fmt::Display for UintTy { } // Bind a type to an associated type: `A=Foo`. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct TypeBinding { pub id: NodeId, pub ident: Ident, @@ -1509,7 +1509,7 @@ pub struct TypeBinding { pub span: Span, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Ty { pub id: NodeId, pub node: TyKind, @@ -1522,7 +1522,7 @@ impl fmt::Debug for Ty { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct BareFnTy { pub unsafety: Unsafety, pub abi: Abi, @@ -1531,7 +1531,7 @@ pub struct BareFnTy { } /// The different kinds of types recognized by the compiler -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum TyKind { /// A variable-length slice (`[T]`) Slice(P<Ty>), @@ -1577,8 +1577,18 @@ pub enum TyKind { Err, } +impl TyKind { + pub fn is_implicit_self(&self) -> bool { + if let TyKind::ImplicitSelf = *self { true } else { false } + } + + crate fn is_unit(&self) -> bool { + if let TyKind::Tup(ref tys) = *self { tys.is_empty() } else { false } + } +} + /// Syntax used to declare a trait object. -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum TraitObjectSyntax { Dyn, None, @@ -1587,7 +1597,7 @@ pub enum TraitObjectSyntax { /// Inline assembly dialect. /// /// E.g. `"intel"` as in `asm!("mov eax, 2" : "={eax}"(result) : : : "intel")` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum AsmDialect { Att, Intel, @@ -1596,7 +1606,7 @@ pub enum AsmDialect { /// Inline assembly. /// /// E.g. `"={eax}"(result)` as in `asm!("mov eax, 2" : "={eax}"(result) : : : "intel")` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct InlineAsmOutput { pub constraint: Symbol, pub expr: P<Expr>, @@ -1607,7 +1617,7 @@ pub struct InlineAsmOutput { /// Inline assembly. /// /// E.g. `asm!("NOP");` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct InlineAsm { pub asm: Symbol, pub asm_str_style: StrStyle, @@ -1623,7 +1633,7 @@ pub struct InlineAsm { /// An argument in a function header. /// /// E.g. `bar: usize` as in `fn foo(bar: usize)` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Arg { pub ty: P<Ty>, pub pat: P<Pat>, @@ -1633,7 +1643,7 @@ pub struct Arg { /// Alternative representation for `Arg`s describing `self` parameter of methods. /// /// E.g. `&mut self` as in `fn foo(&mut self)` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum SelfKind { /// `self`, `mut self` Value(Mutability), @@ -1651,7 +1661,7 @@ impl Arg { if ident.name == keywords::SelfValue.name() { return match self.ty.node { TyKind::ImplicitSelf => Some(respan(self.pat.span, SelfKind::Value(mutbl))), - TyKind::Rptr(lt, MutTy{ref ty, mutbl}) if ty.node == TyKind::ImplicitSelf => { + TyKind::Rptr(lt, MutTy{ref ty, mutbl}) if ty.node.is_implicit_self() => { Some(respan(self.pat.span, SelfKind::Region(lt, mutbl))) } _ => Some(respan(self.pat.span.to(self.ty.span), @@ -1701,7 +1711,7 @@ impl Arg { /// Header (not the body) of a function declaration. /// /// E.g. `fn foo(bar: baz)` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct FnDecl { pub inputs: Vec<Arg>, pub output: FunctionRetTy, @@ -1718,19 +1728,19 @@ impl FnDecl { } /// Is the trait definition an auto trait? -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum IsAuto { Yes, No } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum Unsafety { Unsafe, Normal, } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] pub enum IsAsync { Async { closure_id: NodeId, @@ -1756,13 +1766,13 @@ impl IsAsync { } } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum Constness { Const, NotConst, } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub enum Defaultness { Default, Final, @@ -1777,7 +1787,7 @@ impl fmt::Display for Unsafety { } } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)] pub enum ImplPolarity { /// `impl Trait for Type` Positive, @@ -1795,7 +1805,7 @@ impl fmt::Debug for ImplPolarity { } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum FunctionRetTy { /// Return type is not specified. /// @@ -1819,7 +1829,7 @@ impl FunctionRetTy { /// Module declaration. /// /// E.g. `mod foo;` or `mod foo { .. }` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Mod { /// A span from the first token past `{` to the last token until `}`. /// For `mod foo;`, the inner span ranges from the first token @@ -1831,7 +1841,7 @@ pub struct Mod { /// Foreign module declaration. /// /// E.g. `extern { .. }` or `extern C { .. }` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ForeignMod { pub abi: Abi, pub items: Vec<ForeignItem>, @@ -1840,18 +1850,18 @@ pub struct ForeignMod { /// Global inline assembly /// /// aka module-level assembly or file-scoped assembly -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] pub struct GlobalAsm { pub asm: Symbol, pub ctxt: SyntaxContext, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct EnumDef { pub variants: Vec<Variant>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Variant_ { pub ident: Ident, pub attrs: Vec<Attribute>, @@ -1863,7 +1873,7 @@ pub struct Variant_ { pub type Variant = Spanned<Variant_>; /// Part of `use` item to the right of its prefix. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum UseTreeKind { /// `use prefix` or `use prefix as rename` /// @@ -1878,7 +1888,7 @@ pub enum UseTreeKind { /// A tree of paths sharing common prefixes. /// Used in `use` items both at top-level and inside of braces in import groups. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct UseTree { pub prefix: Path, pub kind: UseTreeKind, @@ -1899,7 +1909,7 @@ impl UseTree { /// Distinguishes between Attributes that decorate items and Attributes that /// are contained as statements within items. These two cases need to be /// distinguished for pretty-printing. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] pub enum AttrStyle { Outer, Inner, @@ -1910,7 +1920,7 @@ pub struct AttrId(pub usize); /// Meta-data associated with an item /// Doc-comments are promoted to attributes that have is_sugared_doc = true -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Attribute { pub id: AttrId, pub style: AttrStyle, @@ -1926,13 +1936,13 @@ pub struct Attribute { /// that the ref_id is for. The impl_id maps to the "self type" of this impl. /// If this impl is an ItemKind::Impl, the impl_id is redundant (it could be the /// same as the impl's node id). -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct TraitRef { pub path: Path, pub ref_id: NodeId, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct PolyTraitRef { /// The `'a` in `<'a> Foo<&'a T>` pub bound_generic_params: Vec<GenericParam>, @@ -1953,7 +1963,7 @@ impl PolyTraitRef { } } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] pub enum CrateSugar { /// Source is `pub(crate)` PubCrate, @@ -1964,7 +1974,7 @@ pub enum CrateSugar { pub type Visibility = Spanned<VisibilityKind>; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum VisibilityKind { Public, Crate(CrateSugar), @@ -1972,10 +1982,16 @@ pub enum VisibilityKind { Inherited, } +impl VisibilityKind { + pub fn is_pub(&self) -> bool { + if let VisibilityKind::Public = *self { true } else { false } + } +} + /// Field of a struct. /// /// E.g. `bar: usize` as in `struct Foo { bar: usize }` -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct StructField { pub span: Span, pub ident: Option<Ident>, @@ -1996,7 +2012,7 @@ pub struct StructField { /// used for `Struct`-structs (but still presents). Structures don't have an analogue of "Id of /// the variant itself" from enum variants. /// Id of the whole struct lives in `Item`. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum VariantData { /// Struct variant. /// @@ -2038,7 +2054,7 @@ impl VariantData { /// An item /// /// The name might be a dummy name in case of anonymous items -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Item { pub ident: Ident, pub attrs: Vec<Attribute>, @@ -2061,7 +2077,7 @@ pub struct Item { /// /// All the information between the visibility & the name of the function is /// included in this struct (e.g. `async unsafe fn` or `const extern "C" fn`) -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)] pub struct FnHeader { pub unsafety: Unsafety, pub asyncness: IsAsync, @@ -2080,7 +2096,7 @@ impl Default for FnHeader { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ItemKind { /// An `extern crate` item, with optional *original* crate name if the crate was renamed. /// @@ -2179,7 +2195,7 @@ impl ItemKind { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct ForeignItem { pub ident: Ident, pub attrs: Vec<Attribute>, @@ -2190,7 +2206,7 @@ pub struct ForeignItem { } /// An item within an `extern` block -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ForeignItemKind { /// A foreign function Fn(P<FnDecl>, Generics), diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index e49a521040f..38ddb501085 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -725,7 +725,7 @@ pub trait Resolver { fn check_unused_macros(&self); } -#[derive(Copy, Clone, Debug, PartialEq)] +#[derive(Copy, Clone, PartialEq, Debug)] pub enum Determinacy { Determined, Undetermined, diff --git a/src/libsyntax/ext/tt/quoted.rs b/src/libsyntax/ext/tt/quoted.rs index 82b0fae3e9c..d21ffabb62e 100644 --- a/src/libsyntax/ext/tt/quoted.rs +++ b/src/libsyntax/ext/tt/quoted.rs @@ -22,7 +22,7 @@ use rustc_data_structures::sync::Lrc; /// Contains the sub-token-trees of a "delimited" token tree, such as the contents of `(`. Note /// that the delimiter itself might be `NoDelim`. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub struct Delimited { pub delim: token::DelimToken, pub tts: Vec<TokenTree>, @@ -60,7 +60,7 @@ impl Delimited { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub struct SequenceRepetition { /// The sequence of token trees pub tts: Vec<TokenTree>, @@ -74,7 +74,7 @@ pub struct SequenceRepetition { /// A Kleene-style [repetition operator](http://en.wikipedia.org/wiki/Kleene_star) /// for token sequences. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum KleeneOp { /// Kleene star (`*`) for zero or more repetitions ZeroOrMore, @@ -85,7 +85,7 @@ pub enum KleeneOp { /// Similar to `tokenstream::TokenTree`, except that `$i`, `$i:ident`, and `$(...)` /// are "first-class" token trees. Useful for parsing macros. -#[derive(Debug, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Debug, Clone, PartialEq, RustcEncodable, RustcDecodable)] pub enum TokenTree { Token(Span, token::Token), Delimited(Span, Lrc<Delimited>), diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 50b2ac3369c..f033c5006c5 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -632,7 +632,7 @@ declare_features! ( // move that documentation into the relevant place in the other docs, and // remove the chapter on the flag. -#[derive(PartialEq, Copy, Clone, Debug)] +#[derive(Copy, Clone, PartialEq, Debug)] pub enum AttributeType { /// Normal, builtin attribute that is consumed /// by the compiler before the unused_attribute check @@ -665,7 +665,7 @@ impl AttributeGate { } } -#[derive(Copy, Clone, PartialEq, Eq, Debug)] +#[derive(Copy, Clone, Debug)] pub enum Stability { Unstable, // Argument is tracking issue link. @@ -1113,7 +1113,7 @@ const GATED_CFGS: &[(&str, &str, fn(&Features) -> bool)] = &[ ("target_has_atomic", "cfg_target_has_atomic", cfg_fn!(cfg_target_has_atomic)), ]; -#[derive(Debug, Eq, PartialEq)] +#[derive(Debug)] pub struct GatedCfg { span: Span, index: usize, @@ -1272,7 +1272,7 @@ pub enum GateIssue { Library(Option<u32>) } -#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[derive(Debug, Copy, Clone, PartialEq)] pub enum GateStrength { /// A hard error. (Most feature gates should use this.) Hard, @@ -1704,7 +1704,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { fn visit_fn_ret_ty(&mut self, ret_ty: &'a ast::FunctionRetTy) { if let ast::FunctionRetTy::Ty(ref output_ty) = *ret_ty { - if output_ty.node != ast::TyKind::Never { + if let ast::TyKind::Never = output_ty.node { + // Do nothing + } else { self.visit_ty(output_ty) } } @@ -2046,7 +2048,7 @@ pub fn check_crate(krate: &ast::Crate, visit::walk_crate(visitor, krate); } -#[derive(Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Clone, Copy, Hash)] pub enum UnstableFeatures { /// Hard errors for unstable features are active, as on /// beta/stable channels. diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 9919d910fbc..4d59f64bb6b 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -16,7 +16,7 @@ use parse::token::{self, Nonterminal}; use parse::parser::{Parser, TokenType, PathStyle}; use tokenstream::TokenStream; -#[derive(PartialEq, Eq, Debug)] +#[derive(Debug)] enum InnerAttributeParsePolicy<'a> { Permitted, NotPermitted { reason: &'a str }, @@ -94,7 +94,7 @@ impl<'a> Parser<'a> { let lo = self.span; self.bump(); - if inner_parse_policy == InnerAttributeParsePolicy::Permitted { + if let InnerAttributeParsePolicy::Permitted = inner_parse_policy { self.expected_tokens.push(TokenType::Token(token::Not)); } let style = if self.token == token::Not { diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index dcc71e78778..bf790e6143a 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -26,7 +26,7 @@ pub mod comments; mod tokentrees; mod unicode_chars; -#[derive(Clone, PartialEq, Eq, Debug)] +#[derive(Clone, Debug)] pub struct TokenAndSpan { pub tok: token::Token, pub sp: Span, @@ -1842,7 +1842,8 @@ mod tests { tok: token::Ident(id, false), sp: Span::new(BytePos(21), BytePos(23), NO_EXPANSION), }; - assert_eq!(tok1, tok2); + assert_eq!(tok1.tok, tok2.tok); + assert_eq!(tok1.sp, tok2.sp); assert_eq!(string_reader.next_token().tok, token::Whitespace); // the 'main' id is already read: assert_eq!(string_reader.pos.clone(), BytePos(28)); @@ -1852,7 +1853,8 @@ mod tests { tok: mk_ident("main"), sp: Span::new(BytePos(24), BytePos(28), NO_EXPANSION), }; - assert_eq!(tok3, tok4); + assert_eq!(tok3.tok, tok4.tok); + assert_eq!(tok3.sp, tok4.sp); // the lparen is already read: assert_eq!(string_reader.pos.clone(), BytePos(29)) }) diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index c443f240780..1754e5f1b9a 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -673,22 +673,40 @@ fn integer_lit(s: &str, suffix: Option<Symbol>, diag: Option<(Span, &Handler)>) }) } +/// `SeqSep` : a sequence separator (token) +/// and whether a trailing separator is allowed. +pub struct SeqSep { + pub sep: Option<token::Token>, + pub trailing_sep_allowed: bool, +} + +impl SeqSep { + pub fn trailing_allowed(t: token::Token) -> SeqSep { + SeqSep { + sep: Some(t), + trailing_sep_allowed: true, + } + } + + pub fn none() -> SeqSep { + SeqSep { + sep: None, + trailing_sep_allowed: false, + } + } +} + #[cfg(test)] mod tests { use super::*; - use syntax_pos::{self, Span, BytePos, Pos, NO_EXPANSION}; - use codemap::{respan, Spanned}; + use syntax_pos::{Span, BytePos, Pos, NO_EXPANSION}; use ast::{self, Ident, PatKind}; - use rustc_target::spec::abi::Abi; use attr::first_attr_value_str_by_name; use parse; - use parse::parser::Parser; use print::pprust::item_to_string; - use ptr::P; use tokenstream::{self, TokenTree}; - use util::parser_testing::{string_to_stream, string_to_parser}; - use util::parser_testing::{string_to_expr, string_to_item, string_to_stmt}; - use util::ThinVec; + use util::parser_testing::string_to_stream; + use util::parser_testing::{string_to_expr, string_to_item}; use with_globals; // produce a syntax_pos::span @@ -696,42 +714,6 @@ mod tests { Span::new(BytePos(a), BytePos(b), NO_EXPANSION) } - fn str2seg(s: &str, lo: u32, hi: u32) -> ast::PathSegment { - ast::PathSegment::from_ident(Ident::new(Symbol::intern(s), sp(lo, hi))) - } - - #[test] fn path_exprs_1() { - with_globals(|| { - assert!(string_to_expr("a".to_string()) == - P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, ast::Path { - span: sp(0, 1), - segments: vec![str2seg("a", 0, 1)], - }), - span: sp(0, 1), - attrs: ThinVec::new(), - })) - }) - } - - #[test] fn path_exprs_2 () { - with_globals(|| { - assert!(string_to_expr("::a::b".to_string()) == - P(ast::Expr { - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, ast::Path { - span: sp(0, 6), - segments: vec![ast::PathSegment::crate_root(sp(0, 0)), - str2seg("a", 2, 3), - str2seg("b", 5, 6)] - }), - span: sp(0, 6), - attrs: ThinVec::new(), - })) - }) - } - #[should_panic] #[test] fn bad_path_expr_1() { with_globals(|| { @@ -832,143 +814,6 @@ mod tests { }) } - #[test] fn ret_expr() { - with_globals(|| { - assert!(string_to_expr("return d".to_string()) == - P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node:ast::ExprKind::Ret(Some(P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node:ast::ExprKind::Path(None, ast::Path{ - span: sp(7, 8), - segments: vec![str2seg("d", 7, 8)], - }), - span:sp(7,8), - attrs: ThinVec::new(), - }))), - span:sp(0,8), - attrs: ThinVec::new(), - })) - }) - } - - #[test] fn parse_stmt_1 () { - with_globals(|| { - assert!(string_to_stmt("b;".to_string()) == - Some(ast::Stmt { - node: ast::StmtKind::Expr(P(ast::Expr { - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, ast::Path { - span:sp(0,1), - segments: vec![str2seg("b", 0, 1)], - }), - span: sp(0,1), - attrs: ThinVec::new()})), - id: ast::DUMMY_NODE_ID, - span: sp(0,1)})) - }) - } - - fn parser_done(p: Parser){ - assert_eq!(p.token.clone(), token::Eof); - } - - #[test] fn parse_ident_pat () { - with_globals(|| { - let sess = ParseSess::new(FilePathMapping::empty()); - let mut parser = string_to_parser(&sess, "b".to_string()); - assert!(panictry!(parser.parse_pat()) - == P(ast::Pat{ - id: ast::DUMMY_NODE_ID, - node: PatKind::Ident(ast::BindingMode::ByValue(ast::Mutability::Immutable), - Ident::new(Symbol::intern("b"), sp(0, 1)), - None), - span: sp(0,1)})); - parser_done(parser); - }) - } - - // check the contents of the tt manually: - #[test] fn parse_fundecl () { - with_globals(|| { - // this test depends on the intern order of "fn" and "i32" - let item = string_to_item("fn a (b : i32) { b; }".to_string()).map(|m| { - m.map(|mut m| { - m.tokens = None; - m - }) - }); - assert_eq!(item, - Some( - P(ast::Item{ident:Ident::from_str("a"), - attrs:Vec::new(), - id: ast::DUMMY_NODE_ID, - tokens: None, - node: ast::ItemKind::Fn(P(ast::FnDecl { - inputs: vec![ast::Arg{ - ty: P(ast::Ty{id: ast::DUMMY_NODE_ID, - node: ast::TyKind::Path(None, ast::Path{ - span:sp(10,13), - segments: vec![str2seg("i32", 10, 13)], - }), - span:sp(10,13) - }), - pat: P(ast::Pat { - id: ast::DUMMY_NODE_ID, - node: PatKind::Ident( - ast::BindingMode::ByValue( - ast::Mutability::Immutable), - Ident::new(Symbol::intern("b"), sp(6, 7)), - None - ), - span: sp(6,7) - }), - id: ast::DUMMY_NODE_ID - }], - output: ast::FunctionRetTy::Default(sp(15, 15)), - variadic: false - }), - ast::FnHeader { - unsafety: ast::Unsafety::Normal, - asyncness: ast::IsAsync::NotAsync, - constness: Spanned { - span: sp(0,2), - node: ast::Constness::NotConst, - }, - abi: Abi::Rust, - }, - ast::Generics{ - params: Vec::new(), - where_clause: ast::WhereClause { - id: ast::DUMMY_NODE_ID, - predicates: Vec::new(), - span: syntax_pos::DUMMY_SP, - }, - span: syntax_pos::DUMMY_SP, - }, - P(ast::Block { - stmts: vec![ast::Stmt { - node: ast::StmtKind::Semi(P(ast::Expr{ - id: ast::DUMMY_NODE_ID, - node: ast::ExprKind::Path(None, - ast::Path{ - span:sp(17,18), - segments: vec![str2seg("b", 17, 18)], - }), - span: sp(17,18), - attrs: ThinVec::new()})), - id: ast::DUMMY_NODE_ID, - span: sp(17,19)}], - id: ast::DUMMY_NODE_ID, - rules: ast::BlockCheckMode::Default, // no idea - span: sp(15,21), - recovered: false, - })), - vis: respan(sp(0, 0), ast::VisibilityKind::Inherited), - span: sp(0,21)}))); - }) - } - #[test] fn parse_use() { with_globals(|| { let use_s = "use foo::bar::baz;"; @@ -1133,26 +978,3 @@ mod tests { }); } } - -/// `SeqSep` : a sequence separator (token) -/// and whether a trailing separator is allowed. -pub struct SeqSep { - pub sep: Option<token::Token>, - pub trailing_sep_allowed: bool, -} - -impl SeqSep { - pub fn trailing_allowed(t: token::Token) -> SeqSep { - SeqSep { - sep: Some(t), - trailing_sep_allowed: true, - } - } - - pub fn none() -> SeqSep { - SeqSep { - sep: None, - trailing_sep_allowed: false, - } - } -} diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index a1b78a23b8f..62bb5fbd04f 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -95,13 +95,13 @@ pub enum PathStyle { Mod, } -#[derive(Clone, Copy, Debug, PartialEq)] +#[derive(Clone, Copy, PartialEq, Debug)] enum SemiColonMode { Break, Ignore, } -#[derive(Clone, Copy, Debug, PartialEq)] +#[derive(Clone, Copy, PartialEq, Debug)] enum BlockMode { Break, Ignore, @@ -376,7 +376,7 @@ impl TokenCursor { } } -#[derive(PartialEq, Eq, Clone)] +#[derive(Clone, PartialEq)] crate enum TokenType { Token(token::Token), Keyword(keywords::Keyword), @@ -522,7 +522,7 @@ fn dummy_arg(span: Span) -> Arg { Arg { ty: P(ty), pat: pat, id: ast::DUMMY_NODE_ID } } -#[derive(Copy, Clone, Debug, PartialEq, Eq)] +#[derive(Copy, Clone, Debug)] enum TokenExpectType { Expect, NoExpect, @@ -6999,7 +6999,7 @@ impl<'a> Parser<'a> { // Verify whether we have encountered a struct or method definition where the user forgot to // add the `struct` or `fn` keyword after writing `pub`: `pub S {}` - if visibility.node == VisibilityKind::Public && + if visibility.node.is_pub() && self.check_ident() && self.look_ahead(1, |t| *t != token::Not) { diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 7ea047d332b..aef3beeccdf 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -30,7 +30,7 @@ use std::{cmp, fmt}; use std::mem; use rustc_data_structures::sync::{Lrc, Lock}; -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum BinOpToken { Plus, Minus, @@ -45,7 +45,7 @@ pub enum BinOpToken { } /// A delimiter token -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum DelimToken { /// A round parenthesis: `(` or `)` Paren, @@ -67,7 +67,7 @@ impl DelimToken { } } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum Lit { Byte(ast::Name), Char(ast::Name), @@ -139,7 +139,7 @@ fn ident_can_begin_type(ident: ast::Ident, is_raw: bool) -> bool { ].contains(&ident.name) } -#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug)] +#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)] pub enum Token { /* Expression-operator symbols. */ Eq, @@ -638,7 +638,7 @@ impl Token { } } -#[derive(Clone, RustcEncodable, RustcDecodable, Eq, Hash)] +#[derive(Clone, RustcEncodable, RustcDecodable)] /// For interpolation during macro expansion. pub enum Nonterminal { NtItem(P<ast::Item>), diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index c5ba7daaeb8..b0a9003a456 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -2641,7 +2641,9 @@ impl<'a> State<'a> { |s, p| s.print_pat(p))?; if let Some(ref p) = *slice { if !before.is_empty() { self.word_space(",")?; } - if p.node != PatKind::Wild { + if let PatKind::Wild = p.node { + // Print nothing + } else { self.print_pat(p)?; } self.s.word("..")?; diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs index 25d916af77d..b86d19ba3ce 100644 --- a/src/libsyntax/ptr.rs +++ b/src/libsyntax/ptr.rs @@ -46,7 +46,7 @@ use serialize::{Encodable, Decodable, Encoder, Decoder}; use rustc_data_structures::stable_hasher::{StableHasher, StableHasherResult, HashStable}; /// An owned smart pointer. -#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Hash, PartialEq, Eq)] pub struct P<T: ?Sized> { ptr: Box<T> } diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index 4d5b0b327dd..d8b8d13a38c 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -329,7 +329,6 @@ fn ignored_span(cx: &TestCtxt, sp: Span) -> Span { sp.with_ctxt(cx.ctxt) } -#[derive(PartialEq)] enum HasTestSignature { Yes, No(BadTestSignature), @@ -354,7 +353,7 @@ fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool { // type implements the `Termination` trait as `libtest` enforces that. let has_output = match decl.output { ast::FunctionRetTy::Default(..) => false, - ast::FunctionRetTy::Ty(ref t) if t.node == ast::TyKind::Tup(vec![]) => false, + ast::FunctionRetTy::Ty(ref t) if t.node.is_unit() => false, _ => true }; diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs index 8736fcf9729..048a041f698 100644 --- a/src/libsyntax/tokenstream.rs +++ b/src/libsyntax/tokenstream.rs @@ -33,10 +33,9 @@ use util::RcSlice; use std::borrow::Cow; use std::{fmt, iter, mem}; -use std::hash::{self, Hash}; /// A delimited sequence of token trees -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] pub struct Delimited { /// The type of delimiter pub delim: token::DelimToken, @@ -93,7 +92,7 @@ impl Delimited { /// /// The RHS of an MBE macro is the only place `SubstNt`s are substituted. /// Nothing special happens to misnamed or misplaced `SubstNt`s. -#[derive(Debug, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] +#[derive(Debug, Clone, PartialEq, RustcEncodable, RustcDecodable)] pub enum TokenTree { /// A single token Token(Span, token::Token), @@ -605,14 +604,6 @@ impl Decodable for TokenStream { } } -impl Hash for TokenStream { - fn hash<H: hash::Hasher>(&self, state: &mut H) { - for tree in self.trees() { - tree.hash(state); - } - } -} - impl Encodable for ThinTokenStream { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), E::Error> { TokenStream::from(self.clone()).encode(encoder) @@ -625,13 +616,6 @@ impl Decodable for ThinTokenStream { } } -impl Hash for ThinTokenStream { - fn hash<H: hash::Hasher>(&self, state: &mut H) { - TokenStream::from(self.clone()).hash(state); - } -} - - #[cfg(test)] mod tests { use super::*; diff --git a/src/libsyntax/util/parser.rs b/src/libsyntax/util/parser.rs index 15d910b33b0..67bc6f947b5 100644 --- a/src/libsyntax/util/parser.rs +++ b/src/libsyntax/util/parser.rs @@ -11,12 +11,10 @@ use parse::token::{Token, BinOpToken}; use symbol::keywords; use ast::{self, BinOpKind}; -use std::cmp::Ordering; - /// Associative operator with precedence. /// /// This is the enum which specifies operator precedence and fixity to the parser. -#[derive(Debug, PartialEq, Eq)] +#[derive(PartialEq, Debug)] pub enum AssocOp { /// `+` Add, @@ -70,7 +68,7 @@ pub enum AssocOp { Colon, } -#[derive(Debug, PartialEq, Eq)] +#[derive(PartialEq, Debug)] pub enum Fixity { /// The operator is left-associative Left, @@ -230,7 +228,7 @@ pub const PREC_POSTFIX: i8 = 60; pub const PREC_PAREN: i8 = 99; pub const PREC_FORCE_PAREN: i8 = 100; -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, Copy)] pub enum ExprPrecedence { Closure, Break, @@ -280,18 +278,6 @@ pub enum ExprPrecedence { Async, } -impl PartialOrd for ExprPrecedence { - fn partial_cmp(&self, other: &Self) -> Option<Ordering> { - Some(self.order().cmp(&other.order())) - } -} - -impl Ord for ExprPrecedence { - fn cmp(&self, other: &Self) -> Ordering { - self.order().cmp(&other.order()) - } -} - impl ExprPrecedence { pub fn order(self) -> i8 { match self { diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs index 42cd7c8faa5..46b7f2d7bda 100644 --- a/src/libsyntax/util/parser_testing.rs +++ b/src/libsyntax/util/parser_testing.rs @@ -63,14 +63,6 @@ pub fn string_to_item (source_str : String) -> Option<P<ast::Item>> { }) } -/// Parse a string, return a stmt -pub fn string_to_stmt(source_str : String) -> Option<ast::Stmt> { - let ps = ParseSess::new(FilePathMapping::empty()); - with_error_checking_parse(source_str, &ps, |p| { - p.parse_stmt() - }) -} - /// Parse a string, return a pat. Uses "irrefutable"... which doesn't /// (currently) affect parsing. pub fn string_to_pat(source_str: String) -> P<ast::Pat> { diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index bb35bcee438..9211a2383b6 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -28,7 +28,7 @@ use syntax_pos::Span; use parse::token::Token; use tokenstream::{TokenTree, TokenStream}; -#[derive(Copy, Clone, PartialEq, Eq)] +#[derive(Copy, Clone)] pub enum FnKind<'a> { /// fn foo() or extern "Abi" fn foo() ItemFn(Ident, FnHeader, &'a Visibility, &'a Block), diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index aad69c109f9..a9f60fd053c 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -188,7 +188,6 @@ pub use self::StaticFields::*; pub use self::SubstructureFields::*; use std::cell::RefCell; -use std::collections::HashSet; use std::vec; use rustc_target::spec::abi::Abi; @@ -617,7 +616,6 @@ impl<'a> TraitDef<'a> { .map(|ty_param| ty_param.ident.name) .collect(); - let mut processed_field_types = HashSet::new(); for field_ty in field_tys { let tys = find_type_parameters(&field_ty, &ty_param_names, self.span, cx); @@ -625,11 +623,9 @@ impl<'a> TraitDef<'a> { // if we have already handled this type, skip it if let ast::TyKind::Path(_, ref p) = ty.node { if p.segments.len() == 1 && - ty_param_names.contains(&p.segments[0].ident.name) || - processed_field_types.contains(&p.segments) { + ty_param_names.contains(&p.segments[0].ident.name) { continue; }; - processed_field_types.insert(p.segments.clone()); } let mut bounds: Vec<_> = self.additional_bounds .iter() @@ -913,7 +909,7 @@ impl<'a> MethodDef<'a> { Self_ if nonstatic => { self_args.push(arg_expr); } - Ptr(ref ty, _) if **ty == Self_ && nonstatic => { + Ptr(ref ty, _) if (if let Self_ = **ty { true } else { false }) && nonstatic => { self_args.push(cx.expr_deref(trait_.span, arg_expr)) } _ => { diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs index 0b809ab585c..dcccb187bef 100644 --- a/src/libsyntax_ext/deriving/generic/ty.rs +++ b/src/libsyntax_ext/deriving/generic/ty.rs @@ -24,8 +24,7 @@ use syntax_pos::Span; use syntax_pos::symbol::keywords; /// The types of pointers -#[derive(Clone, Eq, PartialEq)] -#[allow(dead_code)] +#[derive(Clone)] pub enum PtrTy<'a> { /// &'lifetime mut Borrowed(Option<&'a str>, ast::Mutability), @@ -35,7 +34,7 @@ pub enum PtrTy<'a> { /// A path, e.g. `::std::option::Option::<i32>` (global). Has support /// for type parameters and a lifetime. -#[derive(Clone, Eq, PartialEq)] +#[derive(Clone)] pub struct Path<'a> { path: Vec<&'a str>, lifetime: Option<&'a str>, @@ -43,7 +42,7 @@ pub struct Path<'a> { kind: PathKind, } -#[derive(Clone, Eq, PartialEq)] +#[derive(Clone)] pub enum PathKind { Local, Global, @@ -107,7 +106,7 @@ impl<'a> Path<'a> { } /// A type. Supports pointers, Self, and literals -#[derive(Clone, Eq, PartialEq)] +#[derive(Clone)] pub enum Ty<'a> { Self_, /// &/Box/ Ty diff --git a/src/libsyntax_ext/format_foreign.rs b/src/libsyntax_ext/format_foreign.rs index 2393af76c34..ff9663cdd3c 100644 --- a/src/libsyntax_ext/format_foreign.rs +++ b/src/libsyntax_ext/format_foreign.rs @@ -12,7 +12,7 @@ pub mod printf { use super::strcursor::StrCursor as Cur; /// Represents a single `printf`-style substitution. - #[derive(Clone, Eq, PartialEq, Debug)] + #[derive(Clone, PartialEq, Debug)] pub enum Substitution<'a> { /// A formatted output substitution. Format(Format<'a>), @@ -40,7 +40,7 @@ pub mod printf { } } - #[derive(Clone, Eq, PartialEq, Debug)] + #[derive(Clone, PartialEq, Debug)] /// A single `printf`-style formatting directive. pub struct Format<'a> { /// The entire original formatting directive. @@ -213,7 +213,7 @@ pub mod printf { } /// A general number used in a `printf` formatting directive. - #[derive(Copy, Clone, Eq, PartialEq, Debug)] + #[derive(Copy, Clone, PartialEq, Debug)] pub enum Num { // The range of these values is technically bounded by `NL_ARGMAX`... but, at least for GNU // libc, it apparently has no real fixed limit. A `u16` is used here on the basis that it @@ -739,7 +739,7 @@ pub mod printf { pub mod shell { use super::strcursor::StrCursor as Cur; - #[derive(Clone, Eq, PartialEq, Debug)] + #[derive(Clone, PartialEq, Debug)] pub enum Substitution<'a> { Ordinal(u8), Name(&'a str), diff --git a/src/libsyntax_ext/proc_macro_registrar.rs b/src/libsyntax_ext/proc_macro_registrar.rs index ab2bb446631..2522fa769c5 100644 --- a/src/libsyntax_ext/proc_macro_registrar.rs +++ b/src/libsyntax_ext/proc_macro_registrar.rs @@ -101,9 +101,7 @@ fn is_proc_macro_attr(attr: &ast::Attribute) -> bool { impl<'a> CollectProcMacros<'a> { fn check_not_pub_in_root(&self, vis: &ast::Visibility, sp: Span) { - if self.is_proc_macro_crate && - self.in_root && - vis.node == ast::VisibilityKind::Public { + if self.is_proc_macro_crate && self.in_root && vis.node.is_pub() { self.handler.span_err(sp, "`proc-macro` crate types cannot \ export any items other than functions \ @@ -181,7 +179,7 @@ impl<'a> CollectProcMacros<'a> { Vec::new() }; - if self.in_root && item.vis.node == ast::VisibilityKind::Public { + if self.in_root && item.vis.node.is_pub() { self.derives.push(ProcMacroDerive { span: item.span, trait_name, @@ -206,7 +204,7 @@ impl<'a> CollectProcMacros<'a> { return; } - if self.in_root && item.vis.node == ast::VisibilityKind::Public { + if self.in_root && item.vis.node.is_pub() { self.attr_macros.push(ProcMacroDef { span: item.span, function_name: item.ident, @@ -229,7 +227,7 @@ impl<'a> CollectProcMacros<'a> { return; } - if self.in_root && item.vis.node == ast::VisibilityKind::Public { + if self.in_root && item.vis.node.is_pub() { self.bang_macros.push(ProcMacroDef { span: item.span, function_name: item.ident, @@ -271,7 +269,8 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> { for attr in &item.attrs { if is_proc_macro_attr(&attr) { if let Some(prev_attr) = found_attr { - let msg = if attr.path == prev_attr.path { + let msg = if attr.path.segments[0].ident.name == + prev_attr.path.segments[0].ident.name { format!("Only one `#[{}]` attribute is allowed on any given function", attr.path) } else { diff --git a/src/libsyntax_pos/edition.rs b/src/libsyntax_pos/edition.rs index 67cd9361ad5..fce8fc3db4e 100644 --- a/src/libsyntax_pos/edition.rs +++ b/src/libsyntax_pos/edition.rs @@ -12,7 +12,7 @@ use std::fmt; use std::str::FromStr; /// The edition of the compiler (RFC 2052) -#[derive(Clone, Copy, Hash, PartialOrd, Ord, Eq, PartialEq, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, Hash, PartialEq, PartialOrd, Debug, RustcEncodable, RustcDecodable)] #[non_exhaustive] pub enum Edition { // editions must be kept in order, oldest to newest diff --git a/src/test/run-pass-fulldeps/issue-35829.rs b/src/test/run-pass-fulldeps/issue-35829.rs deleted file mode 100644 index 798c214bc47..00000000000 --- a/src/test/run-pass-fulldeps/issue-35829.rs +++ /dev/null @@ -1,59 +0,0 @@ -// 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-stage1 -// ignore-cross-compile -#![feature(quote, rustc_private)] - -extern crate syntax; -extern crate rustc_data_structures; - -use syntax::ext::base::{ExtCtxt, DummyResolver}; -use syntax::ext::expand::ExpansionConfig; -use syntax::parse::ParseSess; -use syntax::codemap::{FilePathMapping, dummy_spanned}; -use syntax::print::pprust::expr_to_string; -use syntax::ast::{ExprKind, LitKind, RangeLimits}; -use syntax::ptr::P; - -use rustc_data_structures::sync::Lrc; - -fn main() { - syntax::with_globals(|| run()); -} - -fn run() { - let parse_sess = ParseSess::new(FilePathMapping::empty()); - let exp_cfg = ExpansionConfig::default("issue_35829".to_owned()); - let mut resolver = DummyResolver; - let cx = ExtCtxt::new(&parse_sess, exp_cfg, &mut resolver); - - // check byte string - let byte_string = quote_expr!(&cx, b"one"); - let byte_string_lit_kind = LitKind::ByteStr(Lrc::new(b"one".to_vec())); - assert_eq!(byte_string.node, ExprKind::Lit(P(dummy_spanned(byte_string_lit_kind)))); - - // check raw byte string - let raw_byte_string = quote_expr!(&cx, br###"#"two"#"###); - let raw_byte_string_lit_kind = LitKind::ByteStr(Lrc::new(b"#\"two\"#".to_vec())); - assert_eq!(raw_byte_string.node, ExprKind::Lit(P(dummy_spanned(raw_byte_string_lit_kind)))); - - // check dotdoteq - let closed_range = quote_expr!(&cx, 0 ..= 1); - assert_eq!(closed_range.node, ExprKind::Range( - Some(quote_expr!(&cx, 0)), - Some(quote_expr!(&cx, 1)), - RangeLimits::Closed - )); - - // test case from 35829 - let expr_35829 = quote_expr!(&cx, std::io::stdout().write(b"one")); - assert_eq!(expr_to_string(&expr_35829), r#"std::io::stdout().write(b"one")"#); -} |