support default impl for specialization

giannicic · giannicic · commit 715811d0be05 · 2017-04-25T05:28:22.000Z
pr review
diff --git a/cargo b/cargo
@@ -1 +1 @@
-Subproject commit c416fb60b11ecfd2a1ba0fb8567c9a92590b5d28
+Subproject commit 8326a3683a9045d825e4fdc4021af340ee3b3755
diff --git a/rls b/rls
@@ -1 +1 @@
-Subproject commit 016cbc514cf44a2bd3fe806e8afa6b9c50287373
+Subproject commit 6ecff95fdc3ee7ceed2b9b0cc1a3a64876860bce
diff --git a/src/compiler-rt b/src/compiler-rt
@@ -1 +1 @@
-Subproject commit a8fc4c169fac43a5dc204d4fd56ddb1739f8c178
+Subproject commit d30da544a8afc5d78391dee270bdf40e74a215d3
diff --git a/src/doc/book b/src/doc/book
@@ -1 +1 @@
-Subproject commit beea82b9230cd641dd1ca263cf31025ace4aebb5
+Subproject commit ad7de198561b3a12217ea2da76d796d9c7fc0ed3
diff --git a/src/doc/reference b/src/doc/reference
@@ -1 +1 @@
-Subproject commit b060f732145f2fa16df84c74e511df08a3a47c5d
+Subproject commit 6b0de90d87dda15e323ef24cdf7ed873ac5cf4d3
diff --git a/src/grammar/parser-lalr.y b/src/grammar/parser-lalr.y
@@ -89,6 +89,7 @@ extern char *yytext;
 %token TRAIT
 %token TYPE
 %token UNSAFE
+%token DEFAULT
 %token USE
 %token WHILE
 %token CONTINUE
@@ -534,6 +535,11 @@ maybe_unsafe
 | %empty { $$ = mk_none(); }
 ;
 
+maybe_default_impl
+:         IMPL { $$ = mk_none(); }
+| DEFAULT IMPL { $$ = $1 }
+;
+
 trait_method
 : type_method { $$ = mk_node("Required", 1, $1); }
 | method      { $$ = mk_node("Provided", 1, $1); }
@@ -588,27 +594,27 @@ impl_method
 // they are ambiguous with traits. We do the same here, regrettably,
 // by splitting ty into ty and ty_prim.
 item_impl
-: maybe_unsafe IMPL generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+: maybe_unsafe maybe_default_impl generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
 {
-  $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8);
+  $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8, $2);
 }
-| maybe_unsafe IMPL generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+| maybe_unsafe maybe_default_impl generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
 {
-  $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10);
+  $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10, $2);
 }
-| maybe_unsafe IMPL generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+| maybe_unsafe maybe_default_impl generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
 {
-  $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10);
+  $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10, $2);
 }
-| maybe_unsafe IMPL generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
 {
-  $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11);
+  $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11, $2);
 }
-| maybe_unsafe IMPL generic_params trait_ref FOR DOTDOT '{' '}'
+| maybe_unsafe maybe_default_impl generic_params trait_ref FOR DOTDOT '{' '}'
 {
   $$ = mk_node("ItemImplDefault", 3, $1, $3, $4);
 }
-| maybe_unsafe IMPL generic_params '!' trait_ref FOR DOTDOT '{' '}'
+| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR DOTDOT '{' '}'
 {
   $$ = mk_node("ItemImplDefaultNeg", 3, $1, $3, $4);
 }
@@ -1935,4 +1941,4 @@ brackets_delimited_token_trees
                $2,
                mk_node("TTTok", 1, mk_atom("]")));
 }
-;
+;
diff --git a/src/jemalloc b/src/jemalloc
@@ -1 +1 @@
-Subproject commit e058ca661692a8d01f8cf9d35939dfe3105ce968
+Subproject commit 11bfb0dcf85f7aa92abd30524bb1e42e18d108c6
diff --git a/src/liblibc b/src/liblibc
@@ -1 +1 @@
-Subproject commit 05a2d197356ef253dfd985166576619ac9b6947f
+Subproject commit c34a802d1eb037b44c5252078c7270b5472e0f65
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -1362,6 +1362,9 @@ impl<'a> LoweringContext<'a> {
             }
             ItemKind::MacroDef(..) | ItemKind::Mac(..) => panic!("Shouldn't still be around"),
         }
