Derive Hash for TokenStream

Author: Kobzol

compiler/rustc_ast/src/ast.rs

@@ -3243,7 +3243,7 @@ impl UseTree {
 /// Distinguishes between `Attribute`s 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, Encodable, Decodable, Debug, Copy, HashStable_Generic, Walkable)]
+#[derive(Clone, PartialEq, Encodable, Decodable, Hash, Debug, Copy, HashStable_Generic, Walkable)]
 pub enum AttrStyle {
     Outer,
     Inner,

compiler/rustc_ast/src/token.rs

@@ -15,14 +15,14 @@ use rustc_span::{Ident, Symbol};
 use crate::ast;
 use crate::util::case::Case;
 
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Hash, Encodable, Decodable, Debug, HashStable_Generic)]
 pub enum CommentKind {
     Line,
     Block,
 }
 
 // This type must not implement `Hash` due to the unusual `PartialEq` impl below.
-#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic)]
+#[derive(Copy, Clone, Debug, Hash, Encodable, Decodable, HashStable_Generic)]
 pub enum InvisibleOrigin {
     // From the expansion of a metavariable in a declarative macro.
     MetaVar(MetaVarKind),
@@ -113,7 +113,7 @@ impl fmt::Display for MetaVarKind {
 /// Describes how a sequence of token trees is delimited.
 /// Cannot use `proc_macro::Delimiter` directly because this
 /// structure should implement some additional traits.
-#[derive(Copy, Clone, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Copy, Clone, Debug, PartialEq, Hash, Encodable, Decodable, HashStable_Generic)]
 pub enum Delimiter {
     /// `( ... )`
     Parenthesis,
@@ -175,7 +175,7 @@ impl Delimiter {
 // type. This means that float literals like `1f32` are classified by this type
 // as `Int`. Only upon conversion to `ast::LitKind` will such a literal be
 // given the `Float` kind.
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Hash, Encodable, Decodable, Debug, HashStable_Generic)]
 pub enum LitKind {
     Bool, // AST only, must never appear in a `Token`
     Byte,
@@ -192,7 +192,7 @@ pub enum LitKind {
 }
 
 /// A literal token.
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Hash, Encodable, Decodable, Debug, HashStable_Generic)]
 pub struct Lit {
     pub kind: LitKind,
     pub symbol: Symbol,
@@ -338,7 +338,7 @@ fn ident_can_begin_type(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
             .contains(&name)
 }
 
-#[derive(PartialEq, Encodable, Decodable, Debug, Copy, Clone, HashStable_Generic)]
+#[derive(PartialEq, Encodable, Decodable, Hash, Debug, Copy, Clone, HashStable_Generic)]
 pub enum IdentIsRaw {
     No,
     Yes,
@@ -356,7 +356,7 @@ impl From<IdentIsRaw> for bool {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Hash, Encodable, Decodable, Debug, HashStable_Generic)]
 pub enum TokenKind {
     /* Expression-operator symbols. */
     /// `=`
@@ -506,7 +506,7 @@ pub enum TokenKind {
     Eof,
 }
 
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Hash, Encodable, Decodable, Debug, HashStable_Generic)]
 pub struct Token {
     pub kind: TokenKind,
     pub span: Span,

compiler/rustc_ast/src/tokenstream.rs

@@ -22,9 +22,8 @@ use std::{cmp, fmt, iter, mem};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync;
 use rustc_macros::{Decodable, Encodable, HashStable_Generic, Walkable};
-use rustc_serialize::{Decodable, Encodable, Encoder};
-use rustc_span::def_id::{CrateNum, DefIndex};
-use rustc_span::{ByteSymbol, DUMMY_SP, Span, SpanDecoder, SpanEncoder, Symbol, sym};
+use rustc_serialize::{Decodable, Encodable};
+use rustc_span::{DUMMY_SP, Span, SpanDecoder, SpanEncoder, Symbol, sym};
 use thin_vec::ThinVec;
 
 use crate::ast::AttrStyle;
@@ -33,7 +32,7 @@ use crate::token::{self, Delimiter, Token, TokenKind};
 use crate::{AttrVec, Attribute};
 
 /// Part of a `TokenStream`.
-#[derive(Debug, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Debug, Clone, PartialEq, Hash, Encodable, Decodable, HashStable_Generic)]
 pub enum TokenTree {
     /// A single token. Should never be `OpenDelim` or `CloseDelim`, because
     /// delimiters are implicitly represented by `Delimited`.
@@ -559,110 +558,14 @@ pub struct AttrsTarget {
 }
 
 /// A `TokenStream` is an abstract sequence of tokens, organized into [`TokenTree`]s.
-#[derive(Clone, Debug, Default, Encodable, Decodable)]
+#[derive(Clone, Debug, Default, Hash, Encodable, Decodable)]
 pub struct TokenStream(pub(crate) Arc<Vec<TokenTree>>);
 
-struct HashEncoder<H: std::hash::Hasher> {
-    hasher: H,
-}
-
-impl<H: std::hash::Hasher> Encoder for HashEncoder<H> {
-    fn emit_usize(&mut self, v: usize) {
-        self.hasher.write_usize(v)
-    }
-
-    fn emit_u128(&mut self, v: u128) {
-        self.hasher.write_u128(v)
-    }
-
-    fn emit_u64(&mut self, v: u64) {
-        self.hasher.write_u64(v)
-    }
-
-    fn emit_u32(&mut self, v: u32) {
-        self.hasher.write_u32(v)
-    }
-
-    fn emit_u16(&mut self, v: u16) {
-        self.hasher.write_u16(v)
-    }
-
-    fn emit_u8(&mut self, v: u8) {
-        self.hasher.write_u8(v)
-    }
-
-    fn emit_isize(&mut self, v: isize) {
-        self.hasher.write_isize(v)
-    }
-
-    fn emit_i128(&mut self, v: i128) {
-        self.hasher.write_i128(v)
-    }
-
-    fn emit_i64(&mut self, v: i64) {
-        self.hasher.write_i64(v)
-    }
-
-    fn emit_i32(&mut self, v: i32) {
-        self.hasher.write_i32(v)
-    }
-
-    fn emit_i16(&mut self, v: i16) {
-        self.hasher.write_i16(v)
-    }
-
-    fn emit_raw_bytes(&mut self, s: &[u8]) {
-        self.hasher.write(s)
-    }
-}
-
-impl<H: std::hash::Hasher> SpanEncoder for HashEncoder<H> {
-    fn encode_span(&mut self, span: Span) {
-        span.hash(&mut self.hasher)
-    }
-
-    fn encode_symbol(&mut self, symbol: Symbol) {
-        symbol.hash(&mut self.hasher)
-    }
-
-    fn encode_byte_symbol(&mut self, byte_sym: ByteSymbol) {
-        byte_sym.hash(&mut self.hasher);
-    }
-
-    fn encode_expn_id(&mut self, expn_id: rustc_span::ExpnId) {
-        expn_id.hash(&mut self.hasher)
-    }
-
-    fn encode_syntax_context(&mut self, syntax_context: rustc_span::SyntaxContext) {
-        syntax_context.hash(&mut self.hasher)
-    }
-
-    fn encode_crate_num(&mut self, crate_num: CrateNum) {
-        crate_num.hash(&mut self.hasher)
-    }
-
-    fn encode_def_index(&mut self, def_index: DefIndex) {
-        def_index.hash(&mut self.hasher)
-    }
-
-    fn encode_def_id(&mut self, def_id: rustc_span::def_id::DefId) {
-        def_id.hash(&mut self.hasher)
-    }
-}
-
-/// TokenStream needs to be hashable because it is used as a query key for caching derive macro
-/// expansions.
-impl Hash for TokenStream {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        Encodable::encode(self, &mut HashEncoder { hasher: state });
-    }
-}
-
 /// Indicates whether a token can join with the following token to form a
 /// compound token. Used for conversions to `proc_macro::Spacing`. Also used to
 /// guide pretty-printing, which is where the `JointHidden` value (which isn't
 /// part of `proc_macro::Spacing`) comes in useful.
-#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Clone, Copy, Debug, PartialEq, Hash, Encodable, Decodable, HashStable_Generic)]
 pub enum Spacing {
     /// The token cannot join with the following token to form a compound
     /// token.
@@ -1075,7 +978,7 @@ impl TokenCursor {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic, Walkable)]
+#[derive(Debug, Copy, Clone, PartialEq, Hash, Encodable, Decodable, HashStable_Generic, Walkable)]
 pub struct DelimSpan {
     pub open: Span,
     pub close: Span,
@@ -1099,7 +1002,7 @@ impl DelimSpan {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Copy, Clone, Debug, PartialEq, Hash, Encodable, Decodable, HashStable_Generic)]
 pub struct DelimSpacing {
     pub open: Spacing,
     pub close: Spacing,

compiler/rustc_middle/src/query/mod.rs

@@ -168,7 +168,7 @@ rustc_queries! {
     /// Caches the expansion of a derive proc macro, e.g. `#[derive(Serialize)]`.
     /// The key is:
     /// - A unique key corresponding to the invocation of a macro.
-    /// - Strict Version Hash of a crate.
+    /// - Strict Version Hash of the crate defining the proc macro.
     /// - Token stream which serves as an input to the macro.
     ///
     /// The output is the token stream generated by the proc macro.