Add support for unit literals to const_eval.
#![allow(non_camel_case_types)]
-use middle::const_eval::{compare_const_vals, const_bool, const_float, const_val};
+use middle::const_eval::{compare_const_vals, const_bool, const_float, const_nil, const_val};
use middle::const_eval::{eval_const_expr, lookup_const_by_id};
use middle::def::*;
use middle::pat_util::*;
fn const_val_to_expr(value: &const_val) -> Gc<Expr> {
let node = match value {
&const_bool(b) => LitBool(b),
+ &const_nil => LitNil,
_ => unreachable!()
};
box(GC) Expr {
ty::ty_bool =>
[true, false].iter().map(|b| val(const_bool(*b))).collect(),
+ ty::ty_nil =>
+ vec!(val(const_nil)),
+
ty::ty_rptr(_, ty::mt { ty: ty, .. }) => match ty::get(ty).sty {
ty::ty_vec(_, None) => vec_constructors(m),
_ => vec!(single)
ty::ty_vec(_, Some(n)) =>
vec!(vec(n)),
- ty::ty_nil if !m.iter().all(|r| is_wild(cx, *r.get(0))) =>
- vec!(),
-
_ =>
vec!(single)
}
const_uint(u64),
const_str(InternedString),
const_binary(Rc<Vec<u8> >),
- const_bool(bool)
+ const_bool(bool),
+ const_nil
}
pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val {
LitFloat(ref n, _) | LitFloatUnsuffixed(ref n) => {
const_float(from_str::<f64>(n.get()).unwrap() as f64)
}
- LitNil => const_int(0i64),
+ LitNil => const_nil,
LitBool(b) => const_bool(b)
}
}
(&const_str(ref a), &const_str(ref b)) => compare_vals(a, b),
(&const_bool(a), &const_bool(b)) => compare_vals(a, b),
(&const_binary(ref a), &const_binary(ref b)) => compare_vals(a, b),
+ (&const_nil, &const_nil) => compare_vals((), ()),
_ => None
}
}
repeat count but found binary array");
return 0;
}
+ const_eval::const_nil => {
+ tcx.ty_ctxt().sess.span_err(count_expr.span,
+ "expected positive integer for \
+ repeat count but found ()");
+ return 0;
+ }
},
Err(..) => {
tcx.ty_ctxt().sess.span_err(count_expr.span,
--- /dev/null
+// Copyright 2014 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.
+
+pub enum T {
+ T1(()),
+ T2(())
+}
+
+pub enum V {
+ V1(int),
+ V2(bool)
+}
+
+fn main() {
+ match (T1(()), V2(true)) {
+ //~^ ERROR non-exhaustive patterns: `(T1(()), V2(_))` not covered
+ (T1(()), V1(i)) => (),
+ (T2(()), V2(b)) => ()
+ }
+}
}
}
-fn main() {
- struct_with_a_nested_enum_and_vector();
- enum_with_multiple_missing_variants();
- enum_struct_variant();
+fn missing_nil() {
+ match ((), false) {
+ //~^ ERROR non-exhaustive patterns: `((), false)` not covered
+ ((), true) => ()
+ }
}
+
+fn main() {}
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
fn main() {
let n = 1;
let a = [0, ..n]; //~ ERROR expected constant integer for repeat count but found variable
+ let b = [0, ..()]; //~ ERROR expected positive integer for repeat count but found ()
+ let c = [0, ..true]; //~ ERROR expected positive integer for repeat count but found boolean
+ let d = [0, ..0.5]; //~ ERROR expected positive integer for repeat count but found float
+ let e = [0, .."foo"]; //~ ERROR expected positive integer for repeat count but found string
+ let f = [0, ..-4];
+ //~^ ERROR expected positive integer for repeat count but found negative integer
}
--- /dev/null
+// Copyright 2014 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.
+
+pub enum T {
+ T1(()),
+ T2(())
+}
+
+pub enum V {
+ V1(int),
+ V2(bool)
+}
+
+fn foo(x: (T, V)) -> String {
+ match x {
+ (T1(()), V1(i)) => format!("T1(()), V1({})", i),
+ (T2(()), V2(b)) => format!("T2(()), V2({})", b),
+ _ => String::new()
+ }
+}
+
+
+fn main() {
+ assert_eq!(foo((T1(()), V1(99))), "T1(()), V1(99)".to_string());
+ assert_eq!(foo((T2(()), V2(true))), "T2(()), V2(true)".to_string());
+}