Support attaching attributes to modules via the crate file. Issue #487

Author: brson

src/comp/front/ast.rs

@@ -89,8 +89,9 @@ tag crate_directive_ {
     // and redirected to the use of const stmt_decls inside
     // crate directive blocks.
     cdir_let(ident, @expr, vec[@crate_directive]);
-    cdir_src_mod(ident, option::t[filename]);
-    cdir_dir_mod(ident, option::t[filename], vec[@crate_directive]);
+    cdir_src_mod(ident, option::t[filename], vec[attribute]);
+    cdir_dir_mod(ident, option::t[filename],
+                 vec[@crate_directive], vec[attribute]);
     cdir_view_item(@view_item);
     cdir_syntax(path);
     cdir_auth(path, _auth);

src/comp/front/eval.rs

@@ -279,7 +279,7 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
         case (ast::cdir_expr(?x)) {
             eval_crate_directive_expr(cx, e, x, prefix, view_items, items);
         }
-        case (ast::cdir_src_mod(?id, ?file_opt)) {
+        case (ast::cdir_src_mod(?id, ?file_opt, ?attrs)) {
             auto file_path = id + ".rs";
             alt (file_opt) {
                 case (some(?f)) { file_path = f; }
@@ -291,23 +291,25 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
                 new_parser(cx.sess, e, full_path, cx.chpos,
                            cx.next_id);
             auto inner_attrs = parse_inner_attrs_and_next(p0);
+            auto mod_attrs = attrs + inner_attrs._0;
             auto first_item_outer_attrs = inner_attrs._1;
             auto m0 = parse_mod_items(p0, token::EOF, first_item_outer_attrs);
 
             auto i = front::parser::mk_item(p0, cdir.span.lo, cdir.span.hi,
-                                            id, ast::item_mod(m0), []);
+                                            id, ast::item_mod(m0),
+                                            mod_attrs);
             // Thread defids and chpos through the parsers
             cx.chpos = p0.get_chpos();
             cx.next_id = p0.next_id();
             vec::push[@ast::item](items, i);
         }
-        case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
+        case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs, ?attrs)) {
             auto path = id;
             alt (dir_opt) { case (some(?d)) { path = d; } case (none) { } }
             auto full_path = prefix + std::fs::path_sep() + path;
             auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
             auto i = @rec(ident=id,
-                          attrs=[],
+                          attrs=attrs,
                           id=cx.next_id,
                           node=ast::item_mod(m0),
                           span=cdir.span);

src/comp/front/fold.rs

@@ -143,12 +143,12 @@ fn noop_fold_crate_directive(&crate_directive_ cd, ast_fold fld)
             cdir_let(fld.fold_ident(id), fld.fold_expr(e),
                      map(fld.fold_crate_directive, cds))
                 }
