Removed all instances of XXX in preparation for relaxing of FIXME rule

72 files changed, 119 insertions, 119 deletions

diff --git a/Makefile.in b/Makefile.in
index 3380356ee3c..101034f346e 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -636,7 +636,7 @@ CFG_INFO := $(info cfg: *** compiler is in snapshot transition ***)
 CFG_INFO := $(info cfg: *** stage2 and later will not be built ***)
 CFG_INFO := $(info cfg:)
 
-#XXX This is surely busted
+#FIXME This is surely busted
 all: $(SREQ1$(CFG_BUILD)) $(GENERATED) docs
 
 else
diff --git a/doc/tutorial.md b/doc/tutorial.md
index 3c8d721626e..eb95329ed56 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -2895,7 +2895,7 @@ and only if that results in no match look at items you brought in
 scope with corresponding `use` statements.
 
 ~~~ {.ignore}
-# // XXX: Allow unused import in doc test
+# // FIXME: Allow unused import in doc test
 use farm::cow;
 // ...
 # mod farm { pub fn cow() { println!("Hidden ninja cow is hidden.") } }
diff --git a/mk/platform.mk b/mk/platform.mk
index 10c597e61d1..a318348b7bb 100644
--- a/mk/platform.mk
+++ b/mk/platform.mk
@@ -596,7 +596,7 @@ define CFG_MAKE_TOOLCHAIN
   else
 
   # For the ARM and MIPS crosses, use the toolchain assembler
-  # XXX: We should be able to use the LLVM assembler
+  # FIXME: We should be able to use the LLVM assembler
   CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
 		    $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
 
