Parse - Remove TOK_ATTR_OPEN and TOK_CATTR_OPEN

8 files changed, 88 insertions, 175 deletions

diff --git a/src/macro_rules/eval.cpp b/src/macro_rules/eval.cpp
index 8f7072e5..ebee2019 100644
--- a/src/macro_rules/eval.cpp
+++ b/src/macro_rules/eval.cpp
@@ -886,8 +886,6 @@ namespace
                 consume_tt(lex);
             lex.consume();
             break;
-        case TOK_ATTR_OPEN:
-        case TOK_CATTR_OPEN:
         case TOK_SQUARE_OPEN:
             lex.consume();
             while(lex.next() != TOK_SQUARE_CLOSE)
@@ -1474,8 +1472,12 @@ namespace
             }
         };
 
-        while( lex.next() == TOK_ATTR_OPEN )
+        while( lex.next() == TOK_HASH )
+        {
+            lex.consume();
+            lex.consume_if(TOK_EXCLAM);
             consume_tt(lex);
+        }
         if( lex.consume_if(TOK_INTERPOLATED_ITEM) )
             return true;
         if(lex.next() == TOK_RWORD_PUB)
diff --git a/src/macro_rules/mod.cpp b/src/macro_rules/mod.cpp
index eb0f9be0..0f16a377 100644
--- a/src/macro_rules/mod.cpp
+++ b/src/macro_rules/mod.cpp
@@ -129,7 +129,7 @@ bool is_token_stmt(eTokenType tt) {
 bool is_token_item(eTokenType tt) {
     switch( tt )
     {
-    case TOK_ATTR_OPEN:
+    case TOK_HASH:
 
     case TOK_RWORD_PUB:
     case TOK_RWORD_UNSAFE:
diff --git a/src/parse/common.hpp b/src/parse/common.hpp
index 613290f2..ede08984 100644
--- a/src/parse/common.hpp
+++ b/src/parse/common.hpp
@@ -41,6 +41,8 @@ extern AST::PathParams Parse_Path_GenericList(TokenStream& lex);
 
 
 extern ::std::vector< ::std::string> Parse_HRB(TokenStream& lex);
+extern AST::MetaItems  Parse_ItemAttrs(TokenStream& lex);
+extern void Parse_ParentAttrs(TokenStream& lex, AST::MetaItems& out);
 extern AST::MetaItem   Parse_MetaItem(TokenStream& lex);
 extern ::AST::MacroInvocation Parse_MacroInvocation(ProtoSpan ps, ::std::string name, TokenStream& lex);
 extern TypeRef     Parse_Type(TokenStream& lex, bool allow_trait_list = true);
diff --git a/src/parse/eTokenType.enum.h b/src/parse/eTokenType.enum.h
index 23b03c49..1e46721f 100644
--- a/src/parse/eTokenType.enum.h
+++ b/src/parse/eTokenType.enum.h
@@ -24,8 +24,7 @@ _(TOK_FLOAT)
 _(TOK_STRING)
 _(TOK_BYTESTRING)
 
-_(TOK_CATTR_OPEN)
-_(TOK_ATTR_OPEN)
+_(TOK_HASH)
 
 _(TOK_UNDERSCORE)
 
diff --git a/src/parse/expr.cpp b/src/parse/expr.cpp
index 7d9da66c..2ac13728 100644
--- a/src/parse/expr.cpp
+++ b/src/parse/expr.cpp
@@ -66,13 +66,9 @@ ExprNodeP Parse_ExprBlockNode(TokenStream& lex, bool is_unsafe/*=false*/)
         DEBUG("tok = " << tok);
 
         // NOTE: Doc comments can appear within a function and apply to the function
-        // TODO: Use these attributes
-        while( GET_TOK(tok, lex) == TOK_CATTR_OPEN )
-        {
-            /*node_attrs.push_back(*/ Parse_MetaItem(lex) /*)*/;
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-        }
-        PUTBACK(tok, lex);
+        ::AST::MetaItems    node_attrs;
+        Parse_ParentAttrs(lex, node_attrs);
+        (void)node_attrs;   // TODO: Use these attributes
         if( LOOK_AHEAD(lex) == TOK_BRACE_CLOSE )
             break;
 
@@ -102,12 +98,8 @@ ExprNodeP Parse_ExprBlockLine_WithItems(TokenStream& lex, ::std::shared_ptr<AST:
 {
     Token   tok;
 
-    AST::MetaItems  item_attrs;
-    while( GET_TOK(tok, lex) == TOK_ATTR_OPEN )
-    {
-        item_attrs.push_back( Parse_MetaItem(lex) );
-        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-    }
+    AST::MetaItems  item_attrs = Parse_ItemAttrs(lex);
+    GET_TOK(tok, lex);
 
     // `union Ident` - contextual keyword
     if( tok.type() == TOK_IDENT && tok.str() == "union" && lex.lookahead(0) == TOK_IDENT ) {
@@ -439,13 +431,7 @@ ExprNodeP Parse_Expr_Match(TokenStream& lex)
         PUTBACK(tok, lex);
         AST::ExprNode_Match_Arm    arm;
 
-        ::AST::MetaItems   arm_attrs;
-        while( LOOK_AHEAD(lex) == TOK_ATTR_OPEN ) {
-            GET_TOK(tok, lex);
-            arm_attrs.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-        }
-        arm.m_attrs = mv$(arm_attrs);
+        arm.m_attrs = Parse_ItemAttrs(lex);
 
         do {
             // Refutable pattern
@@ -598,13 +584,7 @@ ExprNodeP Parse_Expr0(TokenStream& lex)
     //TRACE_FUNCTION;
     Token tok;
 
-    ::AST::MetaItems  expr_attrs;
-    while( LOOK_AHEAD(lex) == TOK_ATTR_OPEN )
-    {
-        GET_TOK(tok, lex);
-        expr_attrs.push_back( Parse_MetaItem(lex) );
-        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-    }
+    ::AST::MetaItems  expr_attrs = Parse_ItemAttrs(lex);
 
     ExprNodeP rv = Parse_Expr1(lex);
     auto op = AST::ExprNode_Assign::NONE;
@@ -1014,13 +994,13 @@ ExprNodeP Parse_ExprVal_StructLiteral(TokenStream& lex, AST::Path path)
     // - A series of 0 or more pairs of <ident>: <expr>,
     // - '..' <expr>
     ::AST::ExprNode_StructLiteral::t_values items;
-    while( GET_TOK(tok, lex) == TOK_IDENT || tok.type() == TOK_ATTR_OPEN )
+    while( GET_TOK(tok, lex) == TOK_IDENT || tok.type() == TOK_HASH )
     {
         ::AST::MetaItems    attrs;
-        while( tok.type() == TOK_ATTR_OPEN )
+        if( tok.type() == TOK_HASH )
         {
-            attrs.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
+            PUTBACK(tok, lex);
+            attrs = Parse_ItemAttrs(lex);
             GET_TOK(tok, lex);
         }
         CHECK_TOK(tok, TOK_IDENT);
@@ -1328,14 +1308,6 @@ TokenTree Parse_TT(TokenStream& lex, bool unwrapped)
     case TOK_BRACE_OPEN:
         closer = TOK_BRACE_CLOSE;
         break;
-    // HACK! mrustc parses #[ and #![ as composite tokens
-    // TODO: Split these into their component tokens.
-    case TOK_ATTR_OPEN:
-    case TOK_CATTR_OPEN:
-        if( unwrapped )
-            throw ParseError::Unexpected(lex, tok);
-        closer = TOK_SQUARE_CLOSE;
-        break;
 
     case TOK_EOF:
     case TOK_NULL:
diff --git a/src/parse/lex.cpp b/src/parse/lex.cpp
index fb57043d..5e57b418 100644
--- a/src/parse/lex.cpp
+++ b/src/parse/lex.cpp
@@ -64,10 +64,7 @@ static const struct {
   TOKENT("!" , TOK_EXCLAM),
   TOKENT("!=", TOK_EXCLAM_EQUAL),
   TOKENT("\"", DOUBLEQUOTE),
-  TOKENT("#",  0),
-  TOKENT("#!", SHEBANG),
-  TOKENT("#![",TOK_CATTR_OPEN),
-  TOKENT("#[", TOK_ATTR_OPEN),
+  TOKENT("#",  TOK_HASH),
   TOKENT("$",  TOK_DOLLAR),
   TOKENT("%" , TOK_PERCENT),
   TOKENT("%=", TOK_PERCENT_EQUAL),
@@ -294,12 +291,15 @@ Token Lexer::getTokenInt()
                         ch = this->getc();
                     return Token(TOK_NEWLINE);
                 case '[':
-                    return Token(TOK_CATTR_OPEN);
+                    this->ungetc();
+                    this->m_next_token = Token(TOK_EXCLAM);
+                    return Token(TOK_HASH);
                 default:
                     throw ParseError::BadChar(*this, ch.v);
                 }
             case '[':
-                return Token(TOK_ATTR_OPEN);
+                this->ungetc();
+                return Token(TOK_HASH);
             default:
                 this->ungetc();
                 //return Token(TOK_HASH);
diff --git a/src/parse/root.cpp b/src/parse/root.cpp
index e61c2b21..9b4cfcfb 100644
--- a/src/parse/root.cpp
+++ b/src/parse/root.cpp
@@ -41,6 +41,8 @@ Spanned<T> get_spanned(TokenStream& lex, ::std::function<T()> f) {
     return input;
 }
 
+AST::MetaItems Parse_ItemAttrs(TokenStream& lex);
+void Parse_ParentAttrs(TokenStream& lex, AST::MetaItems& out);
 AST::MetaItem   Parse_MetaItem(TokenStream& lex);
 void Parse_ModRoot(TokenStream& lex, AST::Module& mod, AST::MetaItems& mod_attrs);
 bool Parse_MacroInvocation_Opt(TokenStream& lex,  AST::MacroInvocation& out_inv);
@@ -125,18 +127,10 @@ bool Parse_Publicity(TokenStream& lex, bool allow_restricted=true)
     ::std::vector< ::std::string>   lifetimes;
     GET_CHECK_TOK(tok, lex, TOK_LT);
     do {
-        GET_TOK(tok, lex);
-
-        ::AST::MetaItems attrs;
-        while(tok.type() == TOK_ATTR_OPEN)
-        {
-            attrs.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-            GET_TOK(tok, lex);
-        }
+        ::AST::MetaItems attrs = Parse_ItemAttrs(lex);
         (void)attrs;    // TODO: Attributes on generic params
 
-        switch(tok.type())
+        switch(GET_TOK(tok, lex))
         {
         case TOK_LIFETIME:
             lifetimes.push_back(tok.str());
@@ -203,15 +197,11 @@ AST::GenericParams Parse_GenericParams(TokenStream& lex)
             break ;
         }
 
-        ::AST::MetaItems attrs;
-        while(tok.type() == TOK_ATTR_OPEN)
-        {
-            attrs.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-            GET_TOK(tok, lex);
-        }
+        PUTBACK(tok, lex);
+        ::AST::MetaItems attrs = Parse_ItemAttrs(lex);
         (void)attrs;    // TODO: Attributes on generic params
 
+        GET_TOK(tok, lex);
         if( tok.type() == TOK_IDENT )
         {
             // TODO: Hygine
@@ -555,25 +545,20 @@ AST::Struct Parse_Struct(TokenStream& lex, const AST::MetaItems& meta_items)
     {
         // Tuple structs
         ::std::vector<AST::TupleItem>  refs;
-        while(GET_TOK(tok, lex) != TOK_PAREN_CLOSE)
+        while(lex.lookahead(0) != TOK_PAREN_CLOSE)
         {
-            AST::MetaItems  item_attrs;
-            while( tok.type() == TOK_ATTR_OPEN )
-            {
-                item_attrs.push_back( Parse_MetaItem(lex) );
-                GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-                GET_TOK(tok, lex);
-            }
+            AST::MetaItems  item_attrs = Parse_ItemAttrs(lex);
             SET_ATTRS(lex, item_attrs);
 
-            PUTBACK(tok, lex);
             bool    is_pub = Parse_Publicity(lex, /*allow_restricted=*/false);  // HACK: Disable `pub(restricted)` syntax in tuple structs, due to ambiguity
 
             refs.push_back( AST::TupleItem( mv$(item_attrs), is_pub, Parse_Type(lex) ) );
-            if( GET_TOK(tok, lex) != TOK_COMMA )
+            if( GET_TOK(tok, lex) != TOK_COMMA ) {
+                PUTBACK(tok, lex);
                 break;
+            }
         }
-        CHECK_TOK(tok, TOK_PAREN_CLOSE);
+        GET_CHECK_TOK(tok, lex, TOK_PAREN_CLOSE);
 
         if(LOOK_AHEAD(lex) == TOK_RWORD_WHERE)
         {
@@ -595,16 +580,11 @@ AST::Struct Parse_Struct(TokenStream& lex, const AST::MetaItems& meta_items)
         ::std::vector<AST::StructItem>  items;
         while( GET_TOK(tok, lex) != TOK_BRACE_CLOSE )
         {
-            AST::MetaItems  item_attrs;
-            while( tok.type() == TOK_ATTR_OPEN )
-            {
-                item_attrs.push_back( Parse_MetaItem(lex) );
-                GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-                GET_TOK(tok, lex);
-            }
+            PUTBACK(tok, lex);
+
+            AST::MetaItems  item_attrs = Parse_ItemAttrs(lex);
             SET_ATTRS(lex, item_attrs);
 
-            PUTBACK(tok, lex);
             bool is_pub = Parse_Publicity(lex);
 
             GET_CHECK_TOK(tok, lex, TOK_IDENT);
@@ -680,20 +660,14 @@ AST::Trait Parse_TraitDef(TokenStream& lex, const AST::MetaItems& meta_items)
     CHECK_TOK(tok, TOK_BRACE_OPEN);
     while( GET_TOK(tok, lex) != TOK_BRACE_CLOSE )
     {
+        PUTBACK(tok, lex);
 
-        AST::MetaItems  item_attrs;
-        while( tok.type() == TOK_ATTR_OPEN )
-        {
-            item_attrs.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-            GET_TOK(tok, lex);
-        }
+        AST::MetaItems  item_attrs = Parse_ItemAttrs(lex);
         SET_ATTRS(lex, item_attrs);
 
         auto ps = lex.start_span();
         {
             ::AST::MacroInvocation  inv;
-            PUTBACK(tok, lex);
             if( Parse_MacroInvocation_Opt(lex, inv) )
             {
                 trait.items().push_back( AST::Named<AST::Item>("", AST::Item(mv$(inv)), false) );
@@ -847,17 +821,12 @@ AST::Enum Parse_EnumDef(TokenStream& lex, const AST::MetaItems& meta_items)
     while( GET_TOK(tok, lex) != TOK_BRACE_CLOSE )
     {
         auto sp = lex.start_span();
+        PUTBACK(tok, lex);
 
-        AST::MetaItems  item_attrs;
-        while( tok.type() == TOK_ATTR_OPEN )
-        {
-            item_attrs.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-            GET_TOK(tok, lex);
-        }
+        AST::MetaItems  item_attrs = Parse_ItemAttrs(lex);
         SET_ATTRS(lex, item_attrs);
 
-        CHECK_TOK(tok, TOK_IDENT);
+        GET_CHECK_TOK(tok, lex, TOK_IDENT);
         ::std::string   name = mv$(tok.str());
         // Tuple-like variants
         if( GET_TOK(tok, lex) == TOK_PAREN_OPEN )
@@ -872,13 +841,8 @@ AST::Enum Parse_EnumDef(TokenStream& lex, const AST::MetaItems& meta_items)
                     break;
                 }
 
-                AST::MetaItems  field_attrs;
-                while( LOOK_AHEAD(lex) == TOK_ATTR_OPEN )
-                {
-                    GET_TOK(tok, lex);
-                    field_attrs.push_back( Parse_MetaItem(lex) );
-                    GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-                }
+                AST::MetaItems  field_attrs = Parse_ItemAttrs(lex);
+                (void)field_attrs;  // TODO^
 
                 types.push_back( Parse_Type(lex) );
             } while( GET_TOK(tok, lex) == TOK_COMMA );
@@ -898,13 +862,7 @@ AST::Enum Parse_EnumDef(TokenStream& lex, const AST::MetaItems& meta_items)
                     break;
                 }
 
-                AST::MetaItems  field_attrs;
-                while( LOOK_AHEAD(lex) == TOK_ATTR_OPEN )
-                {
-                    GET_TOK(tok, lex);
-                    field_attrs.push_back( Parse_MetaItem(lex) );
-                    GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-                }
+                AST::MetaItems  field_attrs = Parse_ItemAttrs(lex);
 
                 GET_CHECK_TOK(tok, lex, TOK_IDENT);
                 auto name = mv$(tok.str());
@@ -966,13 +924,7 @@ AST::Enum Parse_EnumDef(TokenStream& lex, const AST::MetaItems& meta_items)
             break ;
         }
 
-        AST::MetaItems item_attrs;
-        while( LOOK_AHEAD(lex) == TOK_ATTR_OPEN )
-        {
-            GET_TOK(tok, lex);
-            item_attrs.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-        }
+        AST::MetaItems item_attrs = Parse_ItemAttrs(lex);
         SET_ATTRS(lex, item_attrs);
 
         bool is_pub = Parse_Publicity(lex);
@@ -991,6 +943,31 @@ AST::Enum Parse_EnumDef(TokenStream& lex, const AST::MetaItems& meta_items)
     return ::AST::Union( mv$(params), mv$(variants) );
 }
 
+AST::MetaItems Parse_ItemAttrs(TokenStream& lex)
+{
+    AST::MetaItems  rv;
+    Token   tok;
+    while( lex.lookahead(0) == TOK_HASH )
+    {
+        GET_CHECK_TOK(tok, lex, TOK_HASH);
+        GET_CHECK_TOK(tok, lex, TOK_SQUARE_OPEN);
+        rv.push_back( Parse_MetaItem(lex) );
+        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
+    }
+    return rv;
+}
+void Parse_ParentAttrs(TokenStream& lex, AST::MetaItems& out)
+{
+    Token   tok;
+    while( lex.lookahead(0) == TOK_HASH && lex.lookahead(1) == TOK_EXCLAM )
+    {
+        GET_CHECK_TOK(tok, lex, TOK_HASH);
+        GET_CHECK_TOK(tok, lex, TOK_EXCLAM);
+        GET_CHECK_TOK(tok, lex, TOK_SQUARE_OPEN);
+        out.push_back( Parse_MetaItem(lex) );
+        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
+    }
+}
 /// Parse a meta-item declaration (either #![ or #[)
 AST::MetaItem Parse_MetaItem(TokenStream& lex)
 {
@@ -1123,12 +1100,7 @@ AST::MetaItem Parse_MetaItem(TokenStream& lex)
     }
     GET_CHECK_TOK(tok, lex, TOK_BRACE_OPEN);
 
-    while( LOOK_AHEAD(lex) == TOK_CATTR_OPEN )
-    {
-        GET_TOK(tok, lex);
-        attrs.push_back( Parse_MetaItem(lex) );
-        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-    }
+    Parse_ParentAttrs(lex,  attrs);
 
     AST::Impl   impl( AST::ImplDef( lex.end_span(ps), mv$(attrs), mv$(params), mv$(trait_path), mv$(impl_type) ) );
 
@@ -1156,20 +1128,11 @@ void Parse_Impl_Item(TokenStream& lex, AST::Impl& impl)
     TRACE_FUNCTION;
     Token   tok;
 
-    GET_TOK(tok, lex);
-
-    AST::MetaItems  item_attrs;
-    while( tok.type() == TOK_ATTR_OPEN )
-    {
-        item_attrs.push_back( Parse_MetaItem(lex) );
-        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-        GET_TOK(tok, lex);
-    }
+    AST::MetaItems  item_attrs = Parse_ItemAttrs(lex);
     SET_ATTRS(lex, item_attrs);
 
     auto ps = lex.start_span();
 
-    PUTBACK(tok, lex);
     bool is_public = Parse_Publicity(lex);
     GET_TOK(tok, lex);
 
@@ -1257,29 +1220,18 @@ AST::ExternBlock Parse_ExternBlock(TokenStream& lex, ::std::string abi, ::AST::M
     TRACE_FUNCTION;
     Token   tok;
 
-    while( GET_TOK(tok, lex) == TOK_CATTR_OPEN )
-    {
-        block_attrs.push_back( Parse_MetaItem(lex) );
-        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-    }
-    PUTBACK(tok, lex);
+    Parse_ParentAttrs(lex,  block_attrs);
 
     AST::ExternBlock    rv { abi };
 
     while( GET_TOK(tok, lex) != TOK_BRACE_CLOSE )
     {
-        AST::MetaItems  meta_items;
-        while( tok.type() == TOK_ATTR_OPEN )
-        {
-            meta_items.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-            GET_TOK(tok, lex);
-        }
+        PUTBACK(tok, lex);
+        AST::MetaItems  meta_items = Parse_ItemAttrs(lex);
         SET_ATTRS(lex, meta_items);
 
         auto ps = lex.start_span();
 
-        PUTBACK(tok, lex);
         bool is_public = Parse_Publicity(lex);
         switch( GET_TOK(tok, lex) )
         {
@@ -1501,10 +1453,12 @@ bool Parse_MacroInvocation_Opt(TokenStream& lex,  AST::MacroInvocation& out_inv)
     TRACE_FUNCTION_F("mod_path="<<mod_path<<", meta_items="<<meta_items);
     Token   tok;
 
-    while( LOOK_AHEAD(lex) == TOK_ATTR_OPEN /* || LOOKAHEAD2(lex, TOK_HASH, TOK_SQUARE_OPEN) */ )
+    // NOTE: This assigns into a parameter, so can't use Parse_ItemAttrs
+    while( LOOKAHEAD2(lex, TOK_HASH, TOK_SQUARE_OPEN) )
     {
         // Attributes!
-        GET_CHECK_TOK(tok, lex, TOK_ATTR_OPEN);
+        GET_CHECK_TOK(tok, lex, TOK_HASH);
+        GET_CHECK_TOK(tok, lex, TOK_SQUARE_OPEN);
         meta_items.push_back( Parse_MetaItem(lex) );
         GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
     }
@@ -1941,13 +1895,7 @@ void Parse_ModRoot_Items(TokenStream& lex, AST::Module& mod)
         }
 
         // Attributes on the following item
-        AST::MetaItems  meta_items;
-        while( GET_TOK(tok, lex) == TOK_ATTR_OPEN )
-        {
-            meta_items.push_back( Parse_MetaItem(lex) );
-            GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-        }
-        PUTBACK(tok, lex);
+        AST::MetaItems  meta_items = Parse_ItemAttrs(lex);
         DEBUG("meta_items = " << meta_items);
 
         Parse_Mod_Item(lex, mod, mv$(meta_items));
@@ -1958,17 +1906,8 @@ void Parse_ModRoot(TokenStream& lex, AST::Module& mod, AST::MetaItems& mod_attrs
 {
     TRACE_FUNCTION;
 
-    Token   tok;
-
     // Attributes on module/crate (will continue loop)
-    while( GET_TOK(tok, lex) == TOK_CATTR_OPEN )
-    {
-        AST::MetaItem item = Parse_MetaItem(lex);
-        GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-
-        mod_attrs.push_back( mv$(item) );
-    }
-    PUTBACK(tok, lex);
+    Parse_ParentAttrs(lex,  mod_attrs);
 
     Parse_ModRoot_Items(lex, mod);
 }
diff --git a/src/parse/token.cpp b/src/parse/token.cpp
index 09f50a09..53ea584f 100644
--- a/src/parse/token.cpp
+++ b/src/parse/token.cpp
@@ -310,8 +310,7 @@ struct EscapedString {
     case TOK_FLOAT:     return FMT(m_data.as_Float().m_floatval);
     case TOK_STRING:    return FMT("\"" << EscapedString(m_data.as_String()) << "\"");
     case TOK_BYTESTRING:return FMT("b\"" << m_data.as_String() << "\"");
-    case TOK_CATTR_OPEN:return "#![";
-    case TOK_ATTR_OPEN: return "#[";
+    case TOK_HASH:  return "#";
     case TOK_UNDERSCORE:return "_";
     // Symbols
     case TOK_PAREN_OPEN:    return "(";