---

yaml
---
r: 235599
b: refs/heads/stable
c: 7e9e389
h: refs/heads/master
i:
  235597: 8bc2eba
  235595: a046703
  235591: c4f28da
  235583: 2693e47
v: v3

Author: alexcrichton

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 18557500cb91596f3614d4cf65439f8c5f47b2e0
+refs/heads/stable: 7e9e3896dfcef4852ca8ad90f91baf5187b0248e
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/libcore/fmt/num.rs

@@ -12,6 +12,8 @@
 
 // FIXME: #6220 Implement floating point formatting
 
+#![allow(unsigned_negation)]
+
 use prelude::*;
 
 use fmt;

branches/stable/src/libcore/ops.rs

@@ -517,6 +517,7 @@ pub trait Neg {
 macro_rules! neg_impl_core {
     ($id:ident => $body:expr, $($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
+        #[allow(unsigned_negation)]
         impl Neg for $t {
             #[stable(feature = "rust1", since = "1.0.0")]
             type Output = $t;

branches/stable/src/libcoretest/fmt/num.rs

@@ -7,6 +7,8 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
+#![allow(unsigned_negation)]
+
 use core::fmt::radix;
 
 #[test]

branches/stable/src/librand/isaac.rs

@@ -126,6 +126,7 @@ impl IsaacRng {
 
     /// Refills the output buffer (`self.rsl`)
     #[inline]
+    #[allow(unsigned_negation)]
     fn isaac(&mut self) {
         self.c = self.c + w(1);
         // abbreviations

branches/stable/src/librustc/lint/context.rs

@@ -75,15 +75,6 @@ enum TargetLint {
 
     /// Temporary renaming, used for easing migration pain; see #16545
     Renamed(String, LintId),
-
-    /// Lint with this name existed previously, but has been removed/deprecated.
-    /// The string argument is the reason for removal.
-    Removed(String),
-}
-
-enum FindLintError {
-    NotFound,
-    Removed
 }
 
 impl LintStore {
@@ -175,42 +166,30 @@ impl LintStore {
         self.by_name.insert(old_name.to_string(), Renamed(new_name.to_string(), target));
     }
 
-    pub fn register_removed(&mut self, name: &str, reason: &str) {
-        self.by_name.insert(name.into(), Removed(reason.into()));
-    }
-
     #[allow(unused_variables)]
     fn find_lint(&self, lint_name: &str, sess: &Session, span: Option<Span>)
-                 -> Result<LintId, FindLintError>
+                 -> Option<LintId>
     {
         match self.by_name.get(lint_name) {
-            Some(&Id(lint_id)) => Ok(lint_id),
+            Some(&Id(lint_id)) => Some(lint_id),
             Some(&Renamed(ref new_name, lint_id)) => {
                 let warning = format!("lint {} has been renamed to {}",
                                       lint_name, new_name);
                 match span {
                     Some(span) => sess.span_warn(span, &warning[..]),
                     None => sess.warn(&warning[..]),
                 };
-                Ok(lint_id)
-            },
-            Some(&Removed(ref reason)) => {
-                let warning = format!("lint {} has been removed: {}", lint_name, reason);
-                match span {
-                    Some(span) => sess.span_warn(span, &warning[..]),
-                    None => sess.warn(&warning[..])
-                }
-                Err(FindLintError::Removed)
-            },
-            None => Err(FindLintError::NotFound)
+                Some(lint_id)
+            }
+            None => None
         }
     }
 
     pub fn process_command_line(&mut self, sess: &Session) {
         for &(ref lint_name, level) in &sess.opts.lint_opts {
             match self.find_lint(&lint_name[..], sess, None) {
-                Ok(lint_id) => self.set_level(lint_id, (level, CommandLine)),
-                Err(_) => {
+                Some(lint_id) => self.set_level(lint_id, (level, CommandLine)),
+                None => {
                     match self.lint_groups.iter().map(|(&x, pair)| (x, pair.0.clone()))
                                                  .collect::<FnvHashMap<&'static str,
                                                                        Vec<LintId>>>()
@@ -419,8 +398,8 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
                 }
                 Ok((lint_name, level, span)) => {
                     match self.lints.find_lint(&lint_name, &self.tcx.sess, Some(span)) {
-                        Ok(lint_id) => vec![(lint_id, level, span)],
-                        Err(FindLintError::NotFound) => {
+                        Some(lint_id) => vec![(lint_id, level, span)],
+                        None => {
                             match self.lints.lint_groups.get(&lint_name[..]) {
                                 Some(&(ref v, _)) => v.iter()
                                                       .map(|lint_id: &LintId|
@@ -433,8 +412,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
                                     continue;
                                 }
                             }
-                        },
-                        Err(FindLintError::Removed) => { continue; }
+                        }
                     }
                 }
             };

branches/stable/src/librustc/middle/const_eval.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![allow(non_camel_case_types)]
+#![allow(unsigned_negation)]
 
 use self::ConstVal::*;
 
@@ -26,6 +27,7 @@ use util::num::ToPrimitive;
 use syntax::ast::{self, Expr};
 use syntax::ast_util;
 use syntax::codemap::Span;
+use syntax::feature_gate;
 use syntax::parse::token::InternedString;
 use syntax::ptr::P;
 use syntax::{codemap, visit};
@@ -743,6 +745,13 @@ pub fn eval_const_expr_with_substs<'tcx, S>(tcx: &ty::ctxt<'tcx>,
           Float(f) => Float(-f),
           Int(n) =>  try!(const_int_checked_neg(n, e, expr_int_type)),
           Uint(i) => {
+              if !tcx.sess.features.borrow().negate_unsigned {
+                  feature_gate::emit_feature_err(
+                      &tcx.sess.parse_sess.span_diagnostic,
+                      "negate_unsigned",
+                      e.span,
+                      "unary negation of unsigned integers may be removed in the future");
+              }
               try!(const_uint_checked_neg(i, e, expr_uint_type))
           }
           Str(_) => signal!(e, NegateOnString),

branches/stable/src/librustc_lint/builtin.rs

@@ -88,6 +88,12 @@ impl LintPass for WhileTrue {
     }
 }
 
+declare_lint! {
+    UNSIGNED_NEGATION,
+    Warn,
+    "using an unary minus operator on unsigned type"
+}
+
 declare_lint! {
     UNUSED_COMPARISONS,
     Warn,
@@ -122,7 +128,8 @@ impl TypeLimits {
 
 impl LintPass for TypeLimits {
     fn get_lints(&self) -> LintArray {
-        lint_array!(UNUSED_COMPARISONS, OVERFLOWING_LITERALS, EXCEEDING_BITSHIFTS)
+        lint_array!(UNSIGNED_NEGATION, UNUSED_COMPARISONS, OVERFLOWING_LITERALS,
+                    EXCEEDING_BITSHIFTS)
     }
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
@@ -132,12 +139,9 @@ impl LintPass for TypeLimits {
                     ast::ExprLit(ref lit) => {
                         match lit.node {
                             ast::LitInt(_, ast::UnsignedIntLit(_)) => {
-                                check_unsigned_negation_feature(cx, e.span);
-                            },
-                            ast::LitInt(_, ast::UnsuffixedIntLit(_)) => {
-                                if let ty::TyUint(_) = cx.tcx.expr_ty(e).sty {
-                                    check_unsigned_negation_feature(cx, e.span);
-                                }
+                                cx.span_lint(UNSIGNED_NEGATION, e.span,
+                                             "negation of unsigned int literal may \
+                                             be unintentional");
                             },
                             _ => ()
                         }
@@ -146,7 +150,9 @@ impl LintPass for TypeLimits {
                         let t = cx.tcx.expr_ty(&**expr);
                         match t.sty {
                             ty::TyUint(_) => {
-                                check_unsigned_negation_feature(cx, e.span);
+                                cx.span_lint(UNSIGNED_NEGATION, e.span,
+                                             "negation of unsigned int variable may \
+                                             be unintentional");
                             },
                             _ => ()
                         }
@@ -379,18 +385,6 @@ impl LintPass for TypeLimits {
                 _ => false
             }
         }
-
-        fn check_unsigned_negation_feature(cx: &Context, span: Span) {
-            if !cx.sess().features.borrow().negate_unsigned {
-                // FIXME(#27141): change this to syntax::feature_gate::emit_feature_err…
-                cx.sess().span_warn(span,
-                    "unary negation of unsigned integers will be feature gated in the future");
-                // …and remove following two expressions.
-                if option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some() { return; }
-                cx.sess().fileline_help(span, "add #![feature(negate_unsigned)] to the \
-                                               crate attributes to enable the gate in advance");
-            }
-        }
     }
 }
 

branches/stable/src/librustc_lint/lib.rs

@@ -134,6 +134,4 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
     store.register_renamed("raw_pointer_deriving", "raw_pointer_derive");
 
     store.register_renamed("unknown_features", "unused_features");
-
-    store.register_removed("unsigned_negation", "replaced by negate_unsigned feature gate");
 }

branches/stable/src/librustc_trans/trans/adt.rs

@@ -41,6 +41,8 @@
 //!   used unboxed and any field can have pointers (including mutable)
 //!   taken to it, implementing them for Rust seems difficult.
 
+#![allow(unsigned_negation)]
+
 pub use self::Repr::*;
 
 use std::rc::Rc;

branches/stable/src/librustc_trans/trans/debuginfo/metadata.rs

@@ -796,31 +796,12 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             }
         }
         ty::TyBareFn(_, ref barefnty) => {
-            let fn_metadata = subroutine_type_metadata(cx,
-                                                       unique_type_id,
-                                                       &barefnty.sig,
-                                                       usage_site_span).metadata;
-            match debug_context(cx).type_map
-                                   .borrow()
-                                   .find_metadata_for_unique_id(unique_type_id) {
-                Some(metadata) => return metadata,
-                None => { /* proceed normally */ }
-            };
-
-            // This is actually a function pointer, so wrap it in pointer DI
-            MetadataCreationResult::new(pointer_type_metadata(cx, t, fn_metadata), false)
-
+            subroutine_type_metadata(cx, unique_type_id, &barefnty.sig, usage_site_span)
         }
         ty::TyClosure(def_id, substs) => {
             let infcx = infer::normalizing_infer_ctxt(cx.tcx(), &cx.tcx().tables);
-            let upvars = infcx.closure_upvars(def_id, substs).unwrap();
-            let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
-
-            prepare_tuple_metadata(cx,
-                                   t,
-                                   &upvar_types[..],
-                                   unique_type_id,
-                                   usage_site_span).finalize(cx)
+            let sig = infcx.closure_type(def_id, substs).sig;
+            subroutine_type_metadata(cx, unique_type_id, &sig, usage_site_span)
         }
         ty::TyStruct(def_id, substs) => {
             prepare_struct_metadata(cx,
@@ -939,7 +920,7 @@ pub fn scope_metadata(fcx: &FunctionContext,
     }
 }
 
-pub fn diverging_type_metadata(cx: &CrateContext) -> DIType {
+fn diverging_type_metadata(cx: &CrateContext) -> DIType {
     unsafe {
         llvm::LLVMDIBuilderCreateBasicType(
             DIB(cx),

branches/stable/src/librustc_trans/trans/debuginfo/mod.rs

@@ -18,8 +18,7 @@ use self::utils::{DIB, span_start, assert_type_for_node_id, contains_nodebug_att
                   create_DIArray, is_node_local_to_unit};
 use self::namespace::{namespace_for_item, NamespaceTreeNode};
 use self::type_names::compute_debuginfo_type_name;
-use self::metadata::{type_metadata, diverging_type_metadata};
-use self::metadata::{file_metadata, scope_metadata, TypeMap, compile_unit_metadata};
+use self::metadata::{type_metadata, file_metadata, scope_metadata, TypeMap, compile_unit_metadata};
 use self::source_loc::InternalDebugLocation;
 
 use llvm;
@@ -30,8 +29,8 @@ use middle::subst::{self, Substs};
 use rustc::ast_map;
 use trans::common::{NodeIdAndSpan, CrateContext, FunctionContext, Block};
 use trans;
-use trans::{monomorphize, type_of};
-use middle::ty::{self, Ty};
+use trans::monomorphize;
+use middle::ty::Ty;
 use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo};
 use util::nodemap::{NodeMap, FnvHashMap, FnvHashSet};
 
@@ -41,7 +40,7 @@ use std::ffi::CString;
 use std::ptr;
 use std::rc::Rc;
 use syntax::codemap::{Span, Pos};
-use syntax::{abi, ast, codemap, ast_util};
+use syntax::{ast, codemap, ast_util};
 use syntax::attr::IntType;
 use syntax::parse::token::{self, special_idents};
 
@@ -326,6 +325,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     let function_type_metadata = unsafe {
         let fn_signature = get_function_signature(cx,
                                                   fn_ast_id,
+                                                  &*fn_decl,
                                                   param_substs,
                                                   span);
         llvm::LLVMDIBuilderCreateSubroutineType(DIB(cx), file_metadata, fn_signature)
@@ -402,49 +402,35 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
     fn get_function_signature<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                         fn_ast_id: ast::NodeId,
+                                        fn_decl: &ast::FnDecl,
                                         param_substs: &Substs<'tcx>,
                                         error_reporting_span: Span) -> DIArray {
         if cx.sess().opts.debuginfo == LimitedDebugInfo {
             return create_DIArray(DIB(cx), &[]);
         }
 
-        // Return type -- llvm::DIBuilder wants this at index 0
-        assert_type_for_node_id(cx, fn_ast_id, error_reporting_span);
-        let fn_type = cx.tcx().node_id_to_type(fn_ast_id);
-
-        let (sig, abi) = match fn_type.sty {
-            ty::TyBareFn(_, ref barefnty) => {
-                (cx.tcx().erase_late_bound_regions(&barefnty.sig), barefnty.abi)
-            }
-            ty::TyClosure(def_id, substs) => {
-                let closure_type = cx.tcx().closure_type(def_id, substs);
-                (cx.tcx().erase_late_bound_regions(&closure_type.sig), closure_type.abi)
-            }
-
-            _ => cx.sess().bug("get_function_metdata: Expected a function type!")
-        };
-        let sig = monomorphize::apply_param_substs(cx.tcx(), param_substs, &sig);
-
-        let mut signature = Vec::with_capacity(sig.inputs.len() + 1);
+        let mut signature = Vec::with_capacity(fn_decl.inputs.len() + 1);
 
         // Return type -- llvm::DIBuilder wants this at index 0
-        signature.push(match sig.output {
-            ty::FnConverging(ret_ty) => match ret_ty.sty {
-                ty::TyTuple(ref tys) if tys.is_empty() => ptr::null_mut(),
-                _ => type_metadata(cx, ret_ty, codemap::DUMMY_SP)
-            },
-            ty::FnDiverging => diverging_type_metadata(cx)
-        });
-
-        let inputs = &if abi == abi::RustCall {
-            type_of::untuple_arguments(cx, &sig.inputs)
+        assert_type_for_node_id(cx, fn_ast_id, error_reporting_span);
+        let return_type = cx.tcx().node_id_to_type(fn_ast_id);
+        let return_type = monomorphize::apply_param_substs(cx.tcx(),
+                                                           param_substs,
+                                                           &return_type);
+        if return_type.is_nil() {
+            signature.push(ptr::null_mut())
         } else {
-            sig.inputs
-        };
+            signature.push(type_metadata(cx, return_type, codemap::DUMMY_SP));
+        }
 
         // Arguments types
-        for &argument_type in inputs {
-            signature.push(type_metadata(cx, argument_type, codemap::DUMMY_SP));
+        for arg in &fn_decl.inputs {
+            assert_type_for_node_id(cx, arg.pat.id, arg.pat.span);
+            let arg_type = cx.tcx().node_id_to_type(arg.pat.id);
+            let arg_type = monomorphize::apply_param_substs(cx.tcx(),
+                                                            param_substs,
+                                                            &arg_type);
+            signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP));
         }
 
         return create_DIArray(DIB(cx), &signature[..]);