whitespace, reindentation, and comments only

src/librustc/middle/trans/base.rs

@@ -2760,7 +2760,8 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
 
 pub fn declare_dbg_intrinsics(llmod: ModuleRef, intrinsics: &mut HashMap<&'static str, ValueRef>) {
     ifn!(intrinsics, "llvm.dbg.declare", [Type::metadata(), Type::metadata()], Type::void());
-    ifn!(intrinsics, "llvm.dbg.value",   [Type::metadata(), Type::i64(), Type::metadata()], Type::void());
+    ifn!(intrinsics,
+         "llvm.dbg.value",   [Type::metadata(), Type::i64(), Type::metadata()], Type::void());
 }
 
 pub fn trap(bcx: @mut Block) {

src/librustc/middle/trans/expr.rs

@@ -1139,8 +1139,9 @@ fn trans_rec_or_struct(bcx: @mut Block,
         let mut need_base = vec::from_elem(field_tys.len(), true);
 
         let numbered_fields = do fields.map |field| {
-            let opt_pos = field_tys.iter().position(|field_ty|
-                                                    field_ty.ident.name == field.ident.name);
+            let opt_pos =
+                field_tys.iter().position(|field_ty|
+                                          field_ty.ident.name == field.ident.name);
             match opt_pos {
                 Some(i) => {
                     need_base[i] = false;

src/libsyntax/ast.rs

@@ -36,6 +36,12 @@ impl Eq for ident {
         if (self.ctxt == other.ctxt) {
             self.name == other.name
         } else {
+            // IF YOU SEE ONE OF THESE FAILS: it means that you're comparing
+            // idents that have different contexts. You can't fix this without
+            // knowing whether the comparison should be hygienic or non-hygienic.
+            // if it should be non-hygienic (most things are), just compare the
+            // 'name' fields of the idents. Or, even better, replace the idents
+            // with Name's.
             fail!(fmt!("not allowed to compare these idents: %?, %?", self, other));
         }
     }
@@ -114,6 +120,7 @@ pub type fn_ident = Option<ident>;
 pub struct Lifetime {
     id: NodeId,
     span: span,
+    // FIXME #7743 : change this to Name!
     ident: ident
 }
 
@@ -623,7 +630,6 @@ pub enum matcher_ {
     // lo, hi position-in-match-array used:
     match_seq(~[matcher], Option<::parse::token::Token>, bool, uint, uint),
     // parse a Rust NT: name to bind, name of NT, position in match array:
-    // NOTE: 'name of NT' shouldnt really be represented as an ident, should it?
     match_nonterminal(ident, ident, uint)
 }
 

src/libsyntax/ast_util.rs

@@ -758,11 +758,14 @@ pub fn resolve_internal(id : ident,
                 match table.table[id.ctxt] {
                     EmptyCtxt => id.name,
                     // ignore marks here:
-                    Mark(_,subctxt) => resolve_internal(ident{name:id.name, ctxt: subctxt},table,resolve_table),
+                    Mark(_,subctxt) =>
+                        resolve_internal(ident{name:id.name, ctxt: subctxt},table,resolve_table),
                     // do the rename if necessary:
                     Rename(ident{name,ctxt},toname,subctxt) => {
-                        let resolvedfrom = resolve_internal(ident{name:name,ctxt:ctxt},table,resolve_table);
-                        let resolvedthis = resolve_internal(ident{name:id.name,ctxt:subctxt},table,resolve_table);
+                        let resolvedfrom =
+                            resolve_internal(ident{name:name,ctxt:ctxt},table,resolve_table);
+                        let resolvedthis =
+                            resolve_internal(ident{name:id.name,ctxt:subctxt},table,resolve_table);
                         if ((resolvedthis == resolvedfrom)
                             && (marksof(ctxt,resolvedthis,table)
                                 == marksof(subctxt,resolvedthis,table))) {
@@ -834,9 +837,9 @@ pub fn getLast(arr: &~[Mrk]) -> uint {
 pub fn path_name_eq(a : &ast::Path, b : &ast::Path) -> bool {
     (a.span == b.span)
     && (a.global == b.global)
-    // NOTE: ident->name in lifetimes!
+    // FIXME #7743: ident->name in lifetimes!
     && (a.rp == b.rp)
-    // NOTE: can a type contain an ident?
+    // can types contain idents?
     && (a.types == b.types)
     && (idents_name_eq(a.idents, b.idents))
 }

src/libsyntax/ext/expand.rs

@@ -74,19 +74,20 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
                             // mark before:
                             let marked_before = mark_tts(*tts,fm);
                             let marked_ctxt = new_mark(fm, ctxt);
-                            let expanded = match expandfun(cx, mac.span, marked_before, marked_ctxt) {
-                                MRExpr(e) => e,
-                                MRAny(expr_maker,_,_) => expr_maker(),
-                                _ => {
-                                    cx.span_fatal(
-                                        pth.span,
-                                        fmt!(
-                                            "non-expr macro in expr pos: %s",
-                                            extnamestr
+                            let expanded =
+                                match expandfun(cx, mac.span, marked_before, marked_ctxt) {
+                                    MRExpr(e) => e,
+                                    MRAny(expr_maker,_,_) => expr_maker(),
+                                    _ => {
+                                        cx.span_fatal(
+                                            pth.span,
+                                            fmt!(
+                                                "non-expr macro in expr pos: %s",
+                                                extnamestr
+                                            )
                                         )
-                                    )
-                                }
-                            };
+                                    }
+                                };
                             // mark after:
                             let marked_after = mark_expr(expanded,fm);
 
@@ -1166,7 +1167,8 @@ mod test {
     use print::pprust;
     use std;
     use std::vec;
-    use util::parser_testing::{string_to_crate, string_to_crate_and_sess, string_to_item, string_to_pat, strs_to_idents};
+    use util::parser_testing::{string_to_crate, string_to_crate_and_sess, string_to_item}
+    use util::parser_testing::{string_to_pat, strs_to_idents};
     use visit::{mk_vt};
     use visit;
 
@@ -1362,12 +1364,14 @@ mod test {
                  ~[~[0]])
                 // FIXME #6994: the next string exposes the bug referred to in issue 6994, so I'm
                 // commenting it out.
-                // the z flows into and out of two macros (g & f) along one path, and one (just g) along the
-                // other, so the result of the whole thing should be "let z_123 = 3; z_123"
-                //"macro_rules! g (($x:ident) => ({macro_rules! f(($y:ident)=>({let $y=3;$x}));f!($x)}))
+                // the z flows into and out of two macros (g & f) along one path, and one
+                // (just g) along the other, so the result of the whole thing should
+                // be "let z_123 = 3; z_123"
+                //"macro_rules! g (($x:ident) =>
+                //   ({macro_rules! f(($y:ident)=>({let $y=3;$x}));f!($x)}))
                 //   fn a(){g!(z)}"
-                // create a really evil test case where a $x appears inside a binding of $x but *shouldnt*
-                // bind because it was inserted by a different macro....
+                // create a really evil test case where a $x appears inside a binding of $x
+                // but *shouldnt* bind because it was inserted by a different macro....
             ];
         for tests.iter().advance |s| {
             run_renaming_test(s);
@@ -1449,7 +1453,8 @@ mod test {
         // find the ext_cx binding
         let bindings = @mut ~[];
         visit::visit_crate(crate, (bindings, mk_vt(nv)));
-        let cxbinds : ~[&ast::ident] = bindings.iter().filter(|b|{@"ext_cx" == (ident_to_str(*b))}).collect();
+        let cxbinds : ~[&ast::ident] =
+            bindings.iter().filter(|b|{@"ext_cx" == (ident_to_str(*b))}).collect();
         let cxbind = match cxbinds {
             [b] => b,
             _ => fail!("expected just one binding for ext_cx")

src/libsyntax/ext/tt/macro_rules.rs

@@ -49,7 +49,6 @@ pub fn add_new_extension(cx: @ExtCtxt,
     // ...quasiquoting this would be nice.
     let argument_gram = ~[
         ms(match_seq(~[
-            // NOTE : probably just use an enum for the NT_name ?
             ms(match_nonterminal(lhs_nm, special_idents::matchers, 0u)),
             ms(match_tok(FAT_ARROW)),
             ms(match_nonterminal(rhs_nm, special_idents::tt, 1u)),