Initial stability checking on default type parameters

Co-Authored-By: Avi Dessauer <avi.the.coder@gmail.com>

Author: varkor

src/librustc_passes/stability.rs

@@ -138,10 +138,13 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             } else {
                 debug!("annotate: not found, parent = {:?}", self.parent_stab);
                 if let Some(stab) = self.parent_stab {
-                    // Instability (but not stability) is inherited from the parent.
+                    // Instability (but not typically stability) is inherited from the parent.
                     // If something is unstable, everything inside it should also be
                     // considered unstable.
-                    if stab.level.is_unstable() {
+                    // `AnnotationKind::Optional` items also inherit stability, as they may be
+                    // considered stable-by-default items, requiring an instability attribute to
+                    // override this.
+                    if stab.level.is_unstable() || kind == AnnotationKind::Optional {
                         self.index.stab_map.insert(hir_id, stab);
                     }
                 }
@@ -173,7 +176,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             // Propagate unstability.  This can happen even for non-staged-api crates in case
             // -Zforce-unstable-if-unmarked is set.
             if let Some(stab) = self.parent_stab {
-                if stab.level.is_unstable() {
+                if stab.level.is_unstable() || kind == AnnotationKind::Optional {
                     self.index.stab_map.insert(hir_id, stab);
                 }
             }

src/librustc_typeck/astconv.rs

@@ -697,7 +697,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 (GenericParamDefKind::Lifetime, GenericArg::Lifetime(lt)) => {
                     self.ast_region_to_region(&lt, Some(param)).into()
                 }
-                (GenericParamDefKind::Type { .. }, GenericArg::Type(ty)) => {
+                (GenericParamDefKind::Type { has_default, .. }, GenericArg::Type(ty)) => {
+                    if *has_default {
+                        tcx.check_stability(param.def_id, Some(arg.id()), arg.span());
+                    }
+
                     self.ast_ty_to_ty(&ty).into()
                 }
                 (GenericParamDefKind::Const, GenericArg::Const(ct)) => {

src/test/ui/stability-attribute/auxiliary/unstable_generic_param.rs

@@ -0,0 +1,10 @@
+#![crate_type = "lib"]
+#![feature(staged_api)]
+
+#![stable(feature = "stable_test_feature", since = "1.0.0")]
+
+#[stable(feature = "stable_test_feature", since = "1.0.0")]
+pub trait Trait<#[unstable(feature = "ty", issue = "none")] T = ()> {
+    #[stable(feature = "stable_test_feature", since = "1.0.0")]
+    fn foo() -> T;
+}

src/test/ui/stability-attribute/generics-default-stability.rs

@@ -0,0 +1,15 @@
+// aux-build:unstable_generic_param.rs
+
+extern crate unstable_generic_param;
+
+use unstable_generic_param::Trait;
+
+struct S;
+
+impl Trait<usize> for S {
+    fn foo() -> usize { 0 }
+}
+
+fn main() {
+    let _ = S;
+}