---

yaml
---
r: 210739
b: refs/heads/try
c: ba534f6
h: refs/heads/master
i:
  210737: da3ab9a
  210735: 9ff2be7
v: v3

Author: Nick Hamann

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: 12c93aa278ebbe8527b42d17065d3d5605c26bac
+refs/heads/try: ba534f63c9744cfd4786f07d568f4968147573e1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/AUTHORS.txt

@@ -736,7 +736,6 @@ Rob Hoelz <[email protected]>
 Robert Buonpastore <[email protected]>
 Robert Clipsham <[email protected]>
 Robert Gawdzik <[email protected]>
-Robert Foss <[email protected]>
 Robert Irelan <[email protected]>
 Robert Knight <[email protected]>
 Robert Millar <[email protected]>

branches/try/src/doc/reference.md

@@ -1346,8 +1346,6 @@ vtable when the trait is used as a [trait object](#trait-objects).
 Traits are implemented for specific types through separate
 [implementations](#implementations).
 
-Consider the following trait:
-
 ```
 # type Surface = i32;
 # type BoundingBox = i32;
@@ -1362,20 +1360,6 @@ This defines a trait with two methods. All values that have
 `draw` and `bounding_box` methods called, using `value.bounding_box()`
 [syntax](#method-call-expressions).
 
-Traits can include default implementations of methods, as in:
-
-```
-trait Foo {
-    fn bar(&self);
-
-    fn baz(&self) { println!("We called baz."); }
-}
-```
-
-Here the `baz` method has a default implementation, so types that implement
-`Foo` need only implement `bar`. It is also possible for implementing types
-to override a method that has a default implementation.
-
 Type parameters can be specified for a trait to make it generic. These appear
 after the trait name, using the same syntax used in [generic
 functions](#generic-functions).
@@ -1388,30 +1372,6 @@ trait Seq<T> {
 }
 ```
 
-It is also possible to define associated types for a trait. Consider the
-following example of a `Container` trait. Notice how the type is available
-for use in the method signatures:
-
-```
-trait Container {
-    type E;
-    fn empty() -> Self;
-    fn insert(&mut self, Self::E);
-}
-```
-
-In order for a type to implement this trait, it must not only provide
-implementations for every method, but it must specify the type `E`. Here's
-an implementation of `Container` for the standard library type `Vec`:
-
-```
-impl<T> Container for Vec<T> {
-    type E = T;
-    fn empty() -> Vec<T> { Vec::new() }
-    fn insert(&mut self, x: T) { self.push(x); }
-}
-```
-
 Generic functions may use traits as _bounds_ on their type parameters. This
 will have two effects: only types that have the trait may instantiate the
 parameter, and within the generic function, the methods of the trait can be
@@ -3510,21 +3470,13 @@ more of the closure traits:
 
 ### Trait objects
 
-In Rust, a type like `&SomeTrait` or `Box<SomeTrait>` is called a _trait object_.
-Each instance of a trait object includes:
-
- - a pointer to an instance of a type `T` that implements `SomeTrait`
- - a _virtual method table_, often just called a _vtable_, which contains, for
-   each method of `SomeTrait` that `T` implements, a pointer to `T`'s
-   implementation (i.e. a function pointer).
-
-The purpose of trait objects is to permit "late binding" of methods. A call to
-a method on a trait object is only resolved to a vtable entry at compile time.
-The actual implementation for each vtable entry can vary on an object-by-object
-basis.
-
-Note that for a trait object to be instantiated, the trait must be
-_object-safe_. Object safety rules are defined in [RFC 255][rfc255].
+Every trait item (see [traits](#traits)) defines a type with the same name as
+the trait. This type is called the _trait object_ of the trait. Trait objects
+permit "late binding" of methods, dispatched using _virtual method tables_
+("vtables"). Whereas most calls to trait methods are "early bound" (statically
+resolved) to specific implementations at compile time, a call to a method on an
+trait objects is only resolved to a vtable entry at compile time. The actual
+implementation for each vtable entry can vary on an object-by-object basis.
 
 Given a pointer-typed expression `E` of type `&T` or `Box<T>`, where `T`
 implements trait `R`, casting `E` to the corresponding pointer type `&R` or

branches/try/src/doc/trpl/dining-philosophers.md

@@ -450,7 +450,7 @@ which blocks execution until the thread has completed execution. This ensures
 that the threads complete their work before the program exits.
 
 If you run this program, you’ll see that the philosophers eat out of order!
-We have multi-threading!
+We have mult-threading!
 
 ```text
 Gilles Deleuze is eating.

branches/try/src/librustc/middle/infer/freshen.rs

@@ -129,12 +129,11 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
                                                       .probe(v)
                                                       .map(|v| v.to_type(tcx)),
                     ty::FloatVar(v),
-                    ty::FreshFloatTy)
+                    ty::FreshIntTy)
             }
 
             ty::ty_infer(ty::FreshTy(c)) |
-            ty::ty_infer(ty::FreshIntTy(c)) |
-            ty::ty_infer(ty::FreshFloatTy(c)) => {
+            ty::ty_infer(ty::FreshIntTy(c)) => {
                 if c >= self.freshen_count {
                     tcx.sess.bug(
                         &format!("Encountered a freshend type with id {} \

branches/try/src/librustc/middle/traits/select.rs

@@ -1773,8 +1773,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             ty::ty_err => ok_if(Vec::new()),
 
             ty::ty_infer(ty::FreshTy(_))
-            | ty::ty_infer(ty::FreshIntTy(_))
-            | ty::ty_infer(ty::FreshFloatTy(_)) => {
+            | ty::ty_infer(ty::FreshIntTy(_)) => {
                 self.tcx().sess.bug(
                     &format!(
                         "asked to assemble builtin bounds of unexpected type: {}",
@@ -1836,8 +1835,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             ty::ty_projection(..) |
             ty::ty_infer(ty::TyVar(_)) |
             ty::ty_infer(ty::FreshTy(_)) |
-            ty::ty_infer(ty::FreshIntTy(_)) |
-            ty::ty_infer(ty::FreshFloatTy(_)) => {
+            ty::ty_infer(ty::FreshIntTy(_)) => {
                 self.tcx().sess.bug(
                     &format!(
                         "asked to assemble constituent types of unexpected type: {}",

branches/try/src/librustc/middle/ty.rs

@@ -1697,8 +1697,11 @@ pub enum InferTy {
     /// unbound type variable. This is convenient for caching etc. See
     /// `middle::infer::freshen` for more details.
     FreshTy(u32),
+
+    // FIXME -- once integral fallback is impl'd, we should remove
+    // this type. It's only needed to prevent spurious errors for
+    // integers whose type winds up never being constrained.
     FreshIntTy(u32),
-    FreshFloatTy(u32)
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]
@@ -1770,7 +1773,6 @@ impl fmt::Debug for InferTy {
             FloatVar(ref v) => v.fmt(f),
             FreshTy(v) => write!(f, "FreshTy({:?})", v),
             FreshIntTy(v) => write!(f, "FreshIntTy({:?})", v),
-            FreshFloatTy(v) => write!(f, "FreshFloatTy({:?})", v)
         }
     }
 }
@@ -3773,7 +3775,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
             }
 
             // Scalar and unique types are sendable, and durable
-            ty_infer(ty::FreshIntTy(_)) | ty_infer(ty::FreshFloatTy(_)) |
+            ty_infer(ty::FreshIntTy(_)) |
             ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
             ty_bare_fn(..) | ty::ty_char => {
                 TC::None
@@ -4323,7 +4325,6 @@ pub fn type_is_fresh(ty: Ty) -> bool {
     match ty.sty {
       ty_infer(FreshTy(_)) => true,
       ty_infer(FreshIntTy(_)) => true,
-      ty_infer(FreshFloatTy(_)) => true,
       _ => false
     }
 }
@@ -5025,7 +5026,6 @@ pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String {
         ty_infer(FloatVar(_)) => "floating-point variable".to_string(),
         ty_infer(FreshTy(_)) => "skolemized type".to_string(),
         ty_infer(FreshIntTy(_)) => "skolemized integral type".to_string(),
-        ty_infer(FreshFloatTy(_)) => "skolemized floating-point type".to_string(),
         ty_projection(_) => "associated type".to_string(),
         ty_param(ref p) => {
             if p.space == subst::SelfSpace {

branches/try/src/librustc/middle/ty_match.rs

@@ -67,8 +67,7 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Match<'a, 'tcx> {
 
         match (&a.sty, &b.sty) {
             (_, &ty::ty_infer(ty::FreshTy(_))) |
-            (_, &ty::ty_infer(ty::FreshIntTy(_))) |
-            (_, &ty::ty_infer(ty::FreshFloatTy(_))) => {
+            (_, &ty::ty_infer(ty::FreshIntTy(_))) => {
                 Ok(a)
             }
 

branches/try/src/librustc/plugin/registry.rs

@@ -14,8 +14,8 @@ use lint::{LintPassObject, LintId, Lint};
 use session::Session;
 
 use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT};
-use syntax::ext::base::{IdentTT, Decorator, Modifier, MultiModifier, MultiDecorator};
-use syntax::ext::base::{MacroExpanderFn, MacroRulesTT};
+use syntax::ext::base::{IdentTT, Decorator, Modifier, MultiModifier, MacroRulesTT};
+use syntax::ext::base::MacroExpanderFn;
 use syntax::codemap::Span;
 use syntax::parse::token;
 use syntax::ptr::P;
@@ -84,7 +84,6 @@ impl<'a> Registry<'a> {
     /// Register a syntax extension of any kind.
     ///
     /// This is the most general hook into `libsyntax`'s expansion behavior.
-    #[allow(deprecated)]
     pub fn register_syntax_extension(&mut self, name: ast::Name, extension: SyntaxExtension) {
         self.syntax_exts.push((name, match extension {
             NormalTT(ext, _, allow_internal_unstable) => {
@@ -94,7 +93,6 @@ impl<'a> Registry<'a> {
                 IdentTT(ext, Some(self.krate_span), allow_internal_unstable)
             }
             Decorator(ext) => Decorator(ext),
-            MultiDecorator(ext) => MultiDecorator(ext),
             Modifier(ext) => Modifier(ext),
             MultiModifier(ext) => MultiModifier(ext),
             MacroRulesTT => {

branches/try/src/librustc/util/ppaux.rs

@@ -349,8 +349,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
             ty::FloatVar(ref vid) if print_var_ids => vid.repr(cx),
             ty::TyVar(_) | ty::IntVar(_) | ty::FloatVar(_) => format!("_"),
             ty::FreshTy(v) => format!("FreshTy({})", v),
-            ty::FreshIntTy(v) => format!("FreshIntTy({})", v),
-            ty::FreshFloatTy(v) => format!("FreshFloatTy({})", v)
+            ty::FreshIntTy(v) => format!("FreshIntTy({})", v)
         }
     }
 

branches/try/src/librustc_trans/save/mod.rs

@@ -520,12 +520,12 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         let qualname = format!("::{}", self.analysis.ty_cx.map.path_to_string(item.id));
 
         // If the variable is immutable, save the initialising expression.
-        let (value, keyword) = match mt {
-            ast::MutMutable => (String::from_str("<mutable>"), keywords::Mut),
-            ast::MutImmutable => (self.span.snippet(expr.span), keywords::Static),
+        let value = match mt {
+            ast::MutMutable => String::from_str("<mutable>"),
+            ast::MutImmutable => self.span.snippet(expr.span),
         };
 
-        let sub_span = self.span.sub_span_after_keyword(item.span, keyword);
+        let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Static);
         self.fmt.static_str(item.span,
                             sub_span,
                             item.id,