---

yaml
---
r: 132799
b: refs/heads/dist-snap
c: 89a0060
h: refs/heads/master
i:
  132797: f38c3d3
  132795: 2c16d27
  132791: b0656f5
  132783: 4717b2d
  132767: 06a357e
  132735: 4fc8bc5
v: v3

Author: sfackler

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 457a3c991d79b971be07fce75f9d0c12848fb37c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: d30001d04d2006645468d3c194c9e3ae6ddc4b52
+refs/heads/dist-snap: 89a0060997479de770be0a63731423e2a305beda
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/doc/rust.md

@@ -1928,8 +1928,6 @@ interpreted:
 
 ### Miscellaneous attributes
 
-- `export_name` - on statics and functions, this determines the name of the
-  exported symbol.
 - `link_section` - on statics and functions, this specifies the section of the
   object file that this item's contents will be placed into.
 - `macro_export` - export a macro for cross-crate usage.

branches/dist-snap/src/librustc/lint/builtin.rs

@@ -568,7 +568,6 @@ impl LintPass for UnusedAttribute {
             // FIXME: #14406 these are processed in trans, which happens after the
             // lint pass
             "cold",
-            "export_name",
             "inline",
             "link",
             "link_name",
@@ -579,7 +578,6 @@ impl LintPass for UnusedAttribute {
             "packed",
             "static_assert",
             "thread_local",
-            "no_debug",
 
             // not used anywhere (!?) but apparently we want to keep them around
             "comment",

branches/dist-snap/src/librustc/middle/resolve.rs

@@ -3671,7 +3671,6 @@ impl<'a> Resolver<'a> {
                                                                ItemRibKind),
                                              |this| {
                     this.resolve_type_parameters(&generics.ty_params);
-                    this.resolve_where_clause(&generics.where_clause);
                     visit::walk_item(this, item, ());
                 });
             }
