auto merge of #11217 : eddyb/rust/generic-default-type-params, r=cmr

Author: bors

src/librustc/front/feature_gate.rs

@@ -48,6 +48,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("log_syntax", Active),
     ("trace_macros", Active),
     ("simd", Active),
+    ("default_type_params", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -234,6 +235,20 @@ impl Visitor<()> for Context {
         }
         visit::walk_expr(self, e, ());
     }
+
+    fn visit_generics(&mut self, generics: &ast::Generics, _: ()) {
+        for type_parameter in generics.ty_params.iter() {
+            match type_parameter.default {
+                Some(ty) => {
+                    self.gate_feature("default_type_params", ty.span,
+                                      "default type parameters are \
+                                       experimental and possibly buggy");
+                }
+                None => {}
+            }
+        }
+        visit::walk_generics(self, generics, ());
+    }
 }
 
 pub fn check_crate(sess: Session, crate: &ast::Crate) {

src/librustc/metadata/tydecode.rs

@@ -573,9 +573,12 @@ pub fn parse_type_param_def_data(data: &[u8], start: uint,
 }
 
 fn parse_type_param_def(st: &mut PState, conv: conv_did) -> ty::TypeParameterDef {
-    ty::TypeParameterDef {ident: parse_ident(st, ':'),
-                          def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
-                          bounds: @parse_bounds(st, |x,y| conv(x,y))}
+    ty::TypeParameterDef {
+        ident: parse_ident(st, ':'),
+        def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
+        bounds: @parse_bounds(st, |x,y| conv(x,y)),
+        default: parse_opt(st, |st| parse_ty(st, |x,y| conv(x,y)))
+    }
 }
 
 fn parse_bounds(st: &mut PState, conv: conv_did) -> ty::ParamBounds {

src/librustc/metadata/tyencode.rs

@@ -421,4 +421,5 @@ fn enc_bounds(w: &mut MemWriter, cx: @ctxt, bs: &ty::ParamBounds) {
 pub fn enc_type_param_def(w: &mut MemWriter, cx: @ctxt, v: &ty::TypeParameterDef) {
     mywrite!(w, "{}:{}|", cx.tcx.sess.str_of(v.ident), (cx.ds)(v.def_id));
     enc_bounds(w, cx, v.bounds);
+    enc_opt(w, v.default, |w, t| enc_ty(w, cx, t));
 }

src/librustc/middle/lint.rs

@@ -86,6 +86,7 @@ pub enum Lint {
     AttributeUsage,
     UnknownFeatures,
     UnknownCrateType,
+    DefaultTypeParamUsage,
 
     ManagedHeapMemory,
     OwnedHeapMemory,
@@ -359,6 +360,7 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "unknown features found in crate-level #[feature] directives",
         default: deny,
     }),
+
     ("unknown_crate_type",
     LintSpec {
         lint: UnknownCrateType,
@@ -379,6 +381,13 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "unused result of an expression in a statement",
         default: allow,
     }),
+
+     ("default_type_param_usage",
+     LintSpec {
+         lint: DefaultTypeParamUsage,
+         desc: "prevents explicitly setting a type parameter with a default",
+         default: deny,
+     }),
 ];
 
 /*

src/librustc/middle/resolve.rs

@@ -3931,6 +3931,10 @@ impl Resolver {
             for bound in type_parameter.bounds.iter() {
                 self.resolve_type_parameter_bound(type_parameter.id, bound);
             }
+            match type_parameter.default {
+                Some(ty) => self.resolve_type(ty),
+                None => {}
+            }
         }
     }
 

src/librustc/middle/subst.rs

@@ -164,7 +164,8 @@ impl Subst for ty::TypeParameterDef {
         ty::TypeParameterDef {
             ident: self.ident,
             def_id: self.def_id,
-            bounds: self.bounds.subst(tcx, substs)
+            bounds: self.bounds.subst(tcx, substs),
+            default: self.default.map(|x| x.subst(tcx, substs))
         }
     }
 }

src/librustc/middle/trans/debuginfo.rs

@@ -2000,7 +2000,8 @@ fn trait_metadata(cx: &CrateContext,
                ppaux::mutability_to_str(mutability) +
                token::ident_to_str(&ident);
     // Add type and region parameters
-    let name = ppaux::parameterized(cx.tcx, name, &substs.regions, substs.tps);
+    let name = ppaux::parameterized(cx.tcx, name, &substs.regions,
+                                    substs.tps, def_id, true);
 
     let (containing_scope, definition_span) =
         get_namespace_and_span_for_item(cx, def_id, usage_site_span);

src/librustc/middle/trans/type_of.rs

@@ -330,7 +330,8 @@ pub fn llvm_type_name(cx: &CrateContext,
         an_enum => { "enum" }
     };
     let tstr = ppaux::parameterized(cx.tcx, ty::item_path_str(cx.tcx, did),
-                                    &ty::NonerasedRegions(opt_vec::Empty), tps);
+                                    &ty::NonerasedRegions(opt_vec::Empty),
+                                    tps, did, false);
     if did.crate == 0 {
         format!("{}.{}", name, tstr)
     } else {

src/librustc/middle/ty.rs

@@ -855,7 +855,8 @@ impl ToStr for IntVarValue {
 pub struct TypeParameterDef {
     ident: ast::Ident,
     def_id: ast::DefId,
-    bounds: @ParamBounds
+    bounds: @ParamBounds,
+    default: Option<ty::t>
 }
 
 #[deriving(Encodable, Decodable, Clone)]

src/librustc/middle/typeck/astconv.rs

@@ -51,6 +51,7 @@
 
 
 use middle::const_eval;
+use middle::lint;
 use middle::ty::{substs};
 use middle::ty::{ty_param_substs_and_ty};
 use middle::ty;
@@ -195,21 +196,43 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
     };
 
     // Convert the type parameters supplied by the user.
-    let supplied_type_parameter_count =
-        path.segments.iter().flat_map(|s| s.types.iter()).len();
-    if decl_generics.type_param_defs.len() != supplied_type_parameter_count {
-        this.tcx().sess.span_fatal(
-            path.span,
-            format!("wrong number of type arguments: expected {} but found {}",
-                 decl_generics.type_param_defs.len(),
-                 supplied_type_parameter_count));
+    let supplied_ty_param_count = path.segments.iter().flat_map(|s| s.types.iter()).len();
+    let formal_ty_param_count = decl_generics.type_param_defs.len();
+    let required_ty_param_count = decl_generics.type_param_defs.iter()
+                                               .take_while(|x| x.default.is_none())
+                                               .len();
+    if supplied_ty_param_count < required_ty_param_count {
+        let expected = if required_ty_param_count < formal_ty_param_count {
+            "expected at least"
+        } else {
+            "expected"
+        };
+        this.tcx().sess.span_fatal(path.span,
+            format!("wrong number of type arguments: {} {} but found {}",
+                expected, required_ty_param_count, supplied_ty_param_count));
+    } else if supplied_ty_param_count > formal_ty_param_count {
+        let expected = if required_ty_param_count < formal_ty_param_count {
+            "expected at most"
+        } else {
+            "expected"
+        };
+        this.tcx().sess.span_fatal(path.span,
+            format!("wrong number of type arguments: {} {} but found {}",
+                expected, formal_ty_param_count, supplied_ty_param_count));
+    }
+
+    if supplied_ty_param_count > required_ty_param_count {
+        let id = path.segments.iter().flat_map(|s| s.types.iter())
+                              .nth(required_ty_param_count).unwrap().id;
+        this.tcx().sess.add_lint(lint::DefaultTypeParamUsage, id, path.span,
+                                 ~"provided type arguments with defaults");
     }
-    let tps = path.segments
-                  .iter()
-                  .flat_map(|s| s.types.iter())
-                  .map(|&a_t| ast_ty_to_ty(this, rscope, a_t))
-                  .collect();
 
+    let defaults = decl_generics.type_param_defs.slice_from(supplied_ty_param_count)
+                                .iter().map(|&x| x.default.unwrap());
+    let tps = path.segments.iter().flat_map(|s| s.types.iter())
+                            .map(|&a_t| ast_ty_to_ty(this, rscope, a_t))
+                            .chain(defaults).collect();
     substs {
         regions: ty::NonerasedRegions(regions),
         self_ty: self_ty,