diff options
Diffstat (limited to 'src/libsyntax')
| -rw-r--r-- | src/libsyntax/alternate_crate.rc | 128 | ||||
| -rw-r--r-- | src/libsyntax/ast.rs | 17 | ||||
| -rw-r--r-- | src/libsyntax/ext/pipes/mod.rs | 12 | ||||
| -rw-r--r-- | src/libsyntax/fold.rs | 27 | ||||
| -rw-r--r-- | src/libsyntax/parse.rs | 45 | ||||
| -rw-r--r-- | src/libsyntax/parse/mod.rs | 28 | ||||
| -rw-r--r-- | src/libsyntax/parse/parser.rs | 149 | ||||
| -rw-r--r-- | src/libsyntax/syntax.rc | 4 | ||||
| -rw-r--r-- | src/libsyntax/visit.rs | 10 |
9 files changed, 237 insertions, 183 deletions
diff --git a/src/libsyntax/alternate_crate.rc b/src/libsyntax/alternate_crate.rc new file mode 100644 index 00000000000..d5a28a716ec --- /dev/null +++ b/src/libsyntax/alternate_crate.rc @@ -0,0 +1,128 @@ +#[link(name = "syntax", + vers = "0.5", + uuid = "9311401b-d6ea-4cd9-a1d9-61f89499c645")]; + + + +#[crate_type = "lib"]; + +#[no_core]; + +#[legacy_modes]; +#[legacy_exports]; + +#[allow(vecs_implicitly_copyable)]; +#[allow(non_camel_case_types)]; +#[allow(deprecated_mode)]; +#[allow(deprecated_pattern)]; + +extern mod core(vers = "0.5"); +extern mod std(vers = "0.5"); + +use core::*; + +#[legacy_exports] +mod attr; +#[legacy_exports] +mod diagnostic; +mod codemap; +#[legacy_exports] +mod ast; +#[legacy_exports] +mod ast_util; +#[legacy_exports] +mod ast_map; +#[legacy_exports] +mod visit; +#[legacy_exports] +mod fold; +#[legacy_exports] +mod util { + #[legacy_exports]; + #[legacy_exports] + #[path = "util/interner.rs"] + mod interner; +} + +#[merge = "parse/mod.rs"] +mod parse; + +mod print { + #[legacy_exports]; + #[legacy_exports] + #[path = "print/pp.rs"] + mod pp; + #[legacy_exports] + #[path = "print/pprust.rs"] + mod pprust; +} + +mod ext { + #[legacy_exports]; + #[legacy_exports] + #[path = "ext/base.rs"] + mod base; + #[legacy_exports] + #[path = "ext/expand.rs"] + mod expand; + #[legacy_exports] + #[path = "ext/qquote.rs"] + mod qquote; + + #[path = "ext/quote.rs"] + mod quote; + #[path = "ext/deriving.rs"] + mod deriving; + + #[legacy_exports] + #[path = "ext/build.rs"] + mod build; + + mod tt { + #[legacy_exports]; + #[legacy_exports] + #[path = "ext/tt/transcribe.rs"] + mod transcribe; + #[legacy_exports] + #[path = "ext/tt/macro_parser.rs"] + mod macro_parser; + #[legacy_exports] + #[path = "ext/tt/macro_rules.rs"] + mod macro_rules; + } + + + #[legacy_exports] + #[path = "ext/simplext.rs"] + mod simplext; + #[legacy_exports] + #[path = "ext/fmt.rs"] + mod fmt; + #[legacy_exports] + #[path = "ext/env.rs"] + mod env; + #[legacy_exports] + #[path = "ext/concat_idents.rs"] + mod concat_idents; + #[legacy_exports] + #[path = "ext/ident_to_str.rs"] + mod ident_to_str; + #[legacy_exports] + #[path = "ext/log_syntax.rs"] + mod log_syntax; + #[legacy_exports] + #[path = "ext/auto_serialize.rs"] + mod auto_serialize; + #[legacy_exports] + #[path = "ext/source_util.rs"] + mod source_util; + + #[legacy_exports] + #[path = "ext/pipes.rs"] + #[merge = "ext/pipes/mod.rs"] + mod pipes; + + #[legacy_exports] + #[path = "ext/trace_macros.rs"] + mod trace_macros; +} diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index da28e349a56..21ce366e1c4 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -406,25 +406,10 @@ type crate_cfg = ~[@meta_item]; type crate = spanned<crate_>; type crate_ = - {directives: ~[@crate_directive], - module: _mod, + {module: _mod, attrs: ~[attribute], config: crate_cfg}; -enum crate_directive_ { - cdir_src_mod(visibility, ident, ~[attribute]), - cdir_dir_mod(visibility, ident, ~[@crate_directive], ~[attribute]), - - // NB: cdir_view_item is *not* processed by the rest of the compiler, the - // attached view_items are sunk into the crate's module during parsing, - // and processed (resolved, imported, etc.) there. This enum-variant - // exists only to preserve the view items in order in case we decide to - // pretty-print crates in the future. - cdir_view_item(@view_item), -} - -type crate_directive = spanned<crate_directive_>; - type meta_item = spanned<meta_item_>; #[auto_serialize] diff --git a/src/libsyntax/ext/pipes/mod.rs b/src/libsyntax/ext/pipes/mod.rs new file mode 100644 index 00000000000..638ccad0143 --- /dev/null +++ b/src/libsyntax/ext/pipes/mod.rs @@ -0,0 +1,12 @@ +#[legacy_exports] +mod ast_builder; +#[legacy_exports] +mod parse_proto; +#[legacy_exports] +mod pipec; +#[legacy_exports] +mod proto; +#[legacy_exports] +mod check; +#[legacy_exports] +mod liveness; diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 9d57b5ae814..7369e47eed3 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -21,7 +21,6 @@ export extensions; trait ast_fold { fn fold_crate(crate) -> crate; - fn fold_crate_directive(&&v: @crate_directive) -> @crate_directive; fn fold_view_item(&&v: @view_item) -> @view_item; fn fold_foreign_item(&&v: @foreign_item) -> @foreign_item; fn fold_item(&&v: @item) -> Option<@item>; @@ -51,8 +50,6 @@ trait ast_fold { type ast_fold_precursor = @{ //unlike the others, item_ is non-trivial fold_crate: fn@(crate_, span, ast_fold) -> (crate_, span), - fold_crate_directive: fn@(crate_directive_, span, - ast_fold) -> (crate_directive_, span), fold_view_item: fn@(view_item_, ast_fold) -> view_item_, fold_foreign_item: fn@(&&v: @foreign_item, ast_fold) -> @foreign_item, fold_item: fn@(&&v: @item, ast_fold) -> Option<@item>, @@ -150,29 +147,12 @@ fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ { let fold_attribute = |x| fold_attribute_(x, fld); return { - directives: vec::map(c.directives, |x| fld.fold_crate_directive(*x)), module: fld.fold_mod(c.module), attrs: vec::map(c.attrs, |x| fold_attribute(*x)), config: vec::map(c.config, |x| fold_meta_item(*x)) }; } -fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) -> - crate_directive_ { - return match cd { - cdir_src_mod(vis, id, attrs) => { - cdir_src_mod(vis, fld.fold_ident(id), - /* FIXME (#2543) */ copy attrs) - } - cdir_dir_mod(vis, id, cds, attrs) => { - cdir_dir_mod(vis, fld.fold_ident(id), - vec::map(cds, |x| fld.fold_crate_directive(*x)), - /* FIXME (#2543) */ copy attrs) - } - cdir_view_item(vi) => cdir_view_item(fld.fold_view_item(vi)), - } -} - fn noop_fold_view_item(vi: view_item_, _fld: ast_fold) -> view_item_ { return /* FIXME (#2543) */ copy vi; } @@ -635,7 +615,6 @@ fn noop_span(sp: span) -> span { return sp; } fn default_ast_fold() -> ast_fold_precursor { return @{fold_crate: wrap(noop_fold_crate), - fold_crate_directive: wrap(noop_fold_crate_directive), fold_view_item: noop_fold_view_item, fold_foreign_item: noop_fold_foreign_item, fold_item: noop_fold_item, @@ -666,12 +645,6 @@ impl ast_fold_precursor: ast_fold { let (n, s) = self.fold_crate(c.node, c.span, self as ast_fold); return {node: n, span: self.new_span(s)}; } - fn fold_crate_directive(&&c: @crate_directive) -> @crate_directive { - let (n, s) = self.fold_crate_directive(c.node, c.span, - self as ast_fold); - return @{node: n, - span: self.new_span(s)}; - } fn fold_view_item(&&x: @view_item) -> @view_item { return @{node: self.fold_view_item(x.node, self as ast_fold), diff --git a/src/libsyntax/parse.rs b/src/libsyntax/parse.rs index d1388bedad9..ccca4139c9b 100644 --- a/src/libsyntax/parse.rs +++ b/src/libsyntax/parse.rs @@ -1,5 +1,16 @@ //! The main parser interface +#[legacy_exports]; + +export parser; +export common; +export lexer; +export token; +export comments; +export prec; +export classify; +export attr; + export parse_sess; export new_parse_sess, new_parse_sess_special_handler; export next_node_id; @@ -51,40 +62,6 @@ fn new_parse_sess_special_handler(sh: span_handler, cm: @codemap::CodeMap) fn parse_crate_from_file(input: &Path, cfg: ast::crate_cfg, sess: parse_sess) -> @ast::crate { - if input.filetype() == Some(~".rc") { - parse_crate_from_crate_file(input, cfg, sess) - } else if input.filetype() == Some(~".rs") { - parse_crate_from_source_file(input, cfg, sess) - } else { - sess.span_diagnostic.handler().fatal(~"unknown input file type: " + - input.to_str()) - } -} - -fn parse_crate_from_crate_file(input: &Path, cfg: ast::crate_cfg, - sess: parse_sess) -> @ast::crate { - let p = new_crate_parser_from_file(sess, cfg, input); - let lo = p.span.lo; - let prefix = input.dir_path(); - let leading_attrs = p.parse_inner_attrs_and_next(); - let { inner: crate_attrs, next: first_cdir_attr } = leading_attrs; - let cdirs = p.parse_crate_directives(token::EOF, first_cdir_attr); - let cx = @{sess: sess, cfg: /* FIXME (#2543) */ copy p.cfg}; - let companionmod = input.filestem().map(|s| Path(*s)); - let (m, attrs) = eval::eval_crate_directives_to_mod( - cx, cdirs, &prefix, &companionmod); - let mut hi = p.span.hi; - p.expect(token::EOF); - p.abort_if_errors(); - return @ast_util::respan(ast_util::mk_sp(lo, hi), - {directives: cdirs, - module: m, - attrs: vec::append(crate_attrs, attrs), - config: /* FIXME (#2543) */ copy p.cfg}); -} - -fn parse_crate_from_source_file(input: &Path, cfg: ast::crate_cfg, - sess: parse_sess) -> @ast::crate { let p = new_crate_parser_from_file(sess, cfg, input); let r = p.parse_crate_mod(cfg); return r; diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs new file mode 100644 index 00000000000..a7c5f20fedf --- /dev/null +++ b/src/libsyntax/parse/mod.rs @@ -0,0 +1,28 @@ + +#[legacy_exports] +mod lexer; +#[legacy_exports] +mod parser; +#[legacy_exports] +mod token; +#[legacy_exports] +mod comments; +#[legacy_exports] +mod attr; +#[legacy_exports] + +/// Common routines shared by parser mods +#[legacy_exports] +mod common; + +/// Functions dealing with operator precedence +#[legacy_exports] +mod prec; + +/// Routines the parser uses to classify AST nodes +#[legacy_exports] +mod classify; + +/// Reporting obsolete syntax +#[legacy_exports] +mod obsolete; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 2f32b8436af..382b572f33e 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -27,9 +27,8 @@ use ast::{_mod, add, arg, arm, attribute, bind_by_ref, bind_by_implicit_ref, bind_by_value, bind_by_move, bitand, bitor, bitxor, blk, blk_check_mode, box, by_copy, by_move, by_ref, by_val, capture_clause, - capture_item, cdir_dir_mod, cdir_src_mod, cdir_view_item, - class_immutable, class_mutable, - crate, crate_cfg, crate_directive, decl, decl_item, decl_local, + capture_item, class_immutable, class_mutable, + crate, crate_cfg, decl, decl_item, decl_local, default_blk, deref, div, enum_def, enum_variant_kind, expl, expr, expr_, expr_addr_of, expr_match, expr_again, expr_assert, expr_assign, expr_assign_op, expr_binary, expr_block, expr_break, @@ -2966,15 +2965,7 @@ impl Parser { let info_ = if self.token == token::SEMI { self.bump(); // This mod is in an external file. Let's go get it! - let eval_ctx = @{ - sess: self.sess, - cfg: self.cfg - }; - let prefix = Path(self.sess.cm.span_to_filename(copy self.span)); - let prefix = prefix.dir_path(); - let (m, attrs) = eval::eval_src_mod(eval_ctx, &prefix, - outer_attrs, - id, id_span); + let (m, attrs) = self.eval_src_mod(id, outer_attrs, id_span); (id, m, Some(move attrs)) } else { self.expect(token::LBRACE); @@ -2990,20 +2981,18 @@ impl Parser { // its contents match ::attr::first_attr_value_str_by_name(outer_attrs, ~"merge") { Some(path) => { - let eval_ctx = @{ - sess: self.sess, - cfg: self.cfg - }; - let prefix = Path(self.sess.cm.span_to_filename(copy self.span)); + let prefix = Path( + self.sess.cm.span_to_filename(copy self.span)); let prefix = prefix.dir_path(); let path = Path(path); - let (new_mod_item, new_attrs) = eval::eval_src_mod_from_path( - eval_ctx, &prefix, &path, ~[], id_span); + let (new_mod_item, new_attrs) = self.eval_src_mod_from_path( + prefix, path, ~[], id_span); let (main_id, main_mod_item, main_attrs) = info_; let main_attrs = main_attrs.get(); - let (main_mod, new_mod) = match (main_mod_item, new_mod_item) { + let (main_mod, new_mod) = + match (main_mod_item, new_mod_item) { (item_mod(m), item_mod(n)) => (m, n), _ => self.bug(~"parsed mod item should be mod") }; @@ -3019,6 +3008,51 @@ impl Parser { } } + fn eval_src_mod(id: ast::ident, + outer_attrs: ~[ast::attribute], + id_sp: span) -> (ast::item_, ~[ast::attribute]) { + let prefix = Path(self.sess.cm.span_to_filename(copy self.span)); + let prefix = prefix.dir_path(); + let default_path = self.sess.interner.get(id) + ~".rs"; + let file_path = match ::attr::first_attr_value_str_by_name( + outer_attrs, ~"path") { + + Some(d) => d, + None => default_path + }; + + let file_path = Path(file_path); + self.eval_src_mod_from_path(prefix, file_path, + outer_attrs, id_sp) + } + + fn eval_src_mod_from_path(prefix: Path, path: Path, + outer_attrs: ~[ast::attribute], + id_sp: span + ) -> (ast::item_, ~[ast::attribute]) { + + let full_path = if path.is_absolute { + path + } else { + prefix.push_many(path.components) + }; + let p0 = + new_sub_parser_from_file(self.sess, self.cfg, + &full_path, id_sp); + let inner_attrs = p0.parse_inner_attrs_and_next(); + let mod_attrs = vec::append(outer_attrs, inner_attrs.inner); + let first_item_outer_attrs = inner_attrs.next; + let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs); + return (ast::item_mod(m0), mod_attrs); + + fn cdir_path_opt(default: ~str, attrs: ~[ast::attribute]) -> ~str { + match ::attr::first_attr_value_str_by_name(attrs, ~"path") { + Some(d) => d, + None => default + } + } + } + fn parse_item_foreign_fn( +attrs: ~[attribute]) -> @foreign_item { let lo = self.span.lo; let vis = self.parse_visibility(); @@ -3699,8 +3733,7 @@ impl Parser { let first_item_outer_attrs = crate_attrs.next; let m = self.parse_mod_items(token::EOF, first_item_outer_attrs); return @spanned(lo, self.span.lo, - {directives: ~[], - module: m, + {module: m, attrs: crate_attrs.inner, config: self.cfg}); } @@ -3711,78 +3744,6 @@ impl Parser { _ => self.fatal(~"expected string literal") } } - - // Logic for parsing crate files (.rc) - // - // Each crate file is a sequence of directives. - // - // Each directive imperatively extends its environment with 0 or more - // items. - fn parse_crate_directive(first_outer_attr: ~[attribute]) -> - crate_directive { - - // Collect the next attributes - let outer_attrs = vec::append(first_outer_attr, - self.parse_outer_attributes()); - // In a crate file outer attributes are only going to apply to mods - let expect_mod = vec::len(outer_attrs) > 0u; - - let lo = self.span.lo; - let vis = self.parse_visibility(); - if expect_mod || self.is_keyword(~"mod") { - - self.expect_keyword(~"mod"); - - let id = self.parse_ident(); - match self.token { - // mod x = "foo.rs"; - token::SEMI => { - let mut hi = self.span.hi; - self.bump(); - return spanned(lo, hi, cdir_src_mod(vis, id, outer_attrs)); - } - // mod x = "foo_dir" { ...directives... } - token::LBRACE => { - self.bump(); - let inner_attrs = self.parse_inner_attrs_and_next(); - let mod_attrs = vec::append(outer_attrs, inner_attrs.inner); - let next_outer_attr = inner_attrs.next; - let cdirs = self.parse_crate_directives(token::RBRACE, - next_outer_attr); - let mut hi = self.span.hi; - self.expect(token::RBRACE); - return spanned(lo, hi, - cdir_dir_mod(vis, id, cdirs, mod_attrs)); - } - _ => self.unexpected() - } - } else if self.is_view_item() { - let vi = self.parse_view_item(outer_attrs, vis); - return spanned(lo, vi.span.hi, cdir_view_item(vi)); - } - return self.fatal(~"expected crate directive"); - } - - fn parse_crate_directives(term: token::Token, - first_outer_attr: ~[attribute]) -> - ~[@crate_directive] { - - // This is pretty ugly. If we have an outer attribute then we can't - // accept seeing the terminator next, so if we do see it then fail the - // same way parse_crate_directive would - if vec::len(first_outer_attr) > 0u && self.token == term { - self.expect_keyword(~"mod"); - } - - let mut cdirs: ~[@crate_directive] = ~[]; - let mut first_outer_attr = first_outer_attr; - while self.token != term { - let cdir = @self.parse_crate_directive(first_outer_attr); - cdirs.push(cdir); - first_outer_attr = ~[]; - } - return cdirs; - } } impl restriction : cmp::Eq { diff --git a/src/libsyntax/syntax.rc b/src/libsyntax/syntax.rc index 2837e8fc64f..afd961f22fc 100644 --- a/src/libsyntax/syntax.rc +++ b/src/libsyntax/syntax.rc @@ -1,3 +1,5 @@ +// DIVERT + #[link(name = "syntax", vers = "0.5", uuid = "9311401b-d6ea-4cd9-a1d9-61f89499c645")]; @@ -55,8 +57,6 @@ mod parse { export attr; #[legacy_exports] - mod eval; - #[legacy_exports] mod lexer; #[legacy_exports] mod parser; diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index ae0de2add81..afd928a9fbc 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -93,16 +93,6 @@ fn visit_crate<E>(c: crate, e: E, v: vt<E>) { v.visit_mod(c.node.module, c.span, crate_node_id, e, v); } -fn visit_crate_directive<E>(cd: @crate_directive, e: E, v: vt<E>) { - match cd.node { - cdir_src_mod(_, _, _) => (), - cdir_dir_mod(_, _, cdirs, _) => for cdirs.each |cdir| { - visit_crate_directive(*cdir, e, v); - }, - cdir_view_item(vi) => v.visit_view_item(vi, e, v), - } -} - fn visit_mod<E>(m: _mod, _sp: span, _id: node_id, e: E, v: vt<E>) { for m.view_items.each |vi| { v.visit_view_item(*vi, e, v); } for m.items.each |i| { v.visit_item(*i, e, v); } |