-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
+use crate::deriving::path_std;
+use crate::deriving::generic::*;
+use crate::deriving::generic::ty::*;
-use deriving::generic::*;
-use deriving::generic::ty::*;
-
-use syntax::ast::{MetaItem, Expr};
-use syntax::codemap::Span;
-use syntax::ext::base::{ExtCtxt, Annotatable};
-use syntax::ext::build::AstBuilder;
-use syntax::parse::token::InternedString;
+use syntax::ast::{self, Expr, MetaItem, GenericArg};
+use syntax::ext::base::{Annotatable, ExtCtxt, SpecialDerives};
use syntax::ptr::P;
+use syntax::symbol::{sym, Symbol};
+use syntax_pos::Span;
-pub fn expand_deriving_eq(cx: &mut ExtCtxt,
+pub fn expand_deriving_eq(cx: &mut ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
- push: &mut FnMut(Annotatable))
-{
- fn cs_total_eq_assert(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P<Expr> {
- cs_same_method(
- |cx, span, exprs| {
- // create `a.<method>(); b.<method>(); c.<method>(); ...`
- // (where method is `assert_receiver_is_total_eq`)
- let stmts = exprs.into_iter().map(|e| cx.stmt_expr(e)).collect();
- let block = cx.block(span, stmts, None);
- cx.expr_block(block)
- },
- Box::new(|cx, sp, _, _| {
- cx.span_bug(sp, "non matching enums in derive(Eq)?") }),
- cx,
- span,
- substr
- )
- }
+ push: &mut dyn FnMut(Annotatable)) {
+ cx.resolver.add_derives(cx.current_expansion.id.parent(), SpecialDerives::EQ);
- let inline = cx.meta_word(span, InternedString::new("inline"));
- let hidden = cx.meta_word(span, InternedString::new("hidden"));
- let doc = cx.meta_list(span, InternedString::new("doc"), vec!(hidden));
- let attrs = vec!(cx.attribute(span, inline),
- cx.attribute(span, doc));
+ let inline = cx.meta_word(span, sym::inline);
+ let hidden = cx.meta_list_item_word(span, sym::hidden);
+ let doc = cx.meta_list(span, sym::doc, vec![hidden]);
+ let attrs = vec![cx.attribute(inline), cx.attribute(doc)];
let trait_def = TraitDef {
- span: span,
+ span,
attributes: Vec::new(),
- path: path_std!(cx, core::cmp::Eq),
+ path: path_std!(cx, cmp::Eq),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
is_unsafe: false,
- methods: vec!(
- MethodDef {
- name: "assert_receiver_is_total_eq",
- generics: LifetimeBounds::empty(),
- explicit_self: borrowed_explicit_self(),
- args: vec!(),
- ret_ty: nil_ty(),
- attributes: attrs,
- is_unsafe: false,
- combine_substructure: combine_substructure(Box::new(|a, b, c| {
- cs_total_eq_assert(a, b, c)
- }))
- }
- ),
+ supports_unions: true,
+ methods: vec![MethodDef {
+ name: "assert_receiver_is_total_eq",
+ generics: LifetimeBounds::empty(),
+ explicit_self: borrowed_explicit_self(),
+ args: vec![],
+ ret_ty: nil_ty(),
+ attributes: attrs,
+ is_unsafe: false,
+ unify_fieldless_variants: true,
+ combine_substructure: combine_substructure(Box::new(|a, b, c| {
+ cs_total_eq_assert(a, b, c)
+ })),
+ }],
associated_types: Vec::new(),
};
- trait_def.expand(cx, mitem, item, push)
+ trait_def.expand_ext(cx, mitem, item, push, true)
+}
+
+fn cs_total_eq_assert(cx: &mut ExtCtxt<'_>,
+ trait_span: Span,
+ substr: &Substructure<'_>)
+ -> P<Expr> {
+ fn assert_ty_bounds(cx: &mut ExtCtxt<'_>, stmts: &mut Vec<ast::Stmt>,
+ ty: P<ast::Ty>, span: Span, helper_name: &str) {
+ // Generate statement `let _: helper_name<ty>;`,
+ // set the expn ID so we can use the unstable struct.
+ let span = span.with_ctxt(cx.backtrace());
+ let assert_path = cx.path_all(span, true,
+ cx.std_path(&[sym::cmp, Symbol::intern(helper_name)]),
+ vec![GenericArg::Type(ty)], vec![]);
+ stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path)));
+ }
+ fn process_variant(cx: &mut ExtCtxt<'_>,
+ stmts: &mut Vec<ast::Stmt>,
+ variant: &ast::VariantData) {
+ for field in variant.fields() {
+ // let _: AssertParamIsEq<FieldTy>;
+ assert_ty_bounds(cx, stmts, field.ty.clone(), field.span, "AssertParamIsEq");
+ }
+ }
+
+ let mut stmts = Vec::new();
+ match *substr.fields {
+ StaticStruct(vdata, ..) => {
+ process_variant(cx, &mut stmts, vdata);
+ }
+ StaticEnum(enum_def, ..) => {
+ for variant in &enum_def.variants {
+ process_variant(cx, &mut stmts, &variant.node.data);
+ }
+ }
+ _ => cx.span_bug(trait_span, "unexpected substructure in `derive(Eq)`")
+ }
+ cx.expr_block(cx.block(trait_span, stmts))
}
projects / rustc.git / blobdiff