Rollup of 6 pull requests

src/doc/unstable-book/src/language-features/plugin.md

@@ -59,7 +59,6 @@ extern crate rustc_plugin;
 use syntax::parse::token::{self, Token};
 use syntax::tokenstream::TokenTree;
 use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
-use syntax::ext::build::AstBuilder;  // A trait for expr_usize.
 use syntax_pos::Span;
 use rustc_plugin::Registry;
 
@@ -164,13 +163,6 @@ can continue and find further errors.
 To print syntax fragments for debugging, you can use `span_note` together with
 `syntax::print::pprust::*_to_string`.
 
-The example above produced an integer literal using `AstBuilder::expr_usize`.
-As an alternative to the `AstBuilder` trait, `libsyntax` provides a set of
-quasiquote macros. They are undocumented and very rough around the edges.
-However, the implementation may be a good starting point for an improved
-quasiquote as an ordinary plugin library.
-
-
 # Lint plugins
 
 Plugins can extend [Rust's lint

src/librustc/hir/lowering.rs

@@ -5168,7 +5168,7 @@ impl<'a> LoweringContext<'a> {
                         let uc_nested = attr::mk_nested_word_item(uc_ident);
                         attr::mk_list_item(e.span, allow_ident, vec![uc_nested])
                     };
-                    attr::mk_spanned_attr_outer(e.span, attr::mk_attr_id(), allow)
+                    attr::mk_attr_outer(allow)
                 };
                 let attrs = vec![attr];
 

src/librustc/infer/canonical/canonicalizer.rs

