---

yaml
---
r: 82119
b: refs/heads/master
c: fbd5639
h: refs/heads/master
i:
  82117: 6e347b8
  82115: 515d700
  82111: c5911d8
v: v3

Author: sanxiyn

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ff30566954514b2c3bae3b8d428670abbca05f5e
+refs/heads/master: fbd56396bc35aa65cf0a449d5073086aad2e61b9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/src/libextra/extra.rs

@@ -26,8 +26,7 @@ Rust extras are part of the standard Rust distribution.
        url = "https://github.com/mozilla/rust/tree/master/src/libextra")];
 
 #[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
-      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
-      html_root_url = "http://static.rust-lang.org/doc/master")];
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico")];
 
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];

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

@@ -69,11 +69,12 @@ pub fn type_is_immediate(ccx: &mut CrateContext, ty: ty::t) -> bool {
     if simple {
         return true;
     }
+    // FIXME: #9651: C-like enums should also be immediate
+    if ty::type_is_c_like_enum(ccx.tcx, ty) {
+        return false;
+    }
     match ty::get(ty).sty {
         // FIXME: #9651: small `ty_struct` should also be immediate
-        ty::ty_struct(def_id, ref substs) => {
-            ty::struct_fields(tcx, def_id, substs).is_empty()
-        }
         ty::ty_enum(*) | ty::ty_tup(*) => {
             let llty = sizing_type_of(ccx, ty);
             llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type)

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

@@ -1727,9 +1727,7 @@ fn trans_imm_cast(bcx: @mut Block, expr: &ast::Expr,
             (cast_enum, cast_float) => {
                 let bcx = bcx;
                 let repr = adt::represent_type(ccx, t_in);
-                let slot = Alloca(bcx, ll_t_in, "");
-                Store(bcx, llexpr, slot);
-                let lldiscrim_a = adt::trans_get_discr(bcx, repr, slot);
+                let lldiscrim_a = adt::trans_get_discr(bcx, repr, llexpr);
                 match k_out {
                     cast_integral => int_cast(bcx, ll_t_out,
                                               val_ty(lldiscrim_a),

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

@@ -222,7 +222,7 @@ pub fn trans_native_call(bcx: @mut Block,
         // Ensure that we always have the Rust value indirectly,
         // because it makes bitcasting easier.
         if !rust_indirect {
-            let scratch = base::alloca(bcx, type_of::type_of(ccx, fn_sig.inputs[i]), "__arg");
+            let scratch = base::alloca(bcx, arg_tys[i].ty, "__arg");
             Store(bcx, llarg_rust, scratch);
             llarg_rust = scratch;
         }

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

@@ -12,7 +12,7 @@
 
 use back::{abi};
 use lib::llvm::{SequentiallyConsistent, Acquire, Release, Xchg};
-use lib::llvm::{ValueRef, Pointer, Array, Struct};
+use lib::llvm::{ValueRef, Pointer};
 use lib;
 use middle::trans::base::*;
 use middle::trans::build::*;
@@ -333,12 +333,8 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
                             (Pointer, other) | (other, Pointer) if other != Pointer => {
                                 let tmp = Alloca(bcx, llouttype, "");
                                 Store(bcx, llsrcval, PointerCast(bcx, tmp, llintype.ptr_to()));
-                                Ret(bcx, Load(bcx, tmp));
-                            }
-                            (Array, _) | (_, Array) | (Struct, _) | (_, Struct) => {
-                                let tmp = Alloca(bcx, llouttype, "");
-                                Store(bcx, llsrcval, PointerCast(bcx, tmp, llintype.ptr_to()));
-                                Ret(bcx, Load(bcx, tmp));
+                                let ll_load = Load(bcx, tmp);
+                                Ret(bcx, ll_load);
                             }
                             _ => {
                                 let llbitcast = BitCast(bcx, llsrcval, llouttype);

trunk/src/librustc/middle/typeck/check/method.rs

@@ -1288,7 +1288,13 @@ impl<'self> LookupContext<'self> {
     fn report_candidate(&self, idx: uint, origin: &method_origin) {
         match *origin {
             method_static(impl_did) => {
-                self.report_static_candidate(idx, impl_did)
+                // If it is an instantiated default method, use the original
+                // default method for error reporting.
+                let did = match provided_source(self.tcx(), impl_did) {
+                    None => impl_did,
+                    Some(did) => did
+                };
+                self.report_static_candidate(idx, did)
             }
             method_param(ref mp) => {
                 self.report_param_candidate(idx, (*mp).trait_id)
@@ -1302,7 +1308,8 @@ impl<'self> LookupContext<'self> {
     fn report_static_candidate(&self, idx: uint, did: DefId) {
         let span = if did.crate == ast::LOCAL_CRATE {
             match self.tcx().items.find(&did.node) {
-              Some(&ast_map::node_method(m, _, _)) => m.span,
+              Some(&ast_map::node_method(m, _, _))
+              | Some(&ast_map::node_trait_method(@ast::provided(m), _, _)) => m.span,
               _ => fail2!("report_static_candidate: bad item {:?}", did)
             }
         } else {

trunk/src/librustdoc/clean.rs

@@ -15,18 +15,11 @@ use its = syntax::parse::token::ident_to_str;
 
 use syntax;
 use syntax::ast;
-use syntax::ast_map;
 use syntax::ast_util;
 use syntax::attr;
 use syntax::attr::AttributeMethods;
 
-use rustc::metadata::cstore;
-use rustc::metadata::csearch;
-use rustc::metadata::decoder;
-
 use std;
-use std::hashmap::HashMap;
-
 use doctree;
 use visit_ast;
 use std::local_data;
@@ -68,44 +61,19 @@ impl<T: Clean<U>, U> Clean<~[U]> for syntax::opt_vec::OptVec<T> {
 pub struct Crate {
     name: ~str,
     module: Option<Item>,
-    externs: HashMap<ast::CrateNum, ExternalCrate>,
 }
 
 impl Clean<Crate> for visit_ast::RustdocVisitor {
     fn clean(&self) -> Crate {
         use syntax::attr::{find_linkage_metas, last_meta_item_value_str_by_name};
-        let maybe_meta = last_meta_item_value_str_by_name(
-                                find_linkage_metas(self.attrs), "name");
-        let cx = local_data::get(super::ctxtkey, |x| *x.unwrap());
-
-        let mut externs = HashMap::new();
-        do cstore::iter_crate_data(cx.sess.cstore) |n, meta| {
-            externs.insert(n, meta.clean());
-        }
+        let maybe_meta = last_meta_item_value_str_by_name(find_linkage_metas(self.attrs), "name");
 
         Crate {
             name: match maybe_meta {
                 Some(x) => x.to_owned(),
-                None => fail2!("rustdoc requires a \\#[link(name=\"foo\")] \
-                                crate attribute"),
+                None => fail2!("rustdoc_ng requires a \\#[link(name=\"foo\")] crate attribute"),
             },
             module: Some(self.module.clean()),
-            externs: externs,
-        }
-    }
-}
-
-#[deriving(Clone, Encodable, Decodable)]
-pub struct ExternalCrate {
-    name: ~str,
-    attrs: ~[Attribute],
-}
-
-impl Clean<ExternalCrate> for cstore::crate_metadata {
-    fn clean(&self) -> ExternalCrate {
-        ExternalCrate {
-            name: self.name.to_owned(),
-            attrs: decoder::get_crate_attributes(self.data).clean()
         }
     }
 }
@@ -574,15 +542,7 @@ pub enum Type {
     ResolvedPath {
         path: Path,
         typarams: Option<~[TyParamBound]>,
-        id: ast::NodeId,
-    },
-    /// Same as above, but only external variants
-    ExternalPath {
-        path: Path,
-        typarams: Option<~[TyParamBound]>,
-        fqn: ~[~str],
-        kind: TypeKind,
-        crate: ast::CrateNum,
+        did: ast::DefId
     },
     // I have no idea how to usefully use this.
     TyParamBinder(ast::NodeId),
@@ -612,14 +572,6 @@ pub enum Type {
     // region, raw, other boxes, mutable
 }
 
-#[deriving(Clone, Encodable, Decodable)]
-pub enum TypeKind {
-    TypeStruct,
-    TypeEnum,
-    TypeTrait,
-    TypeFunction,
-}
-
 impl Clean<Type> for ast::Ty {
     fn clean(&self) -> Type {
         use syntax::ast::*;
@@ -1147,12 +1099,26 @@ fn name_from_pat(p: &ast::Pat) -> ~str {
     }
 }
 
+fn remove_comment_tags(s: &str) -> ~str {
+    if s.starts_with("/") {
+        match s.slice(0,3) {
+            &"///" => return s.slice(3, s.len()).trim().to_owned(),
+            &"/**" | &"/*!" => return s.slice(3, s.len() - 2).trim().to_owned(),
+            _ => return s.trim().to_owned()
+        }
+    } else {
+        return s.to_owned();
+    }
+}
+
 /// Given a Type, resolve it using the def_map
 fn resolve_type(path: Path, tpbs: Option<~[TyParamBound]>,
                 id: ast::NodeId) -> Type {
-    let cx = local_data::get(super::ctxtkey, |x| *x.unwrap());
+    use syntax::ast::*;
+
+    let dm = local_data::get(super::ctxtkey, |x| *x.unwrap()).tycx.def_map;
     debug2!("searching for {:?} in defmap", id);
-    let d = match cx.tycx.def_map.find(&id) {
+    let d = match dm.find(&id) {
         Some(k) => k,
         None => {
             let ctxt = local_data::get(super::ctxtkey, |x| *x.unwrap());
@@ -1162,41 +1128,28 @@ fn resolve_type(path: Path, tpbs: Option<~[TyParamBound]>,
         }
     };
 
-    let (def_id, kind) = match *d {
-        ast::DefFn(i, _) => (i, TypeFunction),
-        ast::DefSelf(i) | ast::DefSelfTy(i) => return Self(i),
-        ast::DefTy(i) => (i, TypeEnum),
-        ast::DefTrait(i) => {
+    let def_id = match *d {
+        DefFn(i, _) => i,
+        DefSelf(i) | DefSelfTy(i) => return Self(i),
+        DefTy(i) => i,
+        DefTrait(i) => {
             debug2!("saw DefTrait in def_to_id");
-            (i, TypeTrait)
+            i
         },
-        ast::DefPrimTy(p) => match p {
-            ast::ty_str => return String,
-            ast::ty_bool => return Bool,
+        DefPrimTy(p) => match p {
+            ty_str => return String,
+            ty_bool => return Bool,
             _ => return Primitive(p)
         },
-        ast::DefTyParam(i, _) => return Generic(i.node),
-        ast::DefStruct(i) => (i, TypeStruct),
-        ast::DefTyParamBinder(i) => {
+        DefTyParam(i, _) => return Generic(i.node),
+        DefStruct(i) => i,
+        DefTyParamBinder(i) => {
             debug2!("found a typaram_binder, what is it? {}", i);
             return TyParamBinder(i);
         },
         x => fail2!("resolved type maps to a weird def {:?}", x),
     };
-    if ast_util::is_local(def_id) {
-        ResolvedPath{ path: path, typarams: tpbs, id: def_id.node }
-    } else {
-        let fqn = csearch::get_item_path(cx.tycx, def_id);
-        let fqn = fqn.move_iter().map(|i| {
-            match i {
-                ast_map::path_mod(id) |
-                ast_map::path_name(id) |
-                ast_map::path_pretty_name(id, _) => id.clean()
-            }
-        }).to_owned_vec();
-        ExternalPath{ path: path, typarams: tpbs, fqn: fqn, kind: kind,
-                      crate: def_id.crate }
-    }
+    ResolvedPath{ path: path, typarams: tpbs, did: def_id }
 }
 
 fn resolve_use_source(path: Path, id: ast::NodeId) -> ImportSource {