---

yaml
---
r: 90046
b: refs/heads/master
c: 6ff697d
h: refs/heads/master
v: v3

Author: klutzy

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 720bcd81de9d5fbdb60761fc929d40e487005722
+refs/heads/master: 6ff697d3933754bf9ec5ee5875f487f02a7d087d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/src/etc/extract-tests.py

@@ -63,6 +63,7 @@
 #[ allow(unused_variable) ];\n
 #[ allow(dead_assignment) ];\n
 #[ allow(unused_mut) ];\n
+#[ allow(attribute_usage) ];\n
 #[ feature(macro_rules, globs, struct_variant, managed_boxes) ];\n
 """ + block
             if xfail:

trunk/src/librustc/middle/lint.rs

@@ -76,6 +76,7 @@ pub enum lint {
     type_overflow,
     unused_unsafe,
     unsafe_block,
+    attribute_usage,
 
     managed_heap_memory,
     owned_heap_memory,
@@ -244,6 +245,13 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: allow
     }),
 
+    ("attribute_usage",
+     LintSpec {
+        lint: attribute_usage,
+        desc: "detects bad use of attributes",
+        default: warn
+    }),
+
     ("unused_variable",
      LintSpec {
         lint: unused_variable,
@@ -790,6 +798,27 @@ fn check_heap_item(cx: &Context, it: &ast::item) {
     }
 }
 
+// check if crate-level attribute is used on item,
+// since it is usually caused by mistake of semicolon omission.
+// also make error on obsolete attributes for less confusion.
+fn check_item_attribute_usage(cx: &Context, it: &ast::item) {
+    let crate_attrs = ["crate_type", "link", "feature", "no_uv", "no_main", "no_std"];
+
+    for attr in it.attrs.iter() {
+        let name = attr.node.value.name();
+        for crate_attr in crate_attrs.iter() {
+            if name.equiv(crate_attr) {
+                let msg = match attr.node.style {
+                    ast::AttrOuter  => "crate-level attribute should be an inner attribute: \
+                                   add semicolon at end",
+                    ast::AttrInner => "crate-level attribute should be in the root module",
+                };
+                cx.span_lint(attribute_usage, attr.span, msg);
+            }
+        }
+    }
+}
+
 fn check_heap_expr(cx: &Context, e: &ast::Expr) {
     let ty = ty::expr_ty(cx.tcx, e);
     check_heap_type(cx, e.span, ty);
@@ -1110,6 +1139,7 @@ impl<'self> Visitor<()> for Context<'self> {
             check_item_non_uppercase_statics(cx, it);
             check_heap_item(cx, it);
             check_missing_doc_item(cx, it);
+            check_item_attribute_usage(cx, it);
 
             do cx.visit_ids |v| {
                 v.visit_item(it, ());

trunk/src/librustc/middle/trans/adt.rs

@@ -366,41 +366,22 @@ pub fn ty_of_inttype(ity: IntType) -> ty::t {
 
 
 /**
- * LLVM-level types are a little complicated.
- *
- * C-like enums need to be actual ints, not wrapped in a struct,
- * because that changes the ABI on some platforms (see issue #10308).
- *
- * For nominal types, in some cases, we need to use LLVM named structs
- * and fill in the actual contents in a second pass to prevent
- * unbounded recursion; see also the comments in `trans::type_of`.
+ * Returns the fields of a struct for the given representation.
+ * All nominal types are LLVM structs, in order to be able to use
+ * forward-declared opaque types to prevent circularity in `type_of`.
  */
-pub fn type_of(cx: &mut CrateContext, r: &Repr) -> Type {
-    generic_type_of(cx, r, None, false)
-}
-pub fn sizing_type_of(cx: &mut CrateContext, r: &Repr) -> Type {
-    generic_type_of(cx, r, None, true)
+pub fn fields_of(cx: &mut CrateContext, r: &Repr) -> ~[Type] {
+    generic_fields_of(cx, r, false)
 }
-pub fn incomplete_type_of(cx: &mut CrateContext, r: &Repr, name: &str) -> Type {
-    generic_type_of(cx, r, Some(name), false)
-}
-pub fn finish_type_of(cx: &mut CrateContext, r: &Repr, llty: &mut Type) {
-    match *r {
-        CEnum(*) | General(*) => { }
-        Univariant(ref st, _) | NullablePointer{ nonnull: ref st, _ } =>
-            llty.set_struct_body(struct_llfields(cx, st, false), st.packed)
-    }
+/// Like `fields_of`, but for `type_of::sizing_type_of` (q.v.).
+pub fn sizing_fields_of(cx: &mut CrateContext, r: &Repr) -> ~[Type] {
+    generic_fields_of(cx, r, true)
 }
-
-fn generic_type_of(cx: &mut CrateContext, r: &Repr, name: Option<&str>, sizing: bool) -> Type {
+fn generic_fields_of(cx: &mut CrateContext, r: &Repr, sizing: bool) -> ~[Type] {
     match *r {
-        CEnum(ity, _, _) => ll_inttype(cx, ity),
-        Univariant(ref st, _) | NullablePointer{ nonnull: ref st, _ } => {
-            match name {
-                None => Type::struct_(struct_llfields(cx, st, sizing), st.packed),
-                Some(name) => { assert_eq!(sizing, false); Type::named_struct(name) }
-            }
-        }
+        CEnum(ity, _, _) => ~[ll_inttype(cx, ity)],
+        Univariant(ref st, _dtor) => struct_llfields(cx, st, sizing),
+        NullablePointer{ nonnull: ref st, _ } => struct_llfields(cx, st, sizing),
         General(ity, ref sts) => {
             // We need a representation that has:
             // * The alignment of the most-aligned field
@@ -413,7 +394,8 @@ fn generic_type_of(cx: &mut CrateContext, r: &Repr, name: Option<&str>, sizing:
             // more of its own type, then use alignment-sized ints to get the rest
             // of the size.
             //
-            // FIXME #10604: this breaks when vector types are present.
+            // Note: if/when we start exposing SIMD vector types (or f80, on some
+            // platforms that have it), this will need some adjustment.
             let size = sts.iter().map(|st| st.size).max().unwrap();
             let most_aligned = sts.iter().max_by(|st| st.align).unwrap();
             let align = most_aligned.align;
@@ -429,17 +411,9 @@ fn generic_type_of(cx: &mut CrateContext, r: &Repr, name: Option<&str>, sizing:
             assert_eq!(machine::llalign_of_min(cx, pad_ty) as u64, align);
             let align_units = (size + align - 1) / align;
             assert_eq!(align % discr_size, 0);
-            let fields = ~[discr_ty,
+            ~[discr_ty,
               Type::array(&discr_ty, align / discr_size - 1),
-              Type::array(&pad_ty, align_units - 1)];
-            match name {
-                None => Type::struct_(fields, false),
-                Some(name) => {
-                    let mut llty = Type::named_struct(name);
-                    llty.set_struct_body(fields, false);
-                    llty
-                }
-            }
+              Type::array(&pad_ty, align_units - 1)]
         }
     }
 }
@@ -486,8 +460,7 @@ pub fn trans_get_discr(bcx: @mut Block, r: &Repr, scrutinee: ValueRef, cast_to:
             signed = ity.is_signed();
         }
         General(ity, ref cases) => {
-            let ptr = GEPi(bcx, scrutinee, [0, 0]);
-            val = load_discr(bcx, ity, ptr, 0, (cases.len() - 1) as Disr);
+            val = load_discr(bcx, ity, scrutinee, 0, (cases.len() - 1) as Disr);
             signed = ity.is_signed();
         }
         Univariant(*) => {
@@ -514,8 +487,9 @@ fn nullable_bitdiscr(bcx: @mut Block, nonnull: &Struct, nndiscr: Disr, ptrfield:
 }
 
 /// Helper for cases where the discriminant is simply loaded.
-fn load_discr(bcx: @mut Block, ity: IntType, ptr: ValueRef, min: Disr, max: Disr)
+fn load_discr(bcx: @mut Block, ity: IntType, scrutinee: ValueRef, min: Disr, max: Disr)
     -> ValueRef {
+    let ptr = GEPi(bcx, scrutinee, [0, 0]);
     let llty = ll_inttype(bcx.ccx(), ity);
     assert_eq!(val_ty(ptr), llty.ptr_to());
     let bits = machine::llbitsize_of_real(bcx.ccx(), llty);
@@ -572,7 +546,7 @@ pub fn trans_start_init(bcx: @mut Block, r: &Repr, val: ValueRef, discr: Disr) {
         CEnum(ity, min, max) => {
             assert_discr_in_range(ity, min, max, discr);
             Store(bcx, C_integral(ll_inttype(bcx.ccx(), ity), discr as u64, true),
-                  val)
+                  GEPi(bcx, val, [0, 0]))
         }
         General(ity, _) => {
             Store(bcx, C_integral(ll_inttype(bcx.ccx(), ity), discr as u64, true),

trunk/src/librustc/middle/trans/type_of.rs

@@ -147,17 +147,18 @@ pub fn sizing_type_of(cx: &mut CrateContext, t: ty::t) -> Type {
 
         ty::ty_tup(*) | ty::ty_enum(*) => {
             let repr = adt::represent_type(cx, t);
-            adt::sizing_type_of(cx, repr)
+            Type::struct_(adt::sizing_fields_of(cx, repr), false)
         }
 
-        ty::ty_struct(*) => {
+        ty::ty_struct(did, _) => {
             if ty::type_is_simd(cx.tcx, t) {
                 let et = ty::simd_type(cx.tcx, t);
                 let n = ty::simd_size(cx.tcx, t);
                 Type::vector(&type_of(cx, et), n as u64)
             } else {
                 let repr = adt::represent_type(cx, t);
-                adt::sizing_type_of(cx, repr)
+                let packed = ty::lookup_packed(cx.tcx, did);
+                Type::struct_(adt::sizing_fields_of(cx, repr), packed)
             }
         }
 
@@ -216,9 +217,8 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
         // fill it in *after* placing it into the type cache. This
         // avoids creating more than one copy of the enum when one
         // of the enum's variants refers to the enum itself.
-        let repr = adt::represent_type(cx, t);
-        let name = llvm_type_name(cx, an_enum, did, substs.tps);
-        adt::incomplete_type_of(cx, repr, name)
+
+        Type::named_struct(llvm_type_name(cx, an_enum, did, substs.tps))
       }
       ty::ty_estr(ty::vstore_box) => {
         Type::box(cx, &Type::vec(cx.sess.targ_cfg.arch, &Type::i8())).ptr_to()
@@ -287,7 +287,7 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
       ty::ty_type => cx.tydesc_type.ptr_to(),
       ty::ty_tup(*) => {
           let repr = adt::represent_type(cx, t);
-          adt::type_of(cx, repr)
+          Type::struct_(adt::fields_of(cx, repr), false)
       }
       ty::ty_opaque_closure_ptr(_) => Type::opaque_box(cx).ptr_to(),
       ty::ty_struct(did, ref substs) => {
@@ -299,9 +299,7 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
               // Only create the named struct, but don't fill it in. We fill it
               // in *after* placing it into the type cache. This prevents
               // infinite recursion with recursive struct types.
-              let repr = adt::represent_type(cx, t);
-              let name = llvm_type_name(cx, a_struct, did, substs.tps);
-              adt::incomplete_type_of(cx, repr, name)
+              Type::named_struct(llvm_type_name(cx, a_struct, did, substs.tps))
           }
       }
       ty::ty_self(*) => cx.tcx.sess.unimpl("type_of: ty_self"),
@@ -318,11 +316,19 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
 
     // If this was an enum or struct, fill in the type now.
     match ty::get(t).sty {
-        ty::ty_enum(*) | ty::ty_struct(*) if !ty::type_is_simd(cx.tcx, t) => {
-            let repr = adt::represent_type(cx, t);
-            adt::finish_type_of(cx, repr, &mut llty);
+      ty::ty_enum(*) => {
+          let repr = adt::represent_type(cx, t);
+          llty.set_struct_body(adt::fields_of(cx, repr), false);
+      }
+
+      ty::ty_struct(did, _) => {
+        if !ty::type_is_simd(cx.tcx, t) {
+          let repr = adt::represent_type(cx, t);
+          let packed = ty::lookup_packed(cx.tcx, did);
+          llty.set_struct_body(adt::fields_of(cx, repr), packed);
         }
-        _ => ()
+      }
+      _ => ()
     }
 
     return llty;