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-11-28 18:20:41 -06:00
|
|
|
//! The main parser interface
|
|
|
|
|
2013-01-30 11:56:33 -06:00
|
|
|
|
2012-12-23 16:41:37 -06:00
|
|
|
use ast;
|
2014-01-15 12:58:29 -06:00
|
|
|
use codemap::{Span, CodeMap, FileMap};
|
2012-12-23 16:41:37 -06:00
|
|
|
use codemap;
|
2013-12-31 08:17:59 -06:00
|
|
|
use diagnostic::{SpanHandler, mk_span_handler, mk_handler, Emitter};
|
2014-01-09 07:05:33 -06:00
|
|
|
use parse::attr::ParserAttr;
|
2012-12-23 16:41:37 -06:00
|
|
|
use parse::parser::Parser;
|
|
|
|
|
2013-12-27 13:51:18 -06:00
|
|
|
use std::cell::RefCell;
|
2013-11-11 00:46:32 -06:00
|
|
|
use std::io;
|
|
|
|
use std::io::File;
|
2013-10-13 20:48:47 -05:00
|
|
|
use std::str;
|
2012-12-23 16:41:37 -06:00
|
|
|
|
2013-01-08 21:37:25 -06:00
|
|
|
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
|
2013-01-08 21:37:25 -06:00
|
|
|
pub mod common;
|
2012-11-18 19:56:50 -06:00
|
|
|
|
|
|
|
/// Routines the parser uses to classify AST nodes
|
2013-01-08 21:37:25 -06:00
|
|
|
pub mod classify;
|
2012-11-18 19:56:50 -06:00
|
|
|
|
|
|
|
/// Reporting obsolete syntax
|
2013-01-08 21:37:25 -06:00
|
|
|
pub mod obsolete;
|
2012-11-28 18:20:41 -06:00
|
|
|
|
2013-03-08 12:19:19 -06:00
|
|
|
// info about a parsing session.
|
2013-02-21 02:16:31 -06:00
|
|
|
pub struct ParseSess {
|
2013-03-08 12:19:19 -06:00
|
|
|
cm: @codemap::CodeMap, // better be the same as the one in the reader!
|
2013-12-27 15:48:00 -06:00
|
|
|
span_diagnostic: @SpanHandler, // better be the same as the one in the reader!
|
2013-07-04 12:51:11 -05:00
|
|
|
/// Used to determine and report recursive mod inclusions
|
2013-12-27 13:51:18 -06:00
|
|
|
included_mod_stack: RefCell<~[Path]>,
|
2013-02-21 02:16:31 -06:00
|
|
|
}
|
2012-11-28 18:20:41 -06:00
|
|
|
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn new_parse_sess(demitter: Option<@Emitter>) -> @ParseSess {
|
2012-11-28 18:20:41 -06:00
|
|
|
let cm = @CodeMap::new();
|
2013-12-27 13:56:29 -06:00
|
|
|
@ParseSess {
|
2013-02-21 02:16:31 -06:00
|
|
|
cm: cm,
|
|
|
|
span_diagnostic: mk_span_handler(mk_handler(demitter), cm),
|
2013-12-27 13:51:18 -06:00
|
|
|
included_mod_stack: RefCell::new(~[]),
|
2013-02-21 02:16:31 -06:00
|
|
|
}
|
2012-11-28 18:20:41 -06:00
|
|
|
}
|
|
|
|
|
2013-12-27 15:48:00 -06:00
|
|
|
pub fn new_parse_sess_special_handler(sh: @SpanHandler,
|
2013-03-12 15:00:50 -05:00
|
|
|
cm: @codemap::CodeMap)
|
2013-12-27 15:48:00 -06:00
|
|
|
-> @ParseSess {
|
2013-12-27 13:56:29 -06:00
|
|
|
@ParseSess {
|
2013-02-21 02:16:31 -06:00
|
|
|
cm: cm,
|
|
|
|
span_diagnostic: sh,
|
2013-12-27 13:51:18 -06:00
|
|
|
included_mod_stack: RefCell::new(~[]),
|
2013-02-21 02:16:31 -06:00
|
|
|
}
|
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.
|
|
|
|
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn parse_crate_from_file(
|
|
|
|
input: &Path,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @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
|
|
|
}
|
|
|
|
|
2013-12-19 14:23:39 -06:00
|
|
|
pub fn parse_crate_attrs_from_file(
|
|
|
|
input: &Path,
|
|
|
|
cfg: ast::CrateConfig,
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess
|
2013-12-19 14:23:39 -06:00
|
|
|
) -> ~[ast::Attribute] {
|
2013-12-30 16:04:00 -06:00
|
|
|
let mut parser = new_parser_from_file(sess, cfg, input);
|
2013-12-19 14:23:39 -06:00
|
|
|
let (inner, _) = parser.parse_inner_attrs_and_next();
|
|
|
|
return inner;
|
|
|
|
}
|
|
|
|
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn parse_crate_from_source_str(
|
2013-06-12 12:02:55 -05:00
|
|
|
name: @str,
|
|
|
|
source: @str,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @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
|
|
|
}
|
|
|
|
|
2013-12-19 14:23:39 -06:00
|
|
|
pub fn parse_crate_attrs_from_source_str(
|
|
|
|
name: @str,
|
|
|
|
source: @str,
|
|
|
|
cfg: ast::CrateConfig,
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess
|
2013-12-19 14:23:39 -06:00
|
|
|
) -> ~[ast::Attribute] {
|
2013-12-30 16:04:00 -06:00
|
|
|
let mut p = new_parser_from_source_str(sess,
|
|
|
|
/*bad*/ cfg.clone(),
|
|
|
|
name,
|
|
|
|
source);
|
2013-12-19 14:23:39 -06:00
|
|
|
let (inner, _) = maybe_aborted(p.parse_inner_attrs_and_next(),p);
|
|
|
|
return inner;
|
|
|
|
}
|
|
|
|
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn parse_expr_from_source_str(
|
2013-06-12 12:02:55 -05:00
|
|
|
name: @str,
|
|
|
|
source: @str,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess
|
2013-09-01 20:45:37 -05:00
|
|
|
) -> @ast::Expr {
|
2013-12-30 16:04:00 -06:00
|
|
|
let mut p = new_parser_from_source_str(sess, cfg, name, source);
|
2013-02-26 12:15:29 -06:00
|
|
|
maybe_aborted(p.parse_expr(), p)
|
2012-11-28 18:20:41 -06:00
|
|
|
}
|
|
|
|
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn parse_item_from_source_str(
|
2013-06-12 12:02:55 -05:00
|
|
|
name: @str,
|
|
|
|
source: @str,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-07-19 06:51:37 -05:00
|
|
|
attrs: ~[ast::Attribute],
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess
|
2014-01-09 07:05:33 -06:00
|
|
|
) -> Option<@ast::Item> {
|
2013-12-30 16:04:00 -06:00
|
|
|
let mut p = new_parser_from_source_str(sess, cfg, name, source);
|
2013-02-26 12:15:29 -06:00
|
|
|
maybe_aborted(p.parse_item(attrs),p)
|
2012-11-28 18:20:41 -06:00
|
|
|
}
|
|
|
|
|
2013-01-19 09:52:06 -06:00
|
|
|
pub fn parse_meta_from_source_str(
|
2013-06-12 12:02:55 -05:00
|
|
|
name: @str,
|
|
|
|
source: @str,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess
|
2013-07-19 06:51:37 -05:00
|
|
|
) -> @ast::MetaItem {
|
2013-12-30 16:04:00 -06:00
|
|
|
let mut p = new_parser_from_source_str(sess, cfg, name, source);
|
2013-01-19 09:52:06 -06:00
|
|
|
maybe_aborted(p.parse_meta_item(),p)
|
|
|
|
}
|
|
|
|
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn parse_stmt_from_source_str(
|
2013-06-12 12:02:55 -05:00
|
|
|
name: @str,
|
|
|
|
source: @str,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-07-19 06:51:37 -05:00
|
|
|
attrs: ~[ast::Attribute],
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess
|
2013-09-01 20:45:37 -05:00
|
|
|
) -> @ast::Stmt {
|
2013-12-30 16:04:00 -06:00
|
|
|
let mut p = new_parser_from_source_str(
|
2013-02-26 22:18:01 -06:00
|
|
|
sess,
|
|
|
|
cfg,
|
2013-06-12 12:02:55 -05:00
|
|
|
name,
|
2013-02-26 22:18:01 -06:00
|
|
|
source
|
|
|
|
);
|
2013-02-26 12:15:29 -06:00
|
|
|
maybe_aborted(p.parse_stmt(attrs),p)
|
2012-11-28 18:20:41 -06:00
|
|
|
}
|
|
|
|
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn parse_tts_from_source_str(
|
2013-06-12 12:02:55 -05:00
|
|
|
name: @str,
|
|
|
|
source: @str,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess
|
2014-01-09 07:05:33 -06:00
|
|
|
) -> ~[ast::TokenTree] {
|
2013-12-30 16:04:00 -06:00
|
|
|
let mut p = new_parser_from_source_str(
|
2013-02-26 22:18:01 -06:00
|
|
|
sess,
|
|
|
|
cfg,
|
2013-06-12 12:02:55 -05:00
|
|
|
name,
|
2013-02-26 22:18:01 -06:00
|
|
|
source
|
|
|
|
);
|
2013-12-30 16:40:31 -06:00
|
|
|
p.quote_depth += 1u;
|
2013-04-23 12:57:41 -05:00
|
|
|
// right now this is re-creating the token trees from ... token trees.
|
2013-02-26 12:15:29 -06:00
|
|
|
maybe_aborted(p.parse_all_token_trees(),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
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn new_parser_from_source_str(sess: @ParseSess,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-06-12 12:02:55 -05:00
|
|
|
name: @str,
|
|
|
|
source: @str)
|
2013-03-12 15:00:50 -05:00
|
|
|
-> 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-02-26 12:15:29 -06:00
|
|
|
/// Create a new parser, handling errors as appropriate
|
2012-11-28 18:20:41 -06:00
|
|
|
/// if the file doesn't exist
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn new_parser_from_file(
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-02-26 22:18:01 -06:00
|
|
|
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.
|
2013-02-26 22:18:01 -06:00
|
|
|
pub fn new_sub_parser_from_file(
|
2013-12-27 13:56:29 -06:00
|
|
|
sess: @ParseSess,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2013-02-26 22:18:01 -06:00
|
|
|
path: &Path,
|
2013-08-31 11:13:04 -05:00
|
|
|
sp: Span
|
2013-02-26 22:18:01 -06:00
|
|
|
) -> 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
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn filemap_to_parser(sess: @ParseSess,
|
2013-04-23 12:57:41 -05:00
|
|
|
filemap: @FileMap,
|
2013-07-19 00:38:55 -05:00
|
|
|
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
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn new_parser_from_tts(sess: @ParseSess,
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig,
|
2014-01-09 07:05:33 -06:00
|
|
|
tts: ~[ast::TokenTree]) -> Parser {
|
2013-04-23 12:57:41 -05:00
|
|
|
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.
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn file_to_filemap(sess: @ParseSess, path: &Path, spanopt: Option<Span>)
|
2013-04-23 12:57:41 -05:00
|
|
|
-> @FileMap {
|
2013-10-13 20:48:47 -05:00
|
|
|
let err = |msg: &str| {
|
|
|
|
match spanopt {
|
|
|
|
Some(sp) => sess.span_diagnostic.span_fatal(sp, msg),
|
|
|
|
None => sess.span_diagnostic.handler().fatal(msg),
|
|
|
|
}
|
|
|
|
};
|
2013-10-30 01:31:07 -05:00
|
|
|
let bytes = match io::result(|| File::open(path).read_to_end()) {
|
2013-10-25 19:04:37 -05:00
|
|
|
Ok(bytes) => bytes,
|
|
|
|
Err(e) => {
|
2013-10-13 20:48:47 -05:00
|
|
|
err(format!("couldn't read {}: {}", path.display(), e.desc));
|
2013-10-25 19:04:37 -05:00
|
|
|
unreachable!()
|
2013-10-13 20:48:47 -05:00
|
|
|
}
|
2013-10-25 19:04:37 -05:00
|
|
|
};
|
2013-12-23 10:45:01 -06:00
|
|
|
match str::from_utf8_owned(bytes) {
|
2013-10-13 20:48:47 -05:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
2013-10-13 20:48:47 -05: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
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn string_to_filemap(sess: @ParseSess, source: @str, path: @str)
|
2013-04-23 12:57:41 -05:00
|
|
|
-> @FileMap {
|
|
|
|
sess.cm.new_filemap(path, source)
|
|
|
|
}
|
|
|
|
|
|
|
|
// given a filemap, produce a sequence of token-trees
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn filemap_to_tts(sess: @ParseSess, filemap: @FileMap)
|
2014-01-09 07:05:33 -06:00
|
|
|
-> ~[ast::TokenTree] {
|
2013-04-23 12:57:41 -05:00
|
|
|
// 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 = ~[];
|
2013-06-27 19:41:35 -05:00
|
|
|
let srdr = lexer::new_string_reader(sess.span_diagnostic, filemap);
|
2014-01-09 07:05:33 -06:00
|
|
|
let mut p1 = Parser(sess, cfg, srdr as @lexer::Reader);
|
2013-04-23 12:57:41 -05:00
|
|
|
p1.parse_all_token_trees()
|
|
|
|
}
|
|
|
|
|
|
|
|
// given tts and cfg, produce a parser
|
2013-12-27 13:56:29 -06:00
|
|
|
pub fn tts_to_parser(sess: @ParseSess,
|
2014-01-09 07:05:33 -06:00
|
|
|
tts: ~[ast::TokenTree],
|
2013-07-19 00:38:55 -05:00
|
|
|
cfg: ast::CrateConfig) -> Parser {
|
2013-06-27 19:41:35 -05:00
|
|
|
let trdr = lexer::new_tt_reader(sess.span_diagnostic, None, tts);
|
2014-01-09 07:05:33 -06:00
|
|
|
Parser(sess, cfg, trdr as @lexer::Reader)
|
2012-11-28 18:20:41 -06:00
|
|
|
}
|
2013-01-30 11:56:33 -06:00
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
// abort if necessary
|
2013-12-30 16:04:00 -06:00
|
|
|
pub fn maybe_aborted<T>(result: T, mut p: Parser) -> T {
|
2013-02-26 12:15:29 -06:00
|
|
|
p.abort_if_errors();
|
|
|
|
result
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-04 15:15:17 -06:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
|
|
|
use super::*;
|
2013-05-18 14:39:17 -05:00
|
|
|
use extra::serialize::Encodable;
|
|
|
|
use extra;
|
2013-11-11 00:46:32 -06:00
|
|
|
use std::io;
|
2014-01-15 15:25:09 -06:00
|
|
|
use std::io::MemWriter;
|
2013-10-13 20:48:47 -05:00
|
|
|
use std::str;
|
2013-08-31 11:13:04 -05:00
|
|
|
use codemap::{Span, BytePos, Spanned};
|
2013-04-23 12:57:41 -05:00
|
|
|
use opt_vec;
|
2013-03-06 14:38:13 -06:00
|
|
|
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};
|
2013-05-16 19:42:08 -05:00
|
|
|
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
|
|
|
|
2013-11-29 12:12:08 -06:00
|
|
|
#[cfg(test)]
|
|
|
|
fn to_json_str<'a, E: Encodable<extra::json::Encoder<'a>>>(val: &E) -> ~str {
|
|
|
|
let mut writer = MemWriter::new();
|
2013-12-03 21:18:35 -06:00
|
|
|
let mut encoder = extra::json::Encoder::new(&mut writer as &mut io::Writer);
|
2013-10-13 20:48:47 -05:00
|
|
|
val.encode(&mut encoder);
|
2013-12-23 10:45:01 -06:00
|
|
|
str::from_utf8_owned(writer.unwrap()).unwrap()
|
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 {
|
2013-08-31 11:13:04 -05:00
|
|
|
Span{lo:BytePos(a),hi:BytePos(b),expn_info:None}
|
2013-04-23 12:57:41 -05:00
|
|
|
}
|
|
|
|
|
2013-08-07 11:47:28 -05:00
|
|
|
#[test] fn path_exprs_1() {
|
2013-06-12 12:02:55 -05:00
|
|
|
assert_eq!(string_to_expr(@"a"),
|
2013-09-01 20:45:37 -05:00
|
|
|
@ast::Expr{
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::ExprPath(ast::Path {
|
2013-08-07 11:47:28 -05:00
|
|
|
span: sp(0, 1),
|
|
|
|
global: false,
|
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier: str_to_ident("a"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-19 19:24:04 -05:00
|
|
|
types: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
}
|
|
|
|
],
|
|
|
|
}),
|
|
|
|
span: sp(0, 1)
|
|
|
|
})
|
2013-04-23 12:57:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test] fn path_exprs_2 () {
|
2013-06-12 12:02:55 -05:00
|
|
|
assert_eq!(string_to_expr(@"::a::b"),
|
2013-09-01 20:45:37 -05:00
|
|
|
@ast::Expr {
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::ExprPath(ast::Path {
|
2013-08-07 11:47:28 -05:00
|
|
|
span: sp(0, 6),
|
|
|
|
global: true,
|
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier: str_to_ident("a"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-19 19:24:04 -05:00
|
|
|
types: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
},
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier: str_to_ident("b"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-19 19:24:04 -05:00
|
|
|
types: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
}
|
|
|
|
]
|
2013-08-08 13:38:10 -05:00
|
|
|
}),
|
|
|
|
span: sp(0, 6)
|
2013-08-07 11:47:28 -05:00
|
|
|
})
|
2013-04-23 12:57:41 -05:00
|
|
|
}
|
|
|
|
|
2013-07-25 03:03:53 -05:00
|
|
|
#[should_fail]
|
2013-04-23 12:57:41 -05:00
|
|
|
#[test] fn bad_path_expr_1() {
|
2013-06-12 12:02:55 -05:00
|
|
|
string_to_expr(@"::abc::def::return");
|
2013-07-25 03:03:53 -05:00
|
|
|
}
|
2013-04-23 12:57:41 -05:00
|
|
|
|
2013-09-24 17:57:58 -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 {
|
2014-01-09 07:05:33 -06:00
|
|
|
[ast::TTTok(_,_),
|
|
|
|
ast::TTTok(_,token::NOT),
|
|
|
|
ast::TTTok(_,_),
|
|
|
|
ast::TTDelim(delim_elts)] =>
|
2013-09-24 17:57:58 -05:00
|
|
|
match *delim_elts {
|
2014-01-09 07:05:33 -06:00
|
|
|
[ast::TTTok(_,token::LPAREN),
|
|
|
|
ast::TTDelim(first_set),
|
|
|
|
ast::TTTok(_,token::FAT_ARROW),
|
|
|
|
ast::TTDelim(second_set),
|
|
|
|
ast::TTTok(_,token::RPAREN)] =>
|
2013-09-24 17:57:58 -05:00
|
|
|
match *first_set {
|
2014-01-09 07:05:33 -06:00
|
|
|
[ast::TTTok(_,token::LPAREN),
|
|
|
|
ast::TTTok(_,token::DOLLAR),
|
|
|
|
ast::TTTok(_,_),
|
|
|
|
ast::TTTok(_,token::RPAREN)] =>
|
2013-09-24 17:57:58 -05:00
|
|
|
match *second_set {
|
2014-01-09 07:05:33 -06:00
|
|
|
[ast::TTTok(_,token::LPAREN),
|
|
|
|
ast::TTTok(_,token::DOLLAR),
|
|
|
|
ast::TTTok(_,_),
|
|
|
|
ast::TTTok(_,token::RPAREN)] =>
|
2013-09-24 17:57:58 -05:00
|
|
|
assert_eq!("correct","correct"),
|
|
|
|
_ => assert_eq!("wrong 4","correct")
|
|
|
|
},
|
|
|
|
_ => {
|
2013-10-21 15:08:31 -05:00
|
|
|
error!("failing value 3: {:?}",first_set);
|
2013-09-24 17:57:58 -05:00
|
|
|
assert_eq!("wrong 3","correct")
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_ => {
|
2013-10-21 15:08:31 -05:00
|
|
|
error!("failing value 2: {:?}",delim_elts);
|
2013-09-24 17:57:58 -05:00
|
|
|
assert_eq!("wrong","correct");
|
|
|
|
}
|
|
|
|
|
|
|
|
},
|
|
|
|
_ => {
|
2013-10-21 15:08:31 -05:00
|
|
|
error!("failing value: {:?}",tts);
|
2013-09-24 17:57:58 -05:00
|
|
|
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; }");
|
2014-01-13 10:31:05 -06:00
|
|
|
assert_eq!(to_json_str(&tts),
|
2013-09-16 18:12:54 -05:00
|
|
|
~"[\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
{\
|
|
|
|
\"variant\":\"IDENT\",\
|
|
|
|
\"fields\":[\
|
|
|
|
\"fn\",\
|
|
|
|
false\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
{\
|
|
|
|
\"variant\":\"IDENT\",\
|
|
|
|
\"fields\":[\
|
|
|
|
\"a\",\
|
|
|
|
false\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTDelim\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
[\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
\"LPAREN\"\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
{\
|
|
|
|
\"variant\":\"IDENT\",\
|
|
|
|
\"fields\":[\
|
|
|
|
\"b\",\
|
|
|
|
false\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
\"COLON\"\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
{\
|
|
|
|
\"variant\":\"IDENT\",\
|
|
|
|
\"fields\":[\
|
|
|
|
\"int\",\
|
|
|
|
false\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
\"RPAREN\"\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTDelim\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
[\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
\"LBRACE\"\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
{\
|
|
|
|
\"variant\":\"IDENT\",\
|
|
|
|
\"fields\":[\
|
|
|
|
\"b\",\
|
|
|
|
false\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
\"SEMI\"\
|
|
|
|
]\
|
|
|
|
},\
|
|
|
|
{\
|
2014-01-09 07:05:33 -06:00
|
|
|
\"variant\":\"TTTok\",\
|
2013-09-16 18:12:54 -05:00
|
|
|
\"fields\":[\
|
|
|
|
null,\
|
|
|
|
\"RBRACE\"\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]\
|
|
|
|
]\
|
|
|
|
}\
|
|
|
|
]"
|
2013-09-16 16:12:53 -05:00
|
|
|
);
|
2013-04-23 12:57:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test] fn ret_expr() {
|
2013-06-12 12:02:55 -05:00
|
|
|
assert_eq!(string_to_expr(@"return d"),
|
2013-09-01 20:45:37 -05:00
|
|
|
@ast::Expr{
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node:ast::ExprRet(Some(@ast::Expr{
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node:ast::ExprPath(ast::Path{
|
2013-08-07 11:47:28 -05:00
|
|
|
span: sp(7, 8),
|
|
|
|
global: false,
|
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier: str_to_ident("d"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
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 () {
|
2013-06-12 12:02:55 -05:00
|
|
|
assert_eq!(string_to_stmt(@"b;"),
|
2013-08-31 11:13:04 -05:00
|
|
|
@Spanned{
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::StmtExpr(@ast::Expr {
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::ExprPath(ast::Path {
|
2013-08-07 11:47:28 -05:00
|
|
|
span:sp(0,1),
|
|
|
|
global:false,
|
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier: str_to_ident("b"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
types: opt_vec::Empty,
|
|
|
|
}
|
|
|
|
],
|
|
|
|
}),
|
2013-04-23 12:57:41 -05:00
|
|
|
span: sp(0,1)},
|
2013-09-06 21:11:55 -05:00
|
|
|
ast::DUMMY_NODE_ID),
|
2013-04-23 12:57:41 -05:00
|
|
|
span: sp(0,1)})
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-04-23 18:47:47 -05:00
|
|
|
fn parser_done(p: Parser){
|
2013-12-30 17:09:41 -06:00
|
|
|
assert_eq!(p.token.clone(), token::EOF);
|
2013-04-23 18:47:47 -05:00
|
|
|
}
|
|
|
|
|
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(),
|
2013-09-06 21:11:55 -05:00
|
|
|
@ast::Pat{id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::PatIdent(
|
2013-10-20 07:31:23 -05:00
|
|
|
ast::BindByValue(ast::MutImmutable),
|
2013-08-07 11:47:28 -05:00
|
|
|
ast::Path {
|
|
|
|
span:sp(0,1),
|
|
|
|
global:false,
|
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier: str_to_ident("b"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
types: opt_vec::Empty,
|
|
|
|
}
|
|
|
|
],
|
|
|
|
},
|
|
|
|
None /* no idea */),
|
2013-04-23 12:57:41 -05:00
|
|
|
span: sp(0,1)});
|
2013-04-23 18:47:47 -05:00
|
|
|
parser_done(parser);
|
2013-04-23 12:57:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// check the contents of the tt manually:
|
|
|
|
#[test] fn parse_fundecl () {
|
2013-09-06 21:11:55 -05:00
|
|
|
// this test depends on the intern order of "fn" and "int"
|
2013-06-12 12:02:55 -05:00
|
|
|
assert_eq!(string_to_item(@"fn a (b : int) { b; }"),
|
2013-04-23 12:57:41 -05:00
|
|
|
Some(
|
2014-01-09 07:05:33 -06:00
|
|
|
@ast::Item{ident:str_to_ident("a"),
|
2013-04-23 12:57:41 -05:00
|
|
|
attrs:~[],
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2014-01-09 07:05:33 -06:00
|
|
|
node: ast::ItemFn(ast::P(ast::FnDecl {
|
|
|
|
inputs: ~[ast::Arg{
|
2013-11-30 16:00:39 -06:00
|
|
|
ty: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
|
2014-01-09 07:05:33 -06:00
|
|
|
node: ast::TyPath(ast::Path{
|
2013-04-23 12:57:41 -05:00
|
|
|
span:sp(10,13),
|
|
|
|
global:false,
|
2013-08-07 11:47:28 -05:00
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier:
|
|
|
|
str_to_ident("int"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
types: opt_vec::Empty,
|
|
|
|
}
|
|
|
|
],
|
2013-09-06 21:11:55 -05:00
|
|
|
}, None, ast::DUMMY_NODE_ID),
|
2013-08-07 11:47:28 -05:00
|
|
|
span:sp(10,13)
|
2013-11-30 16:00:39 -06:00
|
|
|
}),
|
2013-09-01 20:45:37 -05:00
|
|
|
pat: @ast::Pat {
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::PatIdent(
|
2013-10-20 07:31:23 -05:00
|
|
|
ast::BindByValue(ast::MutImmutable),
|
2013-08-07 11:47:28 -05:00
|
|
|
ast::Path {
|
|
|
|
span:sp(6,7),
|
|
|
|
global:false,
|
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier:
|
|
|
|
str_to_ident("b"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes: opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
types: opt_vec::Empty,
|
|
|
|
}
|
|
|
|
],
|
|
|
|
},
|
|
|
|
None // no idea
|
|
|
|
),
|
|
|
|
span: sp(6,7)
|
|
|
|
},
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID
|
2013-04-23 12:57:41 -05:00
|
|
|
}],
|
2013-11-30 16:00:39 -06:00
|
|
|
output: ast::P(ast::Ty{id: ast::DUMMY_NODE_ID,
|
2014-01-09 07:05:33 -06:00
|
|
|
node: ast::TyNil,
|
2013-11-30 16:00:39 -06:00
|
|
|
span:sp(15,15)}), // not sure
|
2014-01-09 07:05:33 -06:00
|
|
|
cf: ast::Return,
|
2013-10-25 00:56:34 -05:00
|
|
|
variadic: false
|
2013-11-30 16:00:39 -06:00
|
|
|
}),
|
2014-01-09 07:05:33 -06:00
|
|
|
ast::ImpureFn,
|
2013-04-23 12:57:41 -05:00
|
|
|
abi::AbiSet::Rust(),
|
|
|
|
ast::Generics{ // no idea on either of these:
|
|
|
|
lifetimes: opt_vec::Empty,
|
|
|
|
ty_params: opt_vec::Empty,
|
|
|
|
},
|
2013-11-30 16:00:39 -06:00
|
|
|
ast::P(ast::Block {
|
2013-07-16 13:08:35 -05:00
|
|
|
view_items: ~[],
|
2013-08-31 11:13:04 -05:00
|
|
|
stmts: ~[@Spanned{
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::StmtSemi(@ast::Expr{
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-09-01 20:45:37 -05:00
|
|
|
node: ast::ExprPath(
|
2013-07-16 13:08:35 -05:00
|
|
|
ast::Path{
|
|
|
|
span:sp(17,18),
|
|
|
|
global:false,
|
2013-08-07 11:47:28 -05:00
|
|
|
segments: ~[
|
|
|
|
ast::PathSegment {
|
|
|
|
identifier:
|
|
|
|
str_to_ident(
|
|
|
|
"b"),
|
2013-10-29 05:03:32 -05:00
|
|
|
lifetimes:
|
|
|
|
opt_vec::Empty,
|
2013-08-07 11:47:28 -05:00
|
|
|
types:
|
|
|
|
opt_vec::Empty
|
|
|
|
}
|
|
|
|
],
|
|
|
|
}),
|
2013-07-16 13:08:35 -05:00
|
|
|
span: sp(17,18)},
|
2013-09-06 21:11:55 -05:00
|
|
|
ast::DUMMY_NODE_ID),
|
2013-07-16 13:08:35 -05:00
|
|
|
span: sp(17,18)}],
|
|
|
|
expr: None,
|
2013-09-06 21:11:55 -05:00
|
|
|
id: ast::DUMMY_NODE_ID,
|
2013-07-27 03:25:59 -05:00
|
|
|
rules: ast::DefaultBlock, // no idea
|
2013-04-23 12:57:41 -05:00
|
|
|
span: sp(15,21),
|
2013-11-30 16:00:39 -06:00
|
|
|
})),
|
2014-01-09 07:05:33 -06:00
|
|
|
vis: ast::Inherited,
|
2013-04-23 12:57:41 -05:00
|
|
|
span: sp(0,21)}));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[test] fn parse_exprs () {
|
|
|
|
// just make sure that they parse....
|
2013-06-12 12:02:55 -05:00
|
|
|
string_to_expr(@"3 + 4");
|
|
|
|
string_to_expr(@"a::z.froob(b,@(987+3))");
|
2013-02-04 15:15:17 -06:00
|
|
|
}
|
2013-04-30 14:02:56 -05:00
|
|
|
|
|
|
|
#[test] fn attrs_fix_bug () {
|
2013-06-12 12:02:55 -05:00
|
|
|
string_to_item(@"pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
|
2013-04-30 14:02:56 -05:00
|
|
|
-> 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
|
|
|
}
|