2012-12-03 18:48:01 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2012-09-04 13:37:29 -05:00
|
|
|
use parse::{comments, lexer, token};
|
2012-11-15 21:37:29 -06:00
|
|
|
use codemap::{CodeMap, BytePos};
|
2012-09-04 13:37:29 -05:00
|
|
|
use pp::{break_offset, word, printer, space, zerobreak, hardbreak, breaks};
|
|
|
|
use pp::{consistent, inconsistent, eof};
|
|
|
|
use ast::{required, provided};
|
|
|
|
use ast_util::{operator_prec};
|
|
|
|
use dvec::DVec;
|
|
|
|
use parse::classify::*;
|
|
|
|
use parse::token::ident_interner;
|
2012-11-04 22:41:00 -06:00
|
|
|
use str::{push_str, push_char};
|
2012-08-06 19:50:45 -05:00
|
|
|
|
2011-07-05 04:48:19 -05:00
|
|
|
// The ps is stored here to prevent recursive type.
|
2012-01-19 16:24:03 -06:00
|
|
|
enum ann_node {
|
2012-01-19 19:56:05 -06:00
|
|
|
node_block(ps, ast::blk),
|
|
|
|
node_item(ps, @ast::item),
|
|
|
|
node_expr(ps, @ast::expr),
|
|
|
|
node_pat(ps, @ast::pat),
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
2011-10-18 17:07:40 -05:00
|
|
|
type pp_ann = {pre: fn@(ann_node), post: fn@(ann_node)};
|
2011-07-05 04:48:19 -05:00
|
|
|
|
|
|
|
fn no_ann() -> pp_ann {
|
2011-09-12 04:27:30 -05:00
|
|
|
fn ignore(_node: ann_node) { }
|
2012-08-01 19:30:05 -05:00
|
|
|
return {pre: ignore, post: ignore};
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
type ps =
|
2011-07-27 07:19:39 -05:00
|
|
|
@{s: pp::printer,
|
2012-11-12 18:56:39 -06:00
|
|
|
cm: Option<@CodeMap>,
|
2012-09-19 20:50:24 -05:00
|
|
|
intr: @token::ident_interner,
|
2012-08-20 14:23:37 -05:00
|
|
|
comments: Option<~[comments::cmnt]>,
|
|
|
|
literals: Option<~[comments::lit]>,
|
2012-03-26 20:35:18 -05:00
|
|
|
mut cur_cmnt: uint,
|
|
|
|
mut cur_lit: uint,
|
2012-08-14 18:54:13 -05:00
|
|
|
boxes: DVec<pp::breaks>,
|
2011-07-27 07:19:39 -05:00
|
|
|
ann: pp_ann};
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-05-10 09:24:56 -05:00
|
|
|
fn ibox(s: ps, u: uint) {
|
|
|
|
s.boxes.push(pp::inconsistent);
|
|
|
|
pp::ibox(s.s, u);
|
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-05-10 09:24:56 -05:00
|
|
|
fn end(s: ps) {
|
|
|
|
s.boxes.pop();
|
|
|
|
pp::end(s.s);
|
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn rust_printer(writer: io::Writer, intr: @ident_interner) -> ps {
|
2012-08-06 19:50:45 -05:00
|
|
|
return @{s: pp::mk_printer(writer, default_columns),
|
2012-11-12 18:56:39 -06:00
|
|
|
cm: None::<@CodeMap>,
|
2012-08-06 19:50:45 -05:00
|
|
|
intr: intr,
|
2012-08-20 14:23:37 -05:00
|
|
|
comments: None::<~[comments::cmnt]>,
|
|
|
|
literals: None::<~[comments::lit]>,
|
2012-08-06 19:50:45 -05:00
|
|
|
mut cur_cmnt: 0u,
|
|
|
|
mut cur_lit: 0u,
|
2012-08-27 16:22:25 -05:00
|
|
|
boxes: DVec(),
|
2012-08-06 19:50:45 -05:00
|
|
|
ann: no_ann()};
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
const indent_unit: uint = 4u;
|
|
|
|
const alt_indent_unit: uint = 2u;
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
const default_columns: uint = 78u;
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2011-07-25 16:04:38 -05:00
|
|
|
// Requires you to pass an input filename and reader so that
|
|
|
|
// it can scan the input text for comments and literals to
|
|
|
|
// copy forward.
|
2012-11-12 18:56:39 -06:00
|
|
|
fn print_crate(cm: @CodeMap, intr: @ident_interner,
|
2012-07-17 13:22:11 -05:00
|
|
|
span_diagnostic: diagnostic::span_handler,
|
2012-08-14 15:38:35 -05:00
|
|
|
crate: @ast::crate, filename: ~str, in: io::Reader,
|
|
|
|
out: io::Writer, ann: pp_ann, is_expanded: bool) {
|
2012-04-15 05:57:24 -05:00
|
|
|
let r = comments::gather_comments_and_literals(span_diagnostic,
|
2012-04-15 05:27:24 -05:00
|
|
|
filename, in);
|
2011-07-27 07:19:39 -05:00
|
|
|
let s =
|
|
|
|
@{s: pp::mk_printer(out, default_columns),
|
2012-08-20 14:23:37 -05:00
|
|
|
cm: Some(cm),
|
2012-07-27 16:21:15 -05:00
|
|
|
intr: intr,
|
2012-08-20 14:23:37 -05:00
|
|
|
comments: Some(r.cmnts),
|
2012-06-28 17:29:15 -05:00
|
|
|
// If the code is post expansion, don't use the table of
|
|
|
|
// literals, since it doesn't correspond with the literals
|
|
|
|
// in the AST anymore.
|
2012-08-20 14:23:37 -05:00
|
|
|
literals: if is_expanded { None } else { Some(r.lits) },
|
2012-03-26 20:35:18 -05:00
|
|
|
mut cur_cmnt: 0u,
|
|
|
|
mut cur_lit: 0u,
|
2012-08-27 16:22:25 -05:00
|
|
|
boxes: DVec(),
|
2011-07-27 07:19:39 -05:00
|
|
|
ann: ann};
|
2012-02-21 17:34:26 -06:00
|
|
|
print_crate_(s, crate);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn print_crate_(s: ps, &&crate: @ast::crate) {
|
2011-06-30 18:03:07 -05:00
|
|
|
print_mod(s, crate.node.module, crate.node.attrs);
|
2011-07-05 16:34:34 -05:00
|
|
|
print_remaining_comments(s);
|
2011-05-28 21:16:18 -05:00
|
|
|
eof(s.s);
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-10-15 16:56:42 -05:00
|
|
|
fn ty_to_str(ty: @ast::Ty, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(ty, print_type, intr)
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn pat_to_str(pat: @ast::pat, intr: @ident_interner) -> ~str {
|
2012-12-07 16:39:29 -06:00
|
|
|
to_str(pat, print_irrefutable_pat, intr)
|
2012-07-18 18:18:02 -05:00
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn expr_to_str(e: @ast::expr, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(e, print_expr, intr)
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn tt_to_str(tt: ast::token_tree, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(tt, print_tt, intr)
|
2012-08-06 19:50:45 -05:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn stmt_to_str(s: ast::stmt, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(s, print_stmt, intr)
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn item_to_str(i: @ast::item, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(i, print_item, intr)
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn typarams_to_str(tps: ~[ast::ty_param], intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(tps, print_type_params, intr)
|
2012-02-02 00:41:41 -06:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn path_to_str(&&p: @ast::path, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(p, |a,b| print_path(a, b, false), intr)
|
2011-08-16 11:03:58 -05:00
|
|
|
}
|
2011-05-31 12:58:30 -05:00
|
|
|
|
2011-12-22 10:49:54 -06:00
|
|
|
fn fun_to_str(decl: ast::fn_decl, name: ast::ident,
|
2012-09-19 20:50:24 -05:00
|
|
|
params: ~[ast::ty_param], intr: @ident_interner) -> ~str {
|
2012-09-14 11:40:28 -05:00
|
|
|
do io::with_str_writer |wr| {
|
|
|
|
let s = rust_printer(wr, intr);
|
2012-09-21 20:10:45 -05:00
|
|
|
print_fn(s, decl, None, name, params, None, ast::inherited);
|
2012-09-14 11:40:28 -05:00
|
|
|
end(s); // Close the head box
|
|
|
|
end(s); // Close the outer box
|
|
|
|
eof(s.s);
|
|
|
|
}
|
2011-03-09 04:41:50 -06:00
|
|
|
}
|
|
|
|
|
2012-01-19 20:09:06 -06:00
|
|
|
#[test]
|
|
|
|
fn test_fun_to_str() {
|
|
|
|
let decl: ast::fn_decl = {
|
2012-06-29 18:26:56 -05:00
|
|
|
inputs: ~[],
|
2012-03-12 18:26:31 -05:00
|
|
|
output: @{id: 0,
|
|
|
|
node: ast::ty_nil,
|
|
|
|
span: ast_util::dummy_sp()},
|
2012-01-19 20:09:06 -06:00
|
|
|
purity: ast::impure_fn,
|
2012-07-13 20:43:52 -05:00
|
|
|
cf: ast::return_val
|
2012-01-19 20:09:06 -06:00
|
|
|
};
|
2012-06-29 18:26:56 -05:00
|
|
|
assert fun_to_str(decl, "a", ~[]) == "fn a()";
|
2012-01-19 20:09:06 -06:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn block_to_str(blk: ast::blk, intr: @ident_interner) -> ~str {
|
2012-09-14 11:40:28 -05:00
|
|
|
do io::with_str_writer |wr| {
|
|
|
|
let s = rust_printer(wr, intr);
|
|
|
|
// containing cbox, will be closed by print-block at }
|
|
|
|
cbox(s, indent_unit);
|
|
|
|
// head-ibox, will be closed by print-block after {
|
|
|
|
ibox(s, 0u);
|
|
|
|
print_block(s, blk);
|
|
|
|
eof(s.s);
|
|
|
|
}
|
2011-03-31 19:29:59 -05:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn meta_item_to_str(mi: @ast::meta_item, intr: @ident_interner) -> ~str {
|
2012-08-22 18:43:23 -05:00
|
|
|
to_str(mi, print_meta_item, intr)
|
2011-06-27 20:32:15 -05:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn attribute_to_str(attr: ast::attribute, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(attr, print_attribute, intr)
|
2011-06-27 21:41:48 -05:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn variant_to_str(var: ast::variant, intr: @ident_interner) -> ~str {
|
2012-07-18 18:18:02 -05:00
|
|
|
to_str(var, print_variant, intr)
|
2012-01-25 19:22:08 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_variant_to_str() {
|
|
|
|
let var = ast_util::respan(ast_util::dummy_sp(), {
|
|
|
|
name: "principle_skinner",
|
2012-06-29 18:26:56 -05:00
|
|
|
attrs: ~[],
|
|
|
|
args: ~[],
|
2012-01-25 19:22:08 -06:00
|
|
|
id: 0,
|
|
|
|
disr_expr: none
|
|
|
|
});
|
|
|
|
|
|
|
|
let varstr = variant_to_str(var);
|
|
|
|
assert varstr == "principle_skinner";
|
|
|
|
}
|
|
|
|
|
2012-05-10 09:24:56 -05:00
|
|
|
fn cbox(s: ps, u: uint) {
|
|
|
|
s.boxes.push(pp::consistent);
|
|
|
|
pp::cbox(s.s, u);
|
|
|
|
}
|
2011-06-01 17:29:38 -05:00
|
|
|
|
2012-05-10 09:24:56 -05:00
|
|
|
fn box(s: ps, u: uint, b: pp::breaks) {
|
|
|
|
s.boxes.push(b);
|
|
|
|
pp::box(s.s, u, b);
|
|
|
|
}
|
2011-06-01 17:29:38 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn nbsp(s: ps) { word(s.s, ~" "); }
|
2011-07-26 17:58:43 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn word_nbsp(s: ps, w: ~str) { word(s.s, w); nbsp(s); }
|
2011-05-28 21:16:18 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn word_space(s: ps, w: ~str) { word(s.s, w); space(s.s); }
|
2011-05-28 21:16:18 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn popen(s: ps) { word(s.s, ~"("); }
|
2011-05-28 21:16:18 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn pclose(s: ps) { word(s.s, ~")"); }
|
2011-05-28 21:16:18 -05:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn head(s: ps, w: ~str) {
|
2011-05-28 21:16:18 -05:00
|
|
|
// outer-box is consistent
|
2011-06-01 17:29:38 -05:00
|
|
|
cbox(s, indent_unit);
|
2011-05-28 21:16:18 -05:00
|
|
|
// head-box is inconsistent
|
2012-07-16 21:16:19 -05:00
|
|
|
ibox(s, str::len(w) + 1);
|
2011-05-28 21:16:18 -05:00
|
|
|
// keyword that starts the head
|
2012-11-04 22:41:00 -06:00
|
|
|
if !w.is_empty() {
|
|
|
|
word_nbsp(s, w);
|
|
|
|
}
|
2011-05-28 21:16:18 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn bopen(s: ps) {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"{");
|
2011-06-01 17:29:38 -05:00
|
|
|
end(s); // close the head-box
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-05-28 21:16:18 -05:00
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn bclose_(s: ps, span: codemap::span, indented: uint) {
|
2012-08-09 18:31:47 -05:00
|
|
|
bclose_maybe_open(s, span, indented, true);
|
|
|
|
}
|
|
|
|
fn bclose_maybe_open (s: ps, span: codemap::span, indented: uint,
|
|
|
|
close_box: bool) {
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, span.hi);
|
2011-07-26 17:37:05 -05:00
|
|
|
break_offset_if_not_bol(s, 1u, -(indented as int));
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"}");
|
2012-08-09 18:31:47 -05:00
|
|
|
if close_box {
|
|
|
|
end(s); // close the outer-box
|
|
|
|
}
|
2011-07-21 08:36:41 -05:00
|
|
|
}
|
2011-09-12 04:27:30 -05:00
|
|
|
fn bclose(s: ps, span: codemap::span) { bclose_(s, span, indent_unit); }
|
2011-05-28 21:16:18 -05:00
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn is_begin(s: ps) -> bool {
|
2012-08-06 14:34:08 -05:00
|
|
|
match s.s.last_token() { pp::BEGIN(_) => true, _ => false }
|
2011-08-02 17:25:06 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn is_end(s: ps) -> bool {
|
2012-08-06 14:34:08 -05:00
|
|
|
match s.s.last_token() { pp::END => true, _ => false }
|
2011-08-02 17:25:06 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn is_bol(s: ps) -> bool {
|
2012-08-27 18:26:35 -05:00
|
|
|
return s.s.last_token().is_eof() || s.s.last_token().is_hardbreak_tok();
|
2011-06-20 09:45:05 -05:00
|
|
|
}
|
|
|
|
|
2012-04-19 16:46:11 -05:00
|
|
|
fn in_cbox(s: ps) -> bool {
|
2012-05-10 09:24:56 -05:00
|
|
|
let len = s.boxes.len();
|
2012-08-01 19:30:05 -05:00
|
|
|
if len == 0u { return false; }
|
|
|
|
return s.boxes[len - 1u] == pp::consistent;
|
2012-04-19 16:46:11 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn hardbreak_if_not_bol(s: ps) { if !is_bol(s) { hardbreak(s.s); } }
|
|
|
|
fn space_if_not_bol(s: ps) { if !is_bol(s) { space(s.s); } }
|
|
|
|
fn break_offset_if_not_bol(s: ps, n: uint, off: int) {
|
2011-07-27 07:19:39 -05:00
|
|
|
if !is_bol(s) {
|
2011-07-26 17:37:05 -05:00
|
|
|
break_offset(s.s, n, off);
|
|
|
|
} else {
|
2012-08-27 18:26:35 -05:00
|
|
|
if off != 0 && s.s.last_token().is_hardbreak_tok() {
|
2011-07-26 17:37:05 -05:00
|
|
|
// We do something pretty sketchy here: tuck the nonzero
|
|
|
|
// offset-adjustment we were going to deposit along with the
|
|
|
|
// break into the previous hardbreak.
|
|
|
|
s.s.replace_last_token(pp::hardbreak_tok_offset(off));
|
|
|
|
}
|
2011-06-19 21:55:28 -05:00
|
|
|
}
|
|
|
|
}
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2011-06-01 20:53:52 -05:00
|
|
|
// Synthesizes a comment that was not textually present in the original source
|
|
|
|
// file.
|
2012-07-14 00:57:48 -05:00
|
|
|
fn synth_comment(s: ps, text: ~str) {
|
|
|
|
word(s.s, ~"/*");
|
2011-06-01 20:53:52 -05:00
|
|
|
space(s.s);
|
|
|
|
word(s.s, text);
|
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"*/");
|
2011-06-01 20:53:52 -05:00
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn commasep<IN>(s: ps, b: breaks, elts: ~[IN], op: fn(ps, IN)) {
|
2011-07-05 18:23:07 -05:00
|
|
|
box(s, 0u, b);
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut first = true;
|
2012-06-30 18:19:07 -05:00
|
|
|
for elts.each |elt| {
|
2012-07-14 00:57:48 -05:00
|
|
|
if first { first = false; } else { word_space(s, ~","); }
|
2012-09-19 18:55:01 -05:00
|
|
|
op(s, *elt);
|
2011-07-05 18:23:07 -05:00
|
|
|
}
|
|
|
|
end(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn commasep_cmnt<IN>(s: ps, b: breaks, elts: ~[IN], op: fn(ps, IN),
|
2012-01-23 16:59:00 -06:00
|
|
|
get_span: fn(IN) -> codemap::span) {
|
2011-06-01 17:29:38 -05:00
|
|
|
box(s, 0u, b);
|
2011-08-13 02:09:25 -05:00
|
|
|
let len = vec::len::<IN>(elts);
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut i = 0u;
|
2012-06-30 18:19:07 -05:00
|
|
|
for elts.each |elt| {
|
2012-09-19 18:55:01 -05:00
|
|
|
maybe_print_comment(s, get_span(*elt).hi);
|
|
|
|
op(s, *elt);
|
2011-07-06 18:01:47 -05:00
|
|
|
i += 1u;
|
2011-07-27 07:19:39 -05:00
|
|
|
if i < len {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~",");
|
2012-09-19 18:55:01 -05:00
|
|
|
maybe_print_trailing_comment(s, get_span(*elt),
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(get_span(elts[i]).hi));
|
2011-07-26 17:37:05 -05:00
|
|
|
space_if_not_bol(s);
|
2011-07-06 18:01:47 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
end(s);
|
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn commasep_exprs(s: ps, b: breaks, exprs: ~[@ast::expr]) {
|
2012-08-01 19:30:05 -05:00
|
|
|
fn expr_span(&&expr: @ast::expr) -> codemap::span { return expr.span; }
|
2011-07-12 18:13:30 -05:00
|
|
|
commasep_cmnt(s, b, exprs, print_expr, expr_span);
|
2011-03-29 05:46:55 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn print_mod(s: ps, _mod: ast::_mod, attrs: ~[ast::attribute]) {
|
2011-06-30 18:03:07 -05:00
|
|
|
print_inner_attributes(s, attrs);
|
2012-06-30 18:19:07 -05:00
|
|
|
for _mod.view_items.each |vitem| {
|
2012-09-19 18:55:01 -05:00
|
|
|
print_view_item(s, *vitem);
|
2011-05-12 10:24:54 -05:00
|
|
|
}
|
2012-09-19 18:55:01 -05:00
|
|
|
for _mod.items.each |item| { print_item(s, *item); }
|
2011-03-17 19:39:47 -05:00
|
|
|
}
|
|
|
|
|
2012-06-26 18:18:37 -05:00
|
|
|
fn print_foreign_mod(s: ps, nmod: ast::foreign_mod,
|
2012-06-29 18:26:56 -05:00
|
|
|
attrs: ~[ast::attribute]) {
|
2011-07-26 17:37:36 -05:00
|
|
|
print_inner_attributes(s, attrs);
|
2012-06-30 18:19:07 -05:00
|
|
|
for nmod.view_items.each |vitem| {
|
2012-09-19 18:55:01 -05:00
|
|
|
print_view_item(s, *vitem);
|
2011-07-26 17:37:36 -05:00
|
|
|
}
|
2012-09-19 18:55:01 -05:00
|
|
|
for nmod.items.each |item| { print_foreign_item(s, *item); }
|
2011-07-26 17:37:36 -05:00
|
|
|
}
|
|
|
|
|
2012-11-04 22:41:00 -06:00
|
|
|
fn print_region(s: ps, prefix: ~str, region: @ast::region, sep: ~str) {
|
|
|
|
word(s.s, prefix);
|
2012-08-06 14:34:08 -05:00
|
|
|
match region.node {
|
2012-09-14 17:20:09 -05:00
|
|
|
ast::re_anon => {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ast::re_static => {
|
2012-11-04 22:41:00 -06:00
|
|
|
word_space(s, ~"static")
|
2012-09-14 17:20:09 -05:00
|
|
|
}
|
|
|
|
ast::re_self => {
|
2012-11-04 22:41:00 -06:00
|
|
|
word_space(s, ~"self")
|
2012-09-14 17:20:09 -05:00
|
|
|
}
|
|
|
|
ast::re_named(name) => {
|
|
|
|
print_ident(s, name);
|
|
|
|
}
|
2012-03-08 20:10:07 -06:00
|
|
|
}
|
2012-09-14 17:20:09 -05:00
|
|
|
word(s.s, sep);
|
2012-03-08 20:10:07 -06:00
|
|
|
}
|
|
|
|
|
2012-10-15 16:56:42 -05:00
|
|
|
fn print_type(s: ps, &&ty: @ast::Ty) {
|
2012-05-15 16:51:33 -05:00
|
|
|
print_type_ex(s, ty, false);
|
|
|
|
}
|
|
|
|
|
2012-10-15 16:56:42 -05:00
|
|
|
fn print_type_ex(s: ps, &&ty: @ast::Ty, print_colons: bool) {
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, ty.span.lo);
|
2011-06-01 17:29:38 -05:00
|
|
|
ibox(s, 0u);
|
2012-08-06 14:34:08 -05:00
|
|
|
match ty.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::ty_nil => word(s.s, ~"()"),
|
|
|
|
ast::ty_bot => word(s.s, ~"!"),
|
|
|
|
ast::ty_box(mt) => { word(s.s, ~"@"); print_mt(s, mt); }
|
|
|
|
ast::ty_uniq(mt) => { word(s.s, ~"~"); print_mt(s, mt); }
|
|
|
|
ast::ty_vec(mt) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"[");
|
2012-08-06 14:34:08 -05:00
|
|
|
match mt.mutbl {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::m_mutbl => word_space(s, ~"mut"),
|
|
|
|
ast::m_const => word_space(s, ~"const"),
|
|
|
|
ast::m_imm => ()
|
2011-07-27 14:20:51 -05:00
|
|
|
}
|
2011-08-15 06:45:04 -05:00
|
|
|
print_type(s, mt.ty);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"]");
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::ty_ptr(mt) => { word(s.s, ~"*"); print_mt(s, mt); }
|
|
|
|
ast::ty_rptr(region, mt) => {
|
2012-11-04 22:41:00 -06:00
|
|
|
print_region(s, ~"&", region, ~"/");
|
2012-09-14 17:20:09 -05:00
|
|
|
print_mt(s, mt);
|
2012-03-08 20:10:07 -06:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::ty_rec(ref fields) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"{");
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_field(s: ps, f: ast::ty_field) {
|
2011-07-27 07:19:39 -05:00
|
|
|
cbox(s, indent_unit);
|
2012-02-15 13:25:39 -06:00
|
|
|
print_mutability(s, f.node.mt.mutbl);
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, f.node.ident);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~":");
|
2011-08-15 06:45:04 -05:00
|
|
|
print_type(s, f.node.mt.ty);
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s);
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
fn get_span(f: ast::ty_field) -> codemap::span { return f.span; }
|
2012-12-04 12:50:00 -06:00
|
|
|
commasep_cmnt(s, consistent, (*fields), print_field, get_span);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~",}");
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::ty_tup(elts) => {
|
2011-08-19 17:16:48 -05:00
|
|
|
popen(s);
|
|
|
|
commasep(s, inconsistent, elts, print_type);
|
|
|
|
pclose(s);
|
2011-08-15 04:40:26 -05:00
|
|
|
}
|
2012-11-04 22:41:00 -06:00
|
|
|
ast::ty_fn(f) => {
|
|
|
|
print_ty_fn(s, Some(f.proto), f.region, f.purity,
|
|
|
|
f.onceness, f.bounds, f.decl, None, None, None);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::ty_path(path, _) => print_path(s, path, print_colons),
|
2012-11-04 22:41:00 -06:00
|
|
|
ast::ty_fixed_length_vec(mt, v) => {
|
2012-10-09 12:42:26 -05:00
|
|
|
word(s.s, ~"[");
|
2012-11-04 22:41:00 -06:00
|
|
|
match mt.mutbl {
|
|
|
|
ast::m_mutbl => word_space(s, ~"mut"),
|
|
|
|
ast::m_const => word_space(s, ~"const"),
|
|
|
|
ast::m_imm => ()
|
2012-10-09 12:42:26 -05:00
|
|
|
}
|
2012-11-04 22:41:00 -06:00
|
|
|
print_type(s, mt.ty);
|
2012-10-09 12:42:26 -05:00
|
|
|
word(s.s, ~" * ");
|
2012-11-04 22:41:00 -06:00
|
|
|
word(s.s, fmt!("%u", v));
|
2012-10-09 12:42:26 -05:00
|
|
|
word(s.s, ~"]");
|
2012-04-09 19:32:49 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::ty_mac(_) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
fail ~"print_type doesn't know how to print a ty_mac";
|
2012-01-30 23:00:57 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::ty_infer => {
|
2012-07-14 00:57:48 -05:00
|
|
|
fail ~"print_type shouldn't see a ty_infer";
|
2012-01-30 23:00:57 -06:00
|
|
|
}
|
|
|
|
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
2011-06-01 17:29:38 -05:00
|
|
|
end(s);
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-06-26 18:18:37 -05:00
|
|
|
fn print_foreign_item(s: ps, item: @ast::foreign_item) {
|
2011-07-26 17:37:36 -05:00
|
|
|
hardbreak_if_not_bol(s);
|
|
|
|
maybe_print_comment(s, item.span.lo);
|
|
|
|
print_outer_attributes(s, item.attrs);
|
2012-08-06 14:34:08 -05:00
|
|
|
match item.node {
|
2012-08-23 20:17:16 -05:00
|
|
|
ast::foreign_item_fn(decl, purity, typarams) => {
|
2012-09-21 20:10:45 -05:00
|
|
|
print_fn(s, decl, Some(purity), item.ident, typarams, None,
|
|
|
|
ast::inherited);
|
2011-07-26 17:37:36 -05:00
|
|
|
end(s); // end head-ibox
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~";");
|
2011-07-26 17:37:36 -05:00
|
|
|
end(s); // end the outer fn box
|
|
|
|
}
|
2012-08-25 17:09:33 -05:00
|
|
|
ast::foreign_item_const(t) => {
|
|
|
|
head(s, ~"const");
|
|
|
|
print_ident(s, item.ident);
|
|
|
|
word_space(s, ~":");
|
|
|
|
print_type(s, t);
|
|
|
|
word(s.s, ~";");
|
|
|
|
end(s); // end the head-ibox
|
2012-10-08 03:36:09 -05:00
|
|
|
end(s); // end the outer cbox
|
2012-08-25 17:09:33 -05:00
|
|
|
}
|
2011-07-26 17:37:36 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-06 05:26:12 -05:00
|
|
|
fn print_item(s: ps, &&item: @ast::item) {
|
2011-06-20 11:15:11 -05:00
|
|
|
hardbreak_if_not_bol(s);
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, item.span.lo);
|
2011-06-16 15:00:19 -05:00
|
|
|
print_outer_attributes(s, item.attrs);
|
2011-07-27 07:19:39 -05:00
|
|
|
let ann_node = node_item(s, item);
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.pre)(ann_node);
|
2012-08-06 14:34:08 -05:00
|
|
|
match item.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::item_const(ty, expr) => {
|
2012-09-21 20:10:45 -05:00
|
|
|
head(s, visibility_qualified(item.vis, ~"const"));
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, item.ident);
|
|
|
|
word_space(s, ~":");
|
2011-08-15 06:45:04 -05:00
|
|
|
print_type(s, ty);
|
2011-07-27 07:19:39 -05:00
|
|
|
space(s.s);
|
|
|
|
end(s); // end the head-ibox
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"=");
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, expr);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~";");
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s); // end the outer cbox
|
2011-06-15 13:19:50 -05:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::item_fn(decl, purity, typarams, ref body) => {
|
2012-09-21 20:10:45 -05:00
|
|
|
print_fn(s, decl, Some(purity), item.ident, typarams, None,
|
|
|
|
item.vis);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~" ");
|
2012-12-04 12:50:00 -06:00
|
|
|
print_block_with_attrs(s, (*body), item.attrs);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::item_mod(_mod) => {
|
2012-09-21 20:10:45 -05:00
|
|
|
head(s, visibility_qualified(item.vis, ~"mod"));
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, item.ident);
|
|
|
|
nbsp(s);
|
2011-07-27 07:19:39 -05:00
|
|
|
bopen(s);
|
|
|
|
print_mod(s, _mod, item.attrs);
|
|
|
|
bclose(s, item.span);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::item_foreign_mod(nmod) => {
|
2012-09-21 20:10:45 -05:00
|
|
|
head(s, visibility_qualified(item.vis, ~"extern"));
|
2012-11-27 19:25:55 -06:00
|
|
|
print_string(s, *s.intr.get(nmod.abi));
|
2012-12-04 19:05:42 -06:00
|
|
|
nbsp(s);
|
2012-08-29 14:22:05 -05:00
|
|
|
match nmod.sort {
|
2012-08-31 13:19:07 -05:00
|
|
|
ast::named => {
|
|
|
|
word_nbsp(s, ~"mod");
|
|
|
|
print_ident(s, item.ident);
|
2012-10-14 11:19:54 -05:00
|
|
|
nbsp(s);
|
2012-08-31 13:19:07 -05:00
|
|
|
}
|
|
|
|
ast::anonymous => {}
|
2012-08-29 14:22:05 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
bopen(s);
|
2012-06-26 18:18:37 -05:00
|
|
|
print_foreign_mod(s, nmod, item.attrs);
|
2011-07-27 07:19:39 -05:00
|
|
|
bclose(s, item.span);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::item_ty(ty, params) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
ibox(s, indent_unit);
|
|
|
|
ibox(s, 0u);
|
2012-10-14 11:19:54 -05:00
|
|
|
word_nbsp(s, visibility_qualified(item.vis, ~"type"));
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, item.ident);
|
2011-07-27 07:19:39 -05:00
|
|
|
print_type_params(s, params);
|
|
|
|
end(s); // end the inner ibox
|
|
|
|
|
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"=");
|
2011-08-15 06:45:04 -05:00
|
|
|
print_type(s, ty);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~";");
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s); // end the outer ibox
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::item_enum(ref enum_definition, params) => {
|
|
|
|
print_enum_def(s, (*enum_definition), params, item.ident,
|
2012-10-17 13:23:02 -05:00
|
|
|
item.span, item.vis);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-07 17:34:07 -05:00
|
|
|
ast::item_class(struct_def, tps) => {
|
2012-10-14 11:19:54 -05:00
|
|
|
head(s, visibility_qualified(item.vis, ~"struct"));
|
2012-08-07 18:08:09 -05:00
|
|
|
print_struct(s, struct_def, tps, item.ident, item.span);
|
|
|
|
}
|
2012-07-18 18:18:02 -05:00
|
|
|
|
2012-11-13 21:08:01 -06:00
|
|
|
ast::item_impl(tps, opt_trait, ty, methods) => {
|
2012-10-14 11:19:54 -05:00
|
|
|
head(s, visibility_qualified(item.vis, ~"impl"));
|
2012-08-08 18:26:10 -05:00
|
|
|
if tps.is_not_empty() {
|
|
|
|
print_type_params(s, tps);
|
|
|
|
space(s.s);
|
|
|
|
}
|
|
|
|
print_type(s, ty);
|
|
|
|
|
2012-09-07 17:11:26 -05:00
|
|
|
match opt_trait {
|
|
|
|
Some(t) => {
|
|
|
|
word_space(s, ~":");
|
|
|
|
print_path(s, t.path, false);
|
2012-07-18 11:31:53 -05:00
|
|
|
}
|
2012-09-07 17:11:26 -05:00
|
|
|
None => ()
|
|
|
|
};
|
2011-12-16 03:42:28 -06:00
|
|
|
space(s.s);
|
2012-08-08 18:26:10 -05:00
|
|
|
|
2012-11-13 21:08:01 -06:00
|
|
|
if methods.len() == 0 {
|
|
|
|
word(s.s, ~";");
|
|
|
|
} else {
|
|
|
|
bopen(s);
|
|
|
|
for methods.each |meth| {
|
|
|
|
print_method(s, *meth);
|
2012-10-22 19:57:10 -05:00
|
|
|
}
|
2012-11-13 21:08:01 -06:00
|
|
|
bclose(s, item.span);
|
2011-12-13 06:19:56 -06:00
|
|
|
}
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::item_trait(tps, traits, ref methods) => {
|
2012-10-14 11:19:54 -05:00
|
|
|
head(s, visibility_qualified(item.vis, ~"trait"));
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, item.ident);
|
2012-01-30 04:36:18 -06:00
|
|
|
print_type_params(s, tps);
|
2012-08-03 17:02:01 -05:00
|
|
|
if vec::len(traits) != 0u {
|
2012-12-07 19:55:34 -06:00
|
|
|
word(s.s, ~":");
|
|
|
|
for vec::each(traits) |trait_| {
|
|
|
|
nbsp(s);
|
|
|
|
print_path(s, trait_.path, false);
|
|
|
|
}
|
2012-08-03 17:02:01 -05:00
|
|
|
}
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~" ");
|
2011-12-20 09:33:55 -06:00
|
|
|
bopen(s);
|
2012-12-04 12:50:00 -06:00
|
|
|
for (*methods).each |meth| {
|
2012-09-19 18:55:01 -05:00
|
|
|
print_trait_method(s, *meth);
|
|
|
|
}
|
2011-12-20 09:33:55 -06:00
|
|
|
bclose(s, item.span);
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::item_mac({node: ast::mac_invoc_tt(pth, ref tts), _}) => {
|
2012-10-14 11:19:54 -05:00
|
|
|
print_visibility(s, item.vis);
|
2012-07-18 18:18:02 -05:00
|
|
|
print_path(s, pth, false);
|
2012-08-22 21:08:21 -05:00
|
|
|
word(s.s, ~"! ");
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, item.ident);
|
2012-08-22 21:08:21 -05:00
|
|
|
cbox(s, indent_unit);
|
|
|
|
popen(s);
|
2012-12-04 12:50:00 -06:00
|
|
|
for (*tts).each |tt| {
|
2012-09-19 18:55:01 -05:00
|
|
|
print_tt(s, *tt);
|
|
|
|
}
|
2012-08-22 21:08:21 -05:00
|
|
|
pclose(s);
|
|
|
|
end(s);
|
2012-07-11 12:42:25 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::item_mac(_) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
fail ~"invalid item-position syntax bit"
|
2012-07-05 14:10:33 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.post)(ann_node);
|
2012-08-07 18:08:09 -05:00
|
|
|
}
|
|
|
|
|
2012-08-08 19:14:25 -05:00
|
|
|
fn print_enum_def(s: ps, enum_definition: ast::enum_def,
|
|
|
|
params: ~[ast::ty_param], ident: ast::ident,
|
2012-10-14 11:19:54 -05:00
|
|
|
span: ast::span, visibility: ast::visibility) {
|
2012-08-08 19:14:25 -05:00
|
|
|
let mut newtype =
|
|
|
|
vec::len(enum_definition.variants) == 1u &&
|
2012-07-18 18:18:02 -05:00
|
|
|
ident == enum_definition.variants[0].node.name;
|
2012-08-08 19:14:25 -05:00
|
|
|
if newtype {
|
|
|
|
match enum_definition.variants[0].node.kind {
|
|
|
|
ast::tuple_variant_kind(args) if args.len() == 1 => {}
|
|
|
|
_ => newtype = false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if newtype {
|
|
|
|
ibox(s, indent_unit);
|
2012-10-14 11:19:54 -05:00
|
|
|
word_space(s, visibility_qualified(visibility, ~"enum"));
|
2012-08-08 19:14:25 -05:00
|
|
|
} else {
|
2012-10-14 11:19:54 -05:00
|
|
|
head(s, visibility_qualified(visibility, ~"enum"));
|
2012-08-08 19:14:25 -05:00
|
|
|
}
|
|
|
|
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, ident);
|
2012-08-08 19:14:25 -05:00
|
|
|
print_type_params(s, params);
|
|
|
|
space(s.s);
|
|
|
|
if newtype {
|
|
|
|
word_space(s, ~"=");
|
|
|
|
match enum_definition.variants[0].node.kind {
|
|
|
|
ast::tuple_variant_kind(args) => print_type(s, args[0].ty),
|
|
|
|
_ => fail ~"newtype syntax with struct?"
|
|
|
|
}
|
|
|
|
word(s.s, ~";");
|
|
|
|
end(s);
|
|
|
|
} else {
|
|
|
|
print_variants(s, enum_definition.variants, span);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-08 16:17:52 -05:00
|
|
|
fn print_variants(s: ps, variants: ~[ast::variant], span: ast::span) {
|
|
|
|
bopen(s);
|
|
|
|
for variants.each |v| {
|
|
|
|
space_if_not_bol(s);
|
|
|
|
maybe_print_comment(s, v.span.lo);
|
|
|
|
print_outer_attributes(s, v.node.attrs);
|
|
|
|
ibox(s, indent_unit);
|
2012-09-19 18:55:01 -05:00
|
|
|
print_variant(s, *v);
|
2012-08-08 16:17:52 -05:00
|
|
|
word(s.s, ~",");
|
|
|
|
end(s);
|
2012-11-12 21:32:48 -06:00
|
|
|
maybe_print_trailing_comment(s, v.span, None);
|
2012-08-08 16:17:52 -05:00
|
|
|
}
|
|
|
|
bclose(s, span);
|
|
|
|
}
|
|
|
|
|
2012-09-21 20:10:45 -05:00
|
|
|
fn visibility_to_str(vis: ast::visibility) -> ~str {
|
|
|
|
match vis {
|
|
|
|
ast::private => ~"priv",
|
|
|
|
ast::public => ~"pub",
|
|
|
|
ast::inherited => ~""
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn visibility_qualified(vis: ast::visibility, s: ~str) -> ~str {
|
|
|
|
match vis {
|
|
|
|
ast::private | ast::public =>
|
|
|
|
visibility_to_str(vis) + " " + s,
|
|
|
|
ast::inherited => s
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn print_visibility(s: ps, vis: ast::visibility) {
|
|
|
|
match vis {
|
|
|
|
ast::private | ast::public =>
|
|
|
|
word_nbsp(s, visibility_to_str(vis)),
|
|
|
|
ast::inherited => ()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-07 19:46:07 -05:00
|
|
|
fn print_struct(s: ps, struct_def: @ast::struct_def, tps: ~[ast::ty_param],
|
2012-08-07 18:08:09 -05:00
|
|
|
ident: ast::ident, span: ast::span) {
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, ident);
|
|
|
|
nbsp(s);
|
2012-08-07 18:08:09 -05:00
|
|
|
print_type_params(s, tps);
|
|
|
|
if vec::len(struct_def.traits) != 0u {
|
|
|
|
word_space(s, ~":");
|
|
|
|
commasep(s, inconsistent, struct_def.traits, |s, p|
|
|
|
|
print_path(s, p.path, false));
|
|
|
|
}
|
2012-10-26 14:11:14 -05:00
|
|
|
if ast_util::struct_def_is_tuple_like(struct_def) {
|
|
|
|
popen(s);
|
|
|
|
let mut first = true;
|
|
|
|
for struct_def.fields.each |field| {
|
|
|
|
if first {
|
|
|
|
first = false;
|
|
|
|
} else {
|
|
|
|
word_space(s, ~",");
|
|
|
|
}
|
|
|
|
|
|
|
|
match field.node.kind {
|
|
|
|
ast::named_field(*) => fail ~"unexpected named field",
|
|
|
|
ast::unnamed_field => {
|
|
|
|
maybe_print_comment(s, field.span.lo);
|
|
|
|
print_type(s, field.node.ty);
|
2012-08-15 17:53:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-10-26 14:11:14 -05:00
|
|
|
pclose(s);
|
|
|
|
word(s.s, ~";");
|
|
|
|
end(s); // close the outer-box
|
|
|
|
} else {
|
|
|
|
bopen(s);
|
|
|
|
hardbreak_if_not_bol(s);
|
|
|
|
do struct_def.dtor.iter |dtor| {
|
|
|
|
hardbreak_if_not_bol(s);
|
|
|
|
maybe_print_comment(s, dtor.span.lo);
|
|
|
|
print_outer_attributes(s, dtor.node.attrs);
|
|
|
|
head(s, ~"drop");
|
|
|
|
print_block(s, dtor.node.body);
|
|
|
|
}
|
|
|
|
|
|
|
|
for struct_def.fields.each |field| {
|
|
|
|
match field.node.kind {
|
|
|
|
ast::unnamed_field => fail ~"unexpected unnamed field",
|
|
|
|
ast::named_field(ident, mutability, visibility) => {
|
|
|
|
hardbreak_if_not_bol(s);
|
|
|
|
maybe_print_comment(s, field.span.lo);
|
|
|
|
print_visibility(s, visibility);
|
|
|
|
if mutability == ast::class_mutable {
|
|
|
|
word_nbsp(s, ~"mut");
|
|
|
|
}
|
|
|
|
print_ident(s, ident);
|
|
|
|
word_nbsp(s, ~":");
|
|
|
|
print_type(s, field.node.ty);
|
|
|
|
word(s.s, ~",");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for struct_def.methods.each |method| {
|
|
|
|
print_method(s, *method);
|
|
|
|
}
|
|
|
|
bclose(s, span);
|
2012-08-15 17:53:58 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-07-27 19:38:01 -05:00
|
|
|
/// This doesn't deserve to be called "pretty" printing, but it should be
|
|
|
|
/// meaning-preserving. A quick hack that might help would be to look at the
|
|
|
|
/// spans embedded in the TTs to decide where to put spaces and newlines.
|
|
|
|
/// But it'd be better to parse these according to the grammar of the
|
|
|
|
/// appropriate macro, transcribe back into the grammar we just parsed from,
|
|
|
|
/// and then pretty-print the resulting AST nodes (so, e.g., we print
|
|
|
|
/// expression arguments as expressions). It can be done! I think.
|
|
|
|
fn print_tt(s: ps, tt: ast::token_tree) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match tt {
|
2012-12-04 23:13:02 -06:00
|
|
|
ast::tt_delim(ref tts) =>
|
|
|
|
for (*tts).each() |tt_elt| { print_tt(s, *tt_elt); },
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::tt_tok(_, ref tk) => {
|
|
|
|
match (*tk) {
|
2012-08-03 21:59:04 -05:00
|
|
|
parse::token::IDENT(*) => { // don't let idents run together
|
2012-07-30 19:56:53 -05:00
|
|
|
if s.s.token_tree_last_was_ident { word(s.s, ~" ") }
|
|
|
|
s.s.token_tree_last_was_ident = true;
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => { s.s.token_tree_last_was_ident = false; }
|
2012-07-27 19:38:01 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
word(s.s, parse::token::to_str(s.intr, (*tk)));
|
2012-07-27 19:38:01 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::tt_seq(_, ref tts, ref sep, zerok) => {
|
2012-07-27 19:38:01 -05:00
|
|
|
word(s.s, ~"$(");
|
2012-12-04 12:50:00 -06:00
|
|
|
for (*tts).each() |tt_elt| { print_tt(s, *tt_elt); }
|
2012-07-27 19:38:01 -05:00
|
|
|
word(s.s, ~")");
|
2012-12-04 12:50:00 -06:00
|
|
|
match (*sep) {
|
|
|
|
Some(ref tk) => word(s.s, parse::token::to_str(s.intr, (*tk))),
|
2012-08-20 14:23:37 -05:00
|
|
|
None => ()
|
2012-07-27 19:38:01 -05:00
|
|
|
}
|
|
|
|
word(s.s, if zerok { ~"*" } else { ~"+" });
|
2012-07-30 19:56:53 -05:00
|
|
|
s.s.token_tree_last_was_ident = false;
|
2012-07-27 19:38:01 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::tt_nonterminal(_, name) => {
|
2012-07-18 18:18:02 -05:00
|
|
|
word(s.s, ~"$");
|
|
|
|
print_ident(s, name);
|
2012-07-30 19:56:53 -05:00
|
|
|
s.s.token_tree_last_was_ident = true;
|
2012-07-27 19:38:01 -05:00
|
|
|
}
|
|
|
|
}
|
2012-07-11 12:42:25 -05:00
|
|
|
}
|
|
|
|
|
2012-01-25 19:22:08 -06:00
|
|
|
fn print_variant(s: ps, v: ast::variant) {
|
2012-09-21 20:10:45 -05:00
|
|
|
print_visibility(s, v.node.vis);
|
2012-08-07 16:24:04 -05:00
|
|
|
match v.node.kind {
|
|
|
|
ast::tuple_variant_kind(args) => {
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, v.node.name);
|
2012-10-27 19:14:09 -05:00
|
|
|
if args.is_not_empty() {
|
2012-08-07 16:24:04 -05:00
|
|
|
popen(s);
|
|
|
|
fn print_variant_arg(s: ps, arg: ast::variant_arg) {
|
|
|
|
print_type(s, arg.ty);
|
|
|
|
}
|
|
|
|
commasep(s, consistent, args, print_variant_arg);
|
|
|
|
pclose(s);
|
|
|
|
}
|
2012-01-25 19:22:08 -06:00
|
|
|
}
|
2012-08-07 20:54:44 -05:00
|
|
|
ast::struct_variant_kind(struct_def) => {
|
|
|
|
head(s, ~"");
|
|
|
|
print_struct(s, struct_def, ~[], v.node.name, v.span);
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::enum_variant_kind(ref enum_definition) => {
|
|
|
|
print_variants(s, (*enum_definition).variants, v.span);
|
2012-08-08 16:17:52 -05:00
|
|
|
}
|
2012-01-25 19:22:08 -06:00
|
|
|
}
|
2012-08-06 14:34:08 -05:00
|
|
|
match v.node.disr_expr {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(d) => {
|
2012-01-25 19:22:08 -06:00
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"=");
|
2012-01-25 19:22:08 -06:00
|
|
|
print_expr(s, d);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2012-01-25 19:22:08 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-20 09:33:55 -06:00
|
|
|
fn print_ty_method(s: ps, m: ast::ty_method) {
|
|
|
|
hardbreak_if_not_bol(s);
|
|
|
|
maybe_print_comment(s, m.span.lo);
|
2012-01-30 13:43:45 -06:00
|
|
|
print_outer_attributes(s, m.attrs);
|
2012-11-04 22:41:00 -06:00
|
|
|
print_ty_fn(s, None, None, m.purity, ast::Many,
|
2012-08-20 14:23:37 -05:00
|
|
|
@~[], m.decl, Some(m.ident), Some(m.tps),
|
|
|
|
Some(m.self_ty.node));
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~";");
|
2011-12-20 09:33:55 -06:00
|
|
|
}
|
|
|
|
|
2012-07-10 15:44:20 -05:00
|
|
|
fn print_trait_method(s: ps, m: ast::trait_method) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match m {
|
2012-12-04 12:50:00 -06:00
|
|
|
required(ref ty_m) => print_ty_method(s, (*ty_m)),
|
2012-08-03 21:59:04 -05:00
|
|
|
provided(m) => print_method(s, m)
|
2012-07-10 15:44:20 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-19 12:19:00 -05:00
|
|
|
fn print_method(s: ps, meth: @ast::method) {
|
|
|
|
hardbreak_if_not_bol(s);
|
|
|
|
maybe_print_comment(s, meth.span.lo);
|
|
|
|
print_outer_attributes(s, meth.attrs);
|
2012-08-20 14:23:37 -05:00
|
|
|
print_fn(s, meth.decl, Some(meth.purity),
|
2012-09-21 20:10:45 -05:00
|
|
|
meth.ident, meth.tps, Some(meth.self_ty.node),
|
|
|
|
meth.vis);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~" ");
|
2012-03-19 12:19:00 -05:00
|
|
|
print_block_with_attrs(s, meth.body, meth.attrs);
|
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn print_outer_attributes(s: ps, attrs: ~[ast::attribute]) {
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut count = 0;
|
2012-06-30 18:19:07 -05:00
|
|
|
for attrs.each |attr| {
|
2012-08-06 14:34:08 -05:00
|
|
|
match attr.node.style {
|
2012-09-19 18:55:01 -05:00
|
|
|
ast::attr_outer => { print_attribute(s, *attr); count += 1; }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {/* fallthrough */ }
|
2011-06-14 20:53:12 -05:00
|
|
|
}
|
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
if count > 0 { hardbreak_if_not_bol(s); }
|
2011-06-14 20:53:12 -05:00
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn print_inner_attributes(s: ps, attrs: ~[ast::attribute]) {
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut count = 0;
|
2012-06-30 18:19:07 -05:00
|
|
|
for attrs.each |attr| {
|
2012-08-06 14:34:08 -05:00
|
|
|
match attr.node.style {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::attr_inner => {
|
2012-09-19 18:55:01 -05:00
|
|
|
print_attribute(s, *attr);
|
2012-06-30 05:54:54 -05:00
|
|
|
if !attr.node.is_sugared_doc {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~";");
|
2012-06-30 05:54:54 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
count += 1;
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {/* fallthrough */ }
|
2011-06-16 15:00:19 -05:00
|
|
|
}
|
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
if count > 0 { hardbreak_if_not_bol(s); }
|
2011-06-16 15:00:19 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_attribute(s: ps, attr: ast::attribute) {
|
2011-06-30 19:25:13 -05:00
|
|
|
hardbreak_if_not_bol(s);
|
2011-06-14 20:53:12 -05:00
|
|
|
maybe_print_comment(s, attr.span.lo);
|
2012-06-30 05:54:54 -05:00
|
|
|
if attr.node.is_sugared_doc {
|
|
|
|
let meta = attr::attr_meta(attr);
|
2012-09-20 20:15:39 -05:00
|
|
|
let comment = attr::get_meta_item_value_str(meta).get();
|
2012-07-18 18:18:02 -05:00
|
|
|
word(s.s, comment);
|
2012-06-30 05:54:54 -05:00
|
|
|
} else {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"#[");
|
2012-09-20 20:15:39 -05:00
|
|
|
print_meta_item(s, @attr.node.value);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"]");
|
2012-06-30 05:54:54 -05:00
|
|
|
}
|
2011-06-14 20:53:12 -05:00
|
|
|
}
|
|
|
|
|
2011-12-29 14:03:39 -06:00
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_stmt(s: ps, st: ast::stmt) {
|
2011-05-31 12:58:30 -05:00
|
|
|
maybe_print_comment(s, st.span.lo);
|
2012-08-06 14:34:08 -05:00
|
|
|
match st.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::stmt_decl(decl, _) => {
|
2011-12-29 14:03:39 -06:00
|
|
|
print_decl(s, decl);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::stmt_expr(expr, _) => {
|
2011-12-29 14:03:39 -06:00
|
|
|
space_if_not_bol(s);
|
2012-01-05 00:01:58 -06:00
|
|
|
print_expr(s, expr);
|
2012-07-03 19:30:25 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::stmt_semi(expr, _) => {
|
2012-07-03 19:30:25 -05:00
|
|
|
space_if_not_bol(s);
|
|
|
|
print_expr(s, expr);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~";");
|
2012-01-04 16:16:41 -06:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::stmt_mac(ref mac, semi) => {
|
2012-11-12 22:06:55 -06:00
|
|
|
space_if_not_bol(s);
|
2012-12-04 12:50:00 -06:00
|
|
|
print_mac(s, (*mac));
|
2012-11-21 12:37:43 -06:00
|
|
|
if semi { word(s.s, ~";"); }
|
2012-11-12 22:06:55 -06:00
|
|
|
}
|
2011-05-31 12:58:30 -05:00
|
|
|
}
|
2012-07-14 00:57:48 -05:00
|
|
|
if parse::classify::stmt_ends_with_semi(st) { word(s.s, ~";"); }
|
2012-11-12 21:32:48 -06:00
|
|
|
maybe_print_trailing_comment(s, st.span, None);
|
2011-05-31 12:58:30 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_block(s: ps, blk: ast::blk) {
|
2011-08-15 16:42:33 -05:00
|
|
|
print_possibly_embedded_block(s, blk, block_normal, indent_unit);
|
2011-07-13 17:44:09 -05:00
|
|
|
}
|
2011-07-08 18:35:09 -05:00
|
|
|
|
2012-08-09 18:31:47 -05:00
|
|
|
fn print_block_unclosed(s: ps, blk: ast::blk) {
|
|
|
|
print_possibly_embedded_block_(s, blk, block_normal, indent_unit, ~[],
|
|
|
|
false);
|
|
|
|
}
|
|
|
|
|
2012-08-13 20:13:41 -05:00
|
|
|
fn print_block_unclosed_indent(s: ps, blk: ast::blk, indented: uint) {
|
|
|
|
print_possibly_embedded_block_(s, blk, block_normal, indented, ~[],
|
|
|
|
false);
|
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn print_block_with_attrs(s: ps, blk: ast::blk, attrs: ~[ast::attribute]) {
|
2012-08-09 18:31:47 -05:00
|
|
|
print_possibly_embedded_block_(s, blk, block_normal, indent_unit, attrs,
|
|
|
|
true);
|
2012-01-15 19:23:59 -06:00
|
|
|
}
|
|
|
|
|
2012-07-27 20:06:24 -05:00
|
|
|
enum embed_type { block_block_fn, block_normal, }
|
2011-08-15 16:42:33 -05:00
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_possibly_embedded_block(s: ps, blk: ast::blk, embedded: embed_type,
|
2011-07-27 07:19:39 -05:00
|
|
|
indented: uint) {
|
2012-01-15 19:23:59 -06:00
|
|
|
print_possibly_embedded_block_(
|
2012-08-09 18:31:47 -05:00
|
|
|
s, blk, embedded, indented, ~[], true);
|
2012-01-15 19:23:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
|
2012-08-09 18:31:47 -05:00
|
|
|
indented: uint, attrs: ~[ast::attribute],
|
|
|
|
close_box: bool) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match blk.node.rules {
|
2012-10-17 13:21:45 -05:00
|
|
|
ast::unsafe_blk => word_space(s, ~"unsafe"),
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::default_blk => ()
|
2011-10-06 18:42:27 -05:00
|
|
|
}
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, blk.span.lo);
|
2011-07-27 07:19:39 -05:00
|
|
|
let ann_node = node_block(s, blk);
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.pre)(ann_node);
|
2012-08-06 14:34:08 -05:00
|
|
|
match embedded {
|
2012-08-03 21:59:04 -05:00
|
|
|
block_block_fn => end(s),
|
|
|
|
block_normal => bopen(s)
|
2011-08-15 16:42:33 -05:00
|
|
|
}
|
2011-08-02 22:46:36 -05:00
|
|
|
|
2012-01-15 19:23:59 -06:00
|
|
|
print_inner_attributes(s, attrs);
|
|
|
|
|
2012-09-19 18:55:01 -05:00
|
|
|
for blk.node.view_items.each |vi| { print_view_item(s, *vi); }
|
2012-06-30 18:19:07 -05:00
|
|
|
for blk.node.stmts.each |st| {
|
2012-09-19 18:55:01 -05:00
|
|
|
print_stmt(s, **st);
|
2011-08-02 22:46:36 -05:00
|
|
|
}
|
2012-08-06 14:34:08 -05:00
|
|
|
match blk.node.expr {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(expr) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
space_if_not_bol(s);
|
2012-01-05 00:01:58 -06:00
|
|
|
print_expr(s, expr);
|
2012-08-20 14:23:37 -05:00
|
|
|
maybe_print_trailing_comment(s, expr.span, Some(blk.span.hi));
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
2012-08-09 18:31:47 -05:00
|
|
|
bclose_maybe_open(s, blk.span, indented, close_box);
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.post)(ann_node);
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
|
2012-08-20 14:23:37 -05:00
|
|
|
elseopt: Option<@ast::expr>, chk: bool) {
|
2012-07-14 00:57:48 -05:00
|
|
|
head(s, ~"if");
|
|
|
|
if chk { word_nbsp(s, ~"check"); }
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, test);
|
2011-06-16 16:08:17 -05:00
|
|
|
space(s.s);
|
2011-07-25 15:42:38 -05:00
|
|
|
print_block(s, blk);
|
2012-08-20 14:23:37 -05:00
|
|
|
fn do_else(s: ps, els: Option<@ast::expr>) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match els {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(_else) => {
|
2012-08-06 14:34:08 -05:00
|
|
|
match _else.node {
|
2011-07-27 07:19:39 -05:00
|
|
|
// "another else-if"
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_if(i, ref t, e) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
cbox(s, indent_unit - 1u);
|
|
|
|
ibox(s, 0u);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~" else if ");
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, i);
|
2011-07-27 07:19:39 -05:00
|
|
|
space(s.s);
|
2012-12-04 12:50:00 -06:00
|
|
|
print_block(s, (*t));
|
2011-07-27 07:19:39 -05:00
|
|
|
do_else(s, e);
|
|
|
|
}
|
|
|
|
// "final else"
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_block(ref b) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
cbox(s, indent_unit - 1u);
|
|
|
|
ibox(s, 0u);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~" else ");
|
2012-12-04 12:50:00 -06:00
|
|
|
print_block(s, (*b));
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-01-30 23:00:57 -06:00
|
|
|
// BLEAH, constraints would be great here
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {
|
2012-07-14 00:57:48 -05:00
|
|
|
fail ~"print_if saw if with weird alternative";
|
2012-01-30 23:00:57 -06:00
|
|
|
}
|
2011-06-16 16:08:17 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {/* fall through */ }
|
2011-06-16 16:08:17 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
do_else(s, elseopt);
|
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_mac(s: ps, m: ast::mac) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match m.node {
|
2012-08-24 16:04:38 -05:00
|
|
|
ast::mac_invoc(path, arg, _body) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"#");
|
2011-08-16 11:03:58 -05:00
|
|
|
print_path(s, path, false);
|
2012-08-06 14:34:08 -05:00
|
|
|
match arg {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(@{node: ast::expr_vec(_, _), _}) => (),
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => word(s.s, ~" ")
|
2012-02-01 01:20:31 -06:00
|
|
|
}
|
2012-09-27 19:01:28 -05:00
|
|
|
arg.iter(|a| print_expr(s, *a));
|
2012-05-03 15:04:40 -05:00
|
|
|
// FIXME: extension 'body' (#2339)
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::mac_invoc_tt(pth, ref tts) => {
|
2012-07-18 18:18:02 -05:00
|
|
|
print_path(s, pth, false);
|
2012-08-22 21:08:21 -05:00
|
|
|
word(s.s, ~"!");
|
|
|
|
popen(s);
|
2012-12-04 12:50:00 -06:00
|
|
|
for (*tts).each() |tt| { print_tt(s, *tt); }
|
2012-08-22 21:08:21 -05:00
|
|
|
pclose(s);
|
2012-07-11 12:42:25 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::mac_ellipsis => word(s.s, ~"..."),
|
2012-08-22 19:24:52 -05:00
|
|
|
ast::mac_var(v) => word(s.s, fmt!("$%u", v)),
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => { /* fixme */ }
|
2011-07-08 18:35:09 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-09 19:32:49 -05:00
|
|
|
fn print_vstore(s: ps, t: ast::vstore) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match t {
|
2012-09-14 17:20:09 -05:00
|
|
|
ast::vstore_fixed(Some(i)) => word(s.s, fmt!("%u", i)),
|
|
|
|
ast::vstore_fixed(None) => word(s.s, ~"_"),
|
|
|
|
ast::vstore_uniq => word(s.s, ~"~"),
|
|
|
|
ast::vstore_box => word(s.s, ~"@"),
|
2012-11-04 22:41:00 -06:00
|
|
|
ast::vstore_slice(r) => print_region(s, ~"&", r, ~"/")
|
2012-08-03 21:59:04 -05:00
|
|
|
}
|
2012-04-09 19:32:49 -05:00
|
|
|
}
|
|
|
|
|
2012-09-11 23:25:01 -05:00
|
|
|
fn print_expr_vstore(s: ps, t: ast::expr_vstore) {
|
|
|
|
match t {
|
|
|
|
ast::expr_vstore_fixed(Some(i)) => word(s.s, fmt!("%u", i)),
|
|
|
|
ast::expr_vstore_fixed(None) => word(s.s, ~"_"),
|
|
|
|
ast::expr_vstore_uniq => word(s.s, ~"~"),
|
|
|
|
ast::expr_vstore_box => word(s.s, ~"@"),
|
2012-11-21 13:39:06 -06:00
|
|
|
ast::expr_vstore_mut_box => {
|
|
|
|
word(s.s, ~"@");
|
|
|
|
word(s.s, ~"mut");
|
|
|
|
}
|
2012-09-11 23:25:01 -05:00
|
|
|
ast::expr_vstore_slice => word(s.s, ~"&"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-30 13:18:25 -06:00
|
|
|
fn print_call_pre(s: ps,
|
|
|
|
has_block: bool,
|
|
|
|
base_args: &mut ~[@ast::expr])
|
|
|
|
-> Option<@ast::expr> {
|
|
|
|
if has_block {
|
|
|
|
let blk_arg = base_args.pop();
|
|
|
|
match blk_arg.node {
|
|
|
|
ast::expr_loop_body(_) => { head(s, ~"for"); }
|
|
|
|
ast::expr_do_body(_) => { head(s, ~"do"); }
|
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
Some(blk_arg)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn print_call_post(s: ps,
|
|
|
|
has_block: bool,
|
|
|
|
blk: &Option<@ast::expr>,
|
|
|
|
base_args: &mut ~[@ast::expr]) {
|
|
|
|
if !has_block || base_args.is_not_empty() {
|
|
|
|
popen(s);
|
|
|
|
commasep_exprs(s, inconsistent, *base_args);
|
|
|
|
pclose(s);
|
|
|
|
}
|
|
|
|
if has_block {
|
|
|
|
nbsp(s);
|
|
|
|
match blk.get().node {
|
|
|
|
// need to handle closures specifically
|
|
|
|
ast::expr_do_body(e) | ast::expr_loop_body(e) => {
|
|
|
|
end(s); // we close our head box; closure
|
|
|
|
// will create it's own.
|
|
|
|
print_expr(s, e);
|
|
|
|
end(s); // close outer box, as closures don't
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
// not sure if this can happen.
|
|
|
|
print_expr(s, blk.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-06 05:26:12 -05:00
|
|
|
fn print_expr(s: ps, &&expr: @ast::expr) {
|
2012-07-23 18:39:18 -05:00
|
|
|
fn print_field(s: ps, field: ast::field) {
|
|
|
|
ibox(s, indent_unit);
|
|
|
|
if field.node.mutbl == ast::m_mutbl { word_nbsp(s, ~"mut"); }
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, field.node.ident);
|
2012-07-23 18:39:18 -05:00
|
|
|
word_space(s, ~":");
|
|
|
|
print_expr(s, field.node.expr);
|
|
|
|
end(s);
|
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
fn get_span(field: ast::field) -> codemap::span { return field.span; }
|
2012-07-23 18:39:18 -05:00
|
|
|
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, expr.span.lo);
|
2011-06-01 17:29:38 -05:00
|
|
|
ibox(s, indent_unit);
|
2011-07-27 07:19:39 -05:00
|
|
|
let ann_node = node_expr(s, expr);
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.pre)(ann_node);
|
2012-08-06 14:34:08 -05:00
|
|
|
match expr.node {
|
2012-09-11 23:25:01 -05:00
|
|
|
ast::expr_vstore(e, v) => match v {
|
|
|
|
ast::expr_vstore_fixed(_) => {
|
|
|
|
print_expr(s, e);
|
|
|
|
word(s.s, ~"/");
|
|
|
|
print_expr_vstore(s, v);
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
print_expr_vstore(s, v);
|
|
|
|
print_expr(s, e);
|
|
|
|
}
|
|
|
|
},
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_vec(exprs, mutbl) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
ibox(s, indent_unit);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"[");
|
2012-02-15 13:25:39 -06:00
|
|
|
if mutbl == ast::m_mutbl {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"mut");
|
2011-08-15 18:38:23 -05:00
|
|
|
if vec::len(exprs) > 0u { nbsp(s); }
|
2011-07-27 14:20:51 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
commasep_exprs(s, inconsistent, exprs);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"]");
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s);
|
|
|
|
}
|
2012-08-03 20:01:30 -05:00
|
|
|
|
|
|
|
ast::expr_repeat(element, count, mutbl) => {
|
|
|
|
ibox(s, indent_unit);
|
|
|
|
word(s.s, ~"[");
|
|
|
|
if mutbl == ast::m_mutbl {
|
|
|
|
word(s.s, ~"mut");
|
|
|
|
nbsp(s);
|
|
|
|
}
|
|
|
|
print_expr(s, element);
|
|
|
|
word(s.s, ~",");
|
|
|
|
word(s.s, ~"..");
|
|
|
|
print_expr(s, count);
|
|
|
|
word(s.s, ~"]");
|
|
|
|
end(s);
|
|
|
|
}
|
|
|
|
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_rec(ref fields, wth) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"{");
|
2012-12-04 12:50:00 -06:00
|
|
|
commasep_cmnt(s, consistent, (*fields), print_field, get_span);
|
2012-08-06 14:34:08 -05:00
|
|
|
match wth {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(expr) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
ibox(s, indent_unit);
|
2012-08-13 18:06:21 -05:00
|
|
|
word(s.s, ~",");
|
|
|
|
space(s.s);
|
|
|
|
word(s.s, ~"..");
|
2011-03-24 10:33:20 -05:00
|
|
|
print_expr(s, expr);
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => word(s.s, ~",")
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"}");
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_struct(path, ref fields, wth) => {
|
2012-07-23 18:39:18 -05:00
|
|
|
print_path(s, path, true);
|
|
|
|
word(s.s, ~"{");
|
2012-12-04 12:50:00 -06:00
|
|
|
commasep_cmnt(s, consistent, (*fields), print_field, get_span);
|
2012-08-06 14:34:08 -05:00
|
|
|
match wth {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(expr) => {
|
2012-12-04 12:50:00 -06:00
|
|
|
if vec::len((*fields)) > 0u { space(s.s); }
|
2012-08-06 15:15:40 -05:00
|
|
|
ibox(s, indent_unit);
|
2012-08-13 18:06:21 -05:00
|
|
|
word(s.s, ~",");
|
|
|
|
space(s.s);
|
|
|
|
word(s.s, ~"..");
|
2012-08-06 15:15:40 -05:00
|
|
|
print_expr(s, expr);
|
|
|
|
end(s);
|
|
|
|
}
|
|
|
|
_ => word(s.s, ~",")
|
|
|
|
}
|
2012-07-23 18:39:18 -05:00
|
|
|
word(s.s, ~"}");
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_tup(exprs) => {
|
2011-08-15 04:40:26 -05:00
|
|
|
popen(s);
|
2011-08-15 05:08:05 -05:00
|
|
|
commasep_exprs(s, inconsistent, exprs);
|
2011-08-15 04:40:26 -05:00
|
|
|
pclose(s);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_call(func, args, has_block) => {
|
2012-11-30 13:18:25 -06:00
|
|
|
let mut base_args = copy args;
|
|
|
|
let blk = print_call_pre(s, has_block, &mut base_args);
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, func);
|
2012-11-30 13:18:25 -06:00
|
|
|
print_call_post(s, has_block, &blk, &mut base_args);
|
|
|
|
}
|
|
|
|
ast::expr_method_call(func, ident, tys, args, has_block) => {
|
|
|
|
let mut base_args = copy args;
|
|
|
|
let blk = print_call_pre(s, has_block, &mut base_args);
|
|
|
|
print_expr(s, func);
|
|
|
|
word(s.s, ~".");
|
|
|
|
print_ident(s, ident);
|
|
|
|
if vec::len(tys) > 0u {
|
|
|
|
word(s.s, ~"::<");
|
|
|
|
commasep(s, inconsistent, tys, print_type);
|
|
|
|
word(s.s, ~">");
|
2011-10-21 07:11:24 -05:00
|
|
|
}
|
2012-11-30 13:18:25 -06:00
|
|
|
print_call_post(s, has_block, &blk, &mut base_args);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_binary(op, lhs, rhs) => {
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, lhs);
|
2011-07-27 07:19:39 -05:00
|
|
|
space(s.s);
|
2011-08-27 16:42:29 -05:00
|
|
|
word_space(s, ast_util::binop_to_str(op));
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, rhs);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_unary(op, expr) => {
|
2011-08-27 16:42:29 -05:00
|
|
|
word(s.s, ast_util::unop_to_str(op));
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, expr);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_addr_of(m, expr) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"&");
|
2012-03-08 18:34:36 -06:00
|
|
|
print_mutability(s, m);
|
|
|
|
print_expr(s, expr);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_lit(lit) => print_literal(s, lit),
|
|
|
|
ast::expr_cast(expr, ty) => {
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, expr);
|
2011-07-27 07:19:39 -05:00
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"as");
|
2012-05-15 16:51:33 -05:00
|
|
|
print_type_ex(s, ty, true);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_if(test, ref blk, elseopt) => {
|
|
|
|
print_if(s, test, (*blk), elseopt, false);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_while(test, ref blk) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
head(s, ~"while");
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, test);
|
2011-07-27 07:19:39 -05:00
|
|
|
space(s.s);
|
2012-12-04 12:50:00 -06:00
|
|
|
print_block(s, (*blk));
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_loop(ref blk, opt_ident) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
head(s, ~"loop");
|
2012-03-09 18:11:56 -06:00
|
|
|
space(s.s);
|
2012-10-18 14:20:18 -05:00
|
|
|
opt_ident.iter(|ident| {
|
|
|
|
print_ident(s, *ident);
|
|
|
|
word_space(s, ~":");
|
|
|
|
});
|
2012-12-04 12:50:00 -06:00
|
|
|
print_block(s, (*blk));
|
2012-03-09 18:11:56 -06:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_match(expr, ref arms) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
cbox(s, alt_indent_unit);
|
2012-10-27 19:14:09 -05:00
|
|
|
ibox(s, 4);
|
2012-08-06 14:34:08 -05:00
|
|
|
word_nbsp(s, ~"match");
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, expr);
|
2011-07-27 07:19:39 -05:00
|
|
|
space(s.s);
|
|
|
|
bopen(s);
|
2012-12-04 12:50:00 -06:00
|
|
|
let len = (*arms).len();
|
|
|
|
for (*arms).eachi |i, arm| {
|
2011-03-24 10:33:20 -05:00
|
|
|
space(s.s);
|
2011-07-21 08:36:41 -05:00
|
|
|
cbox(s, alt_indent_unit);
|
2011-07-27 07:19:39 -05:00
|
|
|
ibox(s, 0u);
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut first = true;
|
2012-06-30 18:19:07 -05:00
|
|
|
for arm.pats.each |p| {
|
2011-07-27 07:19:39 -05:00
|
|
|
if first {
|
|
|
|
first = false;
|
2012-07-14 00:57:48 -05:00
|
|
|
} else { space(s.s); word_space(s, ~"|"); }
|
2012-12-07 16:39:29 -06:00
|
|
|
print_refutable_pat(s, *p);
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-06-14 08:20:04 -05:00
|
|
|
space(s.s);
|
2012-08-06 14:34:08 -05:00
|
|
|
match arm.guard {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(e) => {
|
2012-08-03 21:59:04 -05:00
|
|
|
word_space(s, ~"if");
|
|
|
|
print_expr(s, e);
|
|
|
|
space(s.s);
|
|
|
|
}
|
2012-08-20 14:23:37 -05:00
|
|
|
None => ()
|
2011-08-22 07:38:48 -05:00
|
|
|
}
|
2012-07-10 12:37:05 -05:00
|
|
|
word_space(s, ~"=>");
|
2012-08-28 17:54:45 -05:00
|
|
|
|
2012-08-01 18:16:53 -05:00
|
|
|
// Extract the expression from the extra block the parser adds
|
2012-08-28 17:54:45 -05:00
|
|
|
// in the case of foo => expr
|
|
|
|
if arm.body.node.view_items.is_empty() &&
|
|
|
|
arm.body.node.stmts.is_empty() &&
|
|
|
|
arm.body.node.rules == ast::default_blk &&
|
|
|
|
arm.body.node.expr.is_some()
|
|
|
|
{
|
|
|
|
match arm.body.node.expr {
|
|
|
|
Some(expr) => {
|
|
|
|
match expr.node {
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_block(ref blk) => {
|
2012-08-28 17:54:45 -05:00
|
|
|
// the block will close the pattern's ibox
|
|
|
|
print_block_unclosed_indent(
|
2012-12-04 12:50:00 -06:00
|
|
|
s, (*blk), alt_indent_unit);
|
2012-08-28 17:54:45 -05:00
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
end(s); // close the ibox for the pattern
|
|
|
|
print_expr(s, expr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !expr_is_simple_block(expr)
|
|
|
|
&& i < len - 1 {
|
|
|
|
word(s.s, ~",");
|
|
|
|
}
|
|
|
|
end(s); // close enclosing cbox
|
|
|
|
}
|
|
|
|
None => fail
|
2012-08-01 18:16:53 -05:00
|
|
|
}
|
2012-08-28 17:54:45 -05:00
|
|
|
} else {
|
|
|
|
// the block will close the pattern's ibox
|
|
|
|
print_block_unclosed_indent(s, arm.body, alt_indent_unit);
|
2012-07-10 12:37:05 -05:00
|
|
|
}
|
2011-06-14 08:20:04 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
bclose_(s, expr.span, alt_indent_unit);
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_fn(proto, decl, ref body, cap_clause) => {
|
2011-12-30 15:32:42 -06:00
|
|
|
// containing cbox, will be closed by print-block at }
|
|
|
|
cbox(s, indent_unit);
|
|
|
|
// head-box, will be closed by print-block at start
|
|
|
|
ibox(s, 0u);
|
2012-11-04 22:41:00 -06:00
|
|
|
print_fn_header_info(s, None, None, ast::Many,
|
|
|
|
Some(proto), ast::inherited);
|
2012-08-20 14:23:37 -05:00
|
|
|
print_fn_args_and_ret(s, decl, *cap_clause, None);
|
2011-12-20 13:03:21 -06:00
|
|
|
space(s.s);
|
2012-12-04 12:50:00 -06:00
|
|
|
print_block(s, (*body));
|
2011-12-20 13:03:21 -06:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_fn_block(decl, ref body, cap_clause) => {
|
2012-08-09 18:31:47 -05:00
|
|
|
// in do/for blocks we don't want to show an empty
|
|
|
|
// argument list, but at this point we don't know which
|
|
|
|
// we are inside.
|
|
|
|
//
|
|
|
|
// if !decl.inputs.is_empty() {
|
2012-05-07 13:31:57 -05:00
|
|
|
print_fn_block_args(s, decl, *cap_clause);
|
2012-08-09 18:31:47 -05:00
|
|
|
space(s.s);
|
|
|
|
// }
|
2012-12-04 12:50:00 -06:00
|
|
|
assert (*body).node.stmts.is_empty();
|
|
|
|
assert (*body).node.expr.is_some();
|
2012-08-09 18:31:47 -05:00
|
|
|
// we extract the block, so as not to create another set of boxes
|
2012-12-04 12:50:00 -06:00
|
|
|
match (*body).node.expr.get().node {
|
|
|
|
ast::expr_block(ref blk) => {
|
|
|
|
print_block_unclosed(s, (*blk));
|
2012-08-09 18:31:47 -05:00
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
// this is a bare expression
|
2012-12-04 12:50:00 -06:00
|
|
|
print_expr(s, (*body).node.expr.get());
|
2012-08-09 18:31:47 -05:00
|
|
|
end(s); // need to close a box
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// a box will be closed by print_expr, but we didn't want an overall
|
|
|
|
// wrapper so we closed the corresponding opening. so create an
|
|
|
|
// empty box to satisfy the close.
|
|
|
|
ibox(s, 0);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_loop_body(body) => {
|
2012-03-26 09:09:27 -05:00
|
|
|
print_expr(s, body);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_do_body(body) => {
|
2012-06-18 19:42:09 -05:00
|
|
|
print_expr(s, body);
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_block(ref blk) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
// containing cbox, will be closed by print-block at }
|
|
|
|
cbox(s, indent_unit);
|
|
|
|
// head-box, will be closed by print-block after {
|
|
|
|
ibox(s, 0u);
|
2012-12-04 12:50:00 -06:00
|
|
|
print_block(s, (*blk));
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_copy(e) => { word_space(s, ~"copy"); print_expr(s, e); }
|
2012-08-23 18:58:43 -05:00
|
|
|
ast::expr_unary_move(e) => {
|
|
|
|
word_space(s, ~"move");
|
|
|
|
print_expr(s, e);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_assign(lhs, rhs) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, lhs);
|
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"=");
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, rhs);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_swap(lhs, rhs) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, lhs);
|
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"<->");
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, rhs);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_assign_op(op, lhs, rhs) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, lhs);
|
|
|
|
space(s.s);
|
2011-08-27 16:42:29 -05:00
|
|
|
word(s.s, ast_util::binop_to_str(op));
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"=");
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, rhs);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_field(expr, id, tys) => {
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, expr);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~".");
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, id);
|
2011-12-19 03:21:31 -06:00
|
|
|
if vec::len(tys) > 0u {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"::<");
|
2011-12-19 03:21:31 -06:00
|
|
|
commasep(s, inconsistent, tys, print_type);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~">");
|
2011-12-19 03:21:31 -06:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_index(expr, index) => {
|
2012-10-27 19:14:09 -05:00
|
|
|
print_expr(s, expr);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"[");
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, index);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"]");
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_path(path) => print_path(s, path, true),
|
|
|
|
ast::expr_fail(maybe_fail_val) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"fail");
|
2012-08-06 14:34:08 -05:00
|
|
|
match maybe_fail_val {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(expr) => { word(s.s, ~" "); print_expr(s, expr); }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2011-05-27 19:38:52 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-14 21:20:56 -05:00
|
|
|
ast::expr_break(opt_ident) => {
|
|
|
|
word(s.s, ~"break");
|
|
|
|
space(s.s);
|
2012-09-27 19:01:28 -05:00
|
|
|
opt_ident.iter(|ident| {print_ident(s, *ident); space(s.s)});
|
2012-08-14 21:20:56 -05:00
|
|
|
}
|
|
|
|
ast::expr_again(opt_ident) => {
|
2012-09-07 17:32:04 -05:00
|
|
|
word(s.s, ~"loop");
|
2012-08-14 21:20:56 -05:00
|
|
|
space(s.s);
|
2012-09-27 19:01:28 -05:00
|
|
|
opt_ident.iter(|ident| {print_ident(s, *ident); space(s.s)});
|
2012-08-14 21:20:56 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_ret(result) => {
|
2012-08-01 19:30:05 -05:00
|
|
|
word(s.s, ~"return");
|
2012-08-06 14:34:08 -05:00
|
|
|
match result {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(expr) => { word(s.s, ~" "); print_expr(s, expr); }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_log(lvl, lexp, expr) => {
|
2012-08-21 19:22:45 -05:00
|
|
|
match lvl {
|
|
|
|
ast::debug => { word_nbsp(s, ~"log"); print_expr(s, expr); }
|
|
|
|
ast::error => { word_nbsp(s, ~"log_err"); print_expr(s, expr); }
|
2012-11-06 20:41:06 -06:00
|
|
|
ast::log_other => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word_nbsp(s, ~"log");
|
2011-12-21 20:05:08 -06:00
|
|
|
popen(s);
|
2011-12-21 16:31:31 -06:00
|
|
|
print_expr(s, lexp);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~",");
|
2011-12-21 20:05:08 -06:00
|
|
|
space_if_not_bol(s);
|
|
|
|
print_expr(s, expr);
|
|
|
|
pclose(s);
|
2011-12-21 16:31:31 -06:00
|
|
|
}
|
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expr_assert(expr) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word_nbsp(s, ~"assert");
|
2011-07-27 07:19:39 -05:00
|
|
|
print_expr(s, expr);
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::expr_mac(ref m) => print_mac(s, (*m)),
|
2012-10-27 19:14:09 -05:00
|
|
|
ast::expr_paren(e) => {
|
|
|
|
popen(s);
|
|
|
|
print_expr(s, e);
|
|
|
|
pclose(s);
|
|
|
|
}
|
2011-03-24 22:03:12 -05:00
|
|
|
}
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.post)(ann_node);
|
2011-06-01 17:29:38 -05:00
|
|
|
end(s);
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_local_decl(s: ps, loc: @ast::local) {
|
2012-12-07 16:39:29 -06:00
|
|
|
print_irrefutable_pat(s, loc.node.pat);
|
2012-08-06 14:34:08 -05:00
|
|
|
match loc.node.ty.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::ty_infer => (),
|
|
|
|
_ => { word_space(s, ~":"); print_type(s, loc.node.ty); }
|
2011-08-10 14:51:50 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_decl(s: ps, decl: @ast::decl) {
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, decl.span.lo);
|
2012-08-06 14:34:08 -05:00
|
|
|
match decl.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::decl_local(locs) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
space_if_not_bol(s);
|
|
|
|
ibox(s, indent_unit);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_nbsp(s, ~"let");
|
2012-03-22 10:39:41 -05:00
|
|
|
|
2012-03-26 20:35:18 -05:00
|
|
|
// if any are mut, all are mut
|
2012-06-30 18:19:07 -05:00
|
|
|
if vec::any(locs, |l| l.node.is_mutbl) {
|
|
|
|
assert vec::all(locs, |l| l.node.is_mutbl);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_nbsp(s, ~"mut");
|
2012-03-22 10:39:41 -05:00
|
|
|
}
|
|
|
|
|
2012-02-10 07:33:36 -06:00
|
|
|
fn print_local(s: ps, &&loc: @ast::local) {
|
2011-07-28 05:01:45 -05:00
|
|
|
ibox(s, indent_unit);
|
2011-08-10 14:51:50 -05:00
|
|
|
print_local_decl(s, loc);
|
2011-07-28 05:01:45 -05:00
|
|
|
end(s);
|
2012-08-06 14:34:08 -05:00
|
|
|
match loc.node.init {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(init) => {
|
2011-07-27 07:19:39 -05:00
|
|
|
nbsp(s);
|
2012-10-23 13:28:20 -05:00
|
|
|
word_space(s, ~"=");
|
|
|
|
print_expr(s, init);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2011-03-24 22:03:12 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
2011-07-27 09:24:41 -05:00
|
|
|
commasep(s, consistent, locs, print_local);
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::decl_item(item) => print_item(s, item)
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
|
|
|
|
2012-07-18 18:18:02 -05:00
|
|
|
fn print_ident(s: ps, ident: ast::ident) { word(s.s, *s.intr.get(ident)); }
|
2011-04-05 16:18:44 -05:00
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_for_decl(s: ps, loc: @ast::local, coll: @ast::expr) {
|
2011-08-10 14:51:50 -05:00
|
|
|
print_local_decl(s, loc);
|
2011-06-13 19:04:15 -05:00
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"in");
|
2011-07-27 10:18:53 -05:00
|
|
|
print_expr(s, coll);
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2011-11-30 06:38:38 -06:00
|
|
|
fn print_path(s: ps, &&path: @ast::path, colons_before_params: bool) {
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, path.span.lo);
|
2012-07-14 00:57:48 -05:00
|
|
|
if path.global { word(s.s, ~"::"); }
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut first = true;
|
2012-06-30 18:19:07 -05:00
|
|
|
for path.idents.each |id| {
|
2012-07-14 00:57:48 -05:00
|
|
|
if first { first = false; } else { word(s.s, ~"::"); }
|
2012-09-19 18:55:01 -05:00
|
|
|
print_ident(s, *id);
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2012-04-24 17:52:52 -05:00
|
|
|
if path.rp.is_some() || !path.types.is_empty() {
|
2012-07-14 00:57:48 -05:00
|
|
|
if colons_before_params { word(s.s, ~"::"); }
|
2012-04-24 17:52:52 -05:00
|
|
|
|
2012-08-06 14:34:08 -05:00
|
|
|
match path.rp {
|
2012-08-20 14:23:37 -05:00
|
|
|
None => { /* ok */ }
|
|
|
|
Some(r) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"/");
|
2012-11-04 22:41:00 -06:00
|
|
|
print_region(s, ~"&", r, ~"");
|
2012-04-24 17:52:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !path.types.is_empty() {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"<");
|
2012-04-24 17:52:52 -05:00
|
|
|
commasep(s, inconsistent, path.types, print_type);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~">");
|
2012-04-24 17:52:52 -05:00
|
|
|
}
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-12-07 16:39:29 -06:00
|
|
|
fn print_irrefutable_pat(s: ps, &&pat: @ast::pat) {
|
|
|
|
print_pat(s, pat, false)
|
2012-12-07 14:52:01 -06:00
|
|
|
}
|
|
|
|
|
2012-12-07 16:39:29 -06:00
|
|
|
fn print_refutable_pat(s: ps, &&pat: @ast::pat) {
|
|
|
|
print_pat(s, pat, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn print_pat(s: ps, &&pat: @ast::pat, refutable: bool) {
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, pat.span.lo);
|
2011-07-27 07:19:39 -05:00
|
|
|
let ann_node = node_pat(s, pat);
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.pre)(ann_node);
|
2012-01-14 18:05:07 -06:00
|
|
|
/* Pat isn't normalized, but the beauty of it
|
|
|
|
is that it doesn't matter */
|
2012-08-06 14:34:08 -05:00
|
|
|
match pat.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::pat_wild => word(s.s, ~"_"),
|
|
|
|
ast::pat_ident(binding_mode, path, sub) => {
|
2012-12-07 16:39:29 -06:00
|
|
|
if refutable {
|
2012-12-07 14:52:01 -06:00
|
|
|
match binding_mode {
|
|
|
|
ast::bind_by_ref(mutbl) => {
|
|
|
|
word_nbsp(s, ~"ref");
|
|
|
|
print_mutability(s, mutbl);
|
|
|
|
}
|
|
|
|
ast::bind_by_move => {
|
|
|
|
word_nbsp(s, ~"move");
|
|
|
|
}
|
|
|
|
ast::bind_by_value => {
|
|
|
|
word_nbsp(s, ~"copy");
|
|
|
|
}
|
|
|
|
ast::bind_by_implicit_ref => {}
|
|
|
|
}
|
2012-08-24 13:04:07 -05:00
|
|
|
}
|
2012-12-07 14:52:01 -06:00
|
|
|
print_path(s, path, true);
|
|
|
|
match sub {
|
|
|
|
Some(p) => {
|
|
|
|
word(s.s, ~"@");
|
2012-12-07 16:39:29 -06:00
|
|
|
print_pat(s, p, refutable);
|
2012-12-07 14:52:01 -06:00
|
|
|
}
|
|
|
|
None => ()
|
2012-12-07 14:29:46 -06:00
|
|
|
}
|
2011-12-08 04:56:16 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::pat_enum(path, args_) => {
|
2011-08-16 11:03:58 -05:00
|
|
|
print_path(s, path, true);
|
2012-08-06 14:34:08 -05:00
|
|
|
match args_ {
|
2012-08-20 14:23:37 -05:00
|
|
|
None => word(s.s, ~"(*)"),
|
|
|
|
Some(args) => {
|
2012-10-27 19:14:09 -05:00
|
|
|
if args.is_not_empty() {
|
2012-04-20 02:54:42 -05:00
|
|
|
popen(s);
|
2012-12-07 16:39:29 -06:00
|
|
|
commasep(s, inconsistent, args,
|
|
|
|
|s, p| print_pat(s, p, refutable));
|
2012-04-20 02:54:42 -05:00
|
|
|
pclose(s);
|
|
|
|
} else { }
|
|
|
|
}
|
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::pat_rec(fields, etc) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"{");
|
2012-12-07 16:39:29 -06:00
|
|
|
fn print_field(s: ps, f: ast::field_pat, refutable: bool) {
|
2011-07-27 07:19:39 -05:00
|
|
|
cbox(s, indent_unit);
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, f.ident);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~":");
|
2012-12-07 16:39:29 -06:00
|
|
|
print_pat(s, f.pat, refutable);
|
2012-08-06 19:01:14 -05:00
|
|
|
end(s);
|
|
|
|
}
|
|
|
|
fn get_span(f: ast::field_pat) -> codemap::span { return f.pat.span; }
|
2012-12-07 16:39:29 -06:00
|
|
|
commasep_cmnt(s, consistent, fields,
|
|
|
|
|s, f| print_field(s, f, refutable),
|
|
|
|
get_span);
|
2012-08-06 19:01:14 -05:00
|
|
|
if etc {
|
|
|
|
if vec::len(fields) != 0u { word_space(s, ~","); }
|
|
|
|
word(s.s, ~"_");
|
|
|
|
}
|
|
|
|
word(s.s, ~"}");
|
|
|
|
}
|
|
|
|
ast::pat_struct(path, fields, etc) => {
|
|
|
|
print_path(s, path, true);
|
|
|
|
word(s.s, ~"{");
|
2012-12-07 16:39:29 -06:00
|
|
|
fn print_field(s: ps, f: ast::field_pat, refutable: bool) {
|
2012-08-06 19:01:14 -05:00
|
|
|
cbox(s, indent_unit);
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, f.ident);
|
2012-08-06 19:01:14 -05:00
|
|
|
word_space(s, ~":");
|
2012-12-07 16:39:29 -06:00
|
|
|
print_pat(s, f.pat, refutable);
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s);
|
2011-07-11 07:13:20 -05:00
|
|
|
}
|
2012-08-01 19:30:05 -05:00
|
|
|
fn get_span(f: ast::field_pat) -> codemap::span { return f.pat.span; }
|
2012-12-07 16:39:29 -06:00
|
|
|
commasep_cmnt(s, consistent, fields,
|
|
|
|
|s, f| print_field(s,f,refutable),
|
|
|
|
get_span);
|
2011-07-27 07:19:39 -05:00
|
|
|
if etc {
|
2012-07-14 00:57:48 -05:00
|
|
|
if vec::len(fields) != 0u { word_space(s, ~","); }
|
|
|
|
word(s.s, ~"_");
|
2011-07-13 03:50:16 -05:00
|
|
|
}
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"}");
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::pat_tup(elts) => {
|
2011-08-15 06:15:19 -05:00
|
|
|
popen(s);
|
2012-12-07 16:39:29 -06:00
|
|
|
commasep(s, inconsistent, elts, |s, p| print_pat(s, p, refutable));
|
2011-08-15 06:15:19 -05:00
|
|
|
pclose(s);
|
|
|
|
}
|
2012-12-07 14:52:01 -06:00
|
|
|
ast::pat_box(inner) => {
|
|
|
|
word(s.s, ~"@");
|
2012-12-07 16:39:29 -06:00
|
|
|
print_pat(s, inner, refutable);
|
2012-12-07 14:52:01 -06:00
|
|
|
}
|
|
|
|
ast::pat_uniq(inner) => {
|
|
|
|
word(s.s, ~"~");
|
2012-12-07 16:39:29 -06:00
|
|
|
print_pat(s, inner, refutable);
|
2012-12-07 14:52:01 -06:00
|
|
|
}
|
2012-09-07 19:07:32 -05:00
|
|
|
ast::pat_region(inner) => {
|
|
|
|
word(s.s, ~"&");
|
2012-12-07 16:39:29 -06:00
|
|
|
print_pat(s, inner, refutable);
|
2012-09-07 19:07:32 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::pat_lit(e) => print_expr(s, e),
|
|
|
|
ast::pat_range(begin, end) => {
|
2011-12-02 06:42:51 -06:00
|
|
|
print_expr(s, begin);
|
2011-09-28 14:07:33 -05:00
|
|
|
space(s.s);
|
2012-08-13 19:37:08 -05:00
|
|
|
word(s.s, ~"..");
|
2011-12-02 06:42:51 -06:00
|
|
|
print_expr(s, end);
|
2011-09-28 14:07:33 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
2012-11-29 19:51:16 -06:00
|
|
|
(s.ann.post)(ann_node);
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-08-16 18:44:22 -05:00
|
|
|
// Returns whether it printed anything
|
|
|
|
fn print_self_ty(s: ps, self_ty: ast::self_ty_) -> bool {
|
2012-08-17 18:14:57 -05:00
|
|
|
match self_ty {
|
2012-08-16 18:44:22 -05:00
|
|
|
ast::sty_static | ast::sty_by_ref => { return false; }
|
2012-08-17 18:14:57 -05:00
|
|
|
ast::sty_value => { word(s.s, ~"self"); }
|
|
|
|
ast::sty_region(m) => {
|
|
|
|
word(s.s, ~"&"); print_mutability(s, m); word(s.s, ~"self");
|
|
|
|
}
|
|
|
|
ast::sty_box(m) => {
|
|
|
|
word(s.s, ~"@"); print_mutability(s, m); word(s.s, ~"self");
|
|
|
|
}
|
|
|
|
ast::sty_uniq(m) => {
|
|
|
|
word(s.s, ~"~"); print_mutability(s, m); word(s.s, ~"self");
|
|
|
|
}
|
|
|
|
}
|
2012-08-16 18:44:22 -05:00
|
|
|
return true;
|
2012-08-17 18:14:57 -05:00
|
|
|
}
|
|
|
|
|
2012-11-02 15:33:51 -05:00
|
|
|
fn print_fn(s: ps,
|
|
|
|
decl: ast::fn_decl,
|
|
|
|
purity: Option<ast::purity>,
|
2012-08-23 20:17:16 -05:00
|
|
|
name: ast::ident,
|
2012-08-02 18:01:38 -05:00
|
|
|
typarams: ~[ast::ty_param],
|
2012-09-21 20:10:45 -05:00
|
|
|
opt_self_ty: Option<ast::self_ty_>,
|
|
|
|
vis: ast::visibility) {
|
2012-11-04 22:41:00 -06:00
|
|
|
head(s, ~"");
|
|
|
|
print_fn_header_info(s, opt_self_ty, purity, ast::Many, None, vis);
|
|
|
|
nbsp(s);
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, name);
|
2011-03-24 10:33:20 -05:00
|
|
|
print_type_params(s, typarams);
|
2012-08-17 18:14:57 -05:00
|
|
|
print_fn_args_and_ret(s, decl, ~[], opt_self_ty);
|
2011-06-14 08:20:04 -05:00
|
|
|
}
|
|
|
|
|
2012-05-04 14:33:04 -05:00
|
|
|
fn print_fn_args(s: ps, decl: ast::fn_decl,
|
2012-08-17 18:14:57 -05:00
|
|
|
cap_items: ~[ast::capture_item],
|
2012-08-20 14:23:37 -05:00
|
|
|
opt_self_ty: Option<ast::self_ty_>) {
|
2012-08-17 18:14:57 -05:00
|
|
|
// It is unfortunate to duplicate the commasep logic, but we
|
|
|
|
// we want the self type, the args, and the capture clauses all
|
|
|
|
// in the same box.
|
|
|
|
box(s, 0u, inconsistent);
|
|
|
|
let mut first = true;
|
|
|
|
for opt_self_ty.each |self_ty| {
|
2012-09-19 18:55:01 -05:00
|
|
|
first = !print_self_ty(s, *self_ty);
|
2012-08-17 18:14:57 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
for decl.inputs.each |arg| {
|
|
|
|
if first { first = false; } else { word_space(s, ~","); }
|
2012-09-19 18:55:01 -05:00
|
|
|
print_arg(s, *arg);
|
2011-12-30 15:32:42 -06:00
|
|
|
}
|
2012-08-17 18:14:57 -05:00
|
|
|
|
|
|
|
for cap_items.each |cap_item| {
|
|
|
|
if first { first = false; } else { word_space(s, ~","); }
|
|
|
|
if cap_item.is_move { word_nbsp(s, ~"move") }
|
|
|
|
else { word_nbsp(s, ~"copy") }
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, cap_item.name);
|
2012-08-17 18:14:57 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
end(s);
|
2011-12-30 15:32:42 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 14:33:04 -05:00
|
|
|
fn print_fn_args_and_ret(s: ps, decl: ast::fn_decl,
|
2012-08-17 18:14:57 -05:00
|
|
|
cap_items: ~[ast::capture_item],
|
2012-08-20 14:23:37 -05:00
|
|
|
opt_self_ty: Option<ast::self_ty_>) {
|
2011-03-24 10:33:20 -05:00
|
|
|
popen(s);
|
2012-08-17 18:14:57 -05:00
|
|
|
print_fn_args(s, decl, cap_items, opt_self_ty);
|
2011-03-24 10:33:20 -05:00
|
|
|
pclose(s);
|
2012-02-22 04:16:25 -06:00
|
|
|
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, decl.output.span.lo);
|
2012-09-07 20:53:14 -05:00
|
|
|
match decl.output.node {
|
|
|
|
ast::ty_nil => {}
|
|
|
|
_ => {
|
|
|
|
space_if_not_bol(s);
|
|
|
|
word_space(s, ~"->");
|
|
|
|
print_type(s, decl.output);
|
|
|
|
}
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 14:33:04 -05:00
|
|
|
fn print_fn_block_args(s: ps, decl: ast::fn_decl,
|
2012-06-29 18:26:56 -05:00
|
|
|
cap_items: ~[ast::capture_item]) {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"|");
|
2012-08-20 14:23:37 -05:00
|
|
|
print_fn_args(s, decl, cap_items, None);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"|");
|
2012-09-07 20:53:14 -05:00
|
|
|
|
|
|
|
match decl.output.node {
|
|
|
|
ast::ty_infer => {}
|
|
|
|
_ => {
|
|
|
|
space_if_not_bol(s);
|
|
|
|
word_space(s, ~"->");
|
|
|
|
print_type(s, decl.output);
|
|
|
|
}
|
2011-12-20 18:18:18 -06:00
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2011-08-15 16:42:33 -05:00
|
|
|
maybe_print_comment(s, decl.output.span.lo);
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn mode_to_str(m: ast::mode) -> ~str {
|
2012-08-06 14:34:08 -05:00
|
|
|
match m {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::expl(ast::by_move) => ~"-",
|
|
|
|
ast::expl(ast::by_ref) => ~"&&",
|
|
|
|
ast::expl(ast::by_val) => ~"++",
|
|
|
|
ast::expl(ast::by_copy) => ~"+",
|
|
|
|
ast::infer(_) => ~""
|
2011-06-10 05:03:50 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-02 18:50:17 -06:00
|
|
|
fn print_arg_mode(s: ps, m: ast::mode) {
|
|
|
|
let ms = mode_to_str(m);
|
2012-07-14 00:57:48 -05:00
|
|
|
if ms != ~"" { word(s.s, ms); }
|
2012-02-02 18:50:17 -06:00
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
|
2012-10-17 00:14:59 -05:00
|
|
|
if bounds.is_not_empty() {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~":");
|
2012-09-18 23:41:13 -05:00
|
|
|
for vec::each(*bounds) |bound| {
|
2011-12-28 10:50:12 -06:00
|
|
|
nbsp(s);
|
2012-10-17 00:14:59 -05:00
|
|
|
print_type(s, **bound);
|
2011-12-28 10:50:12 -06:00
|
|
|
}
|
2011-08-02 23:26:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn print_type_params(s: ps, &¶ms: ~[ast::ty_param]) {
|
2011-08-15 18:38:23 -05:00
|
|
|
if vec::len(params) > 0u {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"<");
|
2011-09-12 04:27:30 -05:00
|
|
|
fn printParam(s: ps, param: ast::ty_param) {
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, param.ident);
|
2011-12-28 10:50:12 -06:00
|
|
|
print_bounds(s, param.bounds);
|
2011-07-28 12:22:59 -05:00
|
|
|
}
|
2011-07-12 18:13:30 -05:00
|
|
|
commasep(s, inconsistent, params, printParam);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~">");
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-09-20 20:15:39 -05:00
|
|
|
fn print_meta_item(s: ps, &&item: @ast::meta_item) {
|
2011-06-14 20:53:12 -05:00
|
|
|
ibox(s, indent_unit);
|
2012-08-06 14:34:08 -05:00
|
|
|
match item.node {
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::meta_word(ref name) => word(s.s, (*name)),
|
|
|
|
ast::meta_name_value(ref name, value) => {
|
|
|
|
word_space(s, (*name));
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"=");
|
2011-07-27 07:19:39 -05:00
|
|
|
print_literal(s, @value);
|
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::meta_list(ref name, items) => {
|
|
|
|
word(s.s, (*name));
|
2011-07-27 07:19:39 -05:00
|
|
|
popen(s);
|
|
|
|
commasep(s, consistent, items, print_meta_item);
|
|
|
|
pclose(s);
|
|
|
|
}
|
2011-06-21 16:23:16 -05:00
|
|
|
}
|
2011-06-14 20:53:12 -05:00
|
|
|
end(s);
|
|
|
|
}
|
|
|
|
|
2012-02-18 01:05:20 -06:00
|
|
|
fn print_view_path(s: ps, &&vp: @ast::view_path) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match vp.node {
|
2012-08-31 13:19:07 -05:00
|
|
|
ast::view_path_simple(ident, path, namespace, _) => {
|
|
|
|
if namespace == ast::module_ns {
|
|
|
|
word_space(s, ~"mod");
|
|
|
|
}
|
2012-04-23 06:04:46 -05:00
|
|
|
if path.idents[vec::len(path.idents)-1u] != ident {
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, ident);
|
|
|
|
space(s.s);
|
2012-07-14 00:57:48 -05:00
|
|
|
word_space(s, ~"=");
|
2012-02-18 01:05:20 -06:00
|
|
|
}
|
2012-04-13 03:46:56 -05:00
|
|
|
print_path(s, path, false);
|
2012-02-18 01:05:20 -06:00
|
|
|
}
|
|
|
|
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::view_path_glob(path, _) => {
|
2012-04-13 03:46:56 -05:00
|
|
|
print_path(s, path, false);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"::*");
|
2012-02-18 01:05:20 -06:00
|
|
|
}
|
|
|
|
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::view_path_list(path, ref idents, _) => {
|
2012-04-13 03:46:56 -05:00
|
|
|
print_path(s, path, false);
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"::{");
|
2012-12-04 12:50:00 -06:00
|
|
|
do commasep(s, inconsistent, (*idents)) |s, w| {
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, w.node.name);
|
2012-02-18 01:05:20 -06:00
|
|
|
}
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"}");
|
2012-02-18 01:05:20 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-29 18:26:56 -05:00
|
|
|
fn print_view_paths(s: ps, vps: ~[@ast::view_path]) {
|
2012-02-18 01:05:20 -06:00
|
|
|
commasep(s, inconsistent, vps, print_view_path);
|
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_view_item(s: ps, item: @ast::view_item) {
|
2011-06-20 11:15:11 -05:00
|
|
|
hardbreak_if_not_bol(s);
|
2011-03-24 10:33:20 -05:00
|
|
|
maybe_print_comment(s, item.span.lo);
|
2012-07-09 17:39:56 -05:00
|
|
|
print_outer_attributes(s, item.attrs);
|
2012-09-21 20:10:45 -05:00
|
|
|
print_visibility(s, item.vis);
|
2012-08-06 14:34:08 -05:00
|
|
|
match item.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::view_item_use(id, mta, _) => {
|
2012-09-11 19:46:20 -05:00
|
|
|
head(s, ~"extern mod");
|
2012-07-18 18:18:02 -05:00
|
|
|
print_ident(s, id);
|
2012-10-27 19:14:09 -05:00
|
|
|
if mta.is_not_empty() {
|
2011-07-27 07:19:39 -05:00
|
|
|
popen(s);
|
|
|
|
commasep(s, consistent, mta, print_meta_item);
|
|
|
|
pclose(s);
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-02-18 01:05:20 -06:00
|
|
|
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::view_item_import(vps) => {
|
2012-09-07 20:08:21 -05:00
|
|
|
head(s, ~"use");
|
2012-02-18 01:05:20 -06:00
|
|
|
print_view_paths(s, vps);
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-02-18 01:05:20 -06:00
|
|
|
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::view_item_export(vps) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
head(s, ~"export");
|
2012-02-18 01:05:20 -06:00
|
|
|
print_view_paths(s, vps);
|
Export all enum variants by default; new syntax for selectively exporting variants
See issue 1426 for details. Now, the semantics of "export t;" where t is a tag are
to export all of t's variants as well. "export t{};" exports t but not its
variants, while "export t{a, b, c};" exports only variants a, b, c of t.
To do:
- documentation
- there's currently no checking that a, b, c are actually variants of t in the
above example
- there's also no checking that t is an enum type, in the second two examples above
- change the modules listed in issue 1426 that should have the old export
semantics to use the t{} syntax
I deleted the test export-no-tag-variants since we're doing the opposite now,
and other tests cover the same behavior.
2012-01-22 23:09:43 -06:00
|
|
|
}
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~";");
|
2011-06-01 17:29:38 -05:00
|
|
|
end(s); // end inner head-block
|
|
|
|
end(s); // end outer head-block
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-02-15 13:25:39 -06:00
|
|
|
fn print_mutability(s: ps, mutbl: ast::mutability) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match mutbl {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::m_mutbl => word_nbsp(s, ~"mut"),
|
|
|
|
ast::m_const => word_nbsp(s, ~"const"),
|
|
|
|
ast::m_imm => {/* nothing */ }
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-06-15 12:25:23 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_mt(s: ps, mt: ast::mt) {
|
2012-02-15 13:25:39 -06:00
|
|
|
print_mutability(s, mt.mutbl);
|
2011-08-15 06:45:04 -05:00
|
|
|
print_type(s, mt.ty);
|
2011-03-04 00:22:43 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 14:33:04 -05:00
|
|
|
fn print_arg(s: ps, input: ast::arg) {
|
|
|
|
ibox(s, indent_unit);
|
|
|
|
print_arg_mode(s, input.mode);
|
2012-08-06 14:34:08 -05:00
|
|
|
match input.ty.node {
|
2012-12-07 16:39:29 -06:00
|
|
|
ast::ty_infer => print_irrefutable_pat(s, input.pat),
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {
|
2012-11-06 20:41:06 -06:00
|
|
|
match input.pat.node {
|
|
|
|
ast::pat_ident(_, path, _) if
|
|
|
|
path.idents.len() == 1 &&
|
|
|
|
path.idents[0] == parse::token::special_idents::invalid => {
|
|
|
|
// Do nothing.
|
|
|
|
}
|
|
|
|
_ => {
|
2012-12-07 16:39:29 -06:00
|
|
|
print_irrefutable_pat(s, input.pat);
|
2012-11-06 20:41:06 -06:00
|
|
|
word(s.s, ~":");
|
|
|
|
space(s.s);
|
|
|
|
}
|
2012-05-04 14:33:04 -05:00
|
|
|
}
|
|
|
|
print_type(s, input.ty);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end(s);
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:33:51 -05:00
|
|
|
fn print_ty_fn(s: ps,
|
2012-11-04 22:41:00 -06:00
|
|
|
opt_proto: Option<ast::Proto>,
|
|
|
|
opt_region: Option<@ast::region>,
|
2012-11-02 15:33:51 -05:00
|
|
|
purity: ast::purity,
|
|
|
|
onceness: ast::Onceness,
|
2012-08-06 20:54:20 -05:00
|
|
|
bounds: @~[ast::ty_param_bound],
|
2012-08-20 14:23:37 -05:00
|
|
|
decl: ast::fn_decl, id: Option<ast::ident>,
|
|
|
|
tps: Option<~[ast::ty_param]>,
|
|
|
|
opt_self_ty: Option<ast::self_ty_>) {
|
2011-06-01 17:29:38 -05:00
|
|
|
ibox(s, indent_unit);
|
2012-11-04 22:41:00 -06:00
|
|
|
|
|
|
|
// Duplicates the logic in `print_fn_header_info()`. This is because that
|
|
|
|
// function prints the proto in the wrong place. That should be fixed.
|
|
|
|
print_self_ty_if_static(s, opt_self_ty);
|
|
|
|
print_opt_proto(s, opt_proto);
|
|
|
|
for opt_region.each |r| { print_region(s, ~"", *r, ~"/"); }
|
|
|
|
print_purity(s, purity);
|
|
|
|
print_onceness(s, onceness);
|
|
|
|
word(s.s, ~"fn");
|
2012-08-06 20:54:20 -05:00
|
|
|
print_bounds(s, bounds);
|
2012-08-20 14:23:37 -05:00
|
|
|
match id { Some(id) => { word(s.s, ~" "); print_ident(s, id); } _ => () }
|
|
|
|
match tps { Some(tps) => print_type_params(s, tps), _ => () }
|
2011-06-02 19:36:28 -05:00
|
|
|
zerobreak(s.s);
|
2012-08-17 18:14:57 -05:00
|
|
|
|
2011-05-28 21:16:18 -05:00
|
|
|
popen(s);
|
2012-08-17 18:14:57 -05:00
|
|
|
// It is unfortunate to duplicate the commasep logic, but we
|
|
|
|
// we want the self type, the args, and the capture clauses all
|
|
|
|
// in the same box.
|
|
|
|
box(s, 0u, inconsistent);
|
|
|
|
let mut first = true;
|
|
|
|
for opt_self_ty.each |self_ty| {
|
2012-09-19 18:55:01 -05:00
|
|
|
first = !print_self_ty(s, *self_ty);
|
2012-08-17 18:14:57 -05:00
|
|
|
}
|
|
|
|
for decl.inputs.each |arg| {
|
|
|
|
if first { first = false; } else { word_space(s, ~","); }
|
2012-09-19 18:55:01 -05:00
|
|
|
print_arg(s, *arg);
|
2012-08-17 18:14:57 -05:00
|
|
|
}
|
|
|
|
end(s);
|
2011-03-24 10:33:20 -05:00
|
|
|
pclose(s);
|
2012-08-17 18:14:57 -05:00
|
|
|
|
2011-12-23 06:32:17 -06:00
|
|
|
maybe_print_comment(s, decl.output.span.lo);
|
2012-09-07 20:53:14 -05:00
|
|
|
|
|
|
|
match decl.output.node {
|
|
|
|
ast::ty_nil => {}
|
|
|
|
_ => {
|
|
|
|
space_if_not_bol(s);
|
|
|
|
ibox(s, indent_unit);
|
|
|
|
word_space(s, ~"->");
|
|
|
|
if decl.cf == ast::noreturn { word_nbsp(s, ~"!"); }
|
|
|
|
else { print_type(s, decl.output); }
|
|
|
|
end(s);
|
|
|
|
}
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2012-09-07 20:53:14 -05:00
|
|
|
|
2011-06-01 17:29:38 -05:00
|
|
|
end(s);
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn maybe_print_trailing_comment(s: ps, span: codemap::span,
|
2012-11-15 21:37:29 -06:00
|
|
|
next_pos: Option<BytePos>) {
|
2012-03-15 08:47:03 -05:00
|
|
|
let mut cm;
|
2012-08-20 14:23:37 -05:00
|
|
|
match s.cm { Some(ccm) => cm = ccm, _ => return }
|
2012-08-06 14:34:08 -05:00
|
|
|
match next_comment(s) {
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(ref cmnt) => {
|
|
|
|
if (*cmnt).style != comments::trailing { return; }
|
2012-11-12 20:24:56 -06:00
|
|
|
let span_line = cm.lookup_char_pos(span.hi);
|
2012-12-04 12:50:00 -06:00
|
|
|
let comment_line = cm.lookup_char_pos((*cmnt).pos);
|
|
|
|
let mut next = (*cmnt).pos + BytePos(1u);
|
2012-08-20 14:23:37 -05:00
|
|
|
match next_pos { None => (), Some(p) => next = p }
|
2012-12-04 12:50:00 -06:00
|
|
|
if span.hi < (*cmnt).pos && (*cmnt).pos < next &&
|
2011-07-27 07:19:39 -05:00
|
|
|
span_line.line == comment_line.line {
|
2012-12-04 12:50:00 -06:00
|
|
|
print_comment(s, (*cmnt));
|
2011-07-27 07:19:39 -05:00
|
|
|
s.cur_cmnt += 1u;
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-12 04:27:30 -05:00
|
|
|
fn print_remaining_comments(s: ps) {
|
2011-08-03 19:52:25 -05:00
|
|
|
// If there aren't any remaining comments, then we need to manually
|
|
|
|
// make sure there is a line break at the end.
|
2012-09-21 21:37:57 -05:00
|
|
|
if next_comment(s).is_none() { hardbreak(s.s); }
|
2012-03-10 22:34:17 -06:00
|
|
|
loop {
|
2012-08-06 14:34:08 -05:00
|
|
|
match next_comment(s) {
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(ref cmnt) => { print_comment(s, (*cmnt)); s.cur_cmnt += 1u; }
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => break
|
2011-03-24 10:33:20 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-06 05:26:12 -05:00
|
|
|
fn print_literal(s: ps, &&lit: @ast::lit) {
|
2011-07-05 04:48:19 -05:00
|
|
|
maybe_print_comment(s, lit.span.lo);
|
2012-08-06 14:34:08 -05:00
|
|
|
match next_lit(s, lit.span.lo) {
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(ref ltrl) => {
|
|
|
|
word(s.s, (*ltrl).lit);
|
2012-08-01 19:30:05 -05:00
|
|
|
return;
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => ()
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
2012-08-06 14:34:08 -05:00
|
|
|
match lit.node {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::lit_str(st) => print_string(s, *st),
|
|
|
|
ast::lit_int(ch, ast::ty_char) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"'" + char::escape_default(ch as char) + ~"'");
|
2011-12-07 14:06:12 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::lit_int(i, t) => {
|
2012-02-03 19:39:39 -06:00
|
|
|
if i < 0_i64 {
|
|
|
|
word(s.s,
|
2012-07-14 00:57:48 -05:00
|
|
|
~"-" + u64::to_str(-i as u64, 10u)
|
2012-02-03 19:39:39 -06:00
|
|
|
+ ast_util::int_ty_to_str(t));
|
|
|
|
} else {
|
|
|
|
word(s.s,
|
|
|
|
u64::to_str(i as u64, 10u)
|
|
|
|
+ ast_util::int_ty_to_str(t));
|
|
|
|
}
|
2011-12-07 14:06:12 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::lit_uint(u, t) => {
|
2012-02-03 19:39:39 -06:00
|
|
|
word(s.s,
|
|
|
|
u64::to_str(u, 10u)
|
|
|
|
+ ast_util::uint_ty_to_str(t));
|
2011-12-07 14:06:12 -06:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::lit_int_unsuffixed(i) => {
|
2012-06-11 18:31:03 -05:00
|
|
|
if i < 0_i64 {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"-" + u64::to_str(-i as u64, 10u));
|
2012-06-11 18:31:03 -05:00
|
|
|
} else {
|
2012-06-14 21:41:40 -05:00
|
|
|
word(s.s, u64::to_str(i as u64, 10u));
|
2012-06-11 18:31:03 -05:00
|
|
|
}
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::lit_float(f, t) => {
|
2012-06-10 02:49:59 -05:00
|
|
|
word(s.s, *f + ast_util::float_ty_to_str(t));
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-11-07 20:40:34 -06:00
|
|
|
ast::lit_float_unsuffixed(f) => word(s.s, *f),
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::lit_nil => word(s.s, ~"()"),
|
|
|
|
ast::lit_bool(val) => {
|
2012-07-14 00:57:48 -05:00
|
|
|
if val { word(s.s, ~"true"); } else { word(s.s, ~"false"); }
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-18 18:18:02 -05:00
|
|
|
fn lit_to_str(l: @ast::lit) -> ~str {
|
|
|
|
return to_str(l, print_literal, parse::token::mk_fake_ident_interner());
|
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
|
2012-11-15 21:37:29 -06:00
|
|
|
fn next_lit(s: ps, pos: BytePos) -> Option<comments::lit> {
|
2012-08-06 14:34:08 -05:00
|
|
|
match s.literals {
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(ref lits) => {
|
|
|
|
while s.cur_lit < vec::len((*lits)) {
|
|
|
|
let ltrl = (*lits)[s.cur_lit];
|
2012-08-20 14:23:37 -05:00
|
|
|
if ltrl.pos > pos { return None; }
|
2012-01-16 03:50:34 -06:00
|
|
|
s.cur_lit += 1u;
|
2012-08-20 14:23:37 -05:00
|
|
|
if ltrl.pos == pos { return Some(ltrl); }
|
2012-01-16 03:50:34 -06:00
|
|
|
}
|
2012-08-20 14:23:37 -05:00
|
|
|
return None;
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-20 14:23:37 -05:00
|
|
|
_ => return None
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-15 21:37:29 -06:00
|
|
|
fn maybe_print_comment(s: ps, pos: BytePos) {
|
2012-03-10 22:34:17 -06:00
|
|
|
loop {
|
2012-08-06 14:34:08 -05:00
|
|
|
match next_comment(s) {
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(ref cmnt) => {
|
|
|
|
if (*cmnt).pos < pos {
|
|
|
|
print_comment(s, (*cmnt));
|
2011-07-27 07:19:39 -05:00
|
|
|
s.cur_cmnt += 1u;
|
|
|
|
} else { break; }
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => break
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-15 05:27:24 -05:00
|
|
|
fn print_comment(s: ps, cmnt: comments::cmnt) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match cmnt.style {
|
2012-08-03 21:59:04 -05:00
|
|
|
comments::mixed => {
|
2011-08-15 18:38:23 -05:00
|
|
|
assert (vec::len(cmnt.lines) == 1u);
|
2011-07-27 07:19:39 -05:00
|
|
|
zerobreak(s.s);
|
2011-08-27 03:16:40 -05:00
|
|
|
word(s.s, cmnt.lines[0]);
|
2011-07-27 07:19:39 -05:00
|
|
|
zerobreak(s.s);
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
comments::isolated => {
|
2011-07-27 07:19:39 -05:00
|
|
|
pprust::hardbreak_if_not_bol(s);
|
2012-06-30 18:19:07 -05:00
|
|
|
for cmnt.lines.each |line| {
|
2011-08-18 21:19:38 -05:00
|
|
|
// Don't print empty lines because they will end up as trailing
|
|
|
|
// whitespace
|
2012-09-19 18:55:01 -05:00
|
|
|
if str::is_not_empty(*line) { word(s.s, *line); }
|
2011-08-18 21:19:38 -05:00
|
|
|
hardbreak(s.s);
|
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
comments::trailing => {
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~" ");
|
2011-08-15 18:38:23 -05:00
|
|
|
if vec::len(cmnt.lines) == 1u {
|
2011-08-27 03:16:40 -05:00
|
|
|
word(s.s, cmnt.lines[0]);
|
2011-07-05 04:48:19 -05:00
|
|
|
hardbreak(s.s);
|
2011-07-27 07:19:39 -05:00
|
|
|
} else {
|
|
|
|
ibox(s, 0u);
|
2012-06-30 18:19:07 -05:00
|
|
|
for cmnt.lines.each |line| {
|
2012-09-19 18:55:01 -05:00
|
|
|
if str::is_not_empty(*line) { word(s.s, *line); }
|
2011-08-18 21:19:38 -05:00
|
|
|
hardbreak(s.s);
|
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
end(s);
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
comments::blank_line => {
|
2011-07-27 07:19:39 -05:00
|
|
|
// We need to do at least one, possibly two hardbreaks.
|
2011-08-19 17:16:48 -05:00
|
|
|
let is_semi =
|
2012-08-06 14:34:08 -05:00
|
|
|
match s.s.last_token() {
|
2012-08-03 21:59:04 -05:00
|
|
|
pp::STRING(s, _) => *s == ~";",
|
|
|
|
_ => false
|
2011-08-19 17:16:48 -05:00
|
|
|
};
|
2011-09-16 09:57:54 -05:00
|
|
|
if is_semi || is_begin(s) || is_end(s) { hardbreak(s.s); }
|
2011-07-27 07:19:39 -05:00
|
|
|
hardbreak(s.s);
|
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn print_string(s: ps, st: ~str) {
|
|
|
|
word(s.s, ~"\"");
|
2012-05-31 17:31:13 -05:00
|
|
|
word(s.s, str::escape_default(st));
|
2012-07-14 00:57:48 -05:00
|
|
|
word(s.s, ~"\"");
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2012-09-19 20:50:24 -05:00
|
|
|
fn to_str<T>(t: T, f: fn@(ps, T), intr: @ident_interner) -> ~str {
|
2012-09-14 11:40:28 -05:00
|
|
|
do io::with_str_writer |wr| {
|
|
|
|
let s = rust_printer(wr, intr);
|
|
|
|
f(s, t);
|
|
|
|
eof(s.s);
|
|
|
|
}
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
|
2012-08-20 14:23:37 -05:00
|
|
|
fn next_comment(s: ps) -> Option<comments::cmnt> {
|
2012-08-06 14:34:08 -05:00
|
|
|
match s.comments {
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(ref cmnts) => {
|
|
|
|
if s.cur_cmnt < vec::len((*cmnts)) {
|
|
|
|
return Some((*cmnts)[s.cur_cmnt]);
|
2012-08-20 14:23:37 -05:00
|
|
|
} else { return None::<comments::cmnt>; }
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-08-20 14:23:37 -05:00
|
|
|
_ => return None::<comments::cmnt>
|
2011-07-05 04:48:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-04 22:41:00 -06:00
|
|
|
fn print_self_ty_if_static(s: ps,
|
|
|
|
opt_self_ty: Option<ast::self_ty_>) {
|
|
|
|
match opt_self_ty {
|
|
|
|
Some(ast::sty_static) => { word(s.s, ~"static "); }
|
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
}
|
2012-08-02 18:01:38 -05:00
|
|
|
|
2012-11-04 22:41:00 -06:00
|
|
|
fn print_opt_purity(s: ps, opt_purity: Option<ast::purity>) {
|
2012-08-23 20:17:16 -05:00
|
|
|
match opt_purity {
|
2012-11-04 22:41:00 -06:00
|
|
|
Some(ast::impure_fn) => { }
|
|
|
|
Some(purity) => {
|
|
|
|
word_nbsp(s, purity_to_str(purity));
|
|
|
|
}
|
|
|
|
None => {}
|
2012-08-02 18:01:38 -05:00
|
|
|
}
|
2012-11-04 22:41:00 -06:00
|
|
|
}
|
2012-08-02 18:01:38 -05:00
|
|
|
|
2012-11-04 22:41:00 -06:00
|
|
|
fn print_opt_proto(s: ps, opt_proto: Option<ast::Proto>) {
|
|
|
|
match opt_proto {
|
|
|
|
Some(ast::ProtoBare) => { word(s.s, ~"extern "); }
|
|
|
|
Some(ast::ProtoBorrowed) => { word(s.s, ~"&"); }
|
|
|
|
Some(ast::ProtoUniq) => { word(s.s, ~"~"); }
|
|
|
|
Some(ast::ProtoBox) => { word(s.s, ~"@"); }
|
|
|
|
None => {}
|
|
|
|
};
|
|
|
|
}
|
2012-11-02 15:33:51 -05:00
|
|
|
|
2012-11-04 22:41:00 -06:00
|
|
|
fn print_fn_header_info(s: ps,
|
|
|
|
opt_sty: Option<ast::self_ty_>,
|
|
|
|
opt_purity: Option<ast::purity>,
|
|
|
|
onceness: ast::Onceness,
|
|
|
|
opt_proto: Option<ast::Proto>,
|
|
|
|
vis: ast::visibility)
|
|
|
|
{
|
|
|
|
print_self_ty_if_static(s, opt_sty);
|
2012-11-13 12:53:45 -06:00
|
|
|
word(s.s, visibility_qualified(vis, ~""));
|
2012-11-04 22:41:00 -06:00
|
|
|
print_opt_purity(s, opt_purity);
|
|
|
|
print_onceness(s, onceness);
|
|
|
|
word(s.s, ~"fn");
|
|
|
|
print_opt_proto(s, opt_proto);
|
2012-08-02 18:01:38 -05:00
|
|
|
}
|
|
|
|
|
2012-11-04 22:41:00 -06:00
|
|
|
fn opt_proto_to_str(opt_p: Option<ast::Proto>) -> ~str {
|
2012-08-06 14:34:08 -05:00
|
|
|
match opt_p {
|
2012-08-20 14:23:37 -05:00
|
|
|
None => ~"fn",
|
|
|
|
Some(p) => proto_to_str(p)
|
2012-01-11 14:52:25 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-02 17:42:56 -05:00
|
|
|
pure fn purity_to_str(p: ast::purity) -> ~str {
|
2012-08-06 14:34:08 -05:00
|
|
|
match p {
|
2012-08-02 17:42:56 -05:00
|
|
|
ast::impure_fn => ~"impure",
|
|
|
|
ast::unsafe_fn => ~"unsafe",
|
|
|
|
ast::pure_fn => ~"pure",
|
|
|
|
ast::extern_fn => ~"extern"
|
2012-05-25 01:44:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:33:51 -05:00
|
|
|
pure fn onceness_to_str(o: ast::Onceness) -> ~str {
|
|
|
|
match o {
|
|
|
|
ast::Once => ~"once",
|
|
|
|
ast::Many => ~"many"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-25 01:44:58 -05:00
|
|
|
fn print_purity(s: ps, p: ast::purity) {
|
2012-08-06 14:34:08 -05:00
|
|
|
match p {
|
2012-08-03 21:59:04 -05:00
|
|
|
ast::impure_fn => (),
|
|
|
|
_ => word_nbsp(s, purity_to_str(p))
|
2012-05-25 01:44:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-04 22:41:00 -06:00
|
|
|
fn print_onceness(s: ps, o: ast::Onceness) {
|
|
|
|
match o {
|
|
|
|
ast::Once => { word_nbsp(s, ~"once"); }
|
|
|
|
ast::Many => {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn proto_to_str(p: ast::Proto) -> ~str {
|
2012-08-06 14:34:08 -05:00
|
|
|
return match p {
|
2012-11-04 22:41:00 -06:00
|
|
|
ast::ProtoBare => ~"extern fn",
|
|
|
|
ast::ProtoBorrowed => ~"fn&",
|
|
|
|
ast::ProtoUniq => ~"fn~",
|
|
|
|
ast::ProtoBox => ~"fn@"
|
2012-01-12 17:38:44 -06:00
|
|
|
};
|
2011-07-19 20:17:49 -05:00
|
|
|
}
|
|
|
|
|
Handle nested items correctly in typestate_check
Summary says it all. Actually, only nested objects and functions
are handled, but that's better than before. The fold that I was using
before to traverse a crate wasn't working correctly, because annotations
have to reflect the number of local variables of the nearest enclosing
function (in turn, because annotations are represented as bit vectors).
The fold was traversing the AST in the wrong order, first filling in
the annotations correctly, but then re-traversing them with the bit
vector length for any outer nested functions, and so on.
Remedying this required writing a lot of tedious boilerplate code
because I scrapped the idea of using a fold altogether.
I also made typestate_check handle unary, field, alt, and fail.
Also, some miscellaneous changes:
* added annotations to blocks in typeck
* fix pprust so it can handle spawn
* added more logging functions in util.common
* fixed _vec.or
* added maybe and from_maybe in option
* removed fold_block field from ast_fold, since it was never used
2011-04-18 17:33:10 -05:00
|
|
|
//
|
|
|
|
// Local Variables:
|
|
|
|
// mode: rust
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|
|
|
|
//
|