Add nodes for embedding types and blocks in expressions for macros.

3 files changed, 40 insertions, 28 deletions

diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index 64b04693d60..21b1b7ee634 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -361,12 +361,8 @@ fn next_token(&reader rdr) -> token::token {
         } else { ret token::BINOP(op); }
     }
     alt (c) {
-        case (
-             // One-byte tokens.
-             '?') {
-            rdr.bump();
-            ret token::QUES;
-        }
+        // One-byte tokens.
+        case ('?') { rdr.bump(); ret token::QUES; }
         case (';') { rdr.bump(); ret token::SEMI; }
         case (',') { rdr.bump(); ret token::COMMA; }
         case ('.') { rdr.bump(); ret token::DOT; }
@@ -377,7 +373,18 @@ fn next_token(&reader rdr) -> token::token {
         case ('[') { rdr.bump(); ret token::LBRACKET; }
         case (']') { rdr.bump(); ret token::RBRACKET; }
         case ('@') { rdr.bump(); ret token::AT; }
-        case ('#') { rdr.bump(); ret token::POUND; }
+        case ('#') { 
+            rdr.bump(); 
+            if (rdr.curr() == '<') {
+                rdr.bump();
+                ret token::POUND_LT;
+            }
+            if (rdr.curr() == '{') {
+                rdr.bump();
+                ret token::POUND_LBRACE;
+            }
+            ret token::POUND;
+        }
         case ('~') { rdr.bump(); ret token::TILDE; }
         case (':') {
             rdr.bump();
@@ -386,9 +393,8 @@ fn next_token(&reader rdr) -> token::token {
                 ret token::MOD_SEP;
             } else { ret token::COLON; }
         }
-        case (
-             // Multi-byte tokens.
-             '=') {
+        // Multi-byte tokens.
+        case ('=') {
             rdr.bump();
             if (rdr.curr() == '=') {
                 rdr.bump();
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 59b0884704c..7d6fc8561cc 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -804,6 +804,13 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
             parse_seq_to_end_ivec(token::RBRACKET, some(token::COMMA),
                                   parse_expr, p);
         ex = ast::expr_vec(es, mut, ast::sk_rc);
+    } else if (p.peek() == token::POUND_LT) {
+        p.bump();
+        ex = ast::expr_embeded_type(parse_ty(p));
+        expect(p, token::GT);
+    } else if (p.peek() == token::POUND_LBRACE) {
+        p.bump();
+        ex = ast::expr_embeded_block(parse_block_tail(p));
     } else if (p.peek() == token::TILDE) {
         p.bump();
         alt (p.peek()) {
@@ -1715,10 +1722,15 @@ fn stmt_ends_with_semi(&ast::stmt stmt) -> bool {
 }
 
 fn parse_block(&parser p) -> ast::block {
+    expect(p, token::LBRACE);
+    be parse_block_tail(p);
+}
+
+// some blocks start with "#{"... 
+fn parse_block_tail(&parser p) -> ast::block {
     auto lo = p.get_lo_pos();
     let (@ast::stmt)[] stmts = ~[];
     let option::t[@ast::expr] expr = none;
-    expect(p, token::LBRACE);
     while (p.peek() != token::RBRACE) {
         alt (p.peek()) {
             case (token::SEMI) {
@@ -2204,8 +2216,10 @@ fn parse_outer_attrs_or_ext(&parser p) -> attr_or_ext {
         if (p.peek() == token::LBRACKET) {
             auto first_attr = parse_attribute_naked(p, ast::attr_outer, lo);
             ret some(left(~[first_attr] + parse_outer_attributes(p)));
-        } else {
+        } else if (! (p.peek() == token::LT || p.peek() == token::LBRACKET)) {
             ret some(right(parse_syntax_ext_naked(p, lo)));
+        } else {
+            ret none;
         }
     } else {
         ret none;
diff --git a/src/comp/syntax/parse/token.rs b/src/comp/syntax/parse/token.rs
index 2ce5d9e6cb4..6ba8c6ce525 100644
--- a/src/comp/syntax/parse/token.rs
+++ b/src/comp/syntax/parse/token.rs
@@ -60,6 +60,8 @@ tag token {
     LBRACE;
     RBRACE;
     POUND;
+    POUND_LBRACE;
+    POUND_LT;
 
     /* Literals */
     LIT_INT(int);
@@ -110,11 +112,8 @@ fn to_str(lexer::reader r, token t) -> str {
         case (ANDAND) { ret "&&"; }
         case (BINOP(?op)) { ret binop_to_str(op); }
         case (BINOPEQ(?op)) { ret binop_to_str(op) + "="; }
-        case (
              /* Structural symbols */
-             AT) {
-            ret "@";
-        }
+        case (AT) { ret "@"; }
         case (DOT) { ret "."; }
         case (COMMA) { ret ","; }
         case (SEMI) { ret ";"; }
@@ -133,11 +132,10 @@ fn to_str(lexer::reader r, token t) -> str {
         case (LBRACE) { ret "{"; }
         case (RBRACE) { ret "}"; }
         case (POUND) { ret "#"; }
-        case (
+        case (POUND_LBRACE) { ret "#{"; }
+        case (POUND_LT) { ret "#<"; }
              /* Literals */
-             LIT_INT(?i)) {
-            ret int::to_str(i, 10u);
-        }
+        case (LIT_INT(?i)) { ret int::to_str(i, 10u); }
         case (LIT_UINT(?u)) { ret uint::to_str(u, 10u); }
         case (LIT_MACH_INT(?tm, ?i)) {
             ret int::to_str(i, 10u) + "_" + ty_mach_to_str(tm);
@@ -147,25 +145,19 @@ fn to_str(lexer::reader r, token t) -> str {
                     ty_mach_to_str(tm);
         }
         case (LIT_FLOAT(?s)) { ret interner::get[str](*r.get_interner(), s); }
-        case (LIT_STR(?s)) {
-            // FIXME: escape.
-
+        case (LIT_STR(?s)) { // FIXME: escape.
             ret "\"" + interner::get[str](*r.get_interner(), s) + "\"";
         }
         case (LIT_CHAR(?c)) {
             // FIXME: escape.
-
             auto tmp = "'";
             str::push_char(tmp, c);
             str::push_byte(tmp, '\'' as u8);
             ret tmp;
         }
         case (LIT_BOOL(?b)) { if (b) { ret "true"; } else { ret "false"; } }
-        case (
              /* Name components */
-             IDENT(?s, _)) {
-            ret interner::get[str](*r.get_interner(), s);
-        }
+        case (IDENT(?s, _)) { ret interner::get[str](*r.get_interner(), s); }
         case (IDX(?i)) { ret "_" + int::to_str(i, 10u); }
         case (UNDERSCORE) { ret "_"; }
         case (BRACEQUOTE(_)) { ret "<bracequote>"; }