Teach parser and related things to understand const kind bounds.

Author: eholk

src/librustsyntax/ast.rs

@@ -59,6 +59,7 @@ const crate_node_id: node_id = 0;
 enum ty_param_bound {
     bound_copy,
     bound_send,
+    bound_const,
     bound_iface(@ty),
 }
 

src/librustsyntax/fold.rs

@@ -137,7 +137,7 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
 
 fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
     alt tpb {
-      bound_copy | bound_send { tpb }
+      bound_copy | bound_send | bound_const { tpb }
       bound_iface(ty) { bound_iface(fld.fold_ty(ty)) }
     }
 }

src/librustsyntax/parse/parser.rs

@@ -1676,8 +1676,11 @@ class parser {
         let ident = self.parse_ident();
         if self.eat(token::COLON) {
             while self.token != token::COMMA && self.token != token::GT {
-                if self.eat_keyword("send") { bounds += [bound_send]; }
-                else if self.eat_keyword("copy") { bounds += [bound_copy]; }
+                if self.eat_keyword(self, "send") { bounds += [bound_send]; }
+                else if self.eat_keyword(self, "copy")
+                    { bounds += [bound_copy]; }
+                else if self.eat_keyword(self, "const")
+                    { bounds += [bound_const]; }
                 else { bounds += [bound_iface(self.parse_ty(false))]; }
             }
         }

src/librustsyntax/print/pprust.rs

@@ -1400,6 +1400,7 @@ fn print_bounds(s: ps, bounds: @[ast::ty_param_bound]) {
             alt bound {
               ast::bound_copy { word(s.s, "copy"); }
               ast::bound_send { word(s.s, "send"); }
+              ast::bound_const { word(s.s, "const"); }
               ast::bound_iface(t) { print_type(s, t); }
             }
         }

src/librustsyntax/visit.rs

@@ -261,7 +261,7 @@ fn visit_ty_params<E>(tps: [ty_param], e: E, v: vt<E>) {
         for vec::each(*tp.bounds) {|bound|
             alt bound {
               bound_iface(t) { v.visit_ty(t, e, v); }
-              bound_copy | bound_send { }
+              bound_copy | bound_send | bound_const { }
             }
         }
     }

src/rustc/metadata/tydecode.rs

@@ -501,6 +501,7 @@ fn parse_bounds(st: @pstate, conv: conv_did) -> @[ty::param_bound] {
         bounds += [alt check next(st) {
           'S' { ty::bound_send }
           'C' { ty::bound_copy }
+          'K' { ty::bound_const }
           'I' { ty::bound_iface(parse_ty(st, conv)) }
           '.' { break; }
         }];

src/rustc/metadata/tyencode.rs

@@ -392,6 +392,7 @@ fn enc_bounds(w: io::writer, cx: @ctxt, bs: @[ty::param_bound]) {
         alt bound {
           ty::bound_send { w.write_char('S'); }
           ty::bound_copy { w.write_char('C'); }
+          ty::bound_const { w.write_char('K'); }
           ty::bound_iface(tp) {
             w.write_char('I');
             enc_ty(w, cx, tp);

src/rustc/middle/ty.rs

@@ -401,6 +401,7 @@ enum type_err {
 enum param_bound {
     bound_copy,
     bound_send,
+    bound_const,
     bound_iface(t),
 }
 

src/rustc/middle/typeck/check/method.rs

@@ -47,7 +47,9 @@ impl methods for lookup {
         let bounds = tcx.ty_param_bounds.get(did.node);
         for vec::each(*bounds) {|bound|
             let (iid, bound_substs) = alt bound {
-              ty::bound_copy | ty::bound_send { cont; /* ok */ }
+              ty::bound_copy | ty::bound_send | ty::bound_const {
+                cont; /* ok */
+              }
               ty::bound_iface(bound_t) {
                 alt check ty::get(bound_t).struct {
                   ty::ty_iface(i, substs) { (i, substs) }

src/rustc/middle/typeck/check/vtable.rs

@@ -67,7 +67,9 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
         let mut n_bound = 0u;
         for vec::each(*tcx.ty_param_bounds.get(did.node)) { |bound|
             alt bound {
-              ty::bound_send | ty::bound_copy { /* ignore */ }
+              ty::bound_send | ty::bound_copy | ty::bound_const {
+                /* ignore */
+              }
               ty::bound_iface(ity) {
                 alt check ty::get(ity).struct {
                   ty::ty_iface(idid, substs) {

src/rustc/middle/typeck/collect.rs

@@ -657,6 +657,7 @@ fn ty_param_bounds(ccx: @crate_ctxt,
             alt b {
               ast::bound_send { [ty::bound_send] }
               ast::bound_copy { [ty::bound_copy] }
+              ast::bound_const { [ty::bound_const] }
               ast::bound_iface(t) {
                 let ity = ast_ty_to_ty(ccx, empty_rscope, t);
                 alt ty::get(ity).struct {

src/test/run-pass/const-bound.rs

@@ -0,0 +1,13 @@
+// Make sure const bounds work on things, and test that a few types
+// are const.
+
+
+fn foo<T: copy const>(x: T) -> T { x }
+
+fn main() {
+    foo(1);
+    foo("hi");
+    foo([1, 2, 3]);
+    foo({field: 42});
+    foo((1, 2u));
+}