support default impl for specialization

giannicic · giannicic · commit b48eb5e0be2a · 2017-04-26T14:43:09.000Z
`[default] [unsafe] impl` and typecheck
diff --git a/src/grammar/parser-lalr.y b/src/grammar/parser-lalr.y
@@ -535,10 +535,11 @@ maybe_unsafe
 | %empty { $$ = mk_none(); }
 ;
 
-maybe_default_impl
-:         IMPL { $$ = mk_none(); }
-| DEFAULT IMPL { $$ = $1 }
-;
+maybe_default_maybe_unsafe
+: DEFAULT UNSAFE { $$ = mk_atom("DefaultUnsafe"); }
+| DEFAULT        { $$ = mk_atom("Default"); }
+|         UNSAFE { $$ = mk_atom("Unsafe"); }
+| %empty { $$ = mk_none(); }
 
 trait_method
 : type_method { $$ = mk_node("Required", 1, $1); }
@@ -594,27 +595,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 maybe_default_impl generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+: maybe_default_maybe_unsafe 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, $2);
+  $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8);
 }
-| maybe_unsafe maybe_default_impl generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+| maybe_default_maybe_unsafe IMPL generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
 {
-  $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10, $2);
+  $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10);
 }
-| maybe_unsafe maybe_default_impl generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+| maybe_default_maybe_unsafe 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, $2);
+  $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10);
 }
-| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'
+| maybe_default_maybe_unsafe 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, $2);
+  $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11);
 }
-| maybe_unsafe maybe_default_impl generic_params trait_ref FOR DOTDOT '{' '}'
+| maybe_default_maybe_unsafe IMPL generic_params trait_ref FOR DOTDOT '{' '}'
 {
   $$ = mk_node("ItemImplDefault", 3, $1, $3, $4);
 }
-| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR DOTDOT '{' '}'
+| maybe_default_maybe_unsafe IMPL generic_params '!' trait_ref FOR DOTDOT '{' '}'
 {
   $$ = mk_node("ItemImplDefaultNeg", 3, $1, $3, $4);
 }
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -1363,7 +1363,7 @@ 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
+        // [1] `defaultness.has_value()` is never called for an `impl`, always `true` in order to
         //     not cause an assertion failure inside the `lower_defaultness` function
     }
 
diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs
@@ -14,6 +14,7 @@ use ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef};
 use ty::outlives::Component;
 use util::nodemap::FxHashSet;
 use hir::{self};
+use traits::specialize::specialization_graph::NodeItem;
 
 use super::{Obligation, ObligationCause, PredicateObligation, SelectionContext, Normalized};
 
@@ -525,6 +526,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             }
         }
     }
+
+    pub fn impl_item_is_final(self, node_item: &NodeItem<hir::Defaultness>) -> bool {
+        node_item.item.is_final() && !self.impl_is_default(node_item.node.def_id())
+    }
 }
 
 pub enum TupleArgumentsFlag { Yes, No }
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1141,10 +1141,8 @@ fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         .map(|node_item| node_item.map(|parent| parent.defaultness));
 
     if let Some(parent) = parent {
-        if parent.item.is_final() {
-            if !tcx.impl_is_default(parent.node.def_id()) {
-                report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
-            }
+        if tcx.impl_item_is_final(&parent) {
+            report_forbidden_specialization(tcx, impl_item, parent.node.def_id());
         }
     }
 
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
@@ -1226,13 +1226,10 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                     _ => {}
                 }
 
-                match defaultness {
-                    ast::Defaultness::Default => {
-                        gate_feature_post!(&self, specialization,
-                                      i.span,
-                                      "specialization is unstable");
-                    }
-                    _ => {}
+                if let ast::Defaultness::Default = defaultness {
+                    gate_feature_post!(&self, specialization,
+                                       i.span,
+                                       "specialization is unstable");
                 }
             }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -4918,12 +4918,9 @@ 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");
-                }
-                _ => {}
+            if let ast::Defaultness::Default = defaultness {
+                self.span_err(impl_span, "`default impl` is not allowed for \
+                                         default trait implementations");
             }
 
             self.expect(&token::OpenDelim(token::Brace))?;
