Get some stuff compiling

Author: Aaron1011

compiler/rustc_ast/src/ast.rs

@@ -521,6 +521,7 @@ pub struct Crate {
 ///
 /// E.g., the '..' in `#[name(..)]`.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub enum NestedMetaItem {
     /// A full MetaItem, for recursive meta items.
     MetaItem(MetaItem),
@@ -534,6 +535,7 @@ pub enum NestedMetaItem {
 ///
 /// E.g., `#[test]`, `#[derive(..)]`, `#[rustfmt::skip]` or `#[feature = "foo"]`.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct MetaItem {
     pub path: Path,
     pub kind: MetaItemKind,
@@ -544,6 +546,7 @@ pub struct MetaItem {
 ///
 /// E.g., `#[test]`, `#[derive(..)]` or `#[feature = "foo"]`.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub enum MetaItemKind {
     /// Word meta item.
     ///
@@ -1527,6 +1530,7 @@ impl MacCall {
 
 /// Arguments passed to an attribute or a function-like macro.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub enum MacArgs {
     /// No arguments - `#[attr]`.
     Empty,
@@ -1602,6 +1606,7 @@ impl MacDelimiter {
 
 /// Represents a macro definition.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct MacroDef {
     pub body: P<MacArgs>,
     /// `true` if macro was defined with `macro_rules`.
@@ -1621,6 +1626,7 @@ pub enum StrStyle {
 
 /// An AST literal.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct Lit {
     /// The original literal token as written in source code.
     pub token: token::Lit,
@@ -2021,6 +2027,7 @@ bitflags::bitflags! {
 }
 
 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Hash, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub enum InlineAsmTemplatePiece {
     String(String),
     Placeholder { operand_idx: usize, modifier: Option<char>, span: Span },
@@ -2425,6 +2432,7 @@ impl<D: Decoder> rustc_serialize::Decodable<D> for AttrId {
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct AttrItem {
     pub path: Path,
     pub args: MacArgs,

compiler/rustc_ast/src/token.rs

@@ -178,6 +178,7 @@ fn ident_can_begin_type(name: Symbol, span: Span, is_raw: bool) -> bool {
 }
 
 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub enum TokenKind {
     /* Expression-operator symbols. */
     Eq,
@@ -246,6 +247,7 @@ pub enum TokenKind {
 rustc_data_structures::static_assert_size!(TokenKind, 16);
 
 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub struct Token {
     pub kind: TokenKind,
     pub span: Span,

compiler/rustc_ast/src/tokenstream.rs

@@ -38,6 +38,7 @@ use std::{fmt, iter, mem};
 /// 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, Encodable, Decodable, HashStable_Generic)]
+#[stable_hasher(no_hash_stable_eq)]
 pub enum TokenTree {
     /// A single token.
     Token(Token),

compiler/rustc_data_structures/src/stable_hasher.rs

@@ -199,6 +199,10 @@ pub trait HashStable<CTX> {
     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher);
 }
 
+pub trait HashStableEq {
+    fn hash_stable_eq(&self, other: &Self) -> bool;
+}
+
 /// Implement this for types that can be turned into stable keys like, for
 /// example, for DefId that can be converted to a DefPathHash. This is used for
 /// bringing maps into a predictable order before hashing them.
@@ -218,6 +222,13 @@ macro_rules! impl_stable_hash_via_hash {
                 ::std::hash::Hash::hash(self, hasher);
             }
         }
+
+        impl $crate::stable_hasher::HashStableEq for $t {
+            #[inline]
+            fn hash_stable_eq(&self, other: &Self) -> bool {
+                self == other
+            }
+        }
     };
 }
 
@@ -322,6 +333,24 @@ where
     }
 }
 
+impl<T: HashStableEq> HashStableEq for [T] {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        for (first, second) in self.iter().zip(other.iter()) {
+            if !first.hash_stable_eq(second) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl<T: HashStableEq, const N: usize> HashStableEq for [T; N] {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        (self[..]).hash_stable_eq(other)
+    }
+}
+
+
 impl<T: HashStable<CTX>, CTX> HashStable<CTX> for [T] {
     default fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
         self.len().hash_stable(ctx, hasher);
@@ -331,6 +360,15 @@ impl<T: HashStable<CTX>, CTX> HashStable<CTX> for [T] {
     }
 }
 
+impl<T: HashStable<CTX>, CTX, const N: usize> HashStable<CTX> for [T; N] {
+    default fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
+        self.len().hash_stable(ctx, hasher);
+        for item in self {
+            item.hash_stable(ctx, hasher);
+        }
+    }
+}
+
 impl<CTX> HashStable<CTX> for [u8] {
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
         self.len().hash_stable(ctx, hasher);
@@ -405,6 +443,18 @@ impl<T: ?Sized + HashStable<CTX>, CTX> HashStable<CTX> for ::std::sync::Arc<T> {
     }
 }
 
+impl<T: ?Sized + HashStableEq> HashStableEq for ::std::rc::Rc<T> {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        (**self).hash_stable_eq(other)
+    }
+}
+
+impl<T: ?Sized + HashStableEq> HashStableEq for ::std::sync::Arc<T> {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        (**self).hash_stable_eq(other)
+    }
+}
+
 impl<CTX> HashStable<CTX> for str {
     #[inline]
     fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
@@ -434,6 +484,22 @@ impl<CTX> HashStable<CTX> for bool {
     }
 }
 
+impl<T: HashStableEq> HashStableEq for Option<T> {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Some(first), Some(second)) => first.hash_stable_eq(second),
+            (None, None) => true,
+            _ => false
+        }
+    }
+}
+
+impl HashStableEq for bool {
+    fn hash_stable_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
 impl<T, CTX> HashStable<CTX> for Option<T>
 where
     T: HashStable<CTX>,

compiler/rustc_macros/src/hash_stable.rs

@@ -41,7 +41,27 @@ fn parse_attributes(field: &syn::Field) -> Attributes {
     attrs
 }
 
+fn no_hash_stable_eq(s: &synstructure::Structure<'_>) -> bool {
+    for attr in &s.ast().attrs {
+        if let Ok(meta) = attr.parse_meta() {
+            if !meta.path().is_ident("stable_hasher") {
+                continue;
+            }
+            let arg: syn::Ident = attr.parse_args().unwrap();
+            if arg.to_string() == "no_hash_stable_eq" {
+                return true;
+            } else {
+                panic!("Unexpected argument {:?}", arg);
+            }
+        }
+    }
+    return false;
+}
+
 pub fn hash_stable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
+    let orig = s.clone();
+    let no_eq = no_hash_stable_eq(&orig);
+
     let generic: syn::GenericParam = parse_quote!(__CTX);
     s.add_bounds(synstructure::AddBounds::Generics);
     s.add_impl_generic(generic);
@@ -61,6 +81,7 @@ pub fn hash_stable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_ma
         }
     });
 
