---

yaml
---
r: 234781
b: refs/heads/tmp
c: 5f66c70
h: refs/heads/master
i:
  234779: 5e0ca78
v: v3

Author: Manishearth

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: d2e13e822a73e0ea46ae9e21afdd3155fc997f6d
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: f859507de8c410b648d934d8f5ec1c52daac971d
+refs/heads/tmp: 5f66c701b108bfaa65cfff175074afa008e98294
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: ab792abf1fcc28afbd315426213f6428da25c085
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/src/doc/complement-project-faq.md

@@ -22,7 +22,7 @@ Existing languages at this level of abstraction and efficiency are unsatisfactor
 
 # Is any part of this thing production-ready?
 
-Yes!
+No. Feel free to play around, but don't expect completeness or stability yet. Expect incompleteness and breakage.
 
 # Is this a completely Mozilla-planned and orchestrated thing?
 

branches/tmp/src/doc/trpl/error-handling.md

@@ -154,7 +154,7 @@ fn find(haystack: &str, needle: char) -> Option<usize> {
 }
 ```
 
-Notice that when this function finds a matching character, it doesn't just
+Notice that when this function finds a matching character, it doen't just
 return the `offset`. Instead, it returns `Some(offset)`. `Some` is a variant or
 a *value constructor* for the `Option` type. You can think of it as a function
 with the type `fn<T>(value: T) -> Option<T>`. Correspondingly, `None` is also a
@@ -840,7 +840,7 @@ example, the very last call to `map` multiplies the `Ok(...)` value (which is
 an `i32`) by `2`. If an error had occurred before that point, this operation
 would have been skipped because of how `map` is defined.
 
-`map_err` is the trick that makes all of this work. `map_err` is just like
+`map_err` is the trick the makes all of this work. `map_err` is just like
 `map`, except it applies a function to the `Err(...)` value of a `Result`. In
 this case, we want to convert all of our errors to one type: `String`. Since
 both `io::Error` and `num::ParseIntError` implement `ToString`, we can call the

branches/tmp/src/libcore/ptr.rs

@@ -385,6 +385,13 @@ fnptr_impls_args! { A, B }
 fnptr_impls_args! { A, B, C }
 fnptr_impls_args! { A, B, C, D }
 fnptr_impls_args! { A, B, C, D, E }
+fnptr_impls_args! { A, B, C, D, E, F }
+fnptr_impls_args! { A, B, C, D, E, F, G }
+fnptr_impls_args! { A, B, C, D, E, F, G, H }
+fnptr_impls_args! { A, B, C, D, E, F, G, H, I }
+fnptr_impls_args! { A, B, C, D, E, F, G, H, I, J }
+fnptr_impls_args! { A, B, C, D, E, F, G, H, I, J, K }
+fnptr_impls_args! { A, B, C, D, E, F, G, H, I, J, K, L }
 
 // Comparison for pointers
 #[stable(feature = "rust1", since = "1.0.0")]

branches/tmp/src/librustc_typeck/check/mod.rs

@@ -1308,9 +1308,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         match self.inh.locals.borrow().get(&nid) {
             Some(&t) => t,
             None => {
-                span_err!(self.tcx().sess, span, E0513,
-                          "no type for local variable {}",
-                          nid);
+                self.tcx().sess.span_err(
+                    span,
+                    &format!("no type for local variable {}", nid));
                 self.tcx().types.err
             }
         }

branches/tmp/src/librustc_typeck/diagnostics.rs

@@ -3354,6 +3354,5 @@ register_diagnostics! {
            // type because its default value `{}` references the type `Self`"
     E0399, // trait items need to be implemented because the associated
            // type `{}` was overridden
-    E0436, // functional record update requires a struct
-    E0513, // no type for local variable ..
+    E0436,  // functional record update requires a struct
 }

branches/tmp/src/libsyntax/ast.rs

@@ -28,6 +28,7 @@ pub use self::Item_::*;
 pub use self::KleeneOp::*;
 pub use self::Lit_::*;
 pub use self::LitIntType::*;
+pub use self::Mac_::*;
 pub use self::MacStmtStyle::*;
 pub use self::MetaItem_::*;
 pub use self::Mutability::*;
@@ -1131,13 +1132,12 @@ pub type Mac = Spanned<Mac_>;
 /// is being invoked, and the vector of token-trees contains the source
 /// of the macro invocation.
 ///
-/// NB: the additional ident for a macro_rules-style macro is actually
-/// stored in the enclosing item. Oog.
+/// There's only one flavor, now, so this could presumably be simplified.
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub struct Mac_ {
-    pub path: Path,
-    pub tts: Vec<TokenTree>,
-    pub ctxt: SyntaxContext,
+pub enum Mac_ {
+    // NB: the additional ident for a macro_rules-style macro is actually
+    // stored in the enclosing item. Oog.
+    MacInvocTT(Path, Vec<TokenTree>, SyntaxContext),   // new macro-invocation
 }
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]

branches/tmp/src/libsyntax/ext/expand.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use ast::{Block, Crate, DeclLocal, ExprMac, PatMac};
-use ast::{Local, Ident, Mac_};
+use ast::{Local, Ident, MacInvocTT};
 use ast::{ItemMac, MacStmtWithSemicolon, Mrk, Stmt, StmtDecl, StmtMac};
 use ast::{StmtExpr, StmtSemi};
 use ast::TokenTree;
@@ -509,75 +509,78 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac,
     F: for<'a> FnOnce(Box<MacResult+'a>) -> Option<T>,
     G: FnOnce(T, Mrk) -> T,
 {
-    // it would almost certainly be cleaner to pass the whole
-    // macro invocation in, rather than pulling it apart and
-    // marking the tts and the ctxt separately. This also goes
-    // for the other three macro invocation chunks of code
-    // in this file.
-
-    let Mac_ { path: pth, tts, .. } = mac.node;
-    if pth.segments.len() > 1 {
-        fld.cx.span_err(pth.span,
-                        "expected macro name without module \
-                        separators");
-        // let compilation continue
-        return None;
-    }
-    let extname = pth.segments[0].identifier.name;
-    match fld.cx.syntax_env.find(&extname) {
-        None => {
-            fld.cx.span_err(
-                pth.span,
-                &format!("macro undefined: '{}!'",
-                        &extname));
+    match mac.node {
+        // it would almost certainly be cleaner to pass the whole
+        // macro invocation in, rather than pulling it apart and
+        // marking the tts and the ctxt separately. This also goes
+        // for the other three macro invocation chunks of code
+        // in this file.
+        // Token-tree macros:
+        MacInvocTT(pth, tts, _) => {
+            if pth.segments.len() > 1 {
+                fld.cx.span_err(pth.span,
+                                "expected macro name without module \
+                                separators");
+                // let compilation continue
+                return None;
+            }
+            let extname = pth.segments[0].identifier.name;
+            match fld.cx.syntax_env.find(&extname) {
+                None => {
+                    fld.cx.span_err(
+                        pth.span,
+                        &format!("macro undefined: '{}!'",
+                                &extname));
 
-            // let compilation continue
-            None
-        }
-        Some(rc) => match *rc {
-            NormalTT(ref expandfun, exp_span, allow_internal_unstable) => {
-                fld.cx.bt_push(ExpnInfo {
-                        call_site: span,
-                        callee: NameAndSpan {
-                            format: MacroBang(extname),
-                            span: exp_span,
-                            allow_internal_unstable: allow_internal_unstable,
-                        },
-                    });
-                let fm = fresh_mark();
-                let marked_before = mark_tts(&tts[..], fm);
-
-                // The span that we pass to the expanders we want to
-                // be the root of the call stack. That's the most
-                // relevant span and it's the actual invocation of
-                // the macro.
-                let mac_span = fld.cx.original_span();
-
-                let opt_parsed = {
-                    let expanded = expandfun.expand(fld.cx,
-                                                    mac_span,
-                                                    &marked_before[..]);
-                    parse_thunk(expanded)
-                };
-                let parsed = match opt_parsed {
-                    Some(e) => e,
-                    None => {
+                    // let compilation continue
+                    None
+                }
+                Some(rc) => match *rc {
+                    NormalTT(ref expandfun, exp_span, allow_internal_unstable) => {
+                        fld.cx.bt_push(ExpnInfo {
+                                call_site: span,
+                                callee: NameAndSpan {
+                                    format: MacroBang(extname),
+                                    span: exp_span,
+                                    allow_internal_unstable: allow_internal_unstable,
+                                },
+                            });
+                        let fm = fresh_mark();
+                        let marked_before = mark_tts(&tts[..], fm);
+
+                        // The span that we pass to the expanders we want to
+                        // be the root of the call stack. That's the most
+                        // relevant span and it's the actual invocation of
+                        // the macro.
+                        let mac_span = fld.cx.original_span();
+
+                        let opt_parsed = {
+                            let expanded = expandfun.expand(fld.cx,
+                                                            mac_span,
+                                                            &marked_before[..]);
+                            parse_thunk(expanded)
+                        };
+                        let parsed = match opt_parsed {
+                            Some(e) => e,
+                            None => {
+                                fld.cx.span_err(
+                                    pth.span,
+                                    &format!("non-expression macro in expression position: {}",
+                                            extname
+                                            ));
+                                return None;
+                            }
+                        };
+                        Some(mark_thunk(parsed,fm))
+                    }
+                    _ => {
                         fld.cx.span_err(
                             pth.span,
-                            &format!("non-expression macro in expression position: {}",
-                                    extname
-                                    ));
-                        return None;
+                            &format!("'{}' is not a tt-style macro",
+                                    extname));
+                        None
                     }
-                };
-                Some(mark_thunk(parsed,fm))
-            }
-            _ => {
-                fld.cx.span_err(
-                    pth.span,
-                    &format!("'{}' is not a tt-style macro",
-                            extname));
-                None
+                }
             }
         }
     }
@@ -681,11 +684,15 @@ fn contains_macro_use(fld: &mut MacroExpander, attrs: &[ast::Attribute]) -> bool
 // logic as for expression-position macro invocations.
 pub fn expand_item_mac(it: P<ast::Item>,
                        fld: &mut MacroExpander) -> SmallVector<P<ast::Item>> {
-    let (extname, path_span, tts, span, attrs, ident) = it.and_then(|it| match it.node {
-        ItemMac(codemap::Spanned { node: Mac_ { path, tts, .. }, .. }) =>
-            (path.segments[0].identifier.name, path.span, tts, it.span, it.attrs, it.ident),
+    let (extname, path_span, tts, span, attrs, ident) = it.and_then(|it| { match it.node {
+        ItemMac(codemap::Spanned {
+            node: MacInvocTT(pth, tts, _),
+            ..
+        }) => {
+            (pth.segments[0].identifier.name, pth.span, tts, it.span, it.attrs, it.ident)
+        }
         _ => fld.cx.span_bug(it.span, "invalid item macro invocation")
-    });
+    }});
 
     let fm = fresh_mark();
     let items = {
@@ -1053,7 +1060,11 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
     }
     p.map(|ast::Pat {node, span, ..}| {
         let (pth, tts) = match node {
-            PatMac(mac) => (mac.node.path, mac.node.tts),
+            PatMac(mac) => match mac.node {
+                MacInvocTT(pth, tts, _) => {
+                    (pth, tts)
+                }
+            },
             _ => unreachable!()
         };
         if pth.segments.len() > 1 {
@@ -1635,10 +1646,12 @@ impl Folder for Marker {
     }
     fn fold_mac(&mut self, Spanned {node, span}: ast::Mac) -> ast::Mac {
         Spanned {
-            node: Mac_ {
-                path: self.fold_path(node.path),
-                tts: self.fold_tts(&node.tts),
-                ctxt: mtwt::apply_mark(self.mark, node.ctxt),
+            node: match node {
+                MacInvocTT(path, tts, ctxt) => {
+                    MacInvocTT(self.fold_path(path),
+                               self.fold_tts(&tts[..]),
+                               mtwt::apply_mark(self.mark, ctxt))
+                }
             },
             span: span,
         }

branches/tmp/src/libsyntax/feature_gate.rs

@@ -666,7 +666,7 @@ struct MacroVisitor<'a> {
 
 impl<'a, 'v> Visitor<'v> for MacroVisitor<'a> {
     fn visit_mac(&mut self, mac: &ast::Mac) {
-        let path = &mac.node.path;
+        let ast::MacInvocTT(ref path, _, _) = mac.node;
         let id = path.segments.last().unwrap().identifier;
 
         // Issue 22234: If you add a new case here, make sure to also

branches/tmp/src/libsyntax/fold.rs

@@ -567,10 +567,10 @@ pub fn noop_fold_explicit_self<T: Folder>(Spanned {span, node}: ExplicitSelf, fl
 
 pub fn noop_fold_mac<T: Folder>(Spanned {node, span}: Mac, fld: &mut T) -> Mac {
     Spanned {
-        node: Mac_ {
-            path: fld.fold_path(node.path),
-            tts: fld.fold_tts(&node.tts),
-            ctxt: node.ctxt,
+        node: match node {
+            MacInvocTT(p, tts, ctxt) => {
+                MacInvocTT(fld.fold_path(p), fld.fold_tts(&tts), ctxt)
+            }
         },
         span: fld.new_span(span)
     }

branches/tmp/src/libsyntax/parse/mod.rs

@@ -1090,7 +1090,10 @@ mod tests {
             "foo!( fn main() { body } )".to_string(), vec![], &sess);
 
         let tts = match expr.node {
-            ast::ExprMac(ref mac) => mac.node.tts.clone(),
+            ast::ExprMac(ref mac) => {
+                let ast::MacInvocTT(_, ref tts, _) = mac.node;
+                tts.clone()
+            }
             _ => panic!("not a macro"),
         };