@@ -5768,13 +5765,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::Unsafe) &&
-            self.look_ahead(1, |t| t.is_keyword(keywords::Default)) &&
+           (self.check_keyword(keywords::Default) &&
+            self.look_ahead(1, |t| t.is_keyword(keywords::Unsafe)) &&
             self.look_ahead(2, |t| t.is_keyword(keywords::Impl)))
         {
             // IMPL ITEM
-            self.expect_keyword(keywords::Unsafe)?;
             let defaultness = self.parse_defaultness()?;
+            self.expect_keyword(keywords::Unsafe)?;
             self.expect_keyword(keywords::Impl)?;
             let (ident,
                  item_,
diff --git a/src/test/run-pass/specialization/defaultimpl/specialization-basics-unsafe.rs b/src/test/run-pass/specialization/defaultimpl/specialization-basics-unsafe.rs
@@ -17,61 +17,61 @@ unsafe trait Foo {
     fn foo(&self) -> &'static str;
 }
 
-unsafe default impl<T> Foo for T {
+default unsafe impl<T> Foo for T {
     fn foo(&self) -> &'static str {
         "generic"
     }
 }
 
-unsafe default impl<T: Clone> Foo for T {
+default unsafe impl<T: Clone> Foo for T {
     fn foo(&self) -> &'static str {
         "generic Clone"
     }
 }
 
-unsafe default impl<T, U> Foo for (T, U) where T: Clone, U: Clone {
+default unsafe impl<T, U> Foo for (T, U) where T: Clone, U: Clone {
     fn foo(&self) -> &'static str {
         "generic pair"
     }
 }
 
-unsafe default impl<T: Clone> Foo for (T, T) {
+default unsafe impl<T: Clone> Foo for (T, T) {
     fn foo(&self) -> &'static str {
         "generic uniform pair"
     }
 }
 
-unsafe default impl Foo for (u8, u32) {
+default unsafe impl Foo for (u8, u32) {
     fn foo(&self) -> &'static str {
         "(u8, u32)"
     }
 }
 
-unsafe default impl Foo for (u8, u8) {
+default unsafe impl Foo for (u8, u8) {
     fn foo(&self) -> &'static str {
         "(u8, u8)"
     }
 }
 
-unsafe default impl<T: Clone> Foo for Vec<T> {
+default unsafe impl<T: Clone> Foo for Vec<T> {
     fn foo(&self) -> &'static str {
         "generic Vec"
     }
 }
 
-unsafe impl Foo for Vec<i32> {
+default unsafe impl Foo for Vec<i32> {
     fn foo(&self) -> &'static str {
         "Vec<i32>"
     }
 }
 
-unsafe impl Foo for String {
+default unsafe impl Foo for String {
     fn foo(&self) -> &'static str {
         "String"
     }
 }
 
-unsafe impl Foo for i32 {
+default unsafe impl Foo for i32 {
     fn foo(&self) -> &'static str {
         "i32"
     }
@@ -80,7 +80,7 @@ unsafe impl Foo for i32 {
 struct NotClone;
 
 unsafe trait MyMarker {}
-unsafe default impl<T: Clone + MyMarker> Foo for T {
+default unsafe impl<T: Clone + MyMarker> Foo for T {
     fn foo(&self) -> &'static str {
         "generic Clone + MyMarker"
     }

Original file line number	Diff line number	Diff line change
`@@ -535,10 +535,11 @@ maybe_unsafe`
`535`	`535`	`\| %empty { $$ = mk_none(); }`
`536`	`536`	`;`
`537`	`537`
`538`		`-maybe_default_impl`
`539`		`-: IMPL { $$ = mk_none(); }`
`540`		`-\| DEFAULT IMPL { $$ = $1 }`
`541`		`-;`
	`538`	`+maybe_default_maybe_unsafe`
	`539`	`+: DEFAULT UNSAFE { $$ = mk_atom("DefaultUnsafe"); }`
	`540`	`+\| DEFAULT { $$ = mk_atom("Default"); }`
	`541`	`+\| UNSAFE { $$ = mk_atom("Unsafe"); }`
	`542`	`+\| %empty { $$ = mk_none(); }`
`542`	`543`
`543`	`544`	`trait_method`
`544`	`545`	`: type_method { $$ = mk_node("Required", 1, $1); }`
`@@ -594,27 +595,27 @@ impl_method`
`594`	`595`	`// they are ambiguous with traits. We do the same here, regrettably,`
`595`	`596`	`// by splitting ty into ty and ty_prim.`
`596`	`597`	`item_impl`
`597`		`-: maybe_unsafe maybe_default_impl generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`598`	`+: maybe_default_maybe_unsafe IMPL generic_params ty_prim_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`598`	`599`	`{`
`599`		`- $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8, $2);`
	`600`	`+ $$ = mk_node("ItemImpl", 6, $1, $3, $4, $5, $7, $8);`
`600`	`601`	`}`
`601`		`-\| maybe_unsafe maybe_default_impl generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`602`	`+\| maybe_default_maybe_unsafe IMPL generic_params '(' ty ')' maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`602`	`603`	`{`
`603`		`- $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10, $2);`
	`604`	`+ $$ = mk_node("ItemImpl", 6, $1, $3, 5, $6, $9, $10);`
`604`	`605`	`}`
`605`		`-\| maybe_unsafe maybe_default_impl generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`606`	`+\| maybe_default_maybe_unsafe IMPL generic_params trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`606`	`607`	`{`
`607`		`- $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10, $2);`
	`608`	`+ $$ = mk_node("ItemImpl", 6, $3, $4, $6, $7, $9, $10);`
`608`	`609`	`}`
`609`		`-\| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
	`610`	`+\| maybe_default_maybe_unsafe IMPL generic_params '!' trait_ref FOR ty_sum maybe_where_clause '{' maybe_inner_attrs maybe_impl_items '}'`
`610`	`611`	`{`
`611`		`- $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11, $2);`
	`612`	`+ $$ = mk_node("ItemImplNeg", 7, $1, $3, $5, $7, $8, $10, $11);`
`612`	`613`	`}`
`613`		`-\| maybe_unsafe maybe_default_impl generic_params trait_ref FOR DOTDOT '{' '}'`
	`614`	`+\| maybe_default_maybe_unsafe IMPL generic_params trait_ref FOR DOTDOT '{' '}'`
`614`	`615`	`{`
`615`	`616`	`$$ = mk_node("ItemImplDefault", 3, $1, $3, $4);`
`616`	`617`	`}`
`617`		`-\| maybe_unsafe maybe_default_impl generic_params '!' trait_ref FOR DOTDOT '{' '}'`
	`618`	`+\| maybe_default_maybe_unsafe IMPL generic_params '!' trait_ref FOR DOTDOT '{' '}'`
`618`	`619`	`{`
`619`	`620`	`$$ = mk_node("ItemImplDefaultNeg", 3, $1, $3, $4);`
`620`	`621`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1363,7 +1363,7 @@ impl<'a> LoweringContext<'a> {`
`1363`	`1363`	`ItemKind::MacroDef(..) \| ItemKind::Mac(..) => panic!("Shouldn't still be around"),`
`1364`	`1364`	`}`
`1365`	`1365`
`1366`		- // [1] `defaultness.has_value()` is necer called for an `impl`, always `true` in order to
	`1366`	+ // [1] `defaultness.has_value()` is never called for an `impl`, always `true` in order to
`1367`	`1367`	// not cause an assertion failure inside the `lower_defaultness` function
`1368`	`1368`	`}`
`1369`	`1369`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ use ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef};`
`14`	`14`	`use ty::outlives::Component;`
`15`	`15`	`use util::nodemap::FxHashSet;`
`16`	`16`	`use hir::{self};`
	`17`	`+use traits::specialize::specialization_graph::NodeItem;`
`17`	`18`
`18`	`19`	`use super::{Obligation, ObligationCause, PredicateObligation, SelectionContext, Normalized};`
`19`	`20`
`@@ -525,6 +526,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`525`	`526`	`}`
`526`	`527`	`}`
`527`	`528`	`}`
	`529`	`+`
	`530`	`+ pub fn impl_item_is_final(self, node_item: &NodeItem<hir::Defaultness>) -> bool {`
	`531`	`+ node_item.item.is_final() && !self.impl_is_default(node_item.node.def_id())`
	`532`	`+ }`
`528`	`533`	`}`
`529`	`534`
`530`	`535`	`pub enum TupleArgumentsFlag { Yes, No }`
Original file line number	Diff line number	Diff line change
`@@ -1141,10 +1141,8 @@ fn check_specialization_validity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,`
`1141`	`1141`	`.map(\|node_item\| node_item.map(\|parent\| parent.defaultness));`
`1142`	`1142`
`1143`	`1143`	`if let Some(parent) = parent {`
`1144`		`- if parent.item.is_final() {`
`1145`		`- if !tcx.impl_is_default(parent.node.def_id()) {`
`1146`		`- report_forbidden_specialization(tcx, impl_item, parent.node.def_id());`
`1147`		`- }`
	`1144`	`+ if tcx.impl_item_is_final(&parent) {`
	`1145`	`+ report_forbidden_specialization(tcx, impl_item, parent.node.def_id());`
`1148`	`1146`	`}`
`1149`	`1147`	`}`
`1150`	`1148`
Original file line number	Diff line number	Diff line change
`@@ -1226,13 +1226,10 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {`
`1226`	`1226`	`_ => {}`
`1227`	`1227`	`}`
`1228`	`1228`
`1229`		`- match defaultness {`
`1230`		`- ast::Defaultness::Default => {`
`1231`		`- gate_feature_post!(&self, specialization,`
`1232`		`- i.span,`
`1233`		`- "specialization is unstable");`
`1234`		`- }`
`1235`		`- _ => {}`
	`1229`	`+ if let ast::Defaultness::Default = defaultness {`
	`1230`	`+ gate_feature_post!(&self, specialization,`
	`1231`	`+ i.span,`
	`1232`	`+ "specialization is unstable");`
`1236`	`1233`	`}`
`1237`	`1234`	`}`
`1238`	`1235`
Original file line number	Diff line number	Diff line change
`@@ -17,61 +17,61 @@ unsafe trait Foo {`
`17`	`17`	`fn foo(&self) -> &'static str;`
`18`	`18`	`}`
`19`	`19`
`20`		`-unsafe default impl<T> Foo for T {`
	`20`	`+default unsafe impl<T> Foo for T {`
`21`	`21`	`fn foo(&self) -> &'static str {`
`22`	`22`	`"generic"`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`		`-unsafe default impl<T: Clone> Foo for T {`
	`26`	`+default unsafe impl<T: Clone> Foo for T {`
`27`	`27`	`fn foo(&self) -> &'static str {`
`28`	`28`	`"generic Clone"`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`-unsafe default impl<T, U> Foo for (T, U) where T: Clone, U: Clone {`
	`32`	`+default unsafe impl<T, U> Foo for (T, U) where T: Clone, U: Clone {`
`33`	`33`	`fn foo(&self) -> &'static str {`
`34`	`34`	`"generic pair"`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`38`		`-unsafe default impl<T: Clone> Foo for (T, T) {`
	`38`	`+default unsafe impl<T: Clone> Foo for (T, T) {`
`39`	`39`	`fn foo(&self) -> &'static str {`
`40`	`40`	`"generic uniform pair"`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`		`-unsafe default impl Foo for (u8, u32) {`
	`44`	`+default unsafe impl Foo for (u8, u32) {`
`45`	`45`	`fn foo(&self) -> &'static str {`
`46`	`46`	`"(u8, u32)"`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`-unsafe default impl Foo for (u8, u8) {`
	`50`	`+default unsafe impl Foo for (u8, u8) {`
`51`	`51`	`fn foo(&self) -> &'static str {`
`52`	`52`	`"(u8, u8)"`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`-unsafe default impl<T: Clone> Foo for Vec<T> {`
	`56`	`+default unsafe impl<T: Clone> Foo for Vec<T> {`
`57`	`57`	`fn foo(&self) -> &'static str {`
`58`	`58`	`"generic Vec"`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`-unsafe impl Foo for Vec<i32> {`
	`62`	`+default unsafe impl Foo for Vec<i32> {`
`63`	`63`	`fn foo(&self) -> &'static str {`
`64`	`64`	`"Vec<i32>"`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`-unsafe impl Foo for String {`
	`68`	`+default unsafe impl Foo for String {`
`69`	`69`	`fn foo(&self) -> &'static str {`
`70`	`70`	`"String"`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`-unsafe impl Foo for i32 {`
	`74`	`+default unsafe impl Foo for i32 {`
`75`	`75`	`fn foo(&self) -> &'static str {`
`76`	`76`	`"i32"`
`77`	`77`	`}`
`@@ -80,7 +80,7 @@ unsafe impl Foo for i32 {`
`80`	`80`	`struct NotClone;`
`81`	`81`
`82`	`82`	`unsafe trait MyMarker {}`
`83`		`-unsafe default impl<T: Clone + MyMarker> Foo for T {`
	`83`	`+default unsafe impl<T: Clone + MyMarker> Foo for T {`
`84`	`84`	`fn foo(&self) -> &'static str {`
`85`	`85`	`"generic Clone + MyMarker"`
`86`	`86`	`}`