-        case(cdir_src_mod(?id,?fname)) { 
-            cdir_src_mod(fld.fold_ident(id), fname)
+        case(cdir_src_mod(?id,?fname,?attrs)) { 
+            cdir_src_mod(fld.fold_ident(id), fname, attrs)
                 }
-        case(cdir_dir_mod(?id,?fname,?cds)) {
+        case(cdir_dir_mod(?id,?fname,?cds,?attrs)) {
             cdir_dir_mod(fld.fold_ident(id),fname,
-                         map(fld.fold_crate_directive, cds))
+                         map(fld.fold_crate_directive, cds), attrs)
                 }
         case(cdir_view_item(?vi)) { 
             cdir_view_item(fld.fold_view_item(vi))

src/comp/front/parser.rs

@@ -1488,7 +1488,7 @@ fn parse_stmt(&parser p) -> @ast::stmt {
 }
 
 fn parse_crate_stmt(&parser p) -> @ast::stmt {
-    auto cdir = parse_crate_directive(p);
+    auto cdir = parse_crate_directive(p, []);
     ret @spanned(cdir.span.lo, cdir.span.hi,
                  ast::stmt_crate_directive(@cdir));
 }
@@ -2141,15 +2141,6 @@ fn parse_inner_attrs_and_next(&parser p) -> tup(vec[ast::attribute],
     ret tup(inner_attrs, next_outer_attrs);
 }
 
-fn parse_inner_attrs(&parser p) -> vec[ast::attribute] {
-    auto attrs_and_next = parse_inner_attrs_and_next(p);
-    if (vec::len(attrs_and_next._1) > 0u) {
-        ret p.fatal("expected crate directive but found " +
-                  token::to_str(p.get_reader(), p.peek()));
-    }
-    ret attrs_and_next._0;
-}
-
 fn parse_meta_item(&parser p) -> @ast::meta_item {
     auto lo = p.get_lo_pos();
     auto ident = parse_ident(p);
@@ -2350,16 +2341,18 @@ fn parse_str(&parser p) -> ast::ident {
 // Each crate file is a sequence of directives.
 //
 // Each directive imperatively extends its environment with 0 or more items.
-fn parse_crate_directive(&parser p) -> ast::crate_directive {
+fn parse_crate_directive(&parser p, vec[ast::attribute] first_outer_attr)
+    -> ast::crate_directive {
+
+    // Collect the next attributes
+    auto outer_attrs = first_outer_attr
+        + parse_outer_attributes(p);
+    // In a crate file outer attributes are only going to apply to mods
+    auto expect_mod = vec::len(outer_attrs) > 0u;
+
     auto lo = p.get_lo_pos();
-    if (eat_word(p, "auth")) {
-        auto n = parse_path(p);
-        expect(p, token::EQ);
-        auto a = parse_auth(p);
-        auto hi = p.get_hi_pos();
-        expect(p, token::SEMI);
-        ret spanned(lo, hi, ast::cdir_auth(n, a));
-    } else if (eat_word(p, "mod")) {
+    if (expect_mod || is_word(p, "mod")) {
+        expect_word(p, "mod");
         auto id = parse_ident(p);
         auto file_opt =
             alt (p.peek()) {
@@ -2375,27 +2368,40 @@ fn parse_crate_directive(&parser p) -> ast::crate_directive {
                  token::SEMI) {
                 auto hi = p.get_hi_pos();
                 p.bump();
-                ret spanned(lo, hi, ast::cdir_src_mod(id, file_opt));
+                ret spanned(lo, hi, ast::cdir_src_mod(id, file_opt,
+                                                      outer_attrs));
             }
             case (
                  // mod x = "foo_dir" { ...directives... }
                  token::LBRACE) {
                 p.bump();
-                auto cdirs = parse_crate_directives(p, token::RBRACE);
+                auto inner_attrs = parse_inner_attrs_and_next(p);
+                auto mod_attrs = outer_attrs + inner_attrs._0;
+                auto next_outer_attr = inner_attrs._1;
+                auto cdirs = parse_crate_directives(p, token::RBRACE,
+                                                    next_outer_attr);
                 auto hi = p.get_hi_pos();
                 expect(p, token::RBRACE);
-                ret spanned(lo, hi, ast::cdir_dir_mod(id, file_opt, cdirs));
+                ret spanned(lo, hi, ast::cdir_dir_mod(id, file_opt, cdirs,
+                                                      mod_attrs));
             }
             case (?t) { unexpected(p, t); }
         }
+    } else if (eat_word(p, "auth")) {
+        auto n = parse_path(p);
+        expect(p, token::EQ);
+        auto a = parse_auth(p);
+        auto hi = p.get_hi_pos();
+        expect(p, token::SEMI);
+        ret spanned(lo, hi, ast::cdir_auth(n, a));
     } else if (eat_word(p, "let")) {
         expect(p, token::LPAREN);
         auto id = parse_value_ident(p);
         expect(p, token::EQ);
         auto x = parse_expr(p);
         expect(p, token::RPAREN);
         expect(p, token::LBRACE);
-        auto v = parse_crate_directives(p, token::RBRACE);
+        auto v = parse_crate_directives(p, token::RBRACE, []);
         auto hi = p.get_hi_pos();
         expect(p, token::RBRACE);
         ret spanned(lo, hi, ast::cdir_let(id, x, v));
@@ -2409,11 +2415,20 @@ fn parse_crate_directive(&parser p) -> ast::crate_directive {
     fail;
 }
 
-fn parse_crate_directives(&parser p, token::token term) ->
+fn parse_crate_directives(&parser p, token::token term,
+                          vec[ast::attribute] first_outer_attr) ->
    vec[@ast::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 && p.peek() == term) {
+        expect_word(p, "mod");
+    }
+
     let vec[@ast::crate_directive] cdirs = [];
     while (p.peek() != term) {
-        auto cdir = @parse_crate_directive(p);
+        auto cdir = @parse_crate_directive(p, first_outer_attr);
         vec::push(cdirs, cdir);
     }
     ret cdirs;
@@ -2422,8 +2437,10 @@ fn parse_crate_directives(&parser p, token::token term) ->
 fn parse_crate_from_crate_file(&parser p) -> @ast::crate {
     auto lo = p.get_lo_pos();
     auto prefix = std::fs::dirname(p.get_filemap().name);
-    auto crate_attrs = parse_inner_attrs(p);
-    auto cdirs = parse_crate_directives(p, token::EOF);
+    auto leading_attrs = parse_inner_attrs_and_next(p);
+    auto crate_attrs = leading_attrs._0;
+    auto first_cdir_attr = leading_attrs._1;
+    auto cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
     let vec[str] deps = [];
     auto cx =
         @rec(p=p,

src/comp/middle/visit.rs

@@ -66,8 +66,8 @@ fn visit_crate_directive[E](&@crate_directive cd, &E e, &vt[E] v) {
                 visit_crate_directive(cdir, e, v);
             }
         }
-        case (cdir_src_mod(_, _)) { }
-        case (cdir_dir_mod(_, _, ?cdirs)) {
+        case (cdir_src_mod(_, _, _)) { }
+        case (cdir_dir_mod(_, _, ?cdirs, _)) {
             for (@crate_directive cdir in cdirs) {
                 visit_crate_directive(cdir, e, v);
             }

src/comp/middle/walk.rs

@@ -59,8 +59,8 @@ fn walk_crate_directive(&ast_visitor v, @ast::crate_directive cd) {
                 walk_crate_directive(v, cdir);
             }
         }
-        case (ast::cdir_src_mod(_, _)) { }
-        case (ast::cdir_dir_mod(_, _, ?cdirs)) {
+        case (ast::cdir_src_mod(_, _, _)) { }
+        case (ast::cdir_dir_mod(_, _, ?cdirs, _)) {
             for (@ast::crate_directive cdir in cdirs) {
                 walk_crate_directive(v, cdir);
             }

src/test/compile-fail/attr-bad-crate-attr.rc

@@ -1,5 +1,5 @@
 // xfail-stage0
-// error-pattern: expected crate directive
+// error-pattern: expecting mod
 
 #[attr = "val"];
 #[attr = "val"] // Unterminated

src/test/run-pass/crate-attributes.rc

@@ -1,6 +1,10 @@
 #[name = "crate-attributes"];
 #[vers = "1.0"];
 
+#[attr1]
 mod m = "crate-attributes-src" {
+  #[attr_inner];
+
+  #[attr2]
   mod foo;
 }