Remove seq_kind from ast::expr_vec

src/comp/front/test.rs

@@ -236,7 +236,7 @@ fn mk_test_desc_vec(cx: &test_ctxt) -> @ast::expr {
     }
 
     ret @{id: cx.next_node_id(),
-          node: ast::expr_vec(descs, ast::imm, ast::sk_unique),
+          node: ast::expr_vec(descs, ast::imm),
           span: ast::dummy_sp()};
 }
 

src/comp/middle/trans.rs

@@ -5123,8 +5123,7 @@ fn trans_expr_out(cx: &@block_ctxt, e: &@ast::expr, output: out_method) ->
         ret trans_call(cx, f, none::<ValueRef>, args, e.id);
       }
       ast::expr_cast(val, _) { ret trans_cast(cx, val, e.id); }
-      ast::expr_vec(args, _, ast::sk_rc.) { ret trans_vec(cx, args, e.id); }
+      ast::expr_vec(args, _) {
-      ast::expr_vec(args, _, ast::sk_unique.) {
         ret trans_ivec(cx, args, e.id);
       }
       ast::expr_rec(args, base) { ret trans_rec(cx, args, base, e.id); }

src/comp/middle/tstate/pre_post_conditions.rs

@@ -357,7 +357,7 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
           _ { }
         }
       }