@@ -3714,7 +3713,6 @@ impl<'a> Resolver<'a> {
                                                                NormalRibKind),
                                              |this| {
                     this.resolve_type_parameters(&generics.ty_params);
-                    this.resolve_where_clause(&generics.where_clause);
 
                     // Resolve derived traits.
                     for trt in traits.iter() {
@@ -3746,8 +3744,6 @@ impl<'a> Resolver<'a> {
                                 // parameters.
                                 this.resolve_type_parameters(
                                     &ty_m.generics.ty_params);
-                                this.resolve_where_clause(&ty_m.generics
-                                                               .where_clause);
 
                                 for argument in ty_m.decl.inputs.iter() {
                                     this.resolve_type(&*argument.ty);
@@ -3911,7 +3907,6 @@ impl<'a> Resolver<'a> {
                 }
                 HasTypeParameters(ref generics, _, _, _) => {
                     this.resolve_type_parameters(&generics.ty_params);
-                    this.resolve_where_clause(&generics.where_clause);
                 }
             }
 
@@ -4027,30 +4022,6 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    fn resolve_where_clause(&mut self, where_clause: &ast::WhereClause) {
-        for predicate in where_clause.predicates.iter() {
-            match self.resolve_identifier(predicate.ident,
-                                          TypeNS,
-                                          true,
-                                          predicate.span) {
-                Some((def @ DefTyParam(_, _, _), last_private)) => {
-                    self.record_def(predicate.id, (def, last_private));
-                }
-                _ => {
-                    self.resolve_error(
-                        predicate.span,
-                        format!("undeclared type parameter `{}`",
-                                token::get_ident(
-                                    predicate.ident)).as_slice());
-                }
-            }
-
-            for bound in predicate.bounds.iter() {
-                self.resolve_type_parameter_bound(predicate.id, bound);
-            }
-        }
-    }
-
     fn resolve_struct(&mut self,
                       id: NodeId,
                       generics: &Generics,
@@ -4064,7 +4035,6 @@ impl<'a> Resolver<'a> {
                                      |this| {
             // Resolve the type parameters.
             this.resolve_type_parameters(&generics.ty_params);
-            this.resolve_where_clause(&generics.where_clause);
 
             // Resolve the super struct.
             match super_struct {
@@ -4176,7 +4146,6 @@ impl<'a> Resolver<'a> {
                                      |this| {
             // Resolve the type parameters.
             this.resolve_type_parameters(&generics.ty_params);
-            this.resolve_where_clause(&generics.where_clause);
 
             // Resolve the trait reference, if necessary.
             this.with_optional_trait_ref(id, opt_trait_reference, |this| {

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -1947,10 +1947,12 @@ pub fn trans_named_tuple_constructor<'a>(mut bcx: &'a Block<'a>,
     };
 
     if !type_is_zero_size(ccx, result_ty) {
+        let repr = adt::represent_type(ccx, result_ty);
+
         match args {
             callee::ArgExprs(exprs) => {
                 let fields = exprs.iter().map(|x| *x).enumerate().collect::<Vec<_>>();
-                bcx = expr::trans_adt(bcx, result_ty, disr, fields.as_slice(),
+                bcx = expr::trans_adt(bcx, &*repr, disr, fields.as_slice(),
                                       None, expr::SaveIn(llresult));
             }
             _ => ccx.sess().bug("expected expr as arguments for variant/struct tuple constructor")

branches/dist-snap/src/librustc/middle/trans/controlflow.rs

@@ -330,12 +330,13 @@ pub fn trans_for<'a>(
     // Check the discriminant; if the `None` case, exit the loop.
     let option_representation = adt::represent_type(loopback_bcx_out.ccx(),
                                                     method_result_type);
+    let i8_type = Type::i8(loopback_bcx_out.ccx());
     let lldiscriminant = adt::trans_get_discr(loopback_bcx_out,
                                               &*option_representation,
                                               option_datum.val,
-                                              None);
-    let i1_type = Type::i1(loopback_bcx_out.ccx());
-    let llcondition = Trunc(loopback_bcx_out, lldiscriminant, i1_type);
+                                              Some(i8_type));
+    let llzero = C_u8(loopback_bcx_out.ccx(), 0);
+    let llcondition = ICmp(loopback_bcx_out, IntNE, lldiscriminant, llzero);
     CondBr(loopback_bcx_out, llcondition, body_bcx_in.llbb, cleanup_llbb);
 
     // Now we're in the body. Unpack the `Option` value into the programmer-

branches/dist-snap/src/librustc/middle/trans/debuginfo.rs

@@ -208,6 +208,7 @@ use syntax::util::interner::Interner;
 use syntax::codemap::{Span, Pos};
 use syntax::{abi, ast, codemap, ast_util, ast_map};
 use syntax::ast_util::PostExpansionMethod;
+use syntax::owned_slice::OwnedSlice;
 use syntax::parse::token;
 use syntax::parse::token::special_idents;
 
@@ -1122,16 +1123,13 @@ pub fn create_function_debug_context(cx: &CrateContext,
         return FunctionDebugContext { repr: FunctionWithoutDebugInfo };
     }
 
-    let empty_generics = ast_util::empty_generics();
+    let empty_generics = ast::Generics { lifetimes: Vec::new(),
+                                         ty_params: OwnedSlice::empty() };
 
     let fnitem = cx.tcx.map.get(fn_ast_id);
 
     let (ident, fn_decl, generics, top_level_block, span, has_path) = match fnitem {
         ast_map::NodeItem(ref item) => {
-            if contains_nodebug_attribute(item.attrs.as_slice()) {
-                return FunctionDebugContext { repr: FunctionWithoutDebugInfo };
-            }
-
             match item.node {
                 ast::ItemFn(fn_decl, _, _, ref generics, top_level_block) => {
                     (item.ident, fn_decl, generics, top_level_block, item.span, true)
@@ -1145,12 +1143,6 @@ pub fn create_function_debug_context(cx: &CrateContext,
         ast_map::NodeImplItem(ref item) => {
             match **item {
                 ast::MethodImplItem(ref method) => {
-                    if contains_nodebug_attribute(method.attrs.as_slice()) {
-                        return FunctionDebugContext {
-                            repr: FunctionWithoutDebugInfo
-                        };
-                    }
-
                     (method.pe_ident(),
                      method.pe_fn_decl(),
                      method.pe_generics(),
@@ -1183,12 +1175,6 @@ pub fn create_function_debug_context(cx: &CrateContext,
         ast_map::NodeTraitItem(ref trait_method) => {
             match **trait_method {
                 ast::ProvidedMethod(ref method) => {
-                    if contains_nodebug_attribute(method.attrs.as_slice()) {
-                        return FunctionDebugContext {
-                            repr: FunctionWithoutDebugInfo
-                        };
-                    }
-
                     (method.pe_ident(),
                      method.pe_fn_decl(),
                      method.pe_generics(),
@@ -3185,16 +3171,6 @@ fn set_debug_location(cx: &CrateContext, debug_location: DebugLocation) {
 //  Utility Functions
 //=-----------------------------------------------------------------------------
 
-fn contains_nodebug_attribute(attributes: &[ast::Attribute]) -> bool {
-    attributes.iter().any(|attr| {
-        let meta_item: &ast::MetaItem = &*attr.node.value;
-        match meta_item.node {
-            ast::MetaWord(ref value) => value.get() == "no_debug",
-            _ => false
-        }
-    })
-}
-
 /// Return codemap::Loc corresponding to the beginning of the span
 fn span_start(cx: &CrateContext, span: Span) -> codemap::Loc {
     cx.sess().codemap().lookup_char_pos(span.lo)

branches/dist-snap/src/librustc/middle/trans/expr.rs

@@ -746,17 +746,18 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>,
             controlflow::trans_block(bcx, &**blk, dest)
         }
         ast::ExprStruct(_, ref fields, base) => {
-            trans_struct(bcx,
-                         fields.as_slice(),
-                         base,
-                         expr.span,
-                         expr.id,
-                         dest)
+            trans_rec_or_struct(bcx,
+                                fields.as_slice(),
+                                base,
+                                expr.span,
+                                expr.id,
+                                dest)
         }
         ast::ExprTup(ref args) => {
+            let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr));
             let numbered_fields: Vec<(uint, Gc<ast::Expr>)> =
                 args.iter().enumerate().map(|(i, arg)| (i, *arg)).collect();
-            trans_adt(bcx, expr_ty(bcx, expr), 0, numbered_fields.as_slice(), None, dest)
+            trans_adt(bcx, &*repr, 0, numbered_fields.as_slice(), None, dest)
         }
         ast::ExprLit(lit) => {
             match lit.node {
@@ -1041,13 +1042,16 @@ pub fn with_field_tys<R>(tcx: &ty::ctxt,
     }
 }
 
-fn trans_struct<'a>(bcx: &'a Block<'a>,
-                    fields: &[ast::Field],
-                    base: Option<Gc<ast::Expr>>,
-                    expr_span: codemap::Span,
-                    id: ast::NodeId,
-                    dest: Dest) -> &'a Block<'a> {
+fn trans_rec_or_struct<'a>(
+                       bcx: &'a Block<'a>,
+                       fields: &[ast::Field],
+                       base: Option<Gc<ast::Expr>>,
+                       expr_span: codemap::Span,
+                       id: ast::NodeId,
+                       dest: Dest)
+                       -> &'a Block<'a> {
     let _icx = push_ctxt("trans_rec");
+    let bcx = bcx;
 
     let ty = node_id_type(bcx, id);
     let tcx = bcx.tcx();
@@ -1088,7 +1092,8 @@ fn trans_struct<'a>(bcx: &'a Block<'a>,
             }
         };
 
-        trans_adt(bcx, ty, discr, numbered_fields.as_slice(), optbase, dest)
+        let repr = adt::represent_type(bcx.ccx(), ty);
+        trans_adt(bcx, &*repr, discr, numbered_fields.as_slice(), optbase, dest)
     })
 }
 
@@ -1116,71 +1121,60 @@ pub struct StructBaseInfo {
  * - `optbase` contains information on the base struct (if any) from
  * which remaining fields are copied; see comments on `StructBaseInfo`.
  */
-pub fn trans_adt<'a>(mut bcx: &'a Block<'a>,
-                     ty: ty::t,
+pub fn trans_adt<'a>(bcx: &'a Block<'a>,
+                     repr: &adt::Repr,
                      discr: ty::Disr,
                      fields: &[(uint, Gc<ast::Expr>)],
                      optbase: Option<StructBaseInfo>,
                      dest: Dest) -> &'a Block<'a> {
     let _icx = push_ctxt("trans_adt");
     let fcx = bcx.fcx;
-    let repr = adt::represent_type(bcx.ccx(), ty);
-
-    // If we don't care about the result, just make a
-    // temporary stack slot
+    let mut bcx = bcx;
     let addr = match dest {
-        SaveIn(pos) => pos,
-        Ignore => alloc_ty(bcx, ty, "temp"),
+        Ignore => {
+            for &(_i, ref e) in fields.iter() {
+                bcx = trans_into(bcx, &**e, Ignore);
+            }
+            for sbi in optbase.iter() {
+                // FIXME #7261: this moves entire base, not just certain fields
+                bcx = trans_into(bcx, &*sbi.expr, Ignore);
+            }
+            return bcx;
+        }
+        SaveIn(pos) => pos
     };
 
     // This scope holds intermediates that must be cleaned should
     // failure occur before the ADT as a whole is ready.
     let custom_cleanup_scope = fcx.push_custom_cleanup_scope();
 
-    // First we trans the base, if we have one, to the dest
-    for base in optbase.iter() {
-        assert_eq!(discr, 0);
-
-        match ty::expr_kind(bcx.tcx(), &*base.expr) {
-            ty::LvalueExpr => {
-                let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, &*base.expr, "base"));
-                for &(i, t) in base.fields.iter() {
-                    let datum = base_datum.get_element(
-                            t, |srcval| adt::trans_field_ptr(bcx, &*repr, srcval, discr, i));
-                    let dest = adt::trans_field_ptr(bcx, &*repr, addr, discr, i);
-                    bcx = datum.store_to(bcx, dest);
-                }
-            },
-            ty::RvalueDpsExpr | ty::RvalueDatumExpr => {
-                bcx = trans_into(bcx, &*base.expr, SaveIn(addr));
-            },
-            ty::RvalueStmtExpr => bcx.tcx().sess.bug("unexpected expr kind for struct base expr")
-        }
-    }
-
-    // Now, we just overwrite the fields we've explicity specified
     for &(i, ref e) in fields.iter() {
-        let dest = adt::trans_field_ptr(bcx, &*repr, addr, discr, i);
+        let dest = adt::trans_field_ptr(bcx, repr, addr, discr, i);
         let e_ty = expr_ty_adjusted(bcx, &**e);
         bcx = trans_into(bcx, &**e, SaveIn(dest));
         let scope = cleanup::CustomScope(custom_cleanup_scope);
         fcx.schedule_lifetime_end(scope, dest);
         fcx.schedule_drop_mem(scope, dest, e_ty);
     }
 
-    adt::trans_set_discr(bcx, &*repr, addr, discr);
+    for base in optbase.iter() {
+        // FIXME #6573: is it sound to use the destination's repr on the base?
+        // And, would it ever be reasonable to be here with discr != 0?
+        let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, &*base.expr, "base"));
+        for &(i, t) in base.fields.iter() {
+            let datum = base_datum.get_element(
+                t,
+                |srcval| adt::trans_field_ptr(bcx, repr, srcval, discr, i));
+            let dest = adt::trans_field_ptr(bcx, repr, addr, discr, i);
+            bcx = datum.store_to(bcx, dest);
+        }
+    }
+
+    adt::trans_set_discr(bcx, repr, addr, discr);
 
     fcx.pop_custom_cleanup_scope(custom_cleanup_scope);
 
-    // If we don't care about the result drop the temporary we made
-    match dest {
-        SaveIn(_) => bcx,
-        Ignore => {
-            bcx = glue::drop_ty(bcx, addr, ty);
-            base::call_lifetime_end(bcx, addr);
-            bcx
-        }
-    }
+    return bcx;
 }
 
 

branches/dist-snap/src/librustc/middle/trans/glue.rs

@@ -250,9 +250,8 @@ fn trans_struct_drop<'a>(bcx: &'a Block<'a>,
         let args = vec!(self_arg);
 
         // Add all the fields as a value which needs to be cleaned at the end of
-        // this scope. Iterate in reverse order so a Drop impl doesn't reverse
-        // the order in which fields get dropped.
-        for (i, ty) in st.fields.iter().enumerate().rev() {
+        // this scope.
+        for (i, ty) in st.fields.iter().enumerate() {
             let llfld_a = adt::struct_field_ptr(variant_cx, &*st, value, i, false);
             variant_cx.fcx.schedule_drop_mem(cleanup::CustomScope(field_scope),
                                              llfld_a, *ty);