rust/src/libsyntax/parse/mod.rs

775 lines
27 KiB
Rust
Raw Normal View History

// 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-11-28 18:20:41 -06:00
//! The main parser interface
2013-01-30 11:56:33 -06:00
use ast;
use codemap::{Span, CodeMap, FileMap, FileSubstr};
use codemap;
use diagnostic::{SpanHandler, mk_span_handler, mk_handler, Emitter};
use parse::attr::parser_attr;
2013-03-26 15:38:07 -05:00
use parse::lexer::reader;
use parse::parser::Parser;
use std::cell::RefCell;
2013-11-11 00:46:32 -06:00
use std::io;
use std::io::File;
use std::str;
pub mod lexer;
pub mod parser;
pub mod token;
pub mod comments;
pub mod attr;
2012-11-18 19:56:50 -06:00
/// Common routines shared by parser mods
pub mod common;
2012-11-18 19:56:50 -06:00
/// Routines the parser uses to classify AST nodes
pub mod classify;
2012-11-18 19:56:50 -06:00
/// Reporting obsolete syntax
pub mod obsolete;
2012-11-28 18:20:41 -06:00
2013-03-08 12:19:19 -06:00
// info about a parsing session.
pub struct ParseSess {
2013-03-08 12:19:19 -06:00
cm: @codemap::CodeMap, // better be the same as the one in the reader!
span_diagnostic: @mut SpanHandler, // better be the same as the one in the reader!
/// Used to determine and report recursive mod inclusions
included_mod_stack: RefCell<~[Path]>,
}
2012-11-28 18:20:41 -06:00
pub fn new_parse_sess(demitter: Option<@Emitter>) -> @mut ParseSess {
2012-11-28 18:20:41 -06:00
let cm = @CodeMap::new();
@mut ParseSess {
cm: cm,
span_diagnostic: mk_span_handler(mk_handler(demitter), cm),
included_mod_stack: RefCell::new(~[]),
}
2012-11-28 18:20:41 -06:00
}
pub fn new_parse_sess_special_handler(sh: @mut SpanHandler,
cm: @codemap::CodeMap)
-> @mut ParseSess {
@mut ParseSess {
cm: cm,
span_diagnostic: sh,
included_mod_stack: RefCell::new(~[]),
}
2012-11-28 18:20:41 -06:00
}
2013-02-11 15:36:24 -06:00
// a bunch of utility functions of the form parse_<thing>_from_<source>
// where <thing> includes crate, expr, item, stmt, tts, and one that
// uses a HOF to parse anything, and <source> includes file and
// source_str.
pub fn parse_crate_from_file(
input: &Path,
cfg: ast::CrateConfig,
sess: @mut ParseSess
2013-09-27 21:46:09 -05:00
) -> ast::Crate {
2013-07-02 14:47:32 -05:00
new_parser_from_file(sess, /*bad*/ cfg.clone(), input).parse_crate_mod()
2013-02-11 15:36:24 -06:00
// why is there no p.abort_if_errors here?
2012-11-28 18:20:41 -06:00
}
pub fn parse_crate_attrs_from_file(
input: &Path,
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> ~[ast::Attribute] {
2013-12-30 16:04:00 -06:00
let mut parser = new_parser_from_file(sess, cfg, input);
let (inner, _) = parser.parse_inner_attrs_and_next();
return inner;
}
pub fn parse_crate_from_source_str(
name: @str,
source: @str,
cfg: ast::CrateConfig,
sess: @mut ParseSess
2013-09-27 21:46:09 -05:00
) -> ast::Crate {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_str(sess,
/*bad*/ cfg.clone(),
name,
source);
2013-04-23 12:57:41 -05:00
maybe_aborted(p.parse_crate_mod(),p)
2012-11-28 18:20:41 -06:00
}
pub fn parse_crate_attrs_from_source_str(
name: @str,
source: @str,
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> ~[ast::Attribute] {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_str(sess,
/*bad*/ cfg.clone(),
name,
source);
let (inner, _) = maybe_aborted(p.parse_inner_attrs_and_next(),p);
return inner;
}
pub fn parse_expr_from_source_str(
name: @str,
source: @str,
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> @ast::Expr {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_expr(), p)
2012-11-28 18:20:41 -06:00
}
pub fn parse_item_from_source_str(
name: @str,
source: @str,
cfg: ast::CrateConfig,
attrs: ~[ast::Attribute],
sess: @mut ParseSess
) -> Option<@ast::item> {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_item(attrs),p)
2012-11-28 18:20:41 -06:00
}
pub fn parse_meta_from_source_str(
name: @str,
source: @str,
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> @ast::MetaItem {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_str(sess, cfg, name, source);
maybe_aborted(p.parse_meta_item(),p)
}
pub fn parse_stmt_from_source_str(
name: @str,
source: @str,
cfg: ast::CrateConfig,
attrs: ~[ast::Attribute],
sess: @mut ParseSess
) -> @ast::Stmt {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_str(
sess,
cfg,
name,
source
);
maybe_aborted(p.parse_stmt(attrs),p)
2012-11-28 18:20:41 -06:00
}
pub fn parse_tts_from_source_str(
name: @str,
source: @str,
cfg: ast::CrateConfig,
sess: @mut ParseSess
) -> ~[ast::token_tree] {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_str(
sess,
cfg,
name,
source
);
p.quote_depth += 1u;
2013-04-23 12:57:41 -05:00
// right now this is re-creating the token trees from ... token trees.
maybe_aborted(p.parse_all_token_trees(),p)
2012-11-28 18:20:41 -06:00
}
2013-04-23 12:57:41 -05:00
// given a function and parsing information (source str,
// filename, crate cfg, and sess), create a parser,
// apply the function, and check that the parser
// consumed all of the input before returning the function's
// result.
pub fn parse_from_source_str<T>(
2013-12-30 16:04:00 -06:00
f: |&mut Parser| -> T,
name: @str,
ss: codemap::FileSubstr,
source: @str,
cfg: ast::CrateConfig,
sess: @mut ParseSess)
-> T {
2013-12-30 16:04:00 -06:00
let mut p = new_parser_from_source_substr(sess, cfg, name, ss, source);
let r = f(&mut p);
2012-11-28 18:20:41 -06:00
if !p.reader.is_eof() {
p.reader.fatal(~"expected end-of-string");
}
maybe_aborted(r,p)
2012-11-28 18:20:41 -06:00
}
2013-04-23 12:57:41 -05:00
// Create a new parser from a source string
pub fn new_parser_from_source_str(sess: @mut ParseSess,
cfg: ast::CrateConfig,
name: @str,
source: @str)
-> Parser {
2013-04-23 12:57:41 -05:00
filemap_to_parser(sess,string_to_filemap(sess,source,name),cfg)
2012-11-28 18:20:41 -06:00
}
2013-04-23 12:57:41 -05:00
// Create a new parser from a source string where the origin
// is specified as a substring of another file.
pub fn new_parser_from_source_substr(sess: @mut ParseSess,
cfg: ast::CrateConfig,
name: @str,
2013-04-23 12:57:41 -05:00
ss: codemap::FileSubstr,
source: @str)
2013-04-23 12:57:41 -05:00
-> Parser {
filemap_to_parser(sess,substring_to_filemap(sess,source,name,ss),cfg)
2012-11-28 18:20:41 -06:00
}
/// Create a new parser, handling errors as appropriate
2012-11-28 18:20:41 -06:00
/// if the file doesn't exist
pub fn new_parser_from_file(
sess: @mut ParseSess,
cfg: ast::CrateConfig,
path: &Path
) -> Parser {
2013-04-23 12:57:41 -05:00
filemap_to_parser(sess,file_to_filemap(sess,path,None),cfg)
2012-11-28 18:20:41 -06:00
}
2013-04-23 12:57:41 -05:00
/// Given a session, a crate config, a path, and a span, add
/// the file at the given path to the codemap, and return a parser.
/// On an error, use the given span as the source of the problem.
pub fn new_sub_parser_from_file(
sess: @mut ParseSess,
cfg: ast::CrateConfig,
path: &Path,
sp: Span
) -> Parser {
2013-04-23 12:57:41 -05:00
filemap_to_parser(sess,file_to_filemap(sess,path,Some(sp)),cfg)
}
/// Given a filemap and config, return a parser
pub fn filemap_to_parser(sess: @mut ParseSess,
filemap: @FileMap,
cfg: ast::CrateConfig) -> Parser {
2013-04-23 12:57:41 -05:00
tts_to_parser(sess,filemap_to_tts(sess,filemap),cfg)
}
// must preserve old name for now, because quote! from the *existing*
// compiler expands into it
pub fn new_parser_from_tts(sess: @mut ParseSess,
cfg: ast::CrateConfig,
2013-04-23 12:57:41 -05:00
tts: ~[ast::token_tree]) -> Parser {
tts_to_parser(sess,tts,cfg)
}
// base abstractions
/// Given a session and a path and an optional span (for error reporting),
/// add the path to the session's codemap and return the new filemap.
pub fn file_to_filemap(sess: @mut ParseSess, path: &Path, spanopt: Option<Span>)
2013-04-23 12:57:41 -05:00
-> @FileMap {
let err = |msg: &str| {
match spanopt {
Some(sp) => sess.span_diagnostic.span_fatal(sp, msg),
None => sess.span_diagnostic.handler().fatal(msg),
}
};
let bytes = match io::result(|| File::open(path).read_to_end()) {
Ok(bytes) => bytes,
Err(e) => {
err(format!("couldn't read {}: {}", path.display(), e.desc));
unreachable!()
}
};
match str::from_utf8_owned_opt(bytes) {
Some(s) => {
return string_to_filemap(sess, s.to_managed(),
path.as_str().unwrap().to_managed());
}
None => {
err(format!("{} is not UTF-8 encoded", path.display()))
2012-11-28 18:20:41 -06:00
}
}
unreachable!()
2012-11-28 18:20:41 -06:00
}
2013-04-23 12:57:41 -05:00
// given a session and a string, add the string to
// the session's codemap and return the new filemap
pub fn string_to_filemap(sess: @mut ParseSess, source: @str, path: @str)
2013-04-23 12:57:41 -05:00
-> @FileMap {
sess.cm.new_filemap(path, source)
}
// given a session and a string and a path and a FileSubStr, add
// the string to the CodeMap and return the new FileMap
pub fn substring_to_filemap(sess: @mut ParseSess, source: @str, path: @str,
2013-04-23 12:57:41 -05:00
filesubstr: FileSubstr) -> @FileMap {
sess.cm.new_filemap_w_substr(path,filesubstr,source)
}
// given a filemap, produce a sequence of token-trees
pub fn filemap_to_tts(sess: @mut ParseSess, filemap: @FileMap)
-> ~[ast::token_tree] {
// it appears to me that the cfg doesn't matter here... indeed,
// parsing tt's probably shouldn't require a parser at all.
let cfg = ~[];
let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap);
2013-12-30 16:04:00 -06:00
let mut p1 = Parser(sess, cfg, srdr as @mut reader);
2013-04-23 12:57:41 -05:00
p1.parse_all_token_trees()
}
// given tts and cfg, produce a parser
pub fn tts_to_parser(sess: @mut ParseSess,
tts: ~[ast::token_tree],
cfg: ast::CrateConfig) -> Parser {
let trdr = lexer::new_tt_reader(sess.span_diagnostic, None, tts);
Parser(sess, cfg, trdr as @mut reader)
2012-11-28 18:20:41 -06:00
}
2013-01-30 11:56:33 -06:00
// abort if necessary
2013-12-30 16:04:00 -06:00
pub fn maybe_aborted<T>(result: T, mut p: Parser) -> T {
p.abort_if_errors();
result
}
2013-02-04 15:15:17 -06:00
#[cfg(test)]
mod test {
use super::*;
use extra::serialize::Encodable;
use extra;
2013-11-11 00:46:32 -06:00
use std::io;
use std::io::Decorator;
use std::io::mem::MemWriter;
use std::str;
use codemap::{Span, BytePos, Spanned};
2013-04-23 12:57:41 -05:00
use opt_vec;
use ast;
2013-04-23 12:57:41 -05:00
use abi;
use parse::parser::Parser;
2013-06-08 11:21:11 -05:00
use parse::token::{str_to_ident};
2013-09-24 14:31:24 -05:00
use util::parser_testing::{string_to_tts, string_to_parser};
use util::parser_testing::{string_to_expr, string_to_item};
2013-08-30 17:06:11 -05:00
use util::parser_testing::string_to_stmt;
2013-04-23 12:57:41 -05:00
#[cfg(test)]
fn to_json_str<'a, E: Encodable<extra::json::Encoder<'a>>>(val: &E) -> ~str {
let mut writer = MemWriter::new();
let mut encoder = extra::json::Encoder::new(&mut writer as &mut io::Writer);
val.encode(&mut encoder);
2013-11-29 23:26:03 -06:00
str::from_utf8_owned(writer.inner())
2013-02-04 15:15:17 -06:00
}
2013-04-23 12:57:41 -05:00
// produce a codemap::span
2013-11-20 10:32:29 -06:00
fn sp(a: u32, b: u32) -> Span {
Span{lo:BytePos(a),hi:BytePos(b),expn_info:None}
2013-04-23 12:57:41 -05:00
}
#[test] fn path_exprs_1() {
assert_eq!(string_to_expr(@"a"),
@ast::Expr{
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(ast::Path {
span: sp(0, 1),
global: false,
segments: ~[
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: opt_vec::Empty,
2013-08-19 19:24:04 -05:00
types: opt_vec::Empty,
}
],
}),
span: sp(0, 1)
})
2013-04-23 12:57:41 -05:00
}
#[test] fn path_exprs_2 () {
assert_eq!(string_to_expr(@"::a::b"),
@ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(ast::Path {
span: sp(0, 6),
global: true,
segments: ~[
ast::PathSegment {
identifier: str_to_ident("a"),
lifetimes: opt_vec::Empty,
2013-08-19 19:24:04 -05:00
types: opt_vec::Empty,
},
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: opt_vec::Empty,
2013-08-19 19:24:04 -05:00
types: opt_vec::Empty,
}
]
}),
span: sp(0, 6)
})
2013-04-23 12:57:41 -05:00
}
#[should_fail]
2013-04-23 12:57:41 -05:00
#[test] fn bad_path_expr_1() {
string_to_expr(@"::abc::def::return");
}
2013-04-23 12:57:41 -05:00
// check the token-tree-ization of macros
#[test] fn string_to_tts_macro () {
let tts = string_to_tts(@"macro_rules! zip (($a)=>($a))");
match tts {
[ast::tt_tok(_,_),
ast::tt_tok(_,token::NOT),
ast::tt_tok(_,_),
ast::tt_delim(delim_elts)] =>
match *delim_elts {
[ast::tt_tok(_,token::LPAREN),
ast::tt_delim(first_set),
ast::tt_tok(_,token::FAT_ARROW),
ast::tt_delim(second_set),
ast::tt_tok(_,token::RPAREN)] =>
match *first_set {
[ast::tt_tok(_,token::LPAREN),
ast::tt_tok(_,token::DOLLAR),
ast::tt_tok(_,_),
ast::tt_tok(_,token::RPAREN)] =>
match *second_set {
[ast::tt_tok(_,token::LPAREN),
ast::tt_tok(_,token::DOLLAR),
ast::tt_tok(_,_),
ast::tt_tok(_,token::RPAREN)] =>
assert_eq!("correct","correct"),
_ => assert_eq!("wrong 4","correct")
},
_ => {
error!("failing value 3: {:?}",first_set);
assert_eq!("wrong 3","correct")
}
},
_ => {
error!("failing value 2: {:?}",delim_elts);
assert_eq!("wrong","correct");
}
},
_ => {
error!("failing value: {:?}",tts);
assert_eq!("wrong 1","correct");
}
}
}
2013-04-23 12:57:41 -05:00
#[test] fn string_to_tts_1 () {
2013-09-24 14:31:24 -05:00
let tts = string_to_tts(@"fn a (b : int) { b; }");
2013-04-23 12:57:41 -05:00
assert_eq!(to_json_str(@tts),
2013-09-16 18:12:54 -05:00
~"[\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
{\
\"variant\":\"IDENT\",\
\"fields\":[\
\"fn\",\
false\
]\
}\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
{\
\"variant\":\"IDENT\",\
\"fields\":[\
\"a\",\
false\
]\
}\
]\
},\
{\
\"variant\":\"tt_delim\",\
\"fields\":[\
[\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
\"LPAREN\"\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
{\
\"variant\":\"IDENT\",\
\"fields\":[\
\"b\",\
false\
]\
}\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
\"COLON\"\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
{\
\"variant\":\"IDENT\",\
\"fields\":[\
\"int\",\
false\
]\
}\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
\"RPAREN\"\
]\
}\
]\
]\
},\
{\
\"variant\":\"tt_delim\",\
\"fields\":[\
[\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
\"LBRACE\"\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
{\
\"variant\":\"IDENT\",\
\"fields\":[\
\"b\",\
false\
]\
}\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
\"SEMI\"\
]\
},\
{\
\"variant\":\"tt_tok\",\
\"fields\":[\
null,\
\"RBRACE\"\
]\
}\
]\
]\
}\
]"
2013-09-16 16:12:53 -05:00
);
2013-04-23 12:57:41 -05:00
}
#[test] fn ret_expr() {
assert_eq!(string_to_expr(@"return d"),
@ast::Expr{
id: ast::DUMMY_NODE_ID,
node:ast::ExprRet(Some(@ast::Expr{
id: ast::DUMMY_NODE_ID,
node:ast::ExprPath(ast::Path{
span: sp(7, 8),
global: false,
segments: ~[
ast::PathSegment {
identifier: str_to_ident("d"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
}),
span:sp(7,8)
})),
span:sp(0,8)
})
2013-04-23 12:57:41 -05:00
}
#[test] fn parse_stmt_1 () {
assert_eq!(string_to_stmt(@"b;"),
@Spanned{
node: ast::StmtExpr(@ast::Expr {
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(ast::Path {
span:sp(0,1),
global:false,
segments: ~[
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
}),
2013-04-23 12:57:41 -05:00
span: sp(0,1)},
ast::DUMMY_NODE_ID),
2013-04-23 12:57:41 -05:00
span: sp(0,1)})
}
fn parser_done(p: Parser){
assert_eq!(p.token.clone(), token::EOF);
}
2013-04-23 12:57:41 -05:00
#[test] fn parse_ident_pat () {
2014-01-02 14:30:58 -06:00
let mut parser = string_to_parser(@"b");
2013-05-30 20:01:25 -05:00
assert_eq!(parser.parse_pat(),
@ast::Pat{id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(
ast::BindByValue(ast::MutImmutable),
ast::Path {
span:sp(0,1),
global:false,
segments: ~[
ast::PathSegment {
identifier: str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
},
None /* no idea */),
2013-04-23 12:57:41 -05:00
span: sp(0,1)});
parser_done(parser);
2013-04-23 12:57:41 -05:00
}
// check the contents of the tt manually:
#[test] fn parse_fundecl () {
// this test depends on the intern order of "fn" and "int"
assert_eq!(string_to_item(@"fn a (b : int) { b; }"),
2013-04-23 12:57:41 -05:00
Some(
2013-06-04 16:56:33 -05:00
@ast::item{ident:str_to_ident("a"),
2013-04-23 12:57:41 -05:00
attrs:~[],
id: ast::DUMMY_NODE_ID,
node: ast::item_fn(ast::P(ast::fn_decl{
2013-04-23 12:57:41 -05:00
inputs: ~[ast::arg{
ty: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
node: ast::ty_path(ast::Path{
2013-04-23 12:57:41 -05:00
span:sp(10,13),
global:false,
segments: ~[
ast::PathSegment {
identifier:
str_to_ident("int"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
}, None, ast::DUMMY_NODE_ID),
span:sp(10,13)
}),
pat: @ast::Pat {
id: ast::DUMMY_NODE_ID,
node: ast::PatIdent(
ast::BindByValue(ast::MutImmutable),
ast::Path {
span:sp(6,7),
global:false,
segments: ~[
ast::PathSegment {
identifier:
str_to_ident("b"),
lifetimes: opt_vec::Empty,
types: opt_vec::Empty,
}
],
},
None // no idea
),
span: sp(6,7)
},
id: ast::DUMMY_NODE_ID
2013-04-23 12:57:41 -05:00
}],
output: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
node: ast::ty_nil,
span:sp(15,15)}), // not sure
cf: ast::return_val,
variadic: false
}),
2013-04-23 12:57:41 -05:00
ast::impure_fn,
abi::AbiSet::Rust(),
ast::Generics{ // no idea on either of these:
lifetimes: opt_vec::Empty,
ty_params: opt_vec::Empty,
},
ast::P(ast::Block {
view_items: ~[],
stmts: ~[@Spanned{
node: ast::StmtSemi(@ast::Expr{
id: ast::DUMMY_NODE_ID,
node: ast::ExprPath(
ast::Path{
span:sp(17,18),
global:false,
segments: ~[
ast::PathSegment {
identifier:
str_to_ident(
"b"),
lifetimes:
opt_vec::Empty,
types:
opt_vec::Empty
}
],
}),
span: sp(17,18)},
ast::DUMMY_NODE_ID),
span: sp(17,18)}],
expr: None,
id: ast::DUMMY_NODE_ID,
rules: ast::DefaultBlock, // no idea
2013-04-23 12:57:41 -05:00
span: sp(15,21),
})),
2013-04-23 12:57:41 -05:00
vis: ast::inherited,
span: sp(0,21)}));
}
#[test] fn parse_exprs () {
// just make sure that they parse....
string_to_expr(@"3 + 4");
string_to_expr(@"a::z.froob(b,@(987+3))");
2013-02-04 15:15:17 -06:00
}
#[test] fn attrs_fix_bug () {
string_to_item(@"pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
-> Result<@Writer, ~str> {
#[cfg(windows)]
fn wb() -> c_int {
(O_WRONLY | libc::consts::os::extra::O_BINARY) as c_int
}
#[cfg(unix)]
fn wb() -> c_int { O_WRONLY as c_int }
let mut fflags: c_int = wb();
}");
}
2013-02-04 15:15:17 -06:00
}