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



// -*- rust -*-
use std;
import std::vec;

fn some_vec(int x) -> vec[int] { ret []; }

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

fn length_is_even(vec[int] vs) -> bool { ret true; }

fn foo(int acc, int n) {
    if (is_odd(n) || length_is_even(some_vec(1))) { log_err "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 --`
			`use std;`
Finally rename std::_xxx to std::xxx Except for _task, which is still a keyword. 2011-05-17 20:41:41 +02:00			`import std::vec;`
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 source tree (minus a couple tests that are still grumpy). 2011-06-15 11:19:50 -07:00			`fn some_vec(int x) -> vec[int] { ret []; }`
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
			`fn is_odd(int n) -> bool { ret true; }`

Reformat source tree (minus a couple tests that are still grumpy). 2011-06-15 11:19:50 -07:00			`fn length_is_even(vec[int] vs) -> 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 source tree (minus a couple tests that are still grumpy). 2011-06-15 11:19:50 -07:00			`fn foo(int acc, int n) {`
			`if (is_odd(n) \|\| length_is_even(some_vec(1))) { log_err "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			`}`

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