-      expr_vec(args, _, _) { find_pre_post_exprs(fcx, args, e.id); }
+      expr_vec(args, _) { find_pre_post_exprs(fcx, args, e.id); }
       expr_path(p) {
         let rslt = expr_pp(fcx.ccx, e);
         clear_pp(rslt);

src/comp/middle/tstate/states.rs

@@ -312,7 +312,7 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
 
 
     alt e.node {
-      expr_vec(elts, _, _) {
+      expr_vec(elts, _) {
         ret find_pre_post_state_exprs(fcx, pres, e.id,
                                       vec::init_elt(init_assign,
                                                      vec::len(elts)),

src/comp/middle/typeck.rs

@@ -2181,18 +2181,12 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         }
         write::ty_only_fixup(fcx, id, t_1);
       }
-      ast::expr_vec(args, mut, kind) {
+      ast::expr_vec(args, mut) {
         let t: ty::t = next_ty_var(fcx);
         for e: @ast::expr in args {
             bot |= check_expr_with(fcx, e, t);
         }
-        let typ;
+        let typ = ty::mk_ivec(tcx, {ty: t, mut: mut});
-        alt kind {
-          ast::sk_rc. { typ = ty::mk_vec(tcx, {ty: t, mut: mut}); }
-          ast::sk_unique. {
-            typ = ty::mk_ivec(tcx, {ty: t, mut: mut});
-          }
-        }
         write::ty_only_fixup(fcx, id, typ);
       }
       ast::expr_tup(elts) {

src/comp/syntax/ast.rs

@@ -292,7 +292,7 @@ tag seq_kind { sk_unique; sk_rc; }
 type expr = {id: node_id, node: expr_, span: span};
 
 tag expr_ {
-    expr_vec([@expr], mutability, seq_kind);
+    expr_vec([@expr], mutability);
     expr_rec([field], option::t<@expr>);
     expr_call(@expr, [@expr]);
     expr_tup([@expr]);

src/comp/syntax/ext/concat_idents.rs

@@ -5,7 +5,7 @@ import syntax::ast;
 fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      _body: option::t<str>) -> @ast::expr {
     let args: [@ast::expr] = alt arg.node {
-      ast::expr_vec(elts, _, _) { elts }
+      ast::expr_vec(elts, _) { elts }
       _ { cx.span_fatal(sp, "#concat_idents requires a vector argument .") }
     };
     let res: ast::ident = "";

src/comp/syntax/ext/env.rs

@@ -13,7 +13,7 @@ export expand_syntax_ext;
 fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      _body: option::t<str>) -> @ast::expr {
     let args: [@ast::expr] = alt arg.node {
-      ast::expr_vec(elts, _, _) { elts }
+      ast::expr_vec(elts, _) { elts }
       _ { cx.span_fatal(sp, "#env requires arguments of the form `[...]`.") }
     };
     if vec::len::<@ast::expr>(args) != 1u {

src/comp/syntax/ext/fmt.rs

@@ -18,7 +18,7 @@ export expand_syntax_ext;
 fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
                      _body: option::t<str>) -> @ast::expr {
     let args: [@ast::expr] = alt arg.node {
-      ast::expr_vec(elts, _, _) { elts }
+      ast::expr_vec(elts, _) { elts }
       _ { cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.") }
     };
     if vec::len::<@ast::expr>(args) == 0u {
@@ -73,7 +73,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
     }
     fn make_vec_expr(cx: &ext_ctxt, sp: span, exprs: &[@ast::expr]) ->
        @ast::expr {
-        let vecexpr = ast::expr_vec(exprs, ast::imm, ast::sk_unique);
+        let vecexpr = ast::expr_vec(exprs, ast::imm);
         ret @{id: cx.next_id(), node: vecexpr, span: sp};
     }
     fn make_call(cx: &ext_ctxt, sp: span, fn_path: &[ast::ident],

src/comp/syntax/ext/ident_to_str.rs

@@ -6,7 +6,7 @@ import syntax::ast;
 fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
                      _body: option::t<str>) -> @ast::expr {
     let args: [@ast::expr] = alt arg.node {
-      ast::expr_vec(elts, _, _) { elts }
+      ast::expr_vec(elts, _) { elts }
       _ { cx.span_fatal(sp, "#ident_to_str requires a vector argument .") }
     };
     if vec::len::<@ast::expr>(args) != 1u {

src/comp/syntax/ext/simplext.rs

@@ -449,7 +449,7 @@ fn p_t_s_rec(cx: &ext_ctxt, m: &matchable, s: &selector, b: &binders) {
       match_expr(e) {
         alt e.node {
           expr_path(p_pth) { p_t_s_r_path(cx, p_pth, s, b); }
-          expr_vec(p_elts, _, _) {
+          expr_vec(p_elts, _) {
             alt elts_to_ell(cx, p_elts) {
               {pre: pre, rep: some(repeat_me), post: post} {
                 p_t_s_r_length(cx, vec::len(pre) + vec::len(post),
@@ -607,7 +607,7 @@ fn p_t_s_r_ellipses(cx: &ext_ctxt, repeat_me: @expr, offset: uint,
         ret alt m {
               match_expr(e) {
                 alt e.node {
-                  expr_vec(arg_elts, _, _) {
+                  expr_vec(arg_elts, _) {
                     let elts = ~[];
                     let idx = offset;
                     while idx < vec::len(arg_elts) {
@@ -636,7 +636,7 @@ fn p_t_s_r_length(cx: &ext_ctxt, len: uint, at_least: bool, s: selector,
         ret alt m {
               match_expr(e) {
                 alt e.node {
-                  expr_vec(arg_elts, _, _) {
+                  expr_vec(arg_elts, _) {
                     let actual_len = vec::len(arg_elts);
                     if (at_least && actual_len >= len) || actual_len == len {
                         some(leaf(match_exact))
@@ -660,7 +660,7 @@ fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: [@expr], _repeat_after: bool,
             ret alt m {
                   match_expr(e) {
                     alt e.node {
-                      expr_vec(arg_elts, _, _) {
+                      expr_vec(arg_elts, _) {
                         some(leaf(match_expr(arg_elts.(idx))))
                       }
                       _ { none }
@@ -678,7 +678,7 @@ fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: [@expr], _repeat_after: bool,
 fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
                      _body: option::t<str>) -> base::macro_def {
     let args: [@ast::expr] = alt arg.node {
-      ast::expr_vec(elts, _, _) { elts }
+      ast::expr_vec(elts, _) { elts }
       _ {
         cx.span_fatal(sp, "#macro requires arguments of the form `[...]`.")
       }
@@ -688,7 +688,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
     let clauses: [@clause] = ~[];
     for arg: @expr in args {
         alt arg.node {
-          expr_vec(elts, mut, seq_kind) {
+          expr_vec(elts, mut) {
             if vec::len(elts) != 2u {
                 cx.span_fatal((*arg).span,
                               "extension clause must consist of [" +

src/comp/syntax/fold.rs

@@ -339,8 +339,8 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
 
 
     ret alt e {
-          expr_vec(exprs, mut, seq_kind) {
+          expr_vec(exprs, mut) {
-            expr_vec(fld.map_exprs(fld.fold_expr, exprs), mut, seq_kind)
+            expr_vec(fld.map_exprs(fld.fold_expr, exprs), mut)
           }
           expr_rec(fields, maybe_expr) {
             expr_rec(vec::map(fold_field, fields),

src/comp/syntax/parse/parser.rs

@@ -885,7 +885,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
         let es =
             parse_seq_to_end(token::RBRACKET, some(token::COMMA), parse_expr,
                              p);
-        ex = ast::expr_vec(es, mut, ast::sk_unique);
+        ex = ast::expr_vec(es, mut);
     } else if (p.peek() == token::POUND_LT) {
         p.bump();
         let ty = parse_ty(p, false);
@@ -909,7 +909,7 @@ fn parse_bottom_expr(p: &parser) -> @ast::expr {
             let es =
                 parse_seq_to_end(token::RBRACKET, some(token::COMMA),
                                  parse_expr, p);
-            ex = ast::expr_vec(es, mut, ast::sk_unique);
+            ex = ast::expr_vec(es, mut);
           }
           token::LIT_STR(s) {
             p.bump();
@@ -1079,7 +1079,7 @@ fn parse_syntax_ext_naked(p: &parser, lo: uint) -> @ast::expr {
     };
     let hi = es.span.hi;
     let e = mk_expr(p, es.span.lo, hi,
-                    ast::expr_vec(es.node, ast::imm, ast::sk_rc));
+                    ast::expr_vec(es.node, ast::imm));
     ret mk_mac_expr(p, lo, hi, ast::mac_invoc(pth, e, none));
 }
 
@@ -1636,7 +1636,7 @@ fn stmt_ends_with_semi(stmt: &ast::stmt) -> bool {
       }
       ast::stmt_expr(e, _) {
         ret alt e.node {
-              ast::expr_vec(_, _, _) { true }
+              ast::expr_vec(_, _) { true }
               ast::expr_rec(_, _) { true }
               ast::expr_tup(_) { true }
               ast::expr_call(_, _) { true }

src/comp/syntax/print/pprust.rs

@@ -694,7 +694,7 @@ fn print_mac(s: &ps, m: &ast::mac) {
         word(s.s, "#");
         print_path(s, path, false);
         alt (arg.node) {
-          ast::expr_vec(_,_,_) {}
+          ast::expr_vec(_,_) {}
           _ { word(s.s, " "); }
         }
         print_expr(s, arg);
@@ -718,7 +718,7 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
     let ann_node = node_expr(s, expr);
     s.ann.pre(ann_node);
     alt expr.node {
-      ast::expr_vec(exprs, mut, kind) {
+      ast::expr_vec(exprs, mut) {
         ibox(s, indent_unit);
         word(s.s, "[");
         if mut == ast::mut {

src/comp/syntax/visit.rs

@@ -245,7 +245,7 @@ fn visit_mac<E>(m: mac, e: &E, v: &vt<E>) {
 
 fn visit_expr<E>(ex: &@expr, e: &E, v: &vt<E>) {
     alt ex.node {
-      expr_vec(es, _, _) { visit_exprs(es, e, v); }
+      expr_vec(es, _) { visit_exprs(es, e, v); }
       expr_rec(flds, base) {
         for f: field in flds { v.visit_expr(f.node.expr, e, v); }
         visit_expr_opt(base, e, v);