rustc: Introduce the concept of inline to the AST

Author: pcwalton

src/comp/front/test.rs

@@ -59,7 +59,7 @@ fn fold_mod(cx: &test_ctxt, m: &ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     // we want to be main.
     fn nomain(item: &@ast::item) -> option::t[@ast::item] {
         alt item.node {
-          ast::item_fn(f, _) {
+          ast::item_fn(f, _, _) {
             if item.ident == "main" {
                 option::none
             } else { option::some(item) }
@@ -107,7 +107,7 @@ fn is_test_fn(i: &@ast::item) -> bool {
 
     fn has_test_signature(i: &@ast::item) -> bool {
         alt i.node {
-          ast::item_fn(f, tps) {
+          ast::item_fn(f, tps, _) {
             let input_cnt = ivec::len(f.decl.inputs);
             let no_output = f.decl.output.node == ast::ty_nil;
             let tparm_cnt = ivec::len(tps);
@@ -191,7 +191,7 @@ fn mk_tests(cx: &test_ctxt) -> @ast::item {
 
     let fn_ = {decl: decl, proto: proto, body: body};
 
-    let item_ = ast::item_fn(fn_, ~[]);
+    let item_ = ast::item_fn(fn_, ~[], ast::il_normal);
     let item: ast::item =
         {ident: "tests",
          attrs: ~[],
@@ -309,7 +309,7 @@ fn mk_main(cx: &test_ctxt) -> @ast::item {
 
     let fn_ = {decl: decl, proto: proto, body: body};
 
-    let item_ = ast::item_fn(fn_, ~[]);
+    let item_ = ast::item_fn(fn_, ~[], ast::il_normal);
     let item: ast::item =
         {ident: "main",
          attrs: ~[],

src/comp/metadata/encoder.rs

@@ -81,7 +81,7 @@ fn encode_module_item_paths(ebml_w: &ebmlivec::writer, module: &_mod,
             encode_def_id(ebml_w, local_def(it.id));
             ebmlivec::end_tag(ebml_w);
           }
-          item_fn(_, tps) {
+          item_fn(_, tps, _) {
             add_to_index(ebml_w, path, index, it.ident);
             ebmlivec::start_tag(ebml_w, tag_paths_data_item);
             encode_name(ebml_w, it.ident);
@@ -250,7 +250,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: &ebmlivec::writer,
         encode_symbol(ecx, ebml_w, item.id);
         ebmlivec::end_tag(ebml_w);
       }
-      item_fn(fd, tps) {
+      item_fn(fd, tps, _) {
         ebmlivec::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w,

src/comp/middle/alias.rs

@@ -4,6 +4,7 @@ import ast::ident;
 import ast::fn_ident;
 import ast::node_id;
 import ast::def_id;
+import ast::inlineness;
 import syntax::codemap::span;
 import syntax::visit;
 import visit::vt;
@@ -42,7 +43,7 @@ fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
     // Stores information about object fields and function
     // arguments that's otherwise not easily available.
     let cx = @{tcx: tcx, local_map: std::map::new_int_hash()};
-    let v = @{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _),
+    let v = @{visit_fn: bind visit_fn(cx, _, _, _, _, _, _, _, _),
               visit_item: bind visit_item(cx, _, _, _),
               visit_expr: bind visit_expr(cx, _, _, _),
               visit_decl: bind visit_decl(cx, _, _, _)
@@ -51,8 +52,9 @@ fn check_crate(tcx: ty::ctxt, crate: &@ast::crate) {
     tcx.sess.abort_if_errors();
 }
 
-fn visit_fn(cx: &@ctx, f: &ast::_fn, tp: &ast::ty_param[], sp: &span,
-            name: &fn_ident, id: ast::node_id, sc: &scope, v: &vt[scope]) {
+fn visit_fn(cx: &@ctx, f: &ast::_fn, tp: &ast::ty_param[], il: inlineness,
+            sp: &span, name: &fn_ident, id: ast::node_id, sc: &scope,
+            v: &vt[scope]) {
     visit::visit_fn_decl(f.decl, sc, v);
     for arg_: ast::arg  in f.decl.inputs {
         cx.local_map.insert(arg_.id, arg(arg_.mode));

src/comp/middle/freevars.rs

@@ -8,6 +8,7 @@ import std::option;
 import std::int;
 import std::option::*;
 import syntax::ast;
+import syntax::ast::inlineness;
 import syntax::visit;
 import driver::session;
 import middle::resolve;
@@ -45,8 +46,8 @@ fn collect_freevars(def_map: &resolve::def_map, sess: &session::session,
     for decl: ast::node_id  in initial_decls { set_add(decls, decl); }
     let refs = @mutable ~[];
 
-    let walk_fn = lambda(f: &ast::_fn, tps: &ast::ty_param[], sp: &span,
-                         i: &ast::fn_ident, nid: ast::node_id) {
+    let walk_fn = lambda(f: &ast::_fn, tps: &ast::ty_param[], il: inlineness,
+                         sp: &span, i: &ast::fn_ident, nid: ast::node_id) {
         for a: ast::arg  in f.decl.inputs { set_add(decls, a.id); }
     };
     let walk_expr = lambda(expr: &@ast::expr) {
@@ -107,10 +108,10 @@ fn annotate_freevars(sess: &session::session, def_map: &resolve::def_map,
                      crate: &@ast::crate) -> freevar_map {
     let freevars = new_int_hash();
 
-    let walk_fn = lambda(f: &ast::_fn, tps: &ast::ty_param[], sp: &span,
-                         i: &ast::fn_ident, nid: ast::node_id) {
+    let walk_fn = lambda(f: &ast::_fn, tps: &ast::ty_param[], il: inlineness,
+                         sp: &span, i: &ast::fn_ident, nid: ast::node_id) {
         let start_walk = lambda(v: &visit::vt[()]) {
-            v.visit_fn(f, tps, sp, i, nid, (), v);
+            v.visit_fn(f, tps, il, sp, i, nid, (), v);
         };
         let vars = collect_freevars(def_map, sess, start_walk, ~[]);
         freevars.insert(nid, vars);

src/comp/middle/resolve.rs

@@ -7,6 +7,7 @@ import ast::def;
 import ast::def_id;
 import ast::node_id;
 import ast::local_def;
+import ast::inlineness;
 
 import metadata::csearch;
 import metadata::cstore;
@@ -259,7 +260,7 @@ fn resolve_names(e: &@env, c: &@ast::crate) {
           visit_expr: bind walk_expr(e, _, _, _),
           visit_ty: bind walk_ty(e, _, _, _),
           visit_constr: bind walk_constr(e, _, _, _, _, _),
-          visit_fn: bind visit_fn_with_scope(e, _, _, _, _, _, _, _)
+          visit_fn: bind visit_fn_with_scope(e, _, _, _, _, _, _, _, _)
              with *visit::default_visitor()};
     visit::visit_crate(*c, cons(scope_crate, @nil), visit::mk_vt(v));
     e.sess.abort_if_errors();
@@ -328,8 +329,8 @@ fn visit_native_item_with_scope(ni: &@ast::native_item, sc: &scopes,
 }
 
 fn visit_fn_with_scope(e: &@env, f: &ast::_fn, tp: &ast::ty_param[],
-                       sp: &span, name: &fn_ident, id: node_id, sc: &scopes,
-                       v: &vt[scopes]) {
+                       il: inlineness, sp: &span, name: &fn_ident,
+                       id: node_id, sc: &scopes, v: &vt[scopes]) {
     // is this a main fn declaration?
     alt name {
       some(nm) {
@@ -348,7 +349,7 @@ fn visit_fn_with_scope(e: &@env, f: &ast::_fn, tp: &ast::ty_param[],
     for c: @ast::constr  in f.decl.constraints {
         resolve_constr(e, id, c, sc, v);
     }
-    visit::visit_fn(f, tp, sp, name, id,
+    visit::visit_fn(f, tp, il, sp, name, id,
                     cons(scope_fn(f.decl, f.proto, tp), @sc), v);
 }
 
@@ -824,7 +825,7 @@ fn found_def_item(i: &@ast::item, ns: namespace) -> option::t[def] {
       ast::item_const(_, _) {
         if ns == ns_value { ret some(ast::def_const(local_def(i.id))); }
       }
-      ast::item_fn(f, _) {
+      ast::item_fn(f, _, _) {
         if ns == ns_value {
             ret some(ast::def_fn(local_def(i.id), f.decl.purity));
         }
@@ -1082,7 +1083,7 @@ fn index_mod(md: &ast::_mod) -> mod_index {
     }
     for it: @ast::item  in md.items {
         alt it.node {
-          ast::item_const(_, _) | ast::item_fn(_, _) | ast::item_mod(_) |
+          ast::item_const(_, _) | ast::item_fn(_, _, _) | ast::item_mod(_) |
           ast::item_native_mod(_) | ast::item_ty(_, _) |
           ast::item_res(_, _, _, _) | ast::item_obj(_, _, _) {
             add_to_index(index, it.ident, mie_item(it));
@@ -1218,7 +1219,7 @@ fn check_item(e: &@env, i: &@ast::item, x: &(), v: &vt[()]) {
     }
     visit::visit_item(i, x, v);
     alt i.node {
-      ast::item_fn(f, ty_params) {
+      ast::item_fn(f, ty_params, _) {
         check_fn(*e, i.span, f);
         ensure_unique(*e, i.span, typaram_names(ty_params),
                       ident_id, "type parameter");
@@ -1302,7 +1303,7 @@ fn check_block(e: &@env, b: &ast::blk, x: &(), v: &vt[()]) {
                   ast::item_mod(_) | ast::item_native_mod(_) {
                     add_name(mods, it.span, it.ident);
                   }
-                  ast::item_const(_, _) | ast::item_fn(_, _) {
+                  ast::item_const(_, _) | ast::item_fn(_, _, _) {
                     add_name(values, it.span, it.ident);
                   }
                   ast::item_ty(_, _) { add_name(types, it.span, it.ident); }

src/comp/middle/trans.rs

@@ -7329,7 +7329,7 @@ fn trans_const(cx: &@crate_ctxt, e: @ast::expr, id: ast::node_id) {
 
 fn trans_item(cx: @local_ctxt, item: &ast::item) {
     alt item.node {
-      ast::item_fn(f, tps) {
+      ast::item_fn(f, tps, _) {
         let sub_cx = extend_path(cx, item.ident);
         alt cx.ccx.item_ids.find(item.id) {
           some(llfndecl) {
@@ -7740,7 +7740,7 @@ fn collect_item_2(ccx: &@crate_ctxt, i: &@ast::item, pt: &str[],
     let new_pt = pt + item_path(i);
     visit::visit_item(i, new_pt, v);
     alt i.node {
-      ast::item_fn(f, tps) {
+      ast::item_fn(f, tps, _) {
         if !ccx.obj_methods.contains_key(i.id) {
             decl_fn_and_pair(ccx, i.span, new_pt, "fn", tps, i.id);
         }

src/comp/middle/tstate/annotate.rs

@@ -47,15 +47,15 @@ fn collect_ids_local(l: &@local, rs: @mutable node_id[]) {
     *rs += pat_binding_ids(l.node.pat);
 }
 
-fn node_ids_in_fn(f: &_fn, tps: &ty_param[], sp: &span, i: &fn_ident,
-                  id: node_id, rs: @mutable node_id[]) {
+fn node_ids_in_fn(f: &_fn, tps: &ty_param[], il: inlineness, sp: &span,
+                  i: &fn_ident, id: node_id, rs: @mutable node_id[]) {
     let collect_ids =
         visit::mk_simple_visitor(@{visit_expr: bind collect_ids_expr(_, rs),
                                    visit_block: bind collect_ids_block(_, rs),
                                    visit_stmt: bind collect_ids_stmt(_, rs),
                                    visit_local: bind collect_ids_local(_, rs)
                                       with *visit::default_simple_visitor()});
-    visit::visit_fn(f, tps, sp, i, id, (), collect_ids);
+    visit::visit_fn(f, tps, il, sp, i, id, (), collect_ids);
 }
 
 fn init_vecs(ccx: &crate_ctxt, node_ids: &node_id[], len: uint) {
@@ -66,24 +66,25 @@ fn init_vecs(ccx: &crate_ctxt, node_ids: &node_id[], len: uint) {
 }
 
 fn visit_fn(ccx: &crate_ctxt, num_constraints: uint, f: &_fn,
-            tps: &ty_param[], sp: &span, i: &fn_ident, id: node_id) {
+            tps: &ty_param[], il: inlineness, sp: &span, i: &fn_ident,
+            id: node_id) {
     let node_ids: @mutable node_id[] = @mutable ~[];
-    node_ids_in_fn(f, tps, sp, i, id, node_ids);
+    node_ids_in_fn(f, tps, il, sp, i, id, node_ids);
     let node_id_vec = *node_ids;
     init_vecs(ccx, node_id_vec, num_constraints);
 }
 
-fn annotate_in_fn(ccx: &crate_ctxt, f: &_fn, tps: &ty_param[], sp: &span,
-                  i: &fn_ident, id: node_id) {
+fn annotate_in_fn(ccx: &crate_ctxt, f: &_fn, tps: &ty_param[], il: inlineness,
+                  sp: &span, i: &fn_ident, id: node_id) {
     let f_info = get_fn_info(ccx, id);
-    visit_fn(ccx, num_constraints(f_info), f, tps, sp, i, id);
+    visit_fn(ccx, num_constraints(f_info), f, tps, il, sp, i, id);
 }
 
 fn annotate_crate(ccx: &crate_ctxt, crate: &crate) {
     let do_ann =
         visit::mk_simple_visitor(@{visit_fn:
-                                       bind annotate_in_fn(ccx, _, _, _, _, _)
-                                      with *visit::default_simple_visitor()});
+                                   bind annotate_in_fn(ccx, _, _, _, _, _, _)
+                                   with *visit::default_simple_visitor()});
     visit::visit_crate(crate, (), do_ann);
 }
 //

src/comp/middle/tstate/auxiliary.rs

@@ -1051,8 +1051,8 @@ fn op_to_oper_ty(io: init_op) -> oper_type {
 }
 
 // default function visitor
-fn do_nothing[T](f: &_fn, tp: &ty_param[], sp: &span, i: &fn_ident,
-                 iid: node_id, cx: &T, v: &visit::vt[T]) {
+fn do_nothing[T](f: &_fn, tp: &ty_param[], il: inlineness, sp: &span,
+                 i: &fn_ident, iid: node_id, cx: &T, v: &visit::vt[T]) {
 }
 
 

src/comp/middle/tstate/ck.rs

@@ -17,6 +17,7 @@ import ast::crate;
 import ast::return;
 import ast::noreturn;
 import ast::expr;
+import ast::inlineness;
 import syntax::visit;
 import syntax::codemap::span;
 import middle::ty::type_is_nil;
@@ -125,8 +126,8 @@ fn check_states_stmt(s: &@stmt, fcx: &fn_ctxt, v: &visit::vt[fn_ctxt]) {
 }
 
 fn check_states_against_conditions(fcx: &fn_ctxt, f: &_fn,
-                                   tps: &ast::ty_param[], id: node_id,
-                                   sp: &span, i: &fn_ident) {
+                                   tps: &ast::ty_param[], il: inlineness,
+                                   id: node_id, sp: &span, i: &fn_ident) {
     /* Postorder traversal instead of pre is important
        because we want the smallest possible erroneous statement
        or expression. */
@@ -137,7 +138,7 @@ fn check_states_against_conditions(fcx: &fn_ctxt, f: &_fn,
         @{visit_stmt: check_states_stmt,
           visit_expr: check_states_expr,
           visit_fn: do_nothing with *visitor};
-    visit::visit_fn(f, tps, sp, i, id, fcx, visit::mk_vt(visitor));
+    visit::visit_fn(f, tps, il, sp, i, id, fcx, visit::mk_vt(visitor));
 
     /* Check that the return value is initialized */
     let post = aux::block_poststate(fcx.ccx, f.body);
@@ -170,8 +171,8 @@ fn check_states_against_conditions(fcx: &fn_ctxt, f: &_fn,
     check_unused_vars(fcx);
 }
 
-fn check_fn_states(fcx: &fn_ctxt, f: &_fn, tps: &ast::ty_param[], id: node_id,
-                   sp: &span, i: &fn_ident) {
+fn check_fn_states(fcx: &fn_ctxt, f: &_fn, tps: &ast::ty_param[],
+                   il: inlineness, id: node_id, sp: &span, i: &fn_ident) {
     /* Compute the pre- and post-states for this function */
 
     // Fixpoint iteration
@@ -180,19 +181,20 @@ fn check_fn_states(fcx: &fn_ctxt, f: &_fn, tps: &ast::ty_param[], id: node_id,
     /* Now compare each expr's pre-state to its precondition
        and post-state to its postcondition */
 
-    check_states_against_conditions(fcx, f, tps, id, sp, i);
+    check_states_against_conditions(fcx, f, tps, il, id, sp, i);
 }
 
-fn fn_states(f: &_fn, tps: &ast::ty_param[], sp: &span, i: &fn_ident,
-             id: node_id, ccx: &crate_ctxt, v: &visit::vt[crate_ctxt]) {
-    visit::visit_fn(f, tps, sp, i, id, ccx, v);
+fn fn_states(f: &_fn, tps: &ast::ty_param[], il: inlineness, sp: &span,
+             i: &fn_ident, id: node_id, ccx: &crate_ctxt,
+             v: &visit::vt[crate_ctxt]) {
+    visit::visit_fn(f, tps, il, sp, i, id, ccx, v);
     /* Look up the var-to-bit-num map for this function */
 
     assert (ccx.fm.contains_key(id));
     let f_info = ccx.fm.get(id);
     let name = option::from_maybe("anon", i);
     let fcx = {enclosing: f_info, id: id, name: name, ccx: ccx};
-    check_fn_states(fcx, f, tps, id, sp, i);
+    check_fn_states(fcx, f, tps, il, id, sp, i);
 }
 
 fn check_crate(cx: ty::ctxt, crate: @crate) {

src/comp/middle/tstate/collect_locals.rs

@@ -43,16 +43,16 @@ fn collect_pred(e: &@expr, cx: &ctxt, v: &visit::vt[ctxt]) {
     visit::visit_expr(e, cx, v);
 }
 
-fn find_locals(tcx: &ty::ctxt, f: &_fn, tps: &ty_param[], sp: &span,
-               i: &fn_ident, id: node_id) -> ctxt {
+fn find_locals(tcx: &ty::ctxt, f: &_fn, tps: &ty_param[], il: inlineness,
+               sp: &span, i: &fn_ident, id: node_id) -> ctxt {
     let cx: ctxt = {cs: @mutable ~[], tcx: tcx};
     let visitor = visit::default_visitor[ctxt]();
 
     visitor =
         @{visit_local: collect_local,
           visit_expr: collect_pred,
           visit_fn: do_nothing with *visitor};
-    visit::visit_fn(f, tps, sp, i, id, cx, visit::mk_vt(visitor));
+    visit::visit_fn(f, tps, il, sp, i, id, cx, visit::mk_vt(visitor));
     ret cx;
 }
 
@@ -88,13 +88,13 @@ fn add_constraint(tcx: &ty::ctxt, c: sp_constr, next: uint, tbl: constr_map)
 
 /* builds a table mapping each local var defined in f
    to a bit number in the precondition/postcondition vectors */
-fn mk_fn_info(ccx: &crate_ctxt, f: &_fn, tp: &ty_param[], f_sp: &span,
-              f_name: &fn_ident, id: node_id) {
+fn mk_fn_info(ccx: &crate_ctxt, f: &_fn, tp: &ty_param[], il: inlineness,
+              f_sp: &span, f_name: &fn_ident, id: node_id) {
     let name = fn_ident_to_string(id, f_name);
     let res_map = @new_def_hash[constraint]();
     let next: uint = 0u;
 
-    let cx: ctxt = find_locals(ccx.tcx, f, tp, f_sp, f_name, id);
+    let cx: ctxt = find_locals(ccx.tcx, f, tp, il, f_sp, f_name, id);
     /* now we have to add bit nums for both the constraints
        and the variables... */
 
@@ -144,7 +144,7 @@ fn mk_fn_info(ccx: &crate_ctxt, f: &_fn, tp: &ty_param[], f_sp: &span,
 fn mk_f_to_fn_info(ccx: &crate_ctxt, c: @crate) {
     let visitor =
         visit::mk_simple_visitor(@{visit_fn:
-                                       bind mk_fn_info(ccx, _, _, _, _, _)
+                                       bind mk_fn_info(ccx, _, _, _, _, _, _)
                                       with *visit::default_simple_visitor()});
     visit::visit_crate(*c, (), visitor);
 }