rustc: Add support for extern crate foo as bar

The compiler will now issue a warning for crates that have syntax of the form
`extern crate "foo" as bar`, but it will still continue to accept this syntax.
Additionally, the string `foo-bar` will match the crate name `foo_bar` to assist
in the transition period as well.

This patch will land hopefully in tandem with a Cargo patch that will start
translating all crate names to have underscores instead of hyphens.

cc #23533

Author: alexcrichton

src/librustc/metadata/creader.rs

@@ -73,22 +73,24 @@ struct CrateInfo {
 }
 
 pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
-    let err = |s: &str| {
+    let say = |s: &str, warn: bool| {
         match (sp, sess) {
             (_, None) => panic!("{}", s),
+            (Some(sp), Some(sess)) if warn => sess.span_warn(sp, s),
             (Some(sp), Some(sess)) => sess.span_err(sp, s),
+            (None, Some(sess)) if warn => sess.warn(s),
             (None, Some(sess)) => sess.err(s),
         }
     };
     if s.len() == 0 {
-        err("crate name must not be empty");
-    } else if s.char_at(0) == '-' {
-        err(&format!("crate name cannot start with a hyphen: {}", s));
+        say("crate name must not be empty", false);
+    } else if s.contains("-") {
+        say(&format!("crate names soon cannot contain hyphens: {}", s), true);
     }
     for c in s.chars() {
         if c.is_alphanumeric() { continue }
         if c == '_' || c == '-' { continue }
-        err(&format!("invalid character `{}` in crate name: `{}`", c, s));
+        say(&format!("invalid character `{}` in crate name: `{}`", c, s), false);
     }
     match sess {
         Some(sess) => sess.abort_if_errors(),
@@ -153,8 +155,9 @@ impl<'a> CrateReader<'a> {
         }
     }
 
-    // Traverses an AST, reading all the information about use'd crates and extern
-    // libraries necessary for later resolving, typechecking, linking, etc.
+    // Traverses an AST, reading all the information about use'd crates and
+    // extern libraries necessary for later resolving, typechecking, linking,
+    // etc.
     pub fn read_crates(&mut self, krate: &ast::Crate) {
         self.process_crate(krate);
         visit::walk_crate(self, krate);
@@ -184,11 +187,10 @@ impl<'a> CrateReader<'a> {
                 debug!("resolving extern crate stmt. ident: {} path_opt: {:?}",
                        ident, path_opt);
                 let name = match *path_opt {
-                    Some((ref path_str, _)) => {
-                        let name = path_str.to_string();
-                        validate_crate_name(Some(self.sess), &name[..],
+                    Some(name) => {
+                        validate_crate_name(Some(self.sess), name.as_str(),
                                             Some(i.span));
-                        name
+                        name.as_str().to_string()
                     }
                     None => ident.to_string(),
                 };
@@ -304,7 +306,13 @@ impl<'a> CrateReader<'a> {
                       -> Option<ast::CrateNum> {
         let mut ret = None;
         self.sess.cstore.iter_crate_data(|cnum, data| {
-            if data.name != name { return }
+            // For now we do a "fuzzy match" on crate names by considering
+            // hyphens equal to underscores. This is purely meant to be a
+            // transitionary feature while we deprecate the quote syntax of
+            // `extern crate` statements.
+            if data.name != name.replace("-", "_") {
+                return
+            }
 
             match hash {
                 Some(hash) if *hash == data.hash() => { ret = Some(cnum); return }

src/librustc_trans/save/mod.rs

@@ -1165,7 +1165,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                 let name = get_ident(item.ident);
                 let name = &name;
                 let location = match *s {
-                    Some((ref s, _)) => s.to_string(),
+                    Some(s) => s.to_string(),
                     None => name.to_string(),
                 };
                 let alias_span = self.span.span_for_last_ident(item.span);

src/librustdoc/visit_ast.rs

@@ -237,7 +237,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             ast::ItemExternCrate(ref p) => {
                 let path = match *p {
                     None => None,
-                    Some((ref x, _)) => Some(x.to_string()),
+                    Some(x) => Some(x.to_string()),
                 };
                 om.extern_crates.push(ExternCrate {
                     name: name,

src/libsyntax/ast.rs

@@ -1771,8 +1771,8 @@ pub struct Item {
 pub enum Item_ {
     /// An`extern crate` item, with optional original crate name,
     ///
-    /// e.g. `extern crate foo` or `extern crate "foo-bar" as foo`
-    ItemExternCrate(Option<(InternedString, StrStyle)>),
+    /// e.g. `extern crate foo` or `extern crate foo_bar as foo`
+    ItemExternCrate(Option<Name>),
     /// A `use` or `pub use` item
     ItemUse(P<ViewPath>),
 

src/libsyntax/parse/mod.rs

@@ -1060,7 +1060,7 @@ mod test {
         let vitem_s = item_to_string(&*vitem);
         assert_eq!(&vitem_s[..], ex_s);
 
-        let ex_s = "extern crate \"foo\" as bar;";
+        let ex_s = "extern crate foo as bar;";
         let vitem = string_to_item(ex_s.to_string()).unwrap();
         let vitem_s = item_to_string(&*vitem);
         assert_eq!(&vitem_s[..], ex_s);

src/libsyntax/parse/obsolete.rs

@@ -24,6 +24,7 @@ use ptr::P;
 pub enum ObsoleteSyntax {
     ClosureKind,
     EmptyIndex,
+    ExternCrateString,
 }
 
 pub trait ParserObsoleteMethods {
@@ -56,6 +57,11 @@ impl<'a> ParserObsoleteMethods for parser::Parser<'a> {
                 "write `[..]` instead",
                 false, // warning for now
             ),
+            ObsoleteSyntax::ExternCrateString => (
+                "\"crate-name\"",
+                "use an identifier not in quotes instead",
+                false, // warning for now
+            ),
         };
 
         self.report(sp, kind, kind_str, desc, error);

src/libsyntax/parse/parser.rs

@@ -4986,37 +4986,28 @@ impl<'a> Parser<'a> {
                                 attrs: Vec<Attribute>)
                                 -> P<Item> {
 
-        let span = self.span;
         let (maybe_path, ident) = match self.token {
             token::Ident(..) => {
-                let the_ident = self.parse_ident();
-                let path = if self.eat_keyword_noexpect(keywords::As) {
-                    // skip the ident if there is one
-                    if self.token.is_ident() { self.bump(); }
-
-                    self.span_err(span, "expected `;`, found `as`");
-                    self.fileline_help(span,
-                                   &format!("perhaps you meant to enclose the crate name `{}` in \
-                                           a string?",
-                                          the_ident.as_str()));
-                    None
+                let crate_name = self.parse_ident();
+                if self.eat_keyword(keywords::As) {
+                    (Some(crate_name.name), self.parse_ident())
                 } else {
-                    None
-                };
-                self.expect(&token::Semi);
-                (path, the_ident)
+                    (None, crate_name)
+                }
             },
-            token::Literal(token::Str_(..), suf) | token::Literal(token::StrRaw(..), suf) => {
+            token::Literal(token::Str_(..), suf) |
+            token::Literal(token::StrRaw(..), suf) => {
                 let sp = self.span;
                 self.expect_no_suffix(sp, "extern crate name", suf);
                 // forgo the internal suffix check of `parse_str` to
                 // avoid repeats (this unwrap will always succeed due
                 // to the restriction of the `match`)
-                let (s, style, _) = self.parse_optional_str().unwrap();
+                let (s, _, _) = self.parse_optional_str().unwrap();
                 self.expect_keyword(keywords::As);
                 let the_ident = self.parse_ident();
-                self.expect(&token::Semi);
-                (Some((s, style)), the_ident)
+                self.obsolete(sp, ObsoleteSyntax::ExternCrateString);
+                let s = token::intern(&s);
+                (Some(s), the_ident)
             },
             _ => {
                 let span = self.span;
@@ -5027,6 +5018,7 @@ impl<'a> Parser<'a> {
                                         token_str));
             }
         };
+        self.expect(&token::Semi);
 
         let last_span = self.last_span;
         self.mk_item(lo,

src/libsyntax/print/pprust.rs

@@ -821,8 +821,13 @@ impl<'a> State<'a> {
             ast::ItemExternCrate(ref optional_path) => {
                 try!(self.head(&visibility_qualified(item.vis,
                                                      "extern crate")));
-                if let Some((ref p, style)) = *optional_path {
-                    try!(self.print_string(p, style));
+                if let Some(p) = *optional_path {
+                    let val = token::get_name(p);
+                    if val.contains("-") {
+                        try!(self.print_string(&val, ast::CookedStr));
+                    } else {
+                        try!(self.print_name(p));
+                    }
                     try!(space(&mut self.s));
                     try!(word(&mut self.s, "as"));
                     try!(space(&mut self.s));

src/libsyntax/std_inject.rs

@@ -54,8 +54,8 @@ impl fold::Folder for StandardLibraryInjector {
 
         // The name to use in `extern crate "name" as std;`
         let actual_crate_name = match self.alt_std_name {
-            Some(ref s) => token::intern_and_get_ident(&s[..]),
-            None => token::intern_and_get_ident("std"),
+            Some(ref s) => token::intern(&s),
+            None => token::intern("std"),
         };
 
         krate.module.items.insert(0, P(ast::Item {
@@ -64,7 +64,7 @@ impl fold::Folder for StandardLibraryInjector {
             attrs: vec!(
                 attr::mk_attr_outer(attr::mk_attr_id(), attr::mk_word_item(
                         InternedString::new("macro_use")))),
-            node: ast::ItemExternCrate(Some((actual_crate_name, ast::CookedStr))),
+            node: ast::ItemExternCrate(Some(actual_crate_name)),
             vis: ast::Inherited,
             span: DUMMY_SP
         }));