Add str matcher for macros which matches string literals

Author: Zoxc

src/libsyntax/ext/tt/macro_parser.rs

@@ -509,6 +509,7 @@ fn may_begin_with(name: &str, token: &Token) -> bool {
     }
 
     match name {
+        "str" => token.can_begin_str(),
         "expr" => token.can_begin_expr(),
         "ty" => token.can_begin_type(),
         "ident" => token.is_ident(),
@@ -585,7 +586,7 @@ fn parse_nt<'a>(p: &mut Parser<'a>, sp: Span, name: &str) -> Nonterminal {
             }
         },
         "pat" => token::NtPat(panictry!(p.parse_pat())),
-        "expr" => token::NtExpr(panictry!(p.parse_expr())),
+        "expr" | "str" => token::NtExpr(panictry!(p.parse_expr())),
         "ty" => token::NtTy(panictry!(p.parse_ty())),
         // this could be handled like a token, since it is one
         "ident" => match p.token {

src/libsyntax/ext/tt/macro_rules.rs

@@ -634,7 +634,7 @@ fn check_matcher_core(sess: &ParseSess,
                     let msg = format!("invalid fragment specifier `{}`", bad_frag);
                     sess.span_diagnostic.struct_span_err(token.span(), &msg)
                         .help("valid fragment specifiers are `ident`, `block`, `stmt`, `expr`, \
-                              `pat`, `ty`, `path`, `meta`, `tt`, `item` and `vis`")
+                              `pat`, `ty`, `path`, `meta`, `tt`, `item`, `str` and `vis`")
                         .emit();
                     // (This eliminates false positives and duplicates
                     // from error messages.)
@@ -807,7 +807,7 @@ fn is_in_follow(tok: &quoted::TokenTree, frag: &str) -> Result<bool, (String, &'
                 // maintain
                 Ok(true)
             },
-            "stmt" | "expr"  => match *tok {
+            "stmt" | "expr" | "str"  => match *tok {
                 TokenTree::Token(_, ref tok) => match *tok {
                     FatArrow | Comma | Semi => Ok(true),
                     _ => Ok(false)
@@ -859,7 +859,7 @@ fn is_in_follow(tok: &quoted::TokenTree, frag: &str) -> Result<bool, (String, &'
             _ => Err((format!("invalid fragment specifier `{}`", frag),
                      "valid fragment specifiers are `ident`, `block`, \
                       `stmt`, `expr`, `pat`, `ty`, `path`, `meta`, `tt`, \
-                      `item` and `vis`"))
+                      `item`, `str` and `vis`"))
         }
     }
 }
@@ -899,6 +899,18 @@ fn is_legal_fragment_specifier(sess: &ParseSess,
             }
             true
         },
+        "str" => {
+            if     !features.borrow().macro_str_matcher
+                && !attr::contains_name(attrs, "allow_internal_unstable") {
+                let explain = feature_gate::EXPLAIN_STR_MATCHER;
+                emit_feature_err(sess,
+                                 "macro_str_matcher",
+                                 frag_span,
+                                 GateIssue::Language,
+                                 explain);
+            }
+            true
+        },
         _ => false,
     }
 }

src/libsyntax/feature_gate.rs

@@ -405,6 +405,9 @@ declare_features! (
     // `crate` as visibility modifier, synonymous to `pub(crate)`
     (active, crate_visibility_modifier, "1.23.0", Some(45388)),
 
+    // Allows use of the :str macro fragment specifier
+    (active, macro_str_matcher, "1.23.0", None),
+
     // extern types
     (active, extern_types, "1.23.0", Some(43467)),
 );
@@ -1158,6 +1161,9 @@ pub const EXPLAIN_DERIVE_UNDERSCORE: &'static str =
 pub const EXPLAIN_VIS_MATCHER: &'static str =
     ":vis fragment specifier is experimental and subject to change";
 
+pub const EXPLAIN_STR_MATCHER: &'static str =
+    ":str fragment specifier is experimental and subject to change";
+
 pub const EXPLAIN_PLACEMENT_IN: &'static str =
     "placement-in expression syntax is experimental and subject to change.";
 

src/libsyntax/parse/token.rs

@@ -210,6 +210,26 @@ impl Token {
         }
     }
 
+    /// Returns `true` if the token can appear at the start of an string literal.
+    pub fn can_begin_str(&self) -> bool {
+        match *self {
+            Literal(Str_(..), _) |
+            Literal(StrRaw(..), _) => true,
+            Interpolated(ref nt) => {
+                if let NtExpr(ref e) = nt.0 {
+                    if let ast::ExprKind::Lit(ref lit) = e.node {
+                        if let ast::LitKind::Str(..) = lit.node {
+                            return true;
+                        }
+                    }
+                }
+
+                false
+            },
+            _ => false,
+        }
+    }
+
     /// Returns `true` if the token can appear at the start of an expression.
     pub fn can_begin_expr(&self) -> bool {
         match *self {