rust/src/test/run-pass/box-inside-if2.rs



// -*- rust -*-

fn some_box(x: int) -> @int { ret @x; }

fn is_odd(n: int) -> bool { ret true; }

fn length_is_even(vs: @int) -> bool { ret true; }

fn foo(acc: int, n: int) {
    if is_odd(n) || length_is_even(some_box(1)) { #error("bloop"); }
}

fn main() { foo(67, 5); }
Reformat source tree (minus a couple tests that are still grumpy). 2011-06-15 11:19:50 -07:00

Started adding support for return checking and non-returning function annotations * Reorganized typestate into several modules. * Made typestate check that any function with a non-nil return type returns a value. For now, the check is a warning and not an error (see next item). * Added a "bot" type (prettyprinted as _\|_), for constructs like be, ret, break, cont, and fail that don't locally return a value that can be inspected. "bot" is distinct from "nil". There is no concrete syntax for _\|_, while the concrete syntax for the nil type is (). * Added support to the parser for a ! annotation on functions whose result type is _\|_. Such a function is required to have either a fail or a call to another ! function that is reached in all control flow paths. The point of this annotation is to mark functions like unimpl() and span_err(), so that an alt with a call to err() in one case isn't a false positive for the return-value checker. I haven't actually annotated anything with it yet. * Random bugfixes: * * Fixed bug in trans::trans_binary that was throwing away the cleanups for nested subexpressions of an and or or (tests: box-inside-if and box-inside-if2). ** In typeck, unify the expected type arguments of a tag with the actual specified arguments. 2011-05-14 19:02:30 -07:00			`// -- rust --`

Convert most working tests to ivecs I tried to pay attention to what was actually being tested so, e.g. when I test was just using a vec as a boxed thing, I converted to boxed ints, etc. Haven't converted the macro tests yet. Not sure what to do there. 2011-08-12 15:42:39 -07:00			`fn some_box(x: int) -> @int { ret @x; }`
Started adding support for return checking and non-returning function annotations * Reorganized typestate into several modules. * Made typestate check that any function with a non-nil return type returns a value. For now, the check is a warning and not an error (see next item). * Added a "bot" type (prettyprinted as _\|_), for constructs like be, ret, break, cont, and fail that don't locally return a value that can be inspected. "bot" is distinct from "nil". There is no concrete syntax for _\|_, while the concrete syntax for the nil type is (). * Added support to the parser for a ! annotation on functions whose result type is _\|_. Such a function is required to have either a fail or a call to another ! function that is reached in all control flow paths. The point of this annotation is to mark functions like unimpl() and span_err(), so that an alt with a call to err() in one case isn't a false positive for the return-value checker. I haven't actually annotated anything with it yet. * Random bugfixes: * * Fixed bug in trans::trans_binary that was throwing away the cleanups for nested subexpressions of an and or or (tests: box-inside-if and box-inside-if2). ** In typeck, unify the expected type arguments of a tag with the actual specified arguments. 2011-05-14 19:02:30 -07:00
Reformat for new syntax 2011-07-27 14:19:39 +02:00			`fn is_odd(n: int) -> bool { ret true; }`
Started adding support for return checking and non-returning function annotations * Reorganized typestate into several modules. * Made typestate check that any function with a non-nil return type returns a value. For now, the check is a warning and not an error (see next item). * Added a "bot" type (prettyprinted as _\|_), for constructs like be, ret, break, cont, and fail that don't locally return a value that can be inspected. "bot" is distinct from "nil". There is no concrete syntax for _\|_, while the concrete syntax for the nil type is (). * Added support to the parser for a ! annotation on functions whose result type is _\|_. Such a function is required to have either a fail or a call to another ! function that is reached in all control flow paths. The point of this annotation is to mark functions like unimpl() and span_err(), so that an alt with a call to err() in one case isn't a false positive for the return-value checker. I haven't actually annotated anything with it yet. * Random bugfixes: * * Fixed bug in trans::trans_binary that was throwing away the cleanups for nested subexpressions of an and or or (tests: box-inside-if and box-inside-if2). ** In typeck, unify the expected type arguments of a tag with the actual specified arguments. 2011-05-14 19:02:30 -07:00
Convert most working tests to ivecs I tried to pay attention to what was actually being tested so, e.g. when I test was just using a vec as a boxed thing, I converted to boxed ints, etc. Haven't converted the macro tests yet. Not sure what to do there. 2011-08-12 15:42:39 -07:00			`fn length_is_even(vs: @int) -> bool { ret true; }`
Started adding support for return checking and non-returning function annotations * Reorganized typestate into several modules. * Made typestate check that any function with a non-nil return type returns a value. For now, the check is a warning and not an error (see next item). * Added a "bot" type (prettyprinted as _\|_), for constructs like be, ret, break, cont, and fail that don't locally return a value that can be inspected. "bot" is distinct from "nil". There is no concrete syntax for _\|_, while the concrete syntax for the nil type is (). * Added support to the parser for a ! annotation on functions whose result type is _\|_. Such a function is required to have either a fail or a call to another ! function that is reached in all control flow paths. The point of this annotation is to mark functions like unimpl() and span_err(), so that an alt with a call to err() in one case isn't a false positive for the return-value checker. I haven't actually annotated anything with it yet. * Random bugfixes: * * Fixed bug in trans::trans_binary that was throwing away the cleanups for nested subexpressions of an and or or (tests: box-inside-if and box-inside-if2). ** In typeck, unify the expected type arguments of a tag with the actual specified arguments. 2011-05-14 19:02:30 -07:00
Reformat for new syntax 2011-07-27 14:19:39 +02:00			`fn foo(acc: int, n: int) {`
Register snapshots and switch logging over to use of log_full or #error / #debug. 2011-12-22 14:42:52 -08:00			`if is_odd(n) \|\| length_is_even(some_box(1)) { #error("bloop"); }`
Started adding support for return checking and non-returning function annotations * Reorganized typestate into several modules. * Made typestate check that any function with a non-nil return type returns a value. For now, the check is a warning and not an error (see next item). * Added a "bot" type (prettyprinted as _\|_), for constructs like be, ret, break, cont, and fail that don't locally return a value that can be inspected. "bot" is distinct from "nil". There is no concrete syntax for _\|_, while the concrete syntax for the nil type is (). * Added support to the parser for a ! annotation on functions whose result type is _\|_. Such a function is required to have either a fail or a call to another ! function that is reached in all control flow paths. The point of this annotation is to mark functions like unimpl() and span_err(), so that an alt with a call to err() in one case isn't a false positive for the return-value checker. I haven't actually annotated anything with it yet. * Random bugfixes: * * Fixed bug in trans::trans_binary that was throwing away the cleanups for nested subexpressions of an and or or (tests: box-inside-if and box-inside-if2). ** In typeck, unify the expected type arguments of a tag with the actual specified arguments. 2011-05-14 19:02:30 -07:00			`}`

Port the tests to the typaram foo<T> syntax. 2011-08-10 09:27:22 -07:00			`fn main() { foo(67, 5); }`