Change the ivec type syntax to [T].

This preserves the old syntax for now.

Author: erickt

src/comp/syntax/parse/parser.rs

@@ -554,6 +554,11 @@ fn parse_ty(p: &parser) -> @ast::ty {
  t = ast::ty_vec(parse_mt(p));
  hi = p.get_hi_pos();
  expect(p, token::RBRACKET);
+ } else if (p.peek() == token::LBRACKET) {
+ expect(p, token::LBRACKET);
+ t = ast::ty_ivec(parse_mt(p));
+ hi = p.get_hi_pos();
+ expect(p, token::RBRACKET);
  } else if (eat_word(p, "fn")) {
  let flo = p.get_last_lo_pos();
  t = parse_ty_fn(ast::proto_fn, p, flo);

src/comp/syntax/print/pprust.rs

@@ -287,24 +287,13 @@ fn print_type(s: &ps, ty: &ast::ty) {
  ast::ty_box(mt) { word(s.s, "@"); print_mt(s, mt); }
  ast::ty_vec(mt) { word(s.s, "vec["); print_mt(s, mt); word(s.s, "]"); }
  ast::ty_ivec(mt) {
- let parens =
- alt mt.ty.node {
- ast::ty_box(_) | ast::ty_vec(_) | ast::ty_ptr(_) |
- ast::ty_port(_) | ast::ty_chan(_) {
- true
- }
- ast::ty_path(pt, _) { ivec::len(pt.node.types) > 0u }
- _ { false }
- };
- if parens { popen(s); }
- print_type(s, *mt.ty);
- if parens { pclose(s); }
  word(s.s, "[");
  alt mt.mut {
- ast::mut. { word(s.s, "mutable"); }
- ast::maybe_mut. { word(s.s, "mutable?"); }
+ ast::mut. { word_space(s, "mutable"); }
+ ast::maybe_mut. { word_space(s, "mutable?"); }
  ast::imm. {}
  }
+ print_type(s, *mt.ty);
  word(s.s, "]");
  }
  ast::ty_ptr(mt) { word(s.s, "*"); print_mt(s, mt); }

src/test/bench/task-perf-word-count.rs

@@ -73,13 +73,13 @@ mod map_reduce {
  type reducer = fn(str, getter) ;
 
  tag ctrl_proto {
- find_reducer(u8[], chan[chan[reduce_proto]]);
+ find_reducer([u8], chan[chan[reduce_proto]]);
  mapper_done;
  }
 
  tag reduce_proto { emit_val(int); done; ref; release; }
 
- fn start_mappers(ctrl: chan[ctrl_proto], inputs: vec[str]) -> task[] {
+ fn start_mappers(ctrl: chan[ctrl_proto], inputs: vec[str]) -> [task] {
  let tasks = ~[];
  // log_err "starting mappers";
  for i: str in inputs {

src/test/compiletest/compiletest.rs

@@ -25,7 +25,7 @@ fn main(args: vec[str]) {
  run_tests(config);
 }
 
-fn parse_config(args: &str[]) -> config {
+fn parse_config(args: &[str]) -> config {
  let opts =
  ~[getopts::reqopt("compile-lib-path"),
  getopts::reqopt("run-lib-path"), getopts::reqopt("rustc-path"),
@@ -117,7 +117,7 @@ fn test_opts(config: &config) -> test::test_opts {
 }
 
 type tests_and_conv_fn =
- {tests: test::test_desc[], to_task: fn(&fn() ) -> task };
+ {tests: [test::test_desc], to_task: fn(&fn() ) -> task };
 
 fn make_tests(cx: &cx) -> tests_and_conv_fn {
  log #fmt("making tests from %s", cx.config.src_base);

src/test/compiletest/header.rs

@@ -11,7 +11,7 @@ export is_test_ignored;
 
 type test_props = {
  // Lines that should be expected, in order, on standard out
- error_patterns: str[],
+ error_patterns: [str],
  // Extra flags to pass to the compiler
  compile_flags: option::t[str],
  // If present, the name of a file that this test should match when

src/test/compiletest/procsrv.rs

@@ -27,7 +27,7 @@ type reqchan = chan[request];
 type handle = {task: option::t[task], chan: reqchan};
 
 tag request {
- exec(str, str, str[], chan[response]);
+ exec(str, str, [str], chan[response]);
  stop;
 }
 
@@ -189,7 +189,7 @@ fn clone_str(s: &str) -> str {
  new
 }
 
-fn clone_ivecstr(v: &str[]) -> str[] {
+fn clone_ivecstr(v: &[str]) -> [str] {
  let r = ~[];
  for t: str in ivec::slice(v, 0u, ivec::len(v)) {
  r += ~[clone_str(t)];

src/test/pretty/ivec-type.pp

@@ -0,0 +1,9 @@
+// pp-exact:ivec-type.pp
+
+fn f1(x: [int]) { }
+
+fn g1() { f1(~[1, 2, 3]); }
+
+fn f2(x: [int]) { }
+
+fn g2() { f2(~[1, 2, 3]); }

src/test/pretty/ivec-type.rs

@@ -0,0 +1,9 @@
+// pp-exact:ivec-type.pp
+
+fn f1(x: int[]) { }
+
+fn g1() { f1(~[1, 2, 3]); }
+
+fn f2(x: [int]) { }
+
+fn g2() { f2(~[1, 2, 3]); }

src/test/run-pass/alloca-from-derived-tydesc.rs

@@ -2,6 +2,6 @@ tag option[T] { some(T); none; }
 
 type r[T] = {mutable v: (option[T])[]};
 
-fn f[T]() -> T[] { ret ~[]; }
+fn f[T]() -> [T] { ret ~[]; }
 
-fn main() { let r: r[int] = {mutable v: ~[]}; r.v = f(); }
+fn main() { let r: r[int] = {mutable v: ~[]}; r.v = f(); }

src/test/run-pass/autobind.rs

@@ -1,9 +1,9 @@
-fn f[T](x: &T[]) -> T { ret x.(0); }
+fn f[T](x: &[T]) -> T { ret x.(0); }
 
-fn g(act: fn(&int[]) -> int ) -> int { ret act(~[1, 2, 3]); }
+fn g(act: fn(&[int]) -> int ) -> int { ret act(~[1, 2, 3]); }
 
 fn main() {
  assert (g(f) == 1);
- let f1: fn(&str[]) -> str = f;
+ let f1: fn(&[str]) -> str = f;
  assert (f1(~["x", "y", "z"]) == "x");
-}
+}