}
// expr[...]
- // An index expression.
+ // Could be either an index expression or a slicing expression.
token::OpenDelim(token::Bracket) => {
let bracket_pos = self.span.lo;
self.bump();
"use `&expr[]` to construct a slice of the whole of expr");
}
}
-
- // A range expression, either `expr..expr` or `expr..`.
- token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => {
- self.bump();
-
- let opt_end = if self.token.can_begin_expr() {
- let end = self.parse_expr_res(RESTRICTION_NO_DOTS);
- Some(end)
- } else {
- None
- };
-
- let hi = self.span.hi;
- let range = self.mk_range(Some(e), opt_end);
- return self.mk_expr(lo, hi, range);
- }
_ => return e
}
}
token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => {
// A range, closed above: `..expr`.
self.bump();
- let e = self.parse_prefix_expr();
+ let e = self.parse_expr();
hi = e.span.hi;
ex = self.mk_range(None, Some(e));
}
self.restrictions.contains(RESTRICTION_NO_BAR_OP) {
return lhs;
}
+
self.expected_tokens.push(TokenType::Operator);
let cur_opt = self.token.to_binop();
let cur_prec = operator_prec(cur_op);
if cur_prec > min_prec {
self.bump();
+ // TODO
let expr = self.parse_prefix_expr();
let rhs = self.parse_more_binops(expr, cur_prec);
let lhs_span = lhs.span;
let assign_op = self.mk_assign_op(aop, lhs, rhs);
self.mk_expr(span.lo, rhs_span.hi, assign_op)
}
+ // TODO
+ // A range expression, either `expr..expr` or `expr..`.
+ token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => {
+ self.bump();
+
+ let opt_end = if self.token.can_begin_expr() {
+ // TODO only use of RES...DOT
+ let end = self.parse_expr_res(RESTRICTION_NO_DOTS);
+ Some(end)
+ } else {
+ None
+ };
+
+ let lo = lhs.span.lo;
+ let hi = self.span.hi;
+ let range = self.mk_range(Some(lhs), opt_end);
+ return self.mk_expr(lo, hi, range);
+ }
+
_ => {
lhs
}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test that the precedence of ranges is correct
+
+#![feature(slicing_syntax)]
+
+struct Foo {
+ foo: uint,
+}
+
+impl Foo {
+ fn bar(&self) -> uint { 5 }
+}
+
+fn main() {
+ let x = 1+3..4+5;
+ assert!(x == (4..9));
+
+ let x = 1..4+5;
+ assert!(x == (1..9));
+
+ let x = 1+3..4;
+ assert!(x == (4..4));
+
+ let a = Foo { foo: 3 };
+ let x = a.foo..a.bar();
+ assert!(x == (3..5));
+
+ let x = 1+3..;
+ assert!(x == (4..));
+ let x = ..1+3;
+ assert!(x == (..4));
+
+ let a = &[0i32, 1, 2, 3, 4, 5, 6];
+ let x = &a[1+1..2+2];
+ assert!(x == &a[2..4]);
+ let x = &a[..1+2];
+ assert!(x == &a[..3]);
+ let x = &a[1+2..];
+ assert!(x == &a[3..]);
+
+ for _i in 2+4..10-3 {}
+}
+