mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
818d7c9398
rust/src/comp/middle/tstate/states.rs

910 lines
35 KiB
Rust
Raw Normal View History

Finally rename std::_xxx to std::xxx Except for _task, which is still a keyword.
2011-05-17 13:41:41 -05:00
import std::vec;
import std::vec::plus_option;
import std::vec::cat_options;
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 21:02:30 -05:00
import std::option;
import std::option::get;
import std::option::is_none;
import std::option::none;
import std::option::some;
import std::option::maybe;
import tstate::ann::pre_and_post;
import tstate::ann::get_post;
import tstate::ann::postcond;
import tstate::ann::empty_pre_post;
import tstate::ann::empty_poststate;
import tstate::ann::require_and_preserve;
import tstate::ann::intersect;
import tstate::ann::empty_prestate;
import tstate::ann::prestate;
import tstate::ann::poststate;
import tstate::ann::false_postcond;
import tstate::ann::ts_ann;
import tstate::ann::extend_prestate;
import tstate::ann::extend_poststate;
import aux::crate_ctxt;
import aux::fn_ctxt;
Redo typestate-related data structures to support predicate constraints. No actual support yet, just infrastructure.
2011-06-01 20:10:10 -05:00
import aux::num_constraints;
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 21:02:30 -05:00
import aux::expr_pp;
import aux::stmt_pp;
import aux::block_pp;
import aux::set_pre_and_post;
import aux::expr_prestate;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import aux::expr_precond;
import aux::expr_postcond;
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 21:02:30 -05:00
import aux::stmt_poststate;
import aux::expr_poststate;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import aux::block_prestate;
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 21:02:30 -05:00
import aux::block_poststate;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import aux::block_precond;
import aux::block_postcond;
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 21:02:30 -05:00
import aux::fn_info;
import aux::log_pp;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import aux::log_pp_err;
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 21:02:30 -05:00
import aux::extend_prestate_ann;
import aux::extend_poststate_ann;
import aux::set_prestate_ann;
import aux::set_poststate_ann;
import aux::pure_exp;
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
import aux::log_tritv;
import aux::log_tritv_err;
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 21:02:30 -05:00
import aux::stmt_to_ann;
import aux::log_states;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import aux::log_states_err;
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 21:02:30 -05:00
import aux::block_states;
import aux::controlflow_expr;
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
import aux::node_id_to_def;
Start to check expr_check and expr_call constraints in typestate Start writing the cases for expr_check and expr_call to take predicates into account, but this isn't working yet.
2011-06-09 11:56:35 -05:00
import aux::expr_to_constr;
Refactor some typestate-related data structures
2011-06-13 20:10:33 -05:00
import aux::ninit;
import aux::npred;
import aux::path_to_ident;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import aux::if_ty;
import aux::if_check;
import aux::plain_if;
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
import aux::forget_in_poststate;
import tritv::tritv_clone;
import tritv::tritv_set;
import tritv::ttrue;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05: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 21:02:30 -05:00
import bitvectors::seq_preconds;
import bitvectors::intersect_postconds;
import bitvectors::declare_var;
import bitvectors::bit_num;
import bitvectors::gen_poststate;
Correctly check that ! functions always diverge Also make _|_ unify with any type.
2011-05-20 21:50:29 -05:00
import bitvectors::kill_poststate;
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 21:02:30 -05:00
import front::ast;
Now imports are not re-exported unless 'export' is explicitly used.
2011-05-31 20:24:06 -05:00
import front::ast::*;
rustc: Teach rustc to use block results as fn return values. Closes #372
2011-05-31 14:24:18 -05:00
import middle::ty::expr_ty;
import middle::ty::type_is_nil;
import middle::ty::type_is_bot;
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 21:02:30 -05:00
import util::common::new_def_hash;
import util::common::uistr;
import util::common::log_expr;
import util::common::log_block;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import util::common::log_block_err;
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 21:02:30 -05:00
import util::common::log_fn;
import util::common::elt_exprs;
import util::common::field_exprs;
import util::common::has_nonlocal_exits;
import util::common::log_stmt;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
import util::common::log_stmt_err;
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 21:02:30 -05:00
import util::common::log_expr_err;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
fn seq_states(&fn_ctxt fcx, prestate pres, vec[@expr] exprs) ->
tup(bool, poststate) {
auto changed = false;
auto post = pres;
for (@expr e in exprs) {
changed = find_pre_post_state_expr(fcx, post, e) || changed;
post = expr_poststate(fcx.ccx, e);
}
ret tup(changed, post);
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 21:02:30 -05:00
}
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
fn find_pre_post_state_exprs(&fn_ctxt fcx, &prestate pres, ast::node_id id,
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
&vec[@expr] es) -> bool {
Remove uses of variable name 'res' from rustc This in preparation of making 'res' a keyword for defining resources. Please don't introduce too many new ones in the meantime...
2011-06-24 12:04:08 -05:00
auto rslt = seq_states(fcx, pres, es);
auto changed = rslt._0;
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
changed = extend_prestate_ann(fcx.ccx, id, pres) || changed;
Remove uses of variable name 'res' from rustc This in preparation of making 'res' a keyword for defining resources. Please don't introduce too many new ones in the meantime...
2011-06-24 12:04:08 -05:00
changed = extend_poststate_ann(fcx.ccx, id, rslt._1) || changed;
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 21:02:30 -05:00
ret changed;
}
Change decl to local in expr_for and expr_for_each Since the decl in a for or for-each loop must always be a local decl, I changed the AST to express this. Fewer potential match failures and "the impossible happened" error messages = yay!
2011-06-13 19:04:15 -05:00
fn find_pre_post_state_loop(&fn_ctxt fcx, prestate pres, &@local l,
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
&@expr index, &block body, node_id id) -> bool {
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 21:02:30 -05:00
auto changed = false;
/* same issues as while */
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
Change decl to local in expr_for and expr_for_each Since the decl in a for or for-each loop must always be a local decl, I changed the AST to express this. Fewer potential match failures and "the impossible happened" error messages = yay!
2011-06-13 19:04:15 -05:00
// FIXME: also want to set l as initialized, no?
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
changed = extend_prestate_ann(fcx.ccx, id, pres) || changed;
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 21:02:30 -05:00
changed = find_pre_post_state_expr(fcx, pres, index) || changed;
/* in general, would need the intersection of
(poststate of index, poststate of body) */
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
find_pre_post_state_block(fcx, expr_poststate(fcx.ccx, index), body)
|| changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
if (has_nonlocal_exits(body)) {
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
changed = set_poststate_ann(fcx.ccx, id, pres) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
auto res_p =
intersect_postconds([expr_poststate(fcx.ccx, index),
block_poststate(fcx.ccx, body)]);
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
changed = extend_poststate_ann(fcx.ccx, id, res_p) || changed;
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 21:02:30 -05:00
ret changed;
}
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
fn gen_if_local(&fn_ctxt fcx, node_id new_var, node_id id, &path p) -> bool {
alt (node_id_to_def(fcx.ccx, new_var)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
case (some(def_local(?loc))) {
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
ret gen_poststate(fcx, id,
rec(id=loc._1,
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
c=ninit(path_to_ident(fcx.ccx.tcx, p))));
}
case (_) { ret false; }
}
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 21:02:30 -05:00
}
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
&option::t[@expr] maybe_alt, ast::node_id id, &if_ty chk,
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
&prestate pres) -> bool {
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
auto changed = false;
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
changed = extend_prestate_ann(fcx.ccx, id, pres) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
changed = find_pre_post_state_expr(fcx, pres, antec) || changed;
/*
log_err("join_then_else:");
log_expr_err(*antec);
log_bitv_err(fcx, expr_prestate(fcx.ccx, antec));
log_bitv_err(fcx, expr_poststate(fcx.ccx, antec));
log_block_err(conseq);
log_bitv_err(fcx, block_prestate(fcx.ccx, conseq));
log_bitv_err(fcx, block_poststate(fcx.ccx, conseq));
log_err("****");
log_bitv_err(fcx, expr_precond(fcx.ccx, antec));
log_bitv_err(fcx, expr_postcond(fcx.ccx, antec));
log_bitv_err(fcx, block_precond(fcx.ccx, conseq));
log_bitv_err(fcx, block_postcond(fcx.ccx, conseq));
*/
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
alt (maybe_alt) {
case (none) {
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
changed =
find_pre_post_state_block(fcx, expr_poststate(fcx.ccx, antec),
conseq) || changed;
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
changed =
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
extend_poststate_ann(fcx.ccx, id,
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
expr_poststate(fcx.ccx, antec))
|| changed;
}
case (some(?altern)) {
changed =
find_pre_post_state_expr(fcx,
expr_poststate(fcx.ccx,
antec),
altern) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
auto conseq_prestate = expr_poststate(fcx.ccx, antec);
alt (chk) {
case (if_check) {
let aux::constr c = expr_to_constr(fcx.ccx.tcx, antec);
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
conseq_prestate = tritv_clone(conseq_prestate);
tritv_set(bit_num(fcx, c.node), conseq_prestate, ttrue);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
}
case (_) {}
}
changed =
find_pre_post_state_block(fcx, conseq_prestate, conseq)
|| changed;
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
auto poststate_res =
intersect_postconds([block_poststate(fcx.ccx, conseq),
expr_poststate(fcx.ccx,
altern)]);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
/* fcx.ccx.tcx.sess.span_note(antec.span,
"poststate_res = " + aux::bitv_to_str(fcx, poststate_res));
fcx.ccx.tcx.sess.span_note(antec.span,
"altern poststate = " +
aux::bitv_to_str(fcx, expr_poststate(fcx.ccx, altern)));
fcx.ccx.tcx.sess.span_note(antec.span,
"conseq poststate = " + aux::bitv_to_str(fcx,
block_poststate(fcx.ccx, conseq))); */
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
changed =
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
extend_poststate_ann(fcx.ccx, id, poststate_res) ||
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
changed;
}
}
ret changed;
}
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 21:02:30 -05:00
fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
auto changed = false;
auto num_local_vars = num_constraints(fcx.enclosing);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
/*
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
log_err("states:");
log_expr_err(*e);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
aux::log_bitv_err(fcx, expr_prestate(fcx.ccx, e));
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
aux::log_bitv_err(fcx, expr_poststate(fcx.ccx, e));
*/
/* FIXME could get rid of some of the copy/paste */
alt (e.node) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_vec(?elts, _, _)) {
ret find_pre_post_state_exprs(fcx, pres, e.id, elts);
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_tup(?elts)) {
ret find_pre_post_state_exprs(fcx, pres, e.id, elt_exprs(elts));
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_call(?operator, ?operands)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* do the prestate for the rator */
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
/* fcx.ccx.tcx.sess.span_note(operator.span,
"pres = " + aux::bitv_to_str(fcx, pres));
*/
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
find_pre_post_state_expr(fcx, pres, operator) || changed;
/* rands go left-to-right */
changed =
find_pre_post_state_exprs(fcx,
expr_poststate(fcx.ccx, operator),
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
e.id, operands) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* if this is a failing call, it sets everything as initialized */
alt (controlflow_expr(fcx.ccx, operator)) {
case (noreturn) {
changed =
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
set_poststate_ann(fcx.ccx, e.id,
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
false_postcond(num_local_vars)) ||
changed;
}
case (_) { }
Insert plumbing for move that behaves just like assign.
2011-05-27 19:38:52 -05:00
}
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
/* fcx.ccx.tcx.sess.span_note(operator.span,
"pres = " + aux::bitv_to_str(fcx, expr_poststate(fcx.ccx, e)));
*/
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
Insert plumbing for move that behaves just like assign.
2011-05-27 19:38:52 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_spawn(_, _, ?operator, ?operands)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, operator);
ret find_pre_post_state_exprs(fcx,
expr_poststate(fcx.ccx, operator),
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
e.id, operands) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_bind(?operator, ?maybe_args)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
find_pre_post_state_expr(fcx, pres, operator) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
ret find_pre_post_state_exprs
(fcx, expr_poststate(fcx.ccx, operator), e.id,
cat_options[@expr](maybe_args)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_path(_)) { ret pure_exp(fcx.ccx, e.id, pres); }
case (expr_log(_, ?ex)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* factor out the "one exp" pattern */
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr(fcx, pres, ex);
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, ex)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_chan(?ex)) {
changed = find_pre_post_state_expr(fcx, pres, ex);
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, ex)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_ext(_, _, _, ?expanded)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, expanded);
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, expanded)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_put(?maybe_e)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
alt (maybe_e) {
case (some(?arg)) {
changed = find_pre_post_state_expr(fcx, pres, arg);
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann
(fcx.ccx, e.id, pres) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, arg)) ||
changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (none) { ret pure_exp(fcx.ccx, e.id, pres); }
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 21:02:30 -05:00
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_lit(?l)) { ret pure_exp(fcx.ccx, e.id, pres); }
// FIXME This was just put in here as a placeholder
case (expr_fn(?f)) { ret pure_exp(fcx.ccx, e.id, pres); }
case (expr_block(?b)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_block(fcx, pres, b) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, block_poststate(fcx.ccx, b)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_rec(?fields, ?maybe_base)) {
changed = find_pre_post_state_exprs
(fcx, pres, e.id, field_exprs(fields)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
alt (maybe_base) {
case (none) {/* do nothing */ }
case (some(?base)) {
changed =
find_pre_post_state_expr(fcx, pres, base) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, base))
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05: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 21:02:30 -05:00
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_move(?lhs, ?rhs)) {
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
extend_prestate_ann(fcx.ccx, e.id, pres);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
alt (lhs.node) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_path(?p)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
// assignment to local var
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = pure_exp(fcx.ccx, lhs.id, pres) || changed;
changed = find_pre_post_state_expr
(fcx, pres, rhs) || changed;
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
// not extending e's poststate,
// because rhs is getting deinit'd anyway
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = gen_if_local(fcx, lhs.id, e.id, p) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
case (_) {
// assignment to something that must already have been
// init'd
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr(fcx, pres, lhs)
|| changed;
changed = find_pre_post_state_expr
(fcx, expr_poststate(fcx.ccx, lhs), rhs)
|| changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, rhs))
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05: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 21:02:30 -05:00
}
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
changed = forget_in_poststate(fcx, rhs.span, e.id, rhs.id)
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_assign(?lhs, ?rhs)) {
extend_prestate_ann(fcx.ccx, e.id, pres);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
alt (lhs.node) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_path(?p)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
// assignment to local var
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = pure_exp(fcx.ccx, lhs.id, pres) || changed;
changed = find_pre_post_state_expr(fcx, pres, rhs)
|| changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, rhs))
|| changed;
changed = gen_if_local(fcx, lhs.id, e.id, p) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
case (_) {
// assignment to something that must already have been
// init'd
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr(fcx, pres, lhs)
|| changed;
changed = find_pre_post_state_expr
(fcx, expr_poststate(fcx.ccx, lhs), rhs) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, rhs))
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Correctly check that ! functions always diverge Also make _|_ unify with any type.
2011-05-20 21:50:29 -05:00
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
Correctly check that ! functions always diverge Also make _|_ unify with any type.
2011-05-20 21:50:29 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_swap(?lhs, ?rhs)) {
Bring swap through typechecking and typestate.
2011-06-13 19:34:54 -05:00
/* quite similar to binary -- should abstract this */
Reformat a bunch of recent churn.
2011-06-16 18:55:46 -05:00
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat a bunch of recent churn.
2011-06-16 18:55:46 -05:00
changed = find_pre_post_state_expr(fcx, pres, lhs) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr
(fcx, expr_poststate(fcx.ccx, lhs), rhs) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, rhs)) || changed;
Reformat a bunch of recent churn.
2011-06-16 18:55:46 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_recv(?lhs, ?rhs)) {
extend_prestate_ann(fcx.ccx, e.id, pres);
rustc: Store the lhs and rhs of receive exprs in left to right order With the changing of receive semantics the parser has been putting the rhs expression in the first argument of expr_recv and the lhs in the second, and all subsequent passes have been referring to them backwords (but still doing the right thing because they were assuming that lhs was the port and rhs was the receiver). This makes all code agree on what lhs and rhs mean for receive expressions.
2011-06-18 22:16:30 -05:00
alt (rhs.node) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_path(?p)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
// receive to local var
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = pure_exp(fcx.ccx, rhs.id, pres) || changed;
changed = find_pre_post_state_expr(fcx, pres, lhs)
|| changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, lhs))
|| changed;
changed = gen_if_local(fcx, rhs.id, e.id, p) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
case (_) {
// receive to something that must already have been init'd
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr
(fcx, pres, rhs) || changed;
changed = find_pre_post_state_expr
(fcx, expr_poststate(fcx.ccx, rhs), lhs) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, lhs))
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05: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 21:02:30 -05:00
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_ret(?maybe_ret_val)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* normally, everything is true if execution continues after
a ret expression (since execution never continues locally
after a ret expression */
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
set_poststate_ann(fcx.ccx, e.id, false_postcond(num_local_vars));
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* return from an always-failing function clears the return bit */
alt (fcx.enclosing.cf) {
case (noreturn) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
kill_poststate(fcx, e.id, rec(id=fcx.id,
c=ninit(fcx.name)));
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
case (_) { }
}
alt (maybe_ret_val) {
case (none) {/* do nothing */ }
case (some(?ret_val)) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr
(fcx, pres, ret_val) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05: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 21:02:30 -05:00
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_be(?val)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
set_poststate_ann(fcx.ccx, e.id, false_postcond(num_local_vars));
changed = find_pre_post_state_expr(fcx, pres, val) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_if(?antec, ?conseq, ?maybe_alt)) {
changed = join_then_else
(fcx, antec, conseq, maybe_alt, e.id, plain_if, pres)
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
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 21:02:30 -05:00
}
rustc: Add ternary operator. Closes #565 The implementation is so simple it might be considered cheating: at almost every step the expr_ternary is just converted to expr_if.
2011-06-23 17:15:50 -05:00
case (expr_ternary(_, _, _)) {
ret find_pre_post_state_expr(fcx, pres, ternary_to_if(e));
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_binary(?bop, ?l, ?r)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* FIXME: what if bop is lazy? */
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 21:02:30 -05:00
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, l) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr
(fcx, expr_poststate(fcx.ccx, l), r) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, r)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_send(?l, ?r)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, l) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = find_pre_post_state_expr
(fcx, expr_poststate(fcx.ccx, l), r) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, r)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_assign_op(?op, ?lhs, ?rhs)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* quite similar to binary -- should abstract this */
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, lhs) || changed;
changed =
find_pre_post_state_expr(fcx, expr_poststate(fcx.ccx, lhs),
rhs) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, rhs)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_while(?test, ?body)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* to handle general predicates, we need to pass in
pres `intersect` (poststate(a))
like: auto test_pres = intersect_postconds(pres,
expr_postcond(a)); However, this doesn't work right now because
we would be passing in an all-zero prestate initially
FIXME
maybe need a "don't know" state in addition to 0 or 1?
*/
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 21:02:30 -05:00
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, test) || changed;
changed =
find_pre_post_state_block(fcx, expr_poststate(fcx.ccx, test),
body) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
/* conservative approximation: if a loop contains a break
or cont, we assume nothing about the poststate */
if (has_nonlocal_exits(body)) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = set_poststate_ann(fcx.ccx, e.id, pres) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
auto e_post = expr_poststate(fcx.ccx, test);
auto b_post = block_poststate(fcx.ccx, body);
ret extend_poststate_ann
(fcx.ccx, e.id, intersect_postconds([e_post, b_post])) ||
changed
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_do_while(?body, ?test)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
auto changed0 = changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_block(fcx, pres, body) || changed;
/* conservative approximination: if the body of the loop
could break or cont, we revert to the prestate
(TODO: could treat cont differently from break, since
if there's a cont, the test will execute) */
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
auto breaks = has_nonlocal_exits(body);
if (breaks) {
// this should probably be true_poststate and not pres,
// b/c the body could invalidate stuff
// FIXME
// This doesn't set "changed", as if the previous state
// was different, this might come back true every time
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
set_poststate_ann(fcx.ccx, body.node.id, pres);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
changed = changed0;
}
changed =
find_pre_post_state_expr(fcx, block_poststate(fcx.ccx, body),
test) || changed;
if (breaks) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
set_poststate_ann(fcx.ccx, e.id, pres);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
}
else {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_poststate_ann(fcx.ccx, e.id,
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
expr_poststate(fcx.ccx, test)) ||
changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_for(?d, ?index, ?body)) {
ret find_pre_post_state_loop(fcx, pres, d, index, body, e.id);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_for_each(?d, ?index, ?body)) {
ret find_pre_post_state_loop(fcx, pres, d, index, body, e.id);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_index(?val, ?sub)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
changed = find_pre_post_state_expr(fcx, pres, val) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
find_pre_post_state_expr
(fcx, expr_poststate(fcx.ccx, val), sub) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
extend_poststate_ann(fcx.ccx, e.id,
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
expr_poststate(fcx.ccx, sub));
ret changed;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_alt(?val, ?alts)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
changed = find_pre_post_state_expr(fcx, pres, val) || changed;
auto e_post = expr_poststate(fcx.ccx, val);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
auto a_post;
if (vec::len[arm](alts) > 0u) {
a_post = false_postcond(num_local_vars);
for (arm an_alt in alts) {
changed =
find_pre_post_state_block(fcx, e_post, an_alt.block)
|| changed;
intersect(a_post, block_poststate(fcx.ccx, an_alt.block));
// We deliberately do *not* update changed here, because
// we'd go into an infinite loop that way, and the change
// gets made after the if expression.
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 21:02:30 -05:00
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
} else {
// No alts; poststate is the poststate of the test
a_post = e_post;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_poststate_ann(fcx.ccx, e.id, a_post) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_field(?val, _)) {
changed = find_pre_post_state_expr(fcx, pres, val);
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
changed = extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, val)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
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 21:02:30 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_unary(_, ?operand)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, operand) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
ret extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, operand))
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_cast(?operand, _)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, operand) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
ret extend_poststate_ann
(fcx.ccx, e.id, expr_poststate(fcx.ccx, operand))
|| changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_fail(_)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* if execution continues after fail, then everything is true!
woo! */
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = set_poststate_ann
(fcx.ccx, e.id, false_postcond(num_local_vars)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_assert(?p)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
changed = find_pre_post_state_expr(fcx, pres, p) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_poststate_ann(fcx.ccx, e.id, pres) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_check(?p)) {
changed = extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed = find_pre_post_state_expr(fcx, pres, p) || changed;
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = extend_poststate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/* predicate p holds after this expression executes */
let aux::constr c = expr_to_constr(fcx.ccx.tcx, p);
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
changed = gen_poststate(fcx, e.id, c.node) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
ret changed;
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_if_check(?p, ?conseq, ?maybe_alt)) {
changed = join_then_else
(fcx, p, conseq, maybe_alt, e.id, if_check, pres) || changed;
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
Bring back if-check Add "if check" (expr_if_check), a variation on check that executes an "else" clause rather than failing if the check doesn't hold.
2011-06-16 13:56:34 -05:00
ret changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (expr_break) { ret pure_exp(fcx.ccx, e.id, pres); }
case (expr_cont) { ret pure_exp(fcx.ccx, e.id, pres); }
case (expr_port) { ret pure_exp(fcx.ccx, e.id, pres); }
case (expr_self_method(_)) { ret pure_exp(fcx.ccx, e.id, pres); }
case (expr_anon_obj(?anon_obj, _, _)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
alt (anon_obj.with_obj) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (some(?wt)) {
changed = find_pre_post_state_expr(fcx, pres, wt);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
extend_prestate_ann(fcx.ccx, e.id, pres) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
extend_poststate_ann(fcx.ccx, e.id,
expr_poststate(fcx.ccx, wt)) ||
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed;
ret changed;
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (none) { ret pure_exp(fcx.ccx, e.id, pres); }
More work on anonymous objects.
2011-05-20 19:41:36 -05: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 21:02:30 -05:00
}
fn find_pre_post_state_stmt(&fn_ctxt fcx, &prestate pres, @stmt s) -> bool {
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
auto changed = false;
auto stmt_ann = stmt_to_ann(fcx.ccx, *s);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
/*
log_err "*At beginning: stmt = ";
log_stmt_err(*s);
log_err "*prestate = ";
log_err bitv::to_str(stmt_ann.states.prestate);
log_err "*poststate =";
log_err bitv::to_str(stmt_ann.states.poststate);
log_err "*changed =";
log_err changed;
*/
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
alt (s.node) {
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
case (stmt_decl(?adecl, ?id)) {
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
alt (adecl.node) {
case (decl_local(?alocal)) {
Consistify ast::local.
2011-06-16 17:58:25 -05:00
alt (alocal.node.init) {
rustc: Remove unneeded type params from alt patterns
2011-05-30 23:39:19 -05:00
case (some(?an_init)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
extend_prestate(stmt_ann.states.prestate,
pres) || changed;
changed =
find_pre_post_state_expr(fcx, pres,
Consistify ast::local.
2011-06-16 17:58:25 -05:00
an_init.expr)
|| changed;
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
/* FIXME less copypasta */
alt (an_init.op) {
case (init_move) {
changed = forget_in_poststate(fcx,
an_init.expr.span, id, an_init.expr.id)
|| changed;
/* Safe to forget rhs's poststate here 'cause it's a var. */
}
case (_) { /* nothing gets deinitialized */
changed =
extend_poststate(
stmt_ann.states.poststate,
expr_poststate(fcx.ccx, an_init.expr))
|| changed;
}
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
gen_poststate(fcx, id,
Consistify ast::local.
2011-06-16 17:58:25 -05:00
rec(id=alocal.node.id,
c=ninit(alocal.node.ident)))
|| changed;
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
/*
log_err "Summary: stmt = ";
log_stmt_err(*s);
log_err "prestate = ";
log_tritv_err(fcx, stmt_ann.states.prestate);
log_err "poststate =";
log_tritv_err(fcx, stmt_ann.states.poststate);
log_err "changed =";
log_err changed;
*/
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
ret changed;
}
rustc: Remove unneeded type params from alt patterns
2011-05-30 23:39:19 -05:00
case (none) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
extend_prestate(stmt_ann.states.prestate,
pres) || changed;
changed =
extend_poststate(stmt_ann.states.poststate,
pres) || changed;
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
ret changed;
}
}
}
case (decl_item(?an_item)) {
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
extend_prestate(stmt_ann.states.prestate, pres) ||
changed;
changed =
extend_poststate(stmt_ann.states.poststate, pres) ||
changed;
Eliminate explicit recursion in tstate.states (walk does that now), and kill dead code.
2011-05-18 20:03:48 -05:00
/* the outer "walk" will recurse into the item */
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
Eliminate explicit recursion in tstate.states (walk does that now), and kill dead code.
2011-05-18 20:03:48 -05:00
ret changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05: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 21:02:30 -05:00
}
}
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
case (stmt_expr(?ex, _)) {
changed = find_pre_post_state_expr(fcx, pres, ex) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
extend_prestate(stmt_ann.states.prestate,
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
expr_prestate(fcx.ccx, ex)) || changed;
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
changed =
extend_poststate(stmt_ann.states.poststate,
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
expr_poststate(fcx.ccx, ex)) || changed;
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
/*
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
log_err("Summary: stmt = ");
log_stmt_err(*s);
log_err("prestate = ");
// log_err(bitv::to_str(stmt_ann.states.prestate));
log_tritv_err(fcx, stmt_ann.states.prestate);
log_err("poststate =");
// log_err(bitv::to_str(stmt_ann.states.poststate));
log_tritv_err(fcx, stmt_ann.states.poststate);
log_err("changed =");
log_err(changed);
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
*/
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
ret changed;
}
case (_) { ret false; }
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 21:02:30 -05:00
}
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05: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 21:02:30 -05:00
/* Updates the pre- and post-states of statements in the block,
returns a boolean flag saying whether any pre- or poststates changed */
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
fn find_pre_post_state_block(&fn_ctxt fcx, &prestate pres0, &block b) ->
bool {
auto changed = false;
auto num_local_vars = num_constraints(fcx.enclosing);
/* First, set the pre-states and post-states for every expression */
auto pres = pres0;
/* Iterate over each stmt. The new prestate is <pres>. The poststate
consist of improving <pres> with whatever variables this stmt
initializes. Then <pres> becomes the new poststate. */
for (@stmt s in b.node.stmts) {
changed = find_pre_post_state_stmt(fcx, pres, s) || changed;
pres = stmt_poststate(fcx.ccx, *s);
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 21:02:30 -05:00
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
auto post = pres;
alt (b.node.expr) {
case (none) { }
case (some(?e)) {
changed = find_pre_post_state_expr(fcx, pres, e) || changed;
post = expr_poststate(fcx.ccx, e);
}
}
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
set_prestate_ann(fcx.ccx, b.node.id, pres0);
set_poststate_ann(fcx.ccx, b.node.id, post);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
/*
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
log_err "For block:";
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
log_block_err(b);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
log_err "poststate = ";
log_states_err(block_states(fcx.ccx, b));
log_err "pres0:";
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
log_tritv_err(fcx, pres0);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
log_err "post:";
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
log_tritv_err(fcx, post);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
*/
ret changed;
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 21:02:30 -05:00
}
fn find_pre_post_state_fn(&fn_ctxt fcx, &_fn f) -> bool {
Redo typestate-related data structures to support predicate constraints. No actual support yet, just infrastructure.
2011-06-01 20:10:10 -05:00
auto num_local_vars = num_constraints(fcx.enclosing);
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
auto changed =
Compute typestate properly for move typestate now drops constraints correctly in the post-state of a move expression or a declaration whose op is a move. It doesn't yet drop constraints mentioning variables that get updated. To do this, I had to change typestate to use trit-vectors instead of bit-vectors, because for every constraint, there are three possible values: known-to-be-false (e.g. after x <- y, init(y) is known-to-be-false), known-to-be-true, and unknown. Before, we conflated known-to-be-false with unknown. But move requires them to be treated differently. Consider: (program a) (a1) x = 1; (a2) y <- x; (a3) log x; (program b) (b1) x = 1; (b2) y <- z; (b3) log x; With only two values, the postcondition of statement a2 for constraint init(x) is the same as that of b2: 0. But in (a2)'s postcondition, init(x) *must* be false, but in (b2)'s condition, it's just whatever it was in the postcondition of the preceding statement.
2011-06-22 23:26:34 -05:00
find_pre_post_state_block(fcx, block_prestate(fcx.ccx, f.body),
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
f.body);
rustc: Teach rustc to use block results as fn return values. Closes #372
2011-05-31 14:24:18 -05:00
// Treat the tail expression as a return statement
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
rustc: Teach rustc to use block results as fn return values. Closes #372
2011-05-31 14:24:18 -05:00
alt (f.body.node.expr) {
case (some(?tailexpr)) {
auto tailty = expr_ty(fcx.ccx.tcx, tailexpr);
// Since blocks and alts and ifs that don't have results
// implicitly result in nil, we have to be careful to not
// interpret nil-typed block results as the result of a
// function with some other return type
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
if (!type_is_nil(fcx.ccx.tcx, tailty) &&
!type_is_bot(fcx.ccx.tcx, tailty)) {
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
auto p = false_postcond(num_local_vars);
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
set_poststate_ann(fcx.ccx, tailexpr.id, p);
Restructure the "checking" pass in typestate I noticed that typestate was being lazier than it should be, because it was only checking typestate for statements and top-level expression (that is, the expression in a stmt_expr, but not any subexpressions). So I rewrote the checks in tstate/ck.rs to use walk, which exposed a few bugs in typestate that I fixed. Also added some more test cases for if-check.
2011-06-17 21:07:23 -05:00
// be sure to set the block poststate to the same thing
Get rid of def_ids and anns in AST nodes, use single node_id This reduces some redundancy in the AST data structures and cruft in the code that works with them. To get a def_id from a node_id, apply ast::local_def, which adds the local crate_num to the given node_id. Most code only deals with crate-local node_ids, and won't have to create def_ids at all.
2011-06-19 15:41:21 -05:00
set_poststate_ann(fcx.ccx, f.body.node.id, p);
rustc: Teach rustc to use block results as fn return values. Closes #372
2011-05-31 14:24:18 -05:00
alt (fcx.enclosing.cf) {
case (noreturn) {
Move expr ids into the expr record type This simplifies the tag variants a bit and makes expr_node_id obsolete.
2011-06-21 15:16:40 -05:00
kill_poststate(fcx, tailexpr.id,
Refactor some typestate-related data structures
2011-06-13 20:10:33 -05:00
rec(id=fcx.id, c=ninit(fcx.name)));
rustc: Teach rustc to use block results as fn return values. Closes #372
2011-05-31 14:24:18 -05:00
}
case (_) { }
}
}
}
Reformat source tree (minus a couple tests that are still grumpy).
2011-06-15 13:19:50 -05:00
case (none) {/* fallthrough */ }
rustc: Teach rustc to use block results as fn return values. Closes #372
2011-05-31 14:24:18 -05:00
}
ret changed;
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 21:02:30 -05:00
}
Rewrite tstate.annotate to use walk instead of fold and various other tidying in typestate
2011-05-18 17:43:05 -05:00
//
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End:
//
Reference in New Issue Copy Permalink