+
     let discriminant = match s.ast().data {
         syn::Data::Enum(_) => quote! {
             ::std::mem::discriminant(self).hash_stable(__hcx, __hasher);
@@ -69,7 +90,7 @@ pub fn hash_stable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_ma
         syn::Data::Union(_) => panic!("cannot derive on union"),
     };
 
-    s.bound_impl(
+    let impl_body = s.bound_impl(
         quote!(::rustc_data_structures::stable_hasher::HashStable<__CTX>),
         quote! {
             #[inline]
@@ -81,10 +102,72 @@ pub fn hash_stable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_ma
                 match *self { #body }
             }
         },
-    )
+    );
+
+    if no_eq {
+        impl_body
+    } else {
+        let eq_impl = hash_stable_eq_derive(orig);
+        //println!("Eq impl:\n{}", eq_impl);
+        quote! {
+            #impl_body
+            #eq_impl
+        }
+    }
+}
+
+pub fn hash_stable_eq_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
+    let mut other = s.clone();
+    other.binding_name(|_bi, i| Ident::new(&format!("__binding_other_{}", i), proc_macro2::Span::call_site()));
+
+    let eq_body: proc_macro2::TokenStream = s.variants().iter().zip(other.variants()).map(|(variant1, variant2)| {
+
+        let first_pat = variant1.pat();
+        let second_pat = variant2.pat();
+
+        let compare = std::iter::once(quote! { true }).chain(variant1.bindings().iter().zip(variant2.bindings()).map(|(binding1, binding2)| {
+            let attrs = parse_attributes(binding1.ast());
+            if attrs.ignore {
+                quote! { true }
+            } else if let Some(project) = attrs.project {
+                quote! {
+                    ::rustc_data_structures::stable_hasher::HashStableEq::hash_stable_eq(
+                        #binding1.#project, #binding2.#project
+                    )
+                }
+            } else {
+                quote! {
+                    ::rustc_data_structures::stable_hasher::HashStableEq::hash_stable_eq(
+                        #binding1, #binding2
+                    )
+                }
+            }
+        }));
+        quote! {
+            (#first_pat, #second_pat) => {
+                #(#compare)&&*
+            }
+        }
+    }).collect();
+
+    s.add_bounds(synstructure::AddBounds::Generics);
+    s.bound_impl(
+        quote!(::rustc_data_structures::stable_hasher::HashStableEq),
+        quote! {
+            fn hash_stable_eq(&self, other: &Self) -> bool {
+                match (self, other) {
+                    #eq_body
+                    _ => false
+                }
+            }
+        }
+    )    
 }
 
 pub fn hash_stable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
+    let orig = s.clone();
+    let no_eq = no_hash_stable_eq(&orig);
+
     let generic: syn::GenericParam = parse_quote!('__ctx);
     s.add_bounds(synstructure::AddBounds::Generics);
     s.add_impl_generic(generic);
@@ -111,7 +194,7 @@ pub fn hash_stable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::To
         syn::Data::Union(_) => panic!("cannot derive on union"),
     };
 
-    s.bound_impl(
+    let impl_body = s.bound_impl(
         quote!(
             ::rustc_data_structures::stable_hasher::HashStable<
                 ::rustc_query_system::ich::StableHashingContext<'__ctx>,
@@ -127,5 +210,15 @@ pub fn hash_stable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::To
                 match *self { #body }
             }
         },
-    )
+    );
+
+    if no_eq {
+        impl_body
+    } else {
+        let eq_impl = hash_stable_eq_derive(orig);
+        quote! {
+            #impl_body
+            #eq_impl
+        }
+    }
 }

compiler/rustc_macros/src/lib.rs

@@ -25,6 +25,7 @@ pub fn symbols(input: TokenStream) -> TokenStream {
 }
 
 decl_derive!([HashStable, attributes(stable_hasher)] => hash_stable::hash_stable_derive);
+decl_derive!([HashStableEq, attributes(stable_hasher)] => hash_stable::hash_stable_eq_derive);
 decl_derive!(
     [HashStable_Generic, attributes(stable_hasher)] =>
     hash_stable::hash_stable_generic_derive