diff --git a/src/libextra/arena.rs b/src/libextra/arena.rs
index 0660c8ac7ad..87f6e27b632 100644
--- a/src/libextra/arena.rs
+++ b/src/libextra/arena.rs
@@ -276,7 +276,7 @@ impl Arena {
     #[inline]
     pub fn alloc<'a, T>(&'a self, op: || -> T) -> &'a T {
         unsafe {
-            // XXX: Borrow check
+            // FIXME: Borrow check
             let this = transmute_mut(self);
             if intrinsics::needs_drop::<T>() {
                 this.alloc_nonpod(op)
diff --git a/src/libextra/ebml.rs b/src/libextra/ebml.rs
index a44cf2ec063..5bbea491ac2 100644
--- a/src/libextra/ebml.rs
+++ b/src/libextra/ebml.rs
@@ -630,7 +630,7 @@ pub mod writer {
 
     // FIXME (#2741): Provide a function to write the standard ebml header.
     impl<'a> Encoder<'a> {
-        /// XXX(pcwalton): Workaround for badness in trans. DO NOT USE ME.
+        /// FIXME(pcwalton): Workaround for badness in trans. DO NOT USE ME.
         pub unsafe fn unsafe_clone(&self) -> Encoder<'a> {
             Encoder {
                 writer: cast::transmute_copy(&self.writer),
diff --git a/src/libextra/glob.rs b/src/libextra/glob.rs
index 3e2aa511b81..fb760685254 100644
--- a/src/libextra/glob.rs
+++ b/src/libextra/glob.rs
@@ -93,7 +93,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Paths {
     let pat_root = Path::new(pattern).root_path();
     if pat_root.is_some() {
         if check_windows_verbatim(pat_root.get_ref()) {
-            // XXX: How do we want to handle verbatim paths? I'm inclined to return nothing,
+            // FIXME: How do we want to handle verbatim paths? I'm inclined to return nothing,
             // since we can't very well find all UNC shares with a 1-letter server name.
             return Paths { root: root, dir_patterns: ~[], options: options, todo: ~[] };
         }
diff --git a/src/libextra/url.rs b/src/libextra/url.rs
index 7591f564da2..35c53c9307c 100644
--- a/src/libextra/url.rs
+++ b/src/libextra/url.rs
@@ -174,7 +174,7 @@ fn decode_inner(s: &str, full_url: bool) -> ~str {
             let mut bytes = [0, 0];
             match rdr.read(bytes) {
                 Some(2) => {}
-                _ => fail!() // XXX: malformed url?
+                _ => fail!() // FIXME: malformed url?
             }
             let ch = uint::parse_bytes(bytes, 16u).unwrap() as u8 as char;
 
@@ -308,7 +308,7 @@ pub fn decode_form_urlencoded(s: &[u8]) -> HashMap<~str, ~[~str]> {
                         let mut bytes = [0, 0];
                         match rdr.read(bytes) {
                             Some(2) => {}
-                            _ => fail!() // XXX: malformed?
+                            _ => fail!() // FIXME: malformed?
                         }
                         uint::parse_bytes(bytes, 16u).unwrap() as u8 as char
                     }
diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs
index cccca1309f4..d8a97ae2077 100644
--- a/src/libextra/workcache.rs
+++ b/src/libextra/workcache.rs
@@ -413,7 +413,7 @@ impl<'a> Prep<'a> {
                 let (port, chan) = Chan::new();
                 let blk = bo.take_unwrap();
 
-                // XXX: What happens if the task fails?
+                // FIXME: What happens if the task fails?
                 do spawn {
                     let mut exe = Exec {
                         discovered_inputs: WorkMap::new(),
diff --git a/src/libgreen/basic.rs b/src/libgreen/basic.rs
index ef96f554515..f303f100e03 100644
--- a/src/libgreen/basic.rs
+++ b/src/libgreen/basic.rs
@@ -139,7 +139,7 @@ impl EventLoop for BasicLoop {
         self.work.push(f);
     }
 
-    // XXX: Seems like a really weird requirement to have an event loop provide.
+    // FIXME: Seems like a really weird requirement to have an event loop provide.
     fn pausable_idle_callback(&mut self, cb: ~Callback) -> ~PausableIdleCallback {
         let callback = ~BasicPausable::new(self, cb);
         rtassert!(self.idle.is_none());
diff --git a/src/libgreen/macros.rs b/src/libgreen/macros.rs
index 12def918bc9..e07cc1ca000 100644
--- a/src/libgreen/macros.rs
+++ b/src/libgreen/macros.rs
@@ -8,14 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// XXX: this file probably shouldn't exist
+// FIXME: this file probably shouldn't exist
 
 #[macro_escape];
 
 use std::fmt;
 
 // Indicates whether we should perform expensive sanity checks, including rtassert!
-// XXX: Once the runtime matures remove the `true` below to turn off rtassert, etc.
+// FIXME: Once the runtime matures remove the `true` below to turn off rtassert, etc.
 pub static ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) || cfg!(rtassert);
 
 macro_rules! rterrln (
diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs
index 989b8dc31f8..8fa1e6732dc 100644
--- a/src/libgreen/sched.rs
+++ b/src/libgreen/sched.rs
@@ -32,7 +32,7 @@ use task::{TypeSched, GreenTask, HomeSched, AnySched};
 /// struct. The scheduler struct acts like a baton, all scheduling
 /// actions are transfers of the baton.
 ///
-/// XXX: This creates too many callbacks to run_sched_once, resulting
+/// FIXME: This creates too many callbacks to run_sched_once, resulting
 /// in too much allocation and too many events.
 pub struct Scheduler {
     /// ID number of the pool that this scheduler is a member of. When
@@ -171,7 +171,7 @@ impl Scheduler {
         return sched;
     }
 
-    // XXX: This may eventually need to be refactored so that
+    // FIXME: This may eventually need to be refactored so that
     // the scheduler itself doesn't have to call event_loop.run.
     // That will be important for embedding the runtime into external
     // event loops.
@@ -898,7 +898,7 @@ impl CleanupJob {
     }
 }
 
-// XXX: Some hacks to put a || closure in Scheduler without borrowck
+// FIXME: Some hacks to put a || closure in Scheduler without borrowck
 // complaining
 type UnsafeTaskReceiver = raw::Closure;
 trait ClosureConverter {
diff --git a/src/libgreen/stack.rs b/src/libgreen/stack.rs
index bc2c199b83f..4b3db5ef8ed 100644
--- a/src/libgreen/stack.rs
+++ b/src/libgreen/stack.rs
@@ -61,7 +61,7 @@ impl Stack {
             valgrind_id: 0
         };
 
-        // XXX: Using the FFI to call a C macro. Slow
+        // FIXME: Using the FFI to call a C macro. Slow
         stk.valgrind_id = unsafe {
             rust_valgrind_stack_register(stk.start(), stk.end())
         };
@@ -117,7 +117,7 @@ fn protect_last_page(stack: &MemoryMap) -> bool {
 impl Drop for Stack {
     fn drop(&mut self) {
         unsafe {
-            // XXX: Using the FFI to call a C macro. Slow
+            // FIXME: Using the FFI to call a C macro. Slow
             rust_valgrind_stack_deregister(self.valgrind_id);
         }
     }
diff --git a/src/libnative/io/file.rs b/src/libnative/io/file.rs
index af06533d44b..53386433d53 100644
--- a/src/libnative/io/file.rs
+++ b/src/libnative/io/file.rs
@@ -674,7 +674,7 @@ pub fn chown(p: &CString, uid: int, gid: int) -> IoResult<()> {
 pub fn readlink(p: &CString) -> IoResult<Path> {
     return os_readlink(p);
 
-    // XXX: I have a feeling that this reads intermediate symlinks as well.
+    // FIXME: I have a feeling that this reads intermediate symlinks as well.
     #[cfg(windows)]
     fn os_readlink(p: &CString) -> IoResult<Path> {
         let handle = unsafe {
@@ -709,7 +709,7 @@ pub fn readlink(p: &CString) -> IoResult<Path> {
         let p = p.with_ref(|p| p);
         let mut len = unsafe { libc::pathconf(p, libc::_PC_NAME_MAX) };
         if len == -1 {
-            len = 1024; // XXX: read PATH_MAX from C ffi?
+            len = 1024; // FIXME: read PATH_MAX from C ffi?
         }
         let mut buf = vec::with_capacity::<u8>(len as uint);
         match retry(|| unsafe {
@@ -877,7 +877,7 @@ pub fn stat(p: &CString) -> IoResult<io::FileStat> {
 pub fn lstat(p: &CString) -> IoResult<io::FileStat> {
     return os_lstat(p);
 
-    // XXX: windows implementation is missing
+    // FIXME: windows implementation is missing
     #[cfg(windows)]
     fn os_lstat(_p: &CString) -> IoResult<io::FileStat> {
         Err(super::unimpl())
diff --git a/src/libnative/io/mod.rs b/src/libnative/io/mod.rs
index 00f4a0c099d..c94554f510e 100644
--- a/src/libnative/io/mod.rs
+++ b/src/libnative/io/mod.rs
@@ -97,7 +97,7 @@ fn translate_error(errno: i32, detail: bool) -> IoError {
 
     #[cfg(not(windows))]
     fn get_err(errno: i32) -> (io::IoErrorKind, &'static str) {
-        // XXX: this should probably be a bit more descriptive...
+        // FIXME: this should probably be a bit more descriptive...
         match errno {
             libc::EOF => (io::EndOfFile, "end of file"),
             libc::ECONNREFUSED => (io::ConnectionRefused, "connection refused"),
diff --git a/src/libnative/io/timer_timerfd.rs b/src/libnative/io/timer_timerfd.rs
index 0556b0c2599..2bcaf4d5c7c 100644
--- a/src/libnative/io/timer_timerfd.rs
+++ b/src/libnative/io/timer_timerfd.rs
@@ -104,7 +104,7 @@ fn helper(input: libc::c_int, messages: Port<Req>) {
                 let mut bits = [0, ..8];
                 // drain the timerfd of how many times its fired
                 //
-                // XXX: should this perform a send() this number of
+                // FIXME: should this perform a send() this number of
                 //      times?
                 FileDesc::new(fd, false).inner_read(bits);
                 let remove = {
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index f7ee736f144..8aed5623166 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -330,7 +330,7 @@ fn parse_crate_attrs(sess: session::Session,
 /// The diagnostic emitter yielded to the procedure should be used for reporting
 /// errors of the compiler.
 pub fn monitor(f: proc(@diagnostic::Emitter)) {
-    // XXX: This is a hack for newsched since it doesn't support split stacks.
+    // FIXME: This is a hack for newsched since it doesn't support split stacks.
     // rustc needs a lot of stack! When optimizations are disabled, it needs
     // even *more* stack than usual as well.
     #[cfg(rtopt)]
@@ -341,7 +341,7 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
     let mut task_builder = task::task();
     task_builder.name("rustc");
 
-    // XXX: Hacks on hacks. If the env is trying to override the stack size
+    // FIXME: Hacks on hacks. If the env is trying to override the stack size
     // then *don't* set it explicitly.
     if os::getenv("RUST_MIN_STACK").is_none() {
         task_builder.opts.stack_size = Some(STACK_SIZE);
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 114b74b02de..c7d238dac18 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -1275,7 +1275,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
                     // If this is a static method, we've already encoded
                     // this.
                     if method_ty.explicit_self != SelfStatic {
-                        // XXX: I feel like there is something funny going on.
+                        // FIXME: I feel like there is something funny going on.
                         let tpt = ty::lookup_item_type(tcx, method_def_id);
                         encode_bounds_and_type(ebml_w, ecx, &tpt);
                     }
diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
index 72f2e1baddd..b10b833f286 100644
--- a/src/librustc/metadata/loader.rs
+++ b/src/librustc/metadata/loader.rs
@@ -187,7 +187,7 @@ impl Context {
         for lib in libs.mut_iter() {
             match lib.dylib {
                 Some(ref p) if p.filename_str() == Some(file.as_slice()) => {
-                    assert!(lib.rlib.is_none()); // XXX: legit compiler error
+                    assert!(lib.rlib.is_none()); // FIXME: legit compiler error
                     lib.rlib = Some(path.clone());
                     return true;
                 }
@@ -207,7 +207,7 @@ impl Context {
         for lib in libs.mut_iter() {
             match lib.rlib {
                 Some(ref p) if p.filename_str() == Some(file.as_slice()) => {
-                    assert!(lib.dylib.is_none()); // XXX: legit compiler error
+                    assert!(lib.dylib.is_none()); // FIXME: legit compiler error
                     lib.dylib = Some(path.clone());
                     return true;
                 }
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index 5cc522a6e44..b990c5073d1 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -913,7 +913,7 @@ impl<'a,'b> ast_util::IdVisitingOperation for
         // it is mutable. But I believe it's harmless since we generate
         // balanced EBML.
         //
-        // XXX(pcwalton): Don't copy this way.
+        // FIXME(pcwalton): Don't copy this way.
         let mut new_ebml_w = unsafe {
             self.new_ebml_w.unsafe_clone()
         };
diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs
index e45ea77b49e..0ae1fefa2a0 100644
--- a/src/librustc/middle/borrowck/gather_loans/mod.rs
+++ b/src/librustc/middle/borrowck/gather_loans/mod.rs
@@ -416,7 +416,7 @@ impl<'a> GatherLoanCtxt<'a> {
             }
 
             ty::AutoObject(..) => {
-                // XXX: Handle @Trait to &Trait casts here?
+                // FIXME: Handle @Trait to &Trait casts here?
             }
         }
     }
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index f1cccab1239..002f263209a 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -50,7 +50,7 @@ pub mod move_data;
 
 pub struct LoanDataFlowOperator;
 
-/// XXX(pcwalton): Should just be #[deriving(Clone)], but that doesn't work
+/// FIXME(pcwalton): Should just be #[deriving(Clone)], but that doesn't work
 /// yet on unit structs.
 impl Clone for LoanDataFlowOperator {
     fn clone(&self) -> LoanDataFlowOperator {
diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs
index 299a880f02d..ca9bce19ab8 100644
--- a/src/librustc/middle/borrowck/move_data.rs
+++ b/src/librustc/middle/borrowck/move_data.rs
@@ -148,7 +148,7 @@ pub struct Assignment {
 
 pub struct MoveDataFlowOperator;
 
-/// XXX(pcwalton): Should just be #[deriving(Clone)], but that doesn't work
+/// FIXME(pcwalton): Should just be #[deriving(Clone)], but that doesn't work
 /// yet on unit structs.
 impl Clone for MoveDataFlowOperator {
     fn clone(&self) -> MoveDataFlowOperator {
@@ -160,7 +160,7 @@ pub type MoveDataFlow = DataFlowContext<MoveDataFlowOperator>;
 
 pub struct AssignDataFlowOperator;
 
-/// XXX(pcwalton): Should just be #[deriving(Clone)], but that doesn't work
+/// FIXME(pcwalton): Should just be #[deriving(Clone)], but that doesn't work
 /// yet on unit structs.
 impl Clone for AssignDataFlowOperator {
     fn clone(&self) -> AssignDataFlowOperator {
diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs
index 66d706e3621..071371c6b61 100644
--- a/src/librustc/middle/reachable.rs
+++ b/src/librustc/middle/reachable.rs
@@ -404,7 +404,7 @@ impl ReachableContext {
 
     // Step 3: Mark all destructors as reachable.
     //
-    // XXX(pcwalton): This is a conservative overapproximation, but fixing
+    // FIXME(pcwalton): This is a conservative overapproximation, but fixing
     // this properly would result in the necessity of computing *type*
     // reachability, which might result in a compile time loss.
     fn mark_destructors_reachable(&self) {
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index a96b1b86868..b6a4a55186c 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -61,7 +61,7 @@ pub struct Export2 {
 // not contain any entries from local crates.
 pub type ExternalExports = HashSet<DefId>;
 
-// XXX: dox
+// FIXME: dox
 pub type LastPrivateMap = HashMap<NodeId, LastPrivate>;
 
 pub enum LastPrivate {
@@ -1411,7 +1411,7 @@ impl Resolver {
                                        parent: ReducedGraphParent,
                                        parent_public: bool) {
         let ident = variant.node.name;
-        // XXX: this is unfortunate to have to do this privacy calculation
+        // FIXME: this is unfortunate to have to do this privacy calculation
         //      here. This should be living in middle::privacy, but it's
         //      necessary to keep around in some form becaues of glob imports...
         let is_public = parent_public && variant.node.vis != ast::Private;
@@ -5282,7 +5282,7 @@ impl Resolver {
                                                    `{}`",
                                                    interner_get(label))),
                     Some(DlDef(def @ DefLabel(_))) => {
-                        // XXX: is AllPublic correct?
+                        // FIXME: is AllPublic correct?
                         self.record_def(expr.id, (def, AllPublic))
                     }
                     Some(_) => {
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 5bd8eb6386f..c8d2cf36938 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -643,7 +643,7 @@ fn enter_opt<'r,'b>(
             }
             ast::PatEnum(_, ref subpats) => {
                 if opt_eq(tcx, &variant_opt(bcx, p.id), opt) {
-                    // XXX: Must we clone?
+                    // FIXME: Must we clone?
                     match *subpats {
                         None => Some(vec::from_elem(variant_size, dummy)),
                         _ => (*subpats).clone(),
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 7b194690b2f..9f28385aa5c 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -805,7 +805,7 @@ fn padding(size: u64) -> ValueRef {
     C_undef(Type::array(&Type::i8(), size))
 }
 
-// XXX this utility routine should be somewhere more general
+// FIXME this utility routine should be somewhere more general
 #[inline]
 fn roundup(x: u64, a: u64) -> u64 { ((x + (a - 1)) / a) * a }
 
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
index 58f7171452e..21091c4f88e 100644
--- a/src/librustc/middle/trans/closure.rs
+++ b/src/librustc/middle/trans/closure.rs
@@ -384,7 +384,7 @@ pub fn trans_expr_fn<'a>(
 
     let sub_path = vec::append_one(bcx.fcx.path.clone(),
                                    PathName(special_idents::anon));
-    // XXX: Bad copy.
+    // FIXME: Bad copy.
     let s = mangle_internal_name_by_path_and_seq(ccx,
                                                  sub_path.clone(),
                                                  "expr_fn");
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index d70f2ab7d99..a28cb1a030c 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -283,7 +283,7 @@ pub fn const_expr(cx: @CrateContext, e: &ast::Expr) -> (ValueRef, bool) {
     let tsize = machine::llsize_of_alloc(cx, llty);
     if csize != tsize {
         unsafe {
-            // XXX these values could use some context
+            // FIXME these values could use some context
             llvm::LLVMDumpValue(llconst);
             llvm::LLVMDumpValue(C_undef(llty));
         }
diff --git a/src/librustc/middle/trans/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs
index 67505285630..fe2b3578a05 100644
--- a/src/librustc/middle/trans/intrinsic.rs
+++ b/src/librustc/middle/trans/intrinsic.rs
@@ -417,7 +417,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
             RetVoid(bcx);
         }
         "morestack_addr" => {
-            // XXX This is a hack to grab the address of this particular
+            // FIXME This is a hack to grab the address of this particular
             // native function. There should be a general in-language
             // way to do this
             let llfty = type_of_rust_fn(bcx.ccx(), None, [], ty::mk_nil());
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index 3badfc38df6..338b487de46 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -95,7 +95,7 @@ pub fn trans_impl(ccx: @CrateContext,
 /// * `llfn`: a closure returning the LLVM ValueRef for the method
 /// * `impl_id`: the node ID of the impl this method is inside
 ///
-/// XXX(pcwalton) Can we take `path` by reference?
+/// FIXME(pcwalton) Can we take `path` by reference?
 pub fn trans_method(ccx: @CrateContext,
                     path: Path,
                     method: &ast::Method,
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 01fb18d73c2..365fe897720 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -2494,7 +2494,7 @@ pub fn type_is_pod(cx: ctxt, ty: t) -> bool {
       ty_enum(did, ref substs) => {
         let variants = enum_variants(cx, did);
         for variant in (*variants).iter() {
-            // XXX(pcwalton): This is an inefficient way to do this. Don't
+            // FIXME(pcwalton): This is an inefficient way to do this. Don't
             // synthesize a tuple!
             //
             // Perform any type parameter substitutions.
@@ -2655,7 +2655,7 @@ pub fn node_id_to_type(cx: ctxt, id: ast::NodeId) -> t {
     }
 }
 
-// XXX(pcwalton): Makes a copy, bleh. Probably better to not do that.
+// FIXME(pcwalton): Makes a copy, bleh. Probably better to not do that.
 pub fn node_id_to_type_params(cx: ctxt, id: ast::NodeId) -> ~[t] {
     let node_type_substs = cx.node_type_substs.borrow();
     match node_type_substs.get().find(&id) {
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index 293442417d2..002dd0c002a 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -861,7 +861,7 @@ impl<'a> LookupContext<'a> {
                            rcvr_ty: ty::t,
                            candidates: &mut ~[Candidate])
                            -> Option<method_map_entry> {
-        // XXX(pcwalton): Do we need to clone here?
+        // FIXME(pcwalton): Do we need to clone here?
         let relevant_candidates: ~[Candidate] =
             candidates.iter().map(|c| (*c).clone()).
                 filter(|c| self.is_relevant(rcvr_ty, c)).collect();
@@ -1169,7 +1169,7 @@ impl<'a> LookupContext<'a> {
                 let destructors = self.tcx().destructors.borrow();
                 bad = destructors.get().contains(&method_id);
             }
-            // XXX: does this properly enforce this on everything now
+            // FIXME: does this properly enforce this on everything now
             // that self has been merged in? -sully
             method_param(method_param { trait_id: trait_id, .. }) |
             method_object(method_object { trait_id: trait_id, .. }) => {
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 86d347fdac0..5f221994787 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -2691,7 +2691,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
           let mut checked = false;
           match place.node {
               ast::ExprPath(ref path) => {
-                  // XXX(pcwalton): For now we hardcode the two permissible
+                  // FIXME(pcwalton): For now we hardcode the two permissible
                   // places: the exchange heap and the managed heap.
                   let definition = lookup_def(fcx, path.span, place.id);
                   let def_id = ast_util::def_id_of_def(definition);
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
index 8f85c185adb..43af40363cd 100644
--- a/src/librustc/middle/typeck/check/vtable.rs
+++ b/src/librustc/middle/typeck/check/vtable.rs
@@ -330,7 +330,7 @@ fn search_for_vtable(vcx: &VtableContext,
     ty::populate_implementations_for_trait_if_necessary(tcx,
                                                         trait_ref.def_id);
 
-    // XXX: this is a bad way to do this, since we do
+    // FIXME: this is a bad way to do this, since we do
     // pointless allocations.
     let impls = {
         let trait_impls = tcx.trait_impls.borrow();
@@ -371,7 +371,7 @@ fn search_for_vtable(vcx: &VtableContext,
         // we're trying to cast to some_trait.  If not, then we try
         // the next impl.
         //
-        // XXX: document a bit more what this means
+        // FIXME: document a bit more what this means
         //
         // FIXME(#5781) this should be mk_eqty not mk_subty
         let ty::ty_param_substs_and_ty {
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index 89c24cf4116..d533f9b0b13 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -309,7 +309,7 @@ impl CoherenceChecker {
                 // Nothing to do.
             }
             Some(base_type_def_id) => {
-                // XXX: Gather up default methods?
+                // FIXME: Gather up default methods?
                 if associated_traits.len() == 0 {
                     self.add_inherent_impl(base_type_def_id, implementation);
                 }
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 9b1caaa152c..11a8ca0dd45 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -323,7 +323,7 @@ impl fmt::Default for clean::Type {
                        },
                        arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" },
                        ret = decl.decl.output);
-                // XXX: where are bounds and lifetimes printed?!
+                // FIXME: where are bounds and lifetimes printed?!
             }
             clean::BareFunction(ref decl) => {
                 write!(f.buf, "{}{}fn{}{}",
@@ -481,7 +481,7 @@ impl fmt::Default for clean::ViewPath {
 impl fmt::Default for clean::ImportSource {
     fn fmt(v: &clean::ImportSource, f: &mut fmt::Formatter) {
         match v.did {
-            // XXX: shouldn't be restricted to just local imports
+            // FIXME: shouldn't be restricted to just local imports
             Some(did) if ast_util::is_local(did) => {
                 resolved_path(f.buf, did.node, &v.path, true);
             }
@@ -498,7 +498,7 @@ impl fmt::Default for clean::ImportSource {
 impl fmt::Default for clean::ViewListIdent {
     fn fmt(v: &clean::ViewListIdent, f: &mut fmt::Formatter) {
         match v.source {
-            // XXX: shouldn't be limited to just local imports
+            // FIXME: shouldn't be limited to just local imports
             Some(did) if ast_util::is_local(did) => {
                 let path = clean::Path {
                     global: false,
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 393be290506..768ed8ae078 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -301,7 +301,7 @@ fn json_input(input: &str) -> Result<Output, ~str> {
                 }
                 None => return Err(~"malformed json"),
             };
-            // XXX: this should read from the "plugins" field, but currently
+            // FIXME: this should read from the "plugins" field, but currently
             //      Json doesn't implement decodable...
             let plugin_output = ~[];
             Ok((crate, plugin_output))
diff --git a/src/librustpkg/package_source.rs b/src/librustpkg/package_source.rs
index 5ac62c5284e..6bf5c7313f7 100644
--- a/src/librustpkg/package_source.rs
+++ b/src/librustpkg/package_source.rs
@@ -459,7 +459,7 @@ impl PkgSrc {
                                                subcfgs,
                                                opt,
                                                what);
-                    // XXX: result is an Option<Path>. The following code did not take that
+                    // FIXME: result is an Option<Path>. The following code did not take that
                     // into account. I'm not sure if the workcache really likes seeing the
                     // output as "Some(\"path\")". But I don't know what to do about it.
                     // FIXME (#9639): This needs to handle non-utf8 paths
diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs
index 36305c26682..1817be8a594 100644
--- a/src/librustuv/lib.rs
+++ b/src/librustuv/lib.rs
@@ -259,7 +259,7 @@ impl Drop for Request {
     }
 }
 
-/// XXX: Loop(*handle) is buggy with destructors. Normal structs
+/// FIXME: Loop(*handle) is buggy with destructors. Normal structs
 /// with dtors may not be destructured, but tuple structs can,
 /// but the results are not correct.
 pub struct Loop {
@@ -284,7 +284,7 @@ impl Loop {
     }
 }
 
-// XXX: Need to define the error constants like EOF so they can be
+// FIXME: Need to define the error constants like EOF so they can be
 // compared to the UvError type
 
 pub struct UvError(c_int);
@@ -349,7 +349,7 @@ pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
             uvll::EADDRNOTAVAIL => io::ConnectionRefused,
             err => {
                 uvdebug!("uverr.code {}", err as int);
-                // XXX: Need to map remaining uv error types
+                // FIXME: Need to map remaining uv error types
                 io::OtherIoError
             }
         };
diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs
index 004a0144635..74489b70192 100644
--- a/src/librustuv/net.rs
+++ b/src/librustuv/net.rs
@@ -343,7 +343,7 @@ impl rtio::RtioTcpListener for TcpListener {
         let mut acceptor = ~TcpAcceptor { listener: self };
 
         let _m = acceptor.fire_homing_missile();
-        // XXX: the 128 backlog should be configurable
+        // FIXME: the 128 backlog should be configurable
         match unsafe { uvll::uv_listen(acceptor.listener.handle, 128, listen_cb) } {
             0 => Ok(acceptor as ~rtio::RtioTcpAcceptor),
             n => Err(uv_error_to_io_error(UvError(n))),
diff --git a/src/librustuv/pipe.rs b/src/librustuv/pipe.rs
index ff4481e8b97..0fed29631a6 100644
--- a/src/librustuv/pipe.rs
+++ b/src/librustuv/pipe.rs
@@ -179,7 +179,7 @@ impl RtioUnixListener for PipeListener {
         let mut acceptor = ~PipeAcceptor { listener: self };
 
         let _m = acceptor.fire_homing_missile();
-        // XXX: the 128 backlog should be configurable
+        // FIXME: the 128 backlog should be configurable
         match unsafe { uvll::uv_listen(acceptor.listener.pipe, 128, listen_cb) } {
             0 => Ok(acceptor as ~RtioUnixAcceptor),
             n => Err(uv_error_to_io_error(UvError(n))),
diff --git a/src/librustuv/stream.rs b/src/librustuv/stream.rs
index 73173fc677e..262952f8890 100644
--- a/src/librustuv/stream.rs
+++ b/src/librustuv/stream.rs
@@ -157,7 +157,7 @@ extern fn read_cb(handle: *uvll::uv_stream_t, nread: ssize_t, _buf: *Buf) {
     };
     // Stop reading so that no read callbacks are
     // triggered before the user calls `read` again.
-    // XXX: Is there a performance impact to calling
+    // FIXME: Is there a performance impact to calling
     // stop here?
     unsafe { assert_eq!(uvll::uv_read_stop(handle), 0); }
     rcx.result = nread;
diff --git a/src/librustuv/uvll.rs b/src/librustuv/uvll.rs
index c2612d0ed18..c5ff5c60b80 100644
--- a/src/librustuv/uvll.rs
+++ b/src/librustuv/uvll.rs
@@ -361,7 +361,7 @@ fn request_sanity_check() {
     }
 }
 
-// XXX Event loops ignore SIGPIPE by default.
+// FIXME Event loops ignore SIGPIPE by default.
 pub unsafe fn loop_new() -> *c_void {
     return rust_uv_loop_new();
 }
diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs
index 40c4ad842ff..82c1ed7440c 100644
--- a/src/libstd/cleanup.rs
+++ b/src/libstd/cleanup.rs
@@ -55,7 +55,7 @@ unsafe fn each_live_alloc(read_next_before: bool,
 
 #[cfg(unix)]
 fn debug_mem() -> bool {
-    // XXX: Need to port the environment struct to newsched
+    // FIXME: Need to port the environment struct to newsched
     false
 }
 
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index 5b2a792a05b..111eb70eb20 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -780,7 +780,7 @@ impl<'a> Formatter<'a> {
                         rt::Keyword(parse::One) => value == 1,
                         rt::Keyword(parse::Two) => value == 2,
 
-                        // XXX: Few/Many should have a user-specified boundary
+                        // FIXME: Few/Many should have a user-specified boundary
                         //      One possible option would be in the function
                         //      pointer of the 'arg: Argument' struct.
                         rt::Keyword(parse::Few) => value < 8,
@@ -1085,7 +1085,7 @@ integer!(i64, u64)
 macro_rules! floating(($ty:ident) => {
     impl Float for $ty {
         fn fmt(f: &$ty, fmt: &mut Formatter) {
-            // XXX: this shouldn't perform an allocation
+            // FIXME: this shouldn't perform an allocation
             let s = match fmt.precision {
                 Some(i) => ::$ty::to_str_exact(f.abs(), i),
                 None => ::$ty::to_str_digits(f.abs(), 6)
@@ -1096,7 +1096,7 @@ macro_rules! floating(($ty:ident) => {
 
     impl LowerExp for $ty {
         fn fmt(f: &$ty, fmt: &mut Formatter) {
-            // XXX: this shouldn't perform an allocation
+            // FIXME: this shouldn't perform an allocation
             let s = match fmt.precision {
                 Some(i) => ::$ty::to_str_exp_exact(f.abs(), i, false),
                 None => ::$ty::to_str_exp_digits(f.abs(), 6, false)
@@ -1107,7 +1107,7 @@ macro_rules! floating(($ty:ident) => {
 
     impl UpperExp for $ty {
         fn fmt(f: &$ty, fmt: &mut Formatter) {
-            // XXX: this shouldn't perform an allocation
+            // FIXME: this shouldn't perform an allocation
             let s = match fmt.precision {
                 Some(i) => ::$ty::to_str_exp_exact(f.abs(), i, true),
                 None => ::$ty::to_str_exp_digits(f.abs(), 6, true)
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 6a9da944f8b..26e0a0d09ad 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -10,8 +10,8 @@
 
 //! Utility mixins that apply to all Readers and Writers
 
-// XXX: Not sure how this should be structured
-// XXX: Iteration should probably be considered separately
+// FIXME: Not sure how this should be structured
+// FIXME: Iteration should probably be considered separately
 
 use container::Container;
 use iter::Iterator;
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 6141faa90da..8531edeb2c6 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -84,7 +84,7 @@ Some examples of obvious things you might want to do
     ```
 
 * Make an simple HTTP request
-  XXX This needs more improvement: TcpStream constructor taking &str,
+  FIXME This needs more improvement: TcpStream constructor taking &str,
   `write_str` and `write_line` methods.
 
     ```rust,should_fail
@@ -101,7 +101,7 @@ Some examples of obvious things you might want to do
 * Connect based on URL? Requires thinking about where the URL type lives
   and how to make protocol handlers extensible, e.g. the "tcp" protocol
   yields a `TcpStream`.
-  XXX this is not implemented now.
+  FIXME this is not implemented now.
 
     ```rust
     // connect("tcp://localhost:8080");
@@ -209,7 +209,7 @@ if error.is_some() {
 # ::std::io::fs::unlink(&Path::new("diary.txt"));
 ```
 
-XXX: Need better condition handling syntax
+FIXME: Need better condition handling syntax
 
 In this case the condition handler will have the opportunity to
 inspect the IoError raised by either the call to `new` or the call to
@@ -232,8 +232,8 @@ to errors similar to null pointer dereferences.
 In particular code written to ignore errors and expect conditions to be unhandled
 will start passing around null or zero objects when wrapped in a condition handler.
 
-* XXX: How should we use condition handlers that return values?
-* XXX: Should EOF raise default conditions when EOF is not an error?
+* FIXME: How should we use condition handlers that return values?
+* FIXME: Should EOF raise default conditions when EOF is not an error?
 
 # Issues with i/o scheduler affinity, work stealing, task pinning
 
@@ -263,7 +263,7 @@ Out of scope
 * Async I/O. We'll probably want it eventually
 
 
-# XXX Questions and issues
+# FIXME Questions and issues
 
 * Should default constructors take `Path` or `&str`? `Path` makes simple cases verbose.
   Overloading would be nice.
@@ -375,7 +375,7 @@ static DEFAULT_BUF_SIZE: uint = 1024 * 64;
 
 /// The type passed to I/O condition handlers to indicate error
 ///
-/// # XXX
+/// # FIXME
 ///
 /// Is something like this sufficient? It's kind of archaic
 pub struct IoError {
@@ -446,7 +446,7 @@ impl ToStr for IoErrorKind {
     }
 }
 
-// XXX: Can't put doc comments on macros
+// FIXME: Can't put doc comments on macros
 // Raised by `I/O` operations on error.
 condition! {
     pub io_error: IoError -> ();
@@ -491,9 +491,9 @@ pub trait Reader {
     /// Raises the `io_error` condition on error. If the condition
     /// is handled then no guarantee is made about the number of bytes
     /// read and the contents of `buf`. If the condition is handled
-    /// returns `None` (XXX see below).
+    /// returns `None` (FIXME see below).
     ///
-    /// # XXX
+    /// # FIXME
     ///
     /// * Should raise_default error on eof?
     /// * If the condition is handled it should still return the bytes read,
@@ -1218,7 +1218,7 @@ pub enum SeekStyle {
     SeekCur,
 }
 
-/// # XXX
+/// # FIXME
 /// * Are `u64` and `i64` the right choices?
 pub trait Seek {
     /// Return position of file cursor in the stream
@@ -1228,7 +1228,7 @@ pub trait Seek {
     ///
     /// A successful seek clears the EOF indicator.
     ///
-    /// # XXX
+    /// # FIXME
     ///
     /// * What is the behavior when seeking past the end of a stream?
     fn seek(&mut self, pos: i64, style: SeekStyle);
diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs
index 4a8529d0a0a..a1650c9a3a3 100644
--- a/src/libstd/io/net/addrinfo.rs
+++ b/src/libstd/io/net/addrinfo.rs
@@ -91,7 +91,7 @@ pub fn get_host_addresses(host: &str) -> Option<~[IpAddr]> {
 ///
 /// On failure, this will raise on the `io_error` condition.
 ///
-/// XXX: this is not public because the `Hint` structure is not ready for public
+/// FIXME: this is not public because the `Hint` structure is not ready for public
 ///      consumption just yet.
 fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>)
           -> Option<~[Info]> {
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index b901ea99cbe..9f0bf84c8d8 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -584,7 +584,7 @@ mod test {
     })
 
     iotest!(fn socket_and_peer_name_ip6() {
-        // XXX: peer name is not consistent
+        // FIXME: peer name is not consistent
         //peer_name(next_test_ip6());
         socket_name(next_test_ip6());
     })
diff --git a/src/libstd/rand/distributions/mod.rs b/src/libstd/rand/distributions/mod.rs
index a996233abe3..140323110df 100644
--- a/src/libstd/rand/distributions/mod.rs
+++ b/src/libstd/rand/distributions/mod.rs
@@ -51,7 +51,7 @@ pub trait Sample<Support> {
 /// Since no state is recorded, each sample is (statistically)
 /// independent of all others, assuming the `Rng` used has this
 /// property.
-// XXX maybe having this separate is overkill (the only reason is to
+// FIXME maybe having this separate is overkill (the only reason is to
 // take &self rather than &mut self)? or maybe this should be the
 // trait called `Sample` and the other should be `DependentSample`.
 pub trait IndependentSample<Support>: Sample<Support> {
diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs
index 6ea12659e77..8567f0e0251 100644
--- a/src/libstd/rt/crate_map.rs
+++ b/src/libstd/rt/crate_map.rs
@@ -108,7 +108,7 @@ fn do_iter_crate_map<'a>(
 
 /// Iterates recursively over `crate_map` and all child crate maps
 pub fn iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: |&ModEntry|) {
-    // XXX: use random numbers as keys from the OS-level RNG when there is a nice
+    // FIXME: use random numbers as keys from the OS-level RNG when there is a nice
     //        way to do this
     let mut v: HashSet<*CrateMap<'a>> = HashSet::with_capacity_and_keys(0, 0, 32);
     do_iter_crate_map(crate_map, f, &mut v);
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index 36e3bf858e3..42a7e7867f9 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -293,7 +293,7 @@ impl Drop for MemoryRegion {
 
 #[inline]
 pub unsafe fn local_malloc(td: *u8, size: uint) -> *u8 {
-    // XXX: Unsafe borrow for speed. Lame.
+    // FIXME: Unsafe borrow for speed. Lame.
     let task: Option<*mut Task> = Local::try_unsafe_borrow();
     match task {
         Some(task) => {
@@ -306,7 +306,7 @@ pub unsafe fn local_malloc(td: *u8, size: uint) -> *u8 {
 // A little compatibility function
 #[inline]
 pub unsafe fn local_free(ptr: *u8) {
-    // XXX: Unsafe borrow for speed. Lame.
+    // FIXME: Unsafe borrow for speed. Lame.
     let task_ptr: Option<*mut Task> = Local::try_unsafe_borrow();
     match task_ptr {
         Some(task) => {
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 9088ee6898b..56f6c8f8e6c 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -52,7 +52,7 @@ Several modules in `core` are clients of `rt`:
 
 */
 
-// XXX: this should not be here.
+// FIXME: this should not be here.
 #[allow(missing_doc)];
 
 use any::Any;
@@ -71,7 +71,7 @@ pub use self::util::default_sched_threads;
 // Export unwinding facilities used by the failure macros
 pub use self::unwind::{begin_unwind, begin_unwind_raw};
 
-// XXX: these probably shouldn't be public...
+// FIXME: these probably shouldn't be public...
 #[doc(hidden)]
 pub mod shouldnt_be_public {
     pub use super::local_ptr::native::maybe_tls_key;
@@ -155,7 +155,7 @@ pub trait Runtime {
     /// The (low, high) edges of the current stack.
     fn stack_bounds(&self) -> (uint, uint); // (lo, hi)
 
-    // XXX: This is a serious code smell and this should not exist at all.
+    // FIXME: This is a serious code smell and this should not exist at all.
     fn wrap(~self) -> ~Any;
 }
 
@@ -165,7 +165,7 @@ pub trait Runtime {
 /// the crate's logging flags, registering GC
 /// metadata, and storing the process arguments.
 pub fn init(argc: int, argv: **u8) {
-    // XXX: Derefing these pointers is not safe.
+    // FIXME: Derefing these pointers is not safe.
     // Need to propagate the unsafety to `start`.
     unsafe {
         args::init(argc, argv);
diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs
index 6b3d50a76ac..455a84b4ce3 100644
--- a/src/libstd/rt/rtio.rs
+++ b/src/libstd/rt/rtio.rs
@@ -86,7 +86,7 @@ pub struct LocalIo<'a> {
 #[unsafe_destructor]
 impl<'a> Drop for LocalIo<'a> {
     fn drop(&mut self) {
-        // XXX(pcwalton): Do nothing here for now, but eventually we may want
+        // FIXME(pcwalton): Do nothing here for now, but eventually we may want
         // something. For now this serves to make `LocalIo` noncopyable.
     }
 }
@@ -143,7 +143,7 @@ impl<'a> LocalIo<'a> {
     /// Returns the underlying I/O factory as a trait reference.
     #[inline]
     pub fn get<'a>(&'a mut self) -> &'a mut IoFactory {
-        // XXX(pcwalton): I think this is actually sound? Could borrow check
+        // FIXME(pcwalton): I think this is actually sound? Could borrow check
         // allow this safely?
         unsafe {
             cast::transmute_copy(&self.factory)
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index e63208bcaec..e99e7fa4edd 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -212,7 +212,7 @@ impl Task {
         // pretty sketchy and involves shuffling vtables of trait objects
         // around, but it gets the job done.
         //
-        // XXX: This function is a serious code smell and should be avoided at
+        // FIXME: This function is a serious code smell and should be avoided at
         //      all costs. I have yet to think of a method to avoid this
         //      function, and I would be saddened if more usage of the function
         //      crops up.
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index b482e2fb67f..9c17c624987 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -20,7 +20,7 @@ use unstable::running_on_valgrind;
 use vec::ImmutableVector;
 
 // Indicates whether we should perform expensive sanity checks, including rtassert!
-// XXX: Once the runtime matures remove the `true` below to turn off rtassert, etc.
+// FIXME: Once the runtime matures remove the `true` below to turn off rtassert, etc.
 pub static ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) || cfg!(rtassert);
 
 /// Get the number of cores available
diff --git a/src/libstd/send_str.rs b/src/libstd/send_str.rs
index c8143442d6e..b6c9acd2672 100644
--- a/src/libstd/send_str.rs
+++ b/src/libstd/send_str.rs
@@ -119,7 +119,7 @@ impl Str for SendStr {
     fn as_slice<'r>(&'r self) -> &'r str {
         match *self {
             SendStrOwned(ref s) => s.as_slice(),
-            // XXX: Borrowchecker doesn't recognize lifetime as static unless prompted
+            // FIXME: Borrowchecker doesn't recognize lifetime as static unless prompted
             // SendStrStatic(s) => s.as_slice()
             SendStrStatic(s)    => {let tmp: &'static str = s; tmp}
         }
diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs
index e740862fddf..b65feedb2ae 100644
--- a/src/libstd/sync/deque.rs
+++ b/src/libstd/sync/deque.rs
@@ -45,7 +45,7 @@
 // NB: the "buffer pool" strategy is not done for speed, but rather for
 //     correctness. For more info, see the comment on `swap_buffer`
 
-// XXX: all atomic operations in this module use a SeqCst ordering. That is
+// FIXME: all atomic operations in this module use a SeqCst ordering. That is
 //      probably overkill
 
 use cast;
diff --git a/src/libstd/sync/spsc_queue.rs b/src/libstd/sync/spsc_queue.rs
index 6f1b887c271..b4b327cc9d1 100644
--- a/src/libstd/sync/spsc_queue.rs
+++ b/src/libstd/sync/spsc_queue.rs
@@ -43,7 +43,7 @@ use sync::atomics::{AtomicPtr, Relaxed, AtomicUint, Acquire, Release};
 
 // Node within the linked list queue of messages to send
 struct Node<T> {
-    // XXX: this could be an uninitialized T if we're careful enough, and
+    // FIXME: this could be an uninitialized T if we're careful enough, and
     //      that would reduce memory usage (and be a bit faster).
     //      is it worth it?
     value: Option<T>,           // nullable for re-use of nodes
@@ -225,7 +225,7 @@ impl<T: Send, P: Send> State<T, P> {
         if self.cache_bound == 0 {
             self.tail_prev.store(tail, Release);
         } else {
-            // XXX: this is dubious with overflow.
+            // FIXME: this is dubious with overflow.
             let additions = self.cache_additions.load(Relaxed);
             let subtractions = self.cache_subtractions.load(Relaxed);
             let size = additions - subtractions;
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 0585f1abecc..49bea6a33a9 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -86,7 +86,7 @@ pub fn path_elem_to_str(pe: PathElem, itr: @IdentInterner) -> ~str {
 /// from, even if it's hard to read (previously they would all just be
 /// listed as `__extensions__::method_name::hash`, with no indication
 /// of the type).
-// XXX: these dollar signs and the names in general are actually a
+// FIXME: these dollar signs and the names in general are actually a
 //      relic of $ being one of the very few valid symbol names on
 //      unix. These kinds of details shouldn't be exposed way up here
 //      in the ast.
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index d81999c1e5f..d4a412bbe9f 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -41,7 +41,7 @@ pub struct BytePos(u32);
 #[deriving(Eq,IterBytes, Ord)]
 pub struct CharPos(uint);
 
-// XXX: Lots of boilerplate in these impls, but so far my attempts to fix
+// FIXME: Lots of boilerplate in these impls, but so far my attempts to fix
 // have been unsuccessful
 
 impl Pos for BytePos {
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 3c0d7aaf4f3..3b2cc4ca6ed 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -179,7 +179,7 @@ pub trait AstBuilder {
             name: Ident, attrs: ~[ast::Attribute], node: ast::Item_) -> @ast::Item;
 
     fn arg(&self, span: Span, name: Ident, ty: P<ast::Ty>) -> ast::Arg;
-    // XXX unused self
+    // FIXME unused self
     fn fn_decl(&self, inputs: ~[ast::Arg], output: P<ast::Ty>) -> P<ast::FnDecl>;
 
     fn item_fn_poly(&self,
@@ -724,7 +724,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         }
     }
 
-    // XXX unused self
+    // FIXME unused self
     fn fn_decl(&self, inputs: ~[ast::Arg], output: P<ast::Ty>) -> P<ast::FnDecl> {
         P(ast::FnDecl {
             inputs: inputs,
@@ -736,7 +736,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
 
     fn item(&self, span: Span,
             name: Ident, attrs: ~[ast::Attribute], node: ast::Item_) -> @ast::Item {
-        // XXX: Would be nice if our generated code didn't violate
+        // FIXME: Would be nice if our generated code didn't violate
         // Rust coding conventions
         @ast::Item { ident: name,
                     attrs: attrs,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index cd87819917a..1ffff03a80f 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -115,7 +115,7 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
 
                     // Keep going, outside-in.
                     //
-                    // XXX(pcwalton): Is it necessary to clone the
+                    // FIXME(pcwalton): Is it necessary to clone the
                     // node here?
                     let fully_expanded =
                         fld.fold_expr(marked_after).node.clone();
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 20d544f52c9..87a2f374c90 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -173,7 +173,7 @@ fn lockstep_iter_size(t: &TokenTree, r: &TtReader) -> LockstepIterSize {
 // return the next token from the TtReader.
 // EFFECT: advances the reader's token field
 pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
-    // XXX(pcwalton): Bad copy?
+    // FIXME(pcwalton): Bad copy?
     let ret_val = TokenAndSpan {
         tok: r.cur_tok.get(),
         sp: r.cur_span.get(),
@@ -231,7 +231,7 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
     }
     loop { /* because it's easiest, this handles `TTDelim` not starting
     with a `TTTok`, even though it won't happen */
-        // XXX(pcwalton): Bad copy.
+        // FIXME(pcwalton): Bad copy.
         match r.stack.get().forest[r.stack.get().idx.get()].clone() {
           TTDelim(tts) => {
             r.stack.set(@TtFrame {
@@ -250,7 +250,7 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
             return ret_val;
           }
           TTSeq(sp, tts, sep, zerok) => {
-            // XXX(pcwalton): Bad copy.
+            // FIXME(pcwalton): Bad copy.
             let t = TTSeq(sp, tts, sep.clone(), zerok);
             match lockstep_iter_size(&t, r) {
               LisUnconstrained => {
@@ -306,7 +306,7 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
                 return ret_val;
               }
               MatchedNonterminal(ref other_whole_nt) => {
-                // XXX(pcwalton): Bad copy.
+                // FIXME(pcwalton): Bad copy.
                 r.cur_span.set(sp);
                 r.cur_tok.set(INTERPOLATED((*other_whole_nt).clone()));
                 r.stack.get().idx.set(r.stack.get().idx.get() + 1u);
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index f753861892f..2521bb515f7 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -123,7 +123,7 @@ impl Reader for StringReader {
     }
     fn span_diag(@self) -> @SpanHandler { self.span_diagnostic }
     fn peek(@self) -> TokenAndSpan {
-        // XXX(pcwalton): Bad copy!
+        // FIXME(pcwalton): Bad copy!
         TokenAndSpan {
             tok: self.peek_tok.get(),
             sp: self.peek_span.get(),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 557e7e04ebf..fe38ace2ba6 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1237,7 +1237,7 @@ impl Parser {
                 Parser::token_is_lifetime(&self.token) {
             // CLOSURE
             //
-            // XXX(pcwalton): Eventually `token::LT` will not unambiguously
+            // FIXME(pcwalton): Eventually `token::LT` will not unambiguously
             // introduce a closure, once procs can have lifetime bounds. We
             // will need to refactor the grammar a little bit at that point.
 
@@ -3949,7 +3949,7 @@ impl Parser {
         let generics = self.parse_generics();
 
         // This is a new-style impl declaration.
-        // XXX: clownshoes
+        // FIXME: clownshoes
         let ident = special_idents::clownshoes_extensions;
 
         // Special case: if the next identifier that follows is '(', don't
@@ -4071,7 +4071,7 @@ impl Parser {
                                token_str))
         }
 
-        let _ = ast::DUMMY_NODE_ID;  // XXX: Workaround for crazy bug.
+        let _ = ast::DUMMY_NODE_ID;  // FIXME: Workaround for crazy bug.
         let new_id = ast::DUMMY_NODE_ID;
         (class_name,
          ItemStruct(@ast::StructDef {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 54e9a8bd629..36a87658c11 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -2311,7 +2311,7 @@ pub fn print_string(s: &mut State, st: &str, style: ast::StrStyle) {
     word(&mut s.s, st);
 }
 
-// XXX(pcwalton): A nasty function to extract the string from an `io::Writer`
+// FIXME(pcwalton): A nasty function to extract the string from an `io::Writer`
 // that we "know" to be a `MemWriter` that works around the lack of checked
 // downcasts.
 unsafe fn get_mem_writer(writer: &mut ~io::Writer) -> ~str {
diff --git a/src/rt/rust_uv.c b/src/rt/rust_uv.c
index 4d859eacecc..c8f041c6562 100644
--- a/src/rt/rust_uv.c
+++ b/src/rt/rust_uv.c
@@ -25,7 +25,7 @@
 
 void*
 rust_uv_loop_new() {
-// XXX libuv doesn't always ignore SIGPIPE even though we don't need it.
+// FIXME libuv doesn't always ignore SIGPIPE even though we don't need it.
 #ifndef __WIN32__
     signal(SIGPIPE, SIG_IGN);
 #endif
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index d0f91a358a7..3719e76b30f 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -56,7 +56,7 @@ static HOMO_SAPIENS: [AminoAcid, ..4] = [
     AminoAcid { c: 't' as u8, p: 0.3015094502008 },
 ];
 
-// XXX: Use map().
+// FIXME: Use map().
 fn sum_and_scale(a: &'static [AminoAcid]) -> ~[AminoAcid] {
     let mut result = ~[];
     let mut p = 0f32;
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 61e76b99283..94569dc5ac0 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -49,7 +49,7 @@ impl Code {
         code
     }
 
-    // XXX: Inefficient.
+    // FIXME: Inefficient.
     fn unpack(&self, frame: i32) -> ~str {
         let mut key = **self;
         let mut result = ~[];
diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs
index ceec1ae3d8a..ee683d4de46 100644
--- a/src/test/compile-fail/lint-stability.rs
+++ b/src/test/compile-fail/lint-stability.rs
@@ -22,7 +22,7 @@ mod cross_crate {
     use self::lint_stability::*;
 
     fn test() {
-        // XXX: attributes on methods are not encoded cross crate.
+        // FIXME: attributes on methods are not encoded cross crate.
         let foo = MethodTester;
 
         deprecated(); //~ ERROR use of deprecated item
diff --git a/src/test/run-pass/auto-ref-slice-plus-ref.rs b/src/test/run-pass/auto-ref-slice-plus-ref.rs
index 667d9b738c2..eae791b6b08 100644
--- a/src/test/run-pass/auto-ref-slice-plus-ref.rs
+++ b/src/test/run-pass/auto-ref-slice-plus-ref.rs
@@ -37,7 +37,7 @@ pub fn main() {
     (@"test").test_imm();
     (&"test").test_imm();
 
-    // XXX: Other types of mutable vecs don't currently exist
+    // FIXME: Other types of mutable vecs don't currently exist
 
     // NB: We don't do this double autoreffing for &mut self because that would
     // allow creating a mutable pointer to a temporary, which would be a source