---

yaml
---
r: 81922
b: refs/heads/master
c: daee1b4
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

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

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

@@ -25,6 +25,7 @@ use syntax::ast;
 use syntax::ast::Name;
 use syntax::ast_util;
 use syntax::codemap::Span;
+use syntax::visit::Visitor;
 
 pub fn trans_block(bcx: @mut Block, b: &ast::Block, dest: expr::Dest) -> @mut Block {
     let _icx = push_ctxt("trans_block");
@@ -64,12 +65,22 @@ pub fn trans_if(bcx: @mut Block,
     // Drop branches that are known to be impossible
     if is_const(cond_val) && !is_undef(cond_val) {
         if const_to_uint(cond_val) == 1 {
+            match els {
+                Some(elexpr) => {
+                    let mut trans = TransItemVisitor { ccx: bcx.fcx.ccx };
+                    trans.visit_expr(elexpr, ());
+                }
+                None => {}
+            }
             // if true { .. } [else { .. }]
             return do with_scope(bcx, thn.info(), "if_true_then") |bcx| {
                 let bcx_out = trans_block(bcx, thn, dest);
                 trans_block_cleanups(bcx_out, block_cleanups(bcx))
             }
         } else {
+            let mut trans = TransItemVisitor { ccx: bcx.fcx.ccx } ;
+            trans.visit_block(thn, ());
+
             match els {
                 // if false { .. } else { .. }
                 Some(elexpr) => {

trunk/src/librustdoc/clean.rs

@@ -16,7 +16,6 @@ use its = syntax::parse::token::ident_to_str;
 use syntax;
 use syntax::ast;
 use syntax::ast_util;
-use syntax::attr;
 use syntax::attr::AttributeMethods;
 
 use std;
@@ -150,8 +149,6 @@ pub enum ItemEnum {
     MethodItem(Method),
     StructFieldItem(StructField),
     VariantItem(Variant),
-    ForeignFunctionItem(Function),
-    ForeignStaticItem(Static),
 }
 
 #[deriving(Clone, Encodable, Decodable)]
@@ -175,7 +172,6 @@ impl Clean<Item> for doctree::Module {
             inner: ModuleItem(Module {
                items: std::vec::concat(&[self.structs.clean(),
                               self.enums.clean(), self.fns.clean(),
-                              std::vec::concat(self.foreigns.clean()),
                               self.mods.clean(), self.typedefs.clean(),
                               self.statics.clean(), self.traits.clean(),
                               self.impls.clean(), self.view_items.clean()])
@@ -207,25 +203,6 @@ impl Clean<Attribute> for ast::Attribute {
     }
 }
 
-// This is a rough approximation that gets us what we want.
-impl<'self> attr::AttrMetaMethods for &'self Attribute {
-    fn name(&self) -> @str {
-        match **self {
-            Word(ref n) | List(ref n, _) | NameValue(ref n, _) =>
-                n.to_managed()
-        }
-    }
-
-    fn value_str(&self) -> Option<@str> {
-        match **self {
-            NameValue(_, ref v) => Some(v.to_managed()),
-            _ => None,
-        }
-    }
-    fn meta_item_list<'a>(&'a self) -> Option<&'a [@ast::MetaItem]> { None }
-    fn name_str_pair(&self) -> Option<(@str, @str)> { None }
-}
-
 #[deriving(Clone, Encodable, Decodable)]
 pub struct TyParam {
     name: ~str,
@@ -991,41 +968,6 @@ impl Clean<ViewListIdent> for ast::path_list_ident {
     }
 }
 
-impl Clean<~[Item]> for ast::foreign_mod {
-    fn clean(&self) -> ~[Item] {
-        self.items.clean()
-    }
-}
-
-impl Clean<Item> for ast::foreign_item {
-    fn clean(&self) -> Item {
-        let inner = match self.node {
-            ast::foreign_item_fn(ref decl, ref generics) => {
-                ForeignFunctionItem(Function {
-                    decl: decl.clean(),
-                    generics: generics.clean(),
-                    purity: ast::extern_fn,
-                })
-            }
-            ast::foreign_item_static(ref ty, mutbl) => {
-                ForeignStaticItem(Static {
-                    type_: ty.clean(),
-                    mutability: if mutbl {Mutable} else {Immutable},
-                    expr: ~"",
-                })
-            }
-        };
-        Item {
-            name: Some(self.ident.clean()),
-            attrs: self.attrs.clean(),
-            source: self.span.clean(),
-            id: self.id,
-            visibility: self.vis.clean(),
-            inner: inner,
-        }
-    }
-}
-
 // Utilities
 
 trait ToSource {

trunk/src/librustdoc/doctree.rs

@@ -30,7 +30,6 @@ pub struct Module {
     traits: ~[Trait],
     vis: ast::visibility,
     impls: ~[Impl],
-    foreigns: ~[ast::foreign_mod],
     view_items: ~[ast::view_item],
 }
 
@@ -51,7 +50,6 @@ impl Module {
             traits     : ~[],
             impls      : ~[],
             view_items : ~[],
-            foreigns   : ~[],
         }
     }
 }

trunk/src/librustdoc/html/render.rs

@@ -28,7 +28,6 @@ use extra::json::ToJson;
 use extra::sort;
 
 use syntax::ast;
-use syntax::attr;
 
 use clean;
 use doctree;
@@ -522,14 +521,6 @@ impl Context {
                             }
                         }
                     }
-                    clean::StructItem(s) => {
-                        let mut it = s.fields.move_iter();
-                        do self.recurse(name) |this| {
-                            for item in it {
-                                f(this, item);
-                            }
-                        }
-                    }
                     _ => {}
                 }
             }
@@ -541,21 +532,19 @@ impl Context {
 
 fn shortty(item: &clean::Item) -> &'static str {
     match item.inner {
-        clean::ModuleItem(*)          => "mod",
-        clean::StructItem(*)          => "struct",
-        clean::EnumItem(*)            => "enum",
-        clean::FunctionItem(*)        => "fn",
-        clean::TypedefItem(*)         => "typedef",
-        clean::StaticItem(*)          => "static",
-        clean::TraitItem(*)           => "trait",
-        clean::ImplItem(*)            => "impl",
-        clean::ViewItemItem(*)        => "viewitem",
-        clean::TyMethodItem(*)        => "tymethod",
-        clean::MethodItem(*)          => "method",
-        clean::StructFieldItem(*)     => "structfield",
-        clean::VariantItem(*)         => "variant",
-        clean::ForeignFunctionItem(*) => "ffi",
-        clean::ForeignStaticItem(*)   => "ffs",
+        clean::ModuleItem(*)      => "mod",
+        clean::StructItem(*)      => "struct",
+        clean::EnumItem(*)        => "enum",
+        clean::FunctionItem(*)    => "fn",
+        clean::TypedefItem(*)     => "typedef",
+        clean::StaticItem(*)      => "static",
+        clean::TraitItem(*)       => "trait",
+        clean::ImplItem(*)        => "impl",
+        clean::ViewItemItem(*)    => "viewitem",
+        clean::TyMethodItem(*)    => "tymethod",
+        clean::MethodItem(*)      => "method",
+        clean::StructFieldItem(*) => "structfield",
+        clean::VariantItem(*)     => "variant",
     }
 }
 
@@ -569,18 +558,6 @@ impl<'self> Item<'self> {
 
 impl<'self> fmt::Default for Item<'self> {
     fn fmt(it: &Item<'self>, fmt: &mut fmt::Formatter) {
-        match attr::find_stability(it.item.attrs.iter()) {
-            Some(stability) => {
-                write!(fmt.buf,
-                       "<a class='stability {lvl}' title='{reason}'>{lvl}</a>",
-                       lvl = stability.level.to_str(),
-                       reason = match stability.text {
-                           Some(s) => s, None => @"",
-                       });
-            }
-            None => {}
-        }
-
         // Write the breadcrumb trail header for the top
         write!(fmt.buf, "<h1 class='fqn'>");
         match it.item.inner {
@@ -607,15 +584,12 @@ impl<'self> fmt::Default for Item<'self> {
         match it.item.inner {
             clean::ModuleItem(ref m) => item_module(fmt.buf, it.cx,
                                                     it.item, m.items),
-            clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) =>
-                item_function(fmt.buf, it.item, f),
+            clean::FunctionItem(ref f) => item_function(fmt.buf, it.item, f),
             clean::TraitItem(ref t) => item_trait(fmt.buf, it.item, t),
             clean::StructItem(ref s) => item_struct(fmt.buf, it.item, s),
             clean::EnumItem(ref e) => item_enum(fmt.buf, it.item, e),
             clean::TypedefItem(ref t) => item_typedef(fmt.buf, it.item, t),
             clean::VariantItem(*) => item_variant(fmt.buf, it.cx, it.item),
-            clean::StructFieldItem(*) => item_struct_field(fmt.buf, it.cx,
-                                                           it.item),
             _ => {}
         }
     }
@@ -689,10 +663,6 @@ fn item_module(w: &mut io::Writer, cx: &Context,
             (_, &clean::EnumItem(*)) => false,
             (&clean::StaticItem(*), _) => true,
             (_, &clean::StaticItem(*)) => false,
-            (&clean::ForeignFunctionItem(*), _) => true,
-            (_, &clean::ForeignFunctionItem(*)) => false,
-            (&clean::ForeignStaticItem(*), _) => true,
-            (_, &clean::ForeignStaticItem(*)) => false,
             (&clean::TraitItem(*), _) => true,
             (_, &clean::TraitItem(*)) => false,
             (&clean::FunctionItem(*), _) => true,
@@ -720,31 +690,27 @@ fn item_module(w: &mut io::Writer, cx: &Context,
             }
             curty = myty;
             write!(w, "<h2>{}</h2>\n<table>", match myitem.inner {
-                clean::ModuleItem(*)          => "Modules",
-                clean::StructItem(*)          => "Structs",
-                clean::EnumItem(*)            => "Enums",
-                clean::FunctionItem(*)        => "Functions",
-                clean::TypedefItem(*)         => "Type Definitions",
-                clean::StaticItem(*)          => "Statics",
-                clean::TraitItem(*)           => "Traits",
-                clean::ImplItem(*)            => "Implementations",
-                clean::ViewItemItem(*)        => "Reexports",
-                clean::TyMethodItem(*)        => "Type Methods",
-                clean::MethodItem(*)          => "Methods",
-                clean::StructFieldItem(*)     => "Struct Fields",
-                clean::VariantItem(*)         => "Variants",
-                clean::ForeignFunctionItem(*) => "Foreign Functions",
-                clean::ForeignStaticItem(*)   => "Foreign Statics",
+                clean::ModuleItem(*)      => "Modules",
+                clean::StructItem(*)      => "Structs",
+                clean::EnumItem(*)        => "Enums",
+                clean::FunctionItem(*)    => "Functions",
+                clean::TypedefItem(*)     => "Type Definitions",
+                clean::StaticItem(*)      => "Statics",
+                clean::TraitItem(*)       => "Traits",
+                clean::ImplItem(*)        => "Implementations",
+                clean::ViewItemItem(*)    => "Reexports",
+                clean::TyMethodItem(*)    => "Type Methods",
+                clean::MethodItem(*)      => "Methods",
+                clean::StructFieldItem(*) => "Struct Fields",
+                clean::VariantItem(*)     => "Variants",
             });
         }
 
         match myitem.inner {
-            clean::StaticItem(ref s) | clean::ForeignStaticItem(ref s) => {
+            clean::StaticItem(ref s) => {
                 struct Initializer<'self>(&'self str);
                 impl<'self> fmt::Default for Initializer<'self> {
                     fn fmt(s: &Initializer<'self>, f: &mut fmt::Formatter) {
-                        if s.len() == 0 { return; }
-                        write!(f.buf, "<code> = </code>");
                         let tag = if s.contains("\n") { "pre" } else { "code" };
                         write!(f.buf, "<{tag}>{}</{tag}>",
                                s.as_slice(), tag=tag);
@@ -753,7 +719,7 @@ fn item_module(w: &mut io::Writer, cx: &Context,
 
                 write!(w, "
                     <tr>
-                        <td><code>{}static {}: {}</code>{}</td>
+                        <td><code>{}static {}: {} = </code>{}</td>
                         <td class='docblock'>{}&nbsp;</td>
                     </tr>
                 ",
@@ -1014,12 +980,11 @@ fn render_struct(w: &mut io::Writer, it: &clean::Item,
             for field in fields.iter() {
                 match field.inner {
                     clean::StructFieldItem(ref ty) => {
-                        write!(w, "    {}<a name='field.{name}'>{name}</a>: \
-                                   {},\n{}",
+                        write!(w, "    {}{}: {},\n{}",
                                VisSpace(field.visibility),
+                               field.name.get_ref().as_slice(),
                                ty.type_,
-                               tab,
-                               name = field.name.get_ref().as_slice());
+                               tab);
                     }
                     _ => unreachable!()
                 }
@@ -1205,12 +1170,3 @@ fn item_variant(w: &mut io::Writer, cx: &Context, it: &clean::Item) {
            *cx.current.last(),
            it.name.get_ref().as_slice());
 }
-
-fn item_struct_field(w: &mut io::Writer, cx: &Context, it: &clean::Item) {
-    write!(w, "<DOCTYPE html><html><head>\
-                <meta http-equiv='refresh' content='0; \
-                      url=../struct.{}.html\\#field.{}'>\
-               </head><body></body></html>",
-           *cx.current.last(),
-           it.name.get_ref().as_slice());
-}

trunk/src/librustdoc/html/static/main.css

@@ -269,18 +269,3 @@ a {
     float: left;
     padding: 20px;
 }
-
-.stability {
-    border-left: 5px solid #000;
-    border-radius: 3px;
-    padding: 0 3px;
-    float: right;
-    background: #fff;
-    text-transform: lowercase;
-}
-.stability.Deprecated { border-color: #D60027; color: #880017; }
-.stability.Experimental { border-color: #EC5315; color: #a53c0e; }
-.stability.Unstable { border-color: #FFD700; color: #b39800; }
-.stability.Stable { border-color: #AEC516; color: #7c8b10; }
-.stability.Frozen { border-color: #009431; color: #007726; }
-.stability.Locked { border-color: #0084B6; color: #00668c; }