+
+        // [1] `defaultness.has_value()` is necer called for an `impl`, always `true` in order to
+        //     not cause an assertion failure inside the `lower_defaultness` function
     }
 
     fn lower_trait_item(&mut self, i: &TraitItem) -> hir::TraitItem {
diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs
@@ -933,7 +933,7 @@ impl_stable_hash_for!(enum hir::Item_ {
     ItemUnion(variant_data, generics),
     ItemTrait(unsafety, generics, bounds, item_refs),
     ItemDefaultImpl(unsafety, trait_ref),
-    ItemImpl(unsafety, impl_polarity, generics, trait_ref, ty, impl_item_refs)
+    ItemImpl(unsafety, impl_polarity, impl_defaultness, generics, trait_ref, ty, impl_item_refs)
 });
 
 impl_stable_hash_for!(struct hir::TraitItemRef {
diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs
@@ -195,6 +195,7 @@ pub trait CrateStore {
     fn implementations_of_trait(&self, filter: Option<DefId>) -> Vec<DefId>;
 
     // impl info
+    fn impl_defaultness(&self, def: DefId) -> hir::Defaultness;
     fn impl_parent(&self, impl_def_id: DefId) -> Option<DefId>;
 
     // trait/impl-item info
@@ -329,6 +330,7 @@ impl CrateStore for DummyCrateStore {
     fn implementations_of_trait(&self, filter: Option<DefId>) -> Vec<DefId> { vec![] }
 
     // impl info
+    fn impl_defaultness(&self, def: DefId) -> hir::Defaultness { bug!("impl_defaultness") }
     fn impl_parent(&self, def: DefId) -> Option<DefId> { bug!("impl_parent") }
 
     // trait/impl-item info
diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs
@@ -33,7 +33,6 @@ use ty::subst::Subst;
 use ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt};
 use ty::fold::{TypeFoldable, TypeFolder};
 use util::common::FN_OUTPUT_NAME;
-use hir::{self};
 
 /// Depending on the stage of compilation, we want projection to be
 /// more or less conservative.
@@ -924,28 +923,8 @@ fn assemble_candidates_from_impls<'cx, 'gcx, 'tcx>(
                         // being invoked).
                         node_item.item.defaultness.has_value()
                     } else {
-                        let is_default = match selcx.tcx()
-                                                    .map
-                                                    .as_local_node_id(node_item.node.def_id()) {
-                            Some(node_id) => {
-                                let item = selcx.tcx().map.expect_item(node_id);
-                                if let hir::ItemImpl(_, _, defaultness, ..) = item.node {
-                                    defaultness.is_default()
-                                } else {
-                                    false
-                                }
-                            }
-                            None => {
-                                selcx.tcx()
-                                     .global_tcx()
-                                     .sess
-                                     .cstore
-                                     .impl_defaultness(node_item.node.def_id())
-                                     .is_default()
-                            }
-                        };
-
-                        node_item.item.defaultness.is_default() || is_default
+                        node_item.item.defaultness.is_default() ||
+                        selcx.tcx().impl_is_default(node_item.node.def_id())
                     };
 
                     // Only reveal a specializable default if we're past type-checking
diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs
@@ -13,6 +13,7 @@ use ty::subst::{Subst, Substs};
 use ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef};
 use ty::outlives::Component;
 use util::nodemap::FxHashSet;
+use hir::{self};
 
 use super::{Obligation, ObligationCause, PredicateObligation, SelectionContext, Normalized};
 
@@ -504,6 +505,26 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         };
         ty::Binder((trait_ref, sig.skip_binder().output()))
     }
+
+    pub fn impl_is_default(self, node_item_def_id: DefId) -> bool {
+        match self.hir.as_local_node_id(node_item_def_id) {
+            Some(node_id) => {
+                let item = self.hir.expect_item(node_id);
+                if let hir::ItemImpl(_, _, defaultness, ..) = item.node {
+                    defaultness.is_default()
+                } else {
+                    false
+                }
+            }
+            None => {
+                self.global_tcx()
+                    .sess
+                    .cstore
+                    .impl_defaultness(node_item_def_id)
+                    .is_default()
+            }
+        }
+    }
 }
 
 pub enum TupleArgumentsFlag { Yes, No }
diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs
@@ -90,7 +90,6 @@ provide! { <'tcx> tcx, def_id, cdata
     associated_item => { cdata.get_associated_item(def_id.index) }
     impl_trait_ref => { cdata.get_impl_trait(def_id.index, tcx) }
     impl_polarity => { cdata.get_impl_polarity(def_id.index) }
-    impl_defaultness => { cdata.get_impl_defaultness(def_id.index) }
     coerce_unsized_info => {
         cdata.get_coerce_unsized_info(def_id.index).unwrap_or_else(|| {
             bug!("coerce_unsized_info: `{:?}` is missing its info", def_id);
@@ -179,6 +178,12 @@ impl CrateStore for cstore::CStore {
         result
     }
 
+    fn impl_defaultness(&self, def: DefId) -> hir::Defaultness
+    {
+        self.dep_graph.read(DepNode::MetaData(def));
+        self.get_crate_data(def.krate).get_impl_defaultness(def.index)
+    }
+
     fn impl_parent(&self, impl_def: DefId) -> Option<DefId> {
         self.dep_graph.read(DepNode::MetaData(impl_def));
         self.get_crate_data(impl_def.krate).get_parent_impl(impl_def.index)
diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs
@@ -416,6 +416,7 @@ pub struct ImplData<'tcx> {
 
 impl_stable_hash_for!(struct ImplData<'tcx> {
     polarity,
+    defaultness,
     parent_impl,
     coerce_unsized_info,
     trait_ref
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
@@ -429,7 +429,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump + 'll> DumpVisitor<'l, 'tcx, 'll, D> {
                                 }
                             }
                             None => {
-                                if let Some(NodeItem(item)) = self.tcx.map.get_if_local(id) {
+                                if let Some(NodeItem(item)) = self.tcx.hir.get_if_local(id) {
                                     if let hir::ItemImpl(_, _, _, _, _, ref ty, _) = item.node {
                                         trait_id = self.lookup_def_id(ty.id);
                                     }
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1142,21 +1142,7 @@ fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
     if let Some(parent) = parent {
         if parent.item.is_final() {
-            let is_final = match tcx.map.as_local_node_id(parent.node.def_id()) {
-                Some(node_id) => {
-                    let item = tcx.map.expect_item(node_id);
-                    if let hir::ItemImpl(_, _, defaultness, ..) = item.node {
-                        defaultness.is_final()
-                    } else {
-                        true
-                    }
-                }
-                None => {
-                    tcx.global_tcx().sess.cstore.impl_defaultness(parent.node.def_id()).is_final()
-                }
-            };
-
-            if is_final {
+            if !tcx.impl_is_default(parent.node.def_id()) {
                 report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
             }
         }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -309,7 +309,7 @@ fn type_param_predicates<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         NodeItem(item) => {
             match item.node {
                 ItemFn(.., ref generics, _) |
-                ItemImpl(_, _, ref generics, ..) |
+                ItemImpl(_, _, _, ref generics, ..) |
                 ItemTy(_, ref generics) |
                 ItemEnum(_, ref generics) |
                 ItemStruct(_, ref generics) |
@@ -825,7 +825,7 @@ fn generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         NodeItem(item) => {
             match item.node {
                 ItemFn(.., ref generics, _) |
-                ItemImpl(_, _, ref generics, ..) => generics,
+                ItemImpl(_, _, _, ref generics, ..) => generics,
 
                 ItemTy(_, ref generics) |
                 ItemEnum(_, ref generics) |
@@ -1236,7 +1236,7 @@ fn predicates<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         NodeItem(item) => {
             match item.node {
                 ItemFn(.., ref generics, _) |
-                ItemImpl(_, _, ref generics, ..) |
+                ItemImpl(_, _, _, ref generics, ..) |
                 ItemTy(_, ref generics) |
                 ItemEnum(_, ref generics) |
                 ItemStruct(_, ref generics) |
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -4918,6 +4918,14 @@ impl<'a> Parser<'a> {
                                           allowed to have generics");
             }
 
+            match defaultness {
+                ast::Defaultness::Default => {
+                    self.span_err(impl_span, "`default impl` is not allowed for \
+                                               default trait implementations");
+                }
+                _ => {}
+            }
+
             self.expect(&token::OpenDelim(token::Brace))?;
             self.expect(&token::CloseDelim(token::Brace))?;
             Ok((keywords::Invalid.ident(),
@@ -5760,13 +5768,13 @@ impl<'a> Parser<'a> {
         }
         if (self.check_keyword(keywords::Unsafe) &&
             self.look_ahead(1, |t| t.is_keyword(keywords::Impl))) ||
-           (self.check_keyword(keywords::Default) &&
-            self.look_ahead(1, |t| t.is_keyword(keywords::Unsafe)) &&
+           (self.check_keyword(keywords::Unsafe) &&
+            self.look_ahead(1, |t| t.is_keyword(keywords::Default)) &&
             self.look_ahead(2, |t| t.is_keyword(keywords::Impl)))
         {
             // IMPL ITEM
-            let defaultness = self.parse_defaultness()?;
             self.expect_keyword(keywords::Unsafe)?;
+            let defaultness = self.parse_defaultness()?;
             self.expect_keyword(keywords::Impl)?;
             let (ident,
                  item_,
diff --git a/src/rt/hoedown b/src/rt/hoedown
@@ -0,0 +1 @@
+Subproject commit da282f1bb7277b4d30fa1599ee29ad8eb4dd2a92
diff --git a/src/test/compile-fail/specialization/defaultimpl/specialization-no-default-trait-implementations.rs b/src/test/compile-fail/specialization/defaultimpl/specialization-no-default-trait-implementations.rs
@@ -0,0 +1,19 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(specialization)]
+#![feature(optin_builtin_traits)]
+
+trait Foo {}
+
+default impl Foo for .. {}
+//~^ ERROR `default impl` is not allowed for default trait implementations
+
+fn main() {}
diff --git a/src/test/run-pass/specialization/defaultimpl/specialization-basics-unsafe.rs b/src/test/run-pass/specialization/defaultimpl/specialization-basics-unsafe.rs

Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ extern char *yytext;`
`89`	`89`	`%token TRAIT`
`90`	`90`	`%token TYPE`
`91`	`91`	`%token UNSAFE`
	`92`	`+%token DEFAULT`
`92`	`93`	`%token USE`
`93`	`94`	`%token WHILE`
`94`	`95`	`%token CONTINUE`
`@@ -534,6 +535,11 @@ maybe_unsafe`
`534`	`535`	`\| %empty { $$ = mk_none(); }`
`535`	`536`	`;`
`536`	`537`
	`538`	`+maybe_default_impl`
	`539`	`+: IMPL { $$ = mk_none(); }`
	`540`	`+\| DEFAULT IMPL { $$ = $1 }`
	`541`	`+;`
	`542`	`+`
`537`	`543`	`trait_method`
`538`	`544`	`: type_method { $$ = mk_node("Required", 1, $1); }`
`539`	`545`	`\| method { $$ = mk_node("Provided", 1, $1); }`
`@@ -588,27 +594,27 @@ impl_method`
`588`	`594`	`// they are ambiguous with traits. We do the same here, regrettably,`
`589`	`595`	`// by splitting ty into ty and ty_prim.`
`590`	`596`	`item_impl`
`591`		`-: maybe_unsafe IMPL generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`597`	`+: maybe_unsafe maybe_default_impl generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`592`	`598`	`{`
`593`		`- $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8);`
	`599`	`+ $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8, $2);`
`594`	`600`	`}`
`595`		`-\| maybe_unsafe IMPL generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`601`	`+\| maybe_unsafe maybe_default_impl generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`596`	`602`	`{`
`597`		`- $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10);`
	`603`	`+ $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10, $2);`
`598`	`604`	`}`
`599`		`-\| maybe_unsafe IMPL generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`605`	`+\| maybe_unsafe maybe_default_impl generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`600`	`606`	`{`
`601`		`- $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10);`
	`607`	`+ $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10, $2);`
`602`	`608`	`}`
`603`		`-\| maybe_unsafe IMPL generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`609`	`+\| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`604`	`610`	`{`
`605`		`- $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11);`
	`611`	`+ $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11, $2);`
`606`	`612`	`}`
`607`		`-\| maybe_unsafe IMPL generic_params trait_ref FOR DOTDOT '{' '}'`
	`613`	`+\| maybe_unsafe maybe_default_impl generic_params trait_ref FOR DOTDOT '{' '}'`
`608`	`614`	`{`
`609`	`615`	`$$ = mk_node("ItemImplDefault", 3, $1, $3, $4);`
`610`	`616`	`}`
`611`		`-\| maybe_unsafe IMPL generic_params '!' trait_ref FOR DOTDOT '{' '}'`
	`617`	`+\| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR DOTDOT '{' '}'`
`612`	`618`	`{`
`613`	`619`	`$$ = mk_node("ItemImplDefaultNeg", 3, $1, $3, $4);`
`614`	`620`	`}`
`@@ -1935,4 +1941,4 @@ brackets_delimited_token_trees`
`1935`	`1941`	`$2,`
`1936`	`1942`	`mk_node("TTTok", 1, mk_atom("]")));`
`1937`	`1943`	`}`
`1938`		`-;`
	`1944`	`+;`
Original file line number	Diff line number	Diff line change
`@@ -1362,6 +1362,9 @@ impl<'a> LoweringContext<'a> {`
`1362`	`1362`	`}`
`1363`	`1363`	`ItemKind::MacroDef(..) \| ItemKind::Mac(..) => panic!("Shouldn't still be around"),`
`1364`	`1364`	`}`
	`1365`	`+`
	`1366`	+ // [1] `defaultness.has_value()` is necer called for an `impl`, always `true` in order to
	`1367`	+ // not cause an assertion failure inside the `lower_defaultness` function
`1365`	`1368`	`}`
`1366`	`1369`
`1367`	`1370`	`fn lower_trait_item(&mut self, i: &TraitItem) -> hir::TraitItem {`