@@ -693,7 +693,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         const_var: &'tcx ty::Const<'tcx>
     ) -> &'tcx ty::Const<'tcx> {
         let infcx = self.infcx.expect("encountered const-var without infcx");
-        let bound_to = infcx.resolve_const_var(const_var);
+        let bound_to = infcx.shallow_resolve(const_var);
         if bound_to != const_var {
             self.fold_const(bound_to)
         } else {

src/librustc/infer/mod.rs

@@ -1351,23 +1351,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn resolve_const_var(
-        &self,
-        ct: &'tcx ty::Const<'tcx>
-    ) -> &'tcx ty::Const<'tcx> {
-        if let ty::Const { val: ConstValue::Infer(InferConst::Var(v)), .. } = ct {
-            self.const_unification_table
-                .borrow_mut()
-                .probe_value(*v)
-                .val
-                .known()
-                .map(|c| self.resolve_const_var(c))
-                .unwrap_or(ct)
-        } else {
-            ct
-        }
-    }
-
     pub fn fully_resolve<T: TypeFoldable<'tcx>>(&self, value: &T) -> FixupResult<'tcx, T> {
         /*!
          * Attempts to resolve all type/region/const variables in
@@ -1586,7 +1569,7 @@ impl<'a, 'tcx> ShallowResolver<'a, 'tcx> {
                 // it can be resolved to an int/float variable, which
                 // can then be recursively resolved, hence the
                 // recursion. Note though that we prevent type
-                // variables from unifyxing to other type variables
+                // variables from unifying to other type variables
                 // directly (though they may be embedded
                 // structurally), and we prevent cycles in any case,
                 // so this recursion should always be of very limited
@@ -1626,17 +1609,15 @@ impl<'a, 'tcx> TypeFolder<'tcx> for ShallowResolver<'a, 'tcx> {
     }
 
     fn fold_const(&mut self, ct: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {
-        match ct {
-            ty::Const { val: ConstValue::Infer(InferConst::Var(vid)), .. } => {
+        if let ty::Const { val: ConstValue::Infer(InferConst::Var(vid)), .. } = ct {
                 self.infcx.const_unification_table
                     .borrow_mut()
                     .probe_value(*vid)
                     .val
                     .known()
-                    .map(|c| self.fold_const(c))
                     .unwrap_or(ct)
-            }
-            _ => ct,
+        } else {
+            ct
         }
     }
 }

src/librustc/lint/mod.rs

@@ -737,7 +737,7 @@ pub fn struct_lint_level<'a>(sess: &'a Session,
         } else {
             format!("{} in a future release!", STANDARD_MESSAGE)
         };
-        let citation = format!("for more information, see {}",
+        let citation = format!("see {} for more information",
                                future_incompatible.reference);
         err.warn(&explanation);
         err.note(&citation);

src/librustc/session/mod.rs

@@ -1315,9 +1315,9 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
        sess.target.target.options.is_like_msvc &&
        sess.panic_strategy() == PanicStrategy::Unwind &&
        sess.opts.prints.iter().all(|&p| p == PrintRequest::NativeStaticLibs) {
-        sess.err("Profile-guided optimization does not yet work in conjunction \
+        sess.err("profile-guided optimization does not yet work in conjunction \
                   with `-Cpanic=unwind` on Windows when targeting MSVC. \
-                  See https://github.com/rust-lang/rust/issues/61002 for details.");
+                  See issue #61002 <https://github.com/rust-lang/rust/issues/61002> for details.");
     }
 }
 

src/librustc/traits/error_reporting.rs

@@ -728,8 +728,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                             if self.predicate_may_hold(&unit_obligation) {
                                 err.note("the trait is implemented for `()`. \
                                          Possibly this error has been caused by changes to \
-                                         Rust's type-inference algorithm \
-                                         (see: https://github.com/rust-lang/rust/issues/48950 \
+                                         Rust's type-inference algorithm (see issue #48950 \
+                                         <https://github.com/rust-lang/rust/issues/48950> \
                                          for more info). Consider whether you meant to use the \
                                          type `()` here instead.");
                             }

src/librustc/ty/error.rs

@@ -287,7 +287,8 @@ impl<'tcx> TyCtxt<'tcx> {
                 if ty.is_closure() || ty.is_generator() {
                     db.note("closures cannot capture themselves or take themselves as argument;\n\
                              this error may be the result of a recent compiler bug-fix,\n\
-                             see https://github.com/rust-lang/rust/issues/46062 for more details");
+                             see issue #46062 <https://github.com/rust-lang/rust/issues/46062> \
+                             for more information");
                 }
             }
             _ => {}

src/librustc/ty/relate.rs

@@ -594,13 +594,11 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
                 ty: a.ty,
             }))
         }
-        (ConstValue::ByRef { .. }, _) => {
-            bug!(
-                "non-Scalar ConstValue encountered in super_relate_consts {:?} {:?}",
-                a,
-                b,
-            );
-        }
+
+        // FIXME(const_generics): we should either handle `Scalar::Ptr` or add a comment
+        // saying that we're not handling it intentionally.
+
+        // FIXME(const_generics): handle `ConstValue::ByRef` and `ConstValue::Slice`.
 
         // FIXME(const_generics): this is wrong, as it is a projection
         (ConstValue::Unevaluated(a_def_id, a_substs),

src/librustc_lint/lib.rs

@@ -457,37 +457,50 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
     store.register_removed("transmute_from_fn_item_types",
         "always cast functions before transmuting them");
     store.register_removed("hr_lifetime_in_assoc_type",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/33685");
+        "converted into hard error, \
+        see issue #33685 <https://github.com/rust-lang/rust/issues/33685>");
     store.register_removed("inaccessible_extern_crate",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/36886");
+        "converted into hard error, \
+        see issue #36886 <https://github.com/rust-lang/rust/issues/36886>");
     store.register_removed("super_or_self_in_global_path",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/36888");
+        "converted into hard error, \
+        see issue #36888 <https://github.com/rust-lang/rust/issues/36888>");
     store.register_removed("overlapping_inherent_impls",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/36889");
+        "converted into hard error, \
+        see issue #36889 <https://github.com/rust-lang/rust/issues/36889>");
     store.register_removed("illegal_floating_point_constant_pattern",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/36890");
+        "converted into hard error, \
+        see issue #36890 <https://github.com/rust-lang/rust/issues/36890>");
     store.register_removed("illegal_struct_or_enum_constant_pattern",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/36891");
+        "converted into hard error, \
+        see issue #36891 <https://github.com/rust-lang/rust/issues/36891>");
     store.register_removed("lifetime_underscore",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/36892");
+        "converted into hard error, \
+        see issue #36892 <https://github.com/rust-lang/rust/issues/36892>");
     store.register_removed("extra_requirement_in_impl",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/37166");
+        "converted into hard error, \
+        see issue #37166 <https://github.com/rust-lang/rust/issues/37166>");
     store.register_removed("legacy_imports",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/38260");
+        "converted into hard error, \
+        see issue #38260 <https://github.com/rust-lang/rust/issues/38260>");
     store.register_removed("coerce_never",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/48950");
+        "converted into hard error, \
+        see issue #48950 <https://github.com/rust-lang/rust/issues/48950>");
     store.register_removed("resolve_trait_on_defaulted_unit",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/48950");
+        "converted into hard error, \
+        see issue #48950 <https://github.com/rust-lang/rust/issues/48950>");
     store.register_removed("private_no_mangle_fns",
         "no longer a warning, `#[no_mangle]` functions always exported");
     store.register_removed("private_no_mangle_statics",
         "no longer a warning, `#[no_mangle]` statics always exported");
     store.register_removed("bad_repr",
         "replaced with a generic attribute input check");
     store.register_removed("duplicate_matcher_binding_name",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/57742");
+        "converted into hard error, \
+        see issue #57742 <https://github.com/rust-lang/rust/issues/57742>");
     store.register_removed("incoherent_fundamental_impls",
-        "converted into hard error, see https://github.com/rust-lang/rust/issues/46205");
+        "converted into hard error, \
+        see issue #46205 <https://github.com/rust-lang/rust/issues/46205>");
 }
 
 pub fn register_internals(store: &mut lint::LintStore, sess: Option<&Session>) {

src/librustc_metadata/decoder.rs

@@ -980,14 +980,7 @@ impl<'a, 'tcx> CrateMetadata {
     }
 
     fn get_attributes(&self, item: &Entry<'tcx>, sess: &Session) -> Vec<ast::Attribute> {
-        item.attributes
-            .decode((self, sess))
-            .map(|mut attr| {
-                // Need new unique IDs: old thread-local IDs won't map to new threads.
-                attr.id = attr::mk_attr_id();
-                attr
-            })
-            .collect()
+        item.attributes.decode((self, sess)).collect()
     }
 
     // Translate a DefId from the current compilation environment to a DefId

src/librustc_mir/transform/qualify_consts.rs

@@ -1623,8 +1623,9 @@ impl MirPass for QualifyAndPromoteConstants {
                                 "{}",
                                 err,
                             );
-                            diag.note("for more information, see issue \
-                                       https://github.com/rust-lang/rust/issues/57563");
+                            diag.note("see issue \
+                                      #57563 <https://github.com/rust-lang/rust/issues/57563> \
+                                      for more information");
                             diag.help(
                                 "add `#![feature(const_fn)]` to the crate attributes to enable",
                             );
@@ -1667,8 +1668,8 @@ impl MirPass for QualifyAndPromoteConstants {
                             *span,
                             &format!("use of {} here does not actually short circuit due to \
                             the const evaluator presently not being able to do control flow. \
-                            See https://github.com/rust-lang/rust/issues/49146 for more \
-                            information.", kind),
+                            See issue #49146 <https://github.com/rust-lang/rust/issues/49146> \
+                            for more information.", kind),
                         );
                     }
                     for local in locals {

src/librustc_typeck/check/demand.rs

@@ -727,8 +727,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         );
                         err.warn("if the rounded value cannot be represented by the target \
                                   integer type, including `Inf` and `NaN`, casting will cause \
-                                  undefined behavior \
-                                  (https://github.com/rust-lang/rust/issues/10184)");
+                                  undefined behavior. See issue #10184 \
+                                  <https://github.com/rust-lang/rust/issues/10184>");
                     }
                     true
                 }

src/librustc_typeck/check/mod.rs

@@ -4528,7 +4528,7 @@ fn fatally_break_rust(sess: &Session) {
     handler.note_without_error("the compiler expectedly panicked. this is a feature.");
     handler.note_without_error(
         "we would appreciate a joke overview: \
-        https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675"
+        see issue #43162 <https://github.com/rust-lang/rust/issues/43162#issuecomment-320764675>"
     );
     handler.note_without_error(&format!("rustc {} running on {}",
         option_env!("CFG_VERSION").unwrap_or("unknown_version"),

src/librustdoc/config.rs

@@ -518,7 +518,7 @@ fn check_deprecated_options(matches: &getopts::Matches, diag: &errors::Handler)
         if matches.opt_present(flag) {
             let mut err = diag.struct_warn(&format!("the '{}' flag is considered deprecated",
                                                     flag));
-            err.warn("please see https://github.com/rust-lang/rust/issues/44136");
+            err.warn("see issue #44136 <https://github.com/rust-lang/rust/issues/44136>");
 
             if *flag == "no-defaults" {
                 err.help("you may want to use --document-private-items");

src/librustdoc/core.rs

@@ -402,7 +402,8 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
             fn report_deprecated_attr(name: &str, diag: &errors::Handler) {
                 let mut msg = diag.struct_warn(&format!("the `#![doc({})]` attribute is \
                                                          considered deprecated", name));
-                msg.warn("please see https://github.com/rust-lang/rust/issues/44136");
+                msg.warn("see issue \
+                    #44136 <https://github.com/rust-lang/rust/issues/44136>");
 
                 if name == "no_default_passes" {
                     msg.help("you may want to use `#![doc(document_private_items)]`");

src/librustdoc/html/render.rs

@@ -5007,7 +5007,8 @@ fn sidebar_module(fmt: &mut fmt::Formatter<'_>, _it: &clean::Item,
                    ItemType::Enum, ItemType::Constant, ItemType::Static, ItemType::Trait,
                    ItemType::Function, ItemType::Typedef, ItemType::Union, ItemType::Impl,
                    ItemType::TyMethod, ItemType::Method, ItemType::StructField, ItemType::Variant,
-                   ItemType::AssocType, ItemType::AssocConst, ItemType::ForeignType] {
+                   ItemType::AssocType, ItemType::AssocConst, ItemType::ForeignType,
+                   ItemType::Keyword] {
         if items.iter().any(|it| !it.is_stripped() && it.type_() == myty) {
             let (short, name) = item_ty_to_strs(&myty);
             sidebar.push_str(&format!("<li><a href=\"#{id}\">{name}</a></li>",

src/libsyntax/ast.rs

@@ -2104,9 +2104,7 @@ pub enum AttrStyle {
     Inner,
 }
 
-#[derive(
-    Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, PartialOrd, Ord, Copy,
-)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, Copy)]
 pub struct AttrId(pub usize);
 
 impl Idx for AttrId {
@@ -2118,6 +2116,18 @@ impl Idx for AttrId {
     }
 }
 
+impl rustc_serialize::Encodable for AttrId {
+    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+        s.emit_unit()
+    }
+}
+
+impl rustc_serialize::Decodable for AttrId {
+    fn decode<D: Decoder>(d: &mut D) -> Result<AttrId, D::Error> {
+        d.read_nil().map(|_| crate::attr::mk_attr_id())
+    }
+}
+
 /// Metadata associated with an item.
 /// Doc-comments are promoted to attributes that have `is_sugared_doc = true`.
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug)]

src/libsyntax/attr/builtin.rs

@@ -3,7 +3,6 @@
 use crate::ast::{self, Attribute, MetaItem, NestedMetaItem};
 use crate::early_buffered_lints::BufferedEarlyLintId;
 use crate::ext::base::ExtCtxt;
-use crate::ext::build::AstBuilder;
 use crate::feature_gate::{Features, GatedCfg};
 use crate::parse::ParseSess;
 
@@ -929,7 +928,7 @@ pub fn find_transparency(
 pub fn check_builtin_macro_attribute(ecx: &ExtCtxt<'_>, meta_item: &MetaItem, name: Symbol) {
     // All the built-in macro attributes are "words" at the moment.
     let template = AttributeTemplate { word: true, list: None, name_value_str: None };
-    let attr = ecx.attribute(meta_item.span, meta_item.clone());
+    let attr = ecx.attribute(meta_item.clone());
     check_builtin_attribute(ecx.parse_sess, &attr, name, template);
 }