diff --git a/configure b/configure
index ef474fcf79dab..97c998a5cda3c 100755
--- a/configure
+++ b/configure
@@ -523,30 +523,35 @@ fi
 BOOL_OPTIONS=""
 VAL_OPTIONS=""
 
+opt debug 0 "debug mode"
 opt valgrind 0 "run tests with valgrind (memcheck by default)"
 opt helgrind 0 "run tests with helgrind instead of memcheck"
 opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind"
 opt docs     1 "build standard library documentation"
 opt compiler-docs     0 "build compiler documentation"
-opt optimize 1 "build optimized rust code"
-opt optimize-cxx 1 "build optimized C++ code"
-opt optimize-llvm 1 "build optimized LLVM"
 opt optimize-tests 1 "build tests with optimizations"
 opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang"
-opt llvm-assertions 1 "build LLVM with assertions"
-opt debug 1 "build with extra debug fun"
+opt llvm-assertions 0 "build LLVM with assertions"
+opt debug-assertions 0 "build with debugging assertions"
 opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
 opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
 opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM"
 opt rpath 0 "build rpaths into rustc itself"
-opt nightly 0 "build nightly packages"
-opt verify-install 1 "verify installed binaries work"
 # This is used by the automation to produce single-target nightlies
 opt dist-host-only 0 "only install bins for the host architecture"
 opt inject-std-version 1 "inject the current compiler version of libstd into programs"
 opt llvm-version-check 1 "don't check if the LLVM version is supported, build anyway"
 
+# Optimization and debugging options. These may be overridden by the release channel, etc.
+opt_nosave optimize 1 "build optimized rust code"
+opt_nosave optimize-cxx 1 "build optimized C++ code"
+opt_nosave optimize-llvm 1 "build optimized LLVM"
+opt_nosave llvm-assertions 0 "build LLVM with assertions"
+opt_nosave debug-assertions 0 "build with debugging assertions"
+opt_nosave debuginfo 0 "build with debugger metadata"
+opt_nosave debug-jemalloc 0 "build jemalloc with --enable-debug --enable-fill"
+
 valopt localstatedir "/var/lib" "local state directory"
 valopt sysconfdir "/etc" "install system configuration files"
 
@@ -556,6 +561,7 @@ valopt llvm-root "" "set LLVM root"
 valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located"
 valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple"
 valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path"
+valopt release-channel "dev" "the name of the release channel to build"
 
 # Many of these are saved below during the "writing configuration" step
 # (others are conditionally saved).
@@ -568,7 +574,6 @@ valopt_nosave local-rust-root "/usr/local" "set prefix for local rust binary"
 valopt_nosave host "${CFG_BUILD}" "GNUs ./configure syntax LLVM host triples"
 valopt_nosave target "${CFG_HOST}" "GNUs ./configure syntax LLVM target triples"
 valopt_nosave mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
-valopt_nosave release-channel "dev" "the name of the release channel to build"
 
 # Temporarily support old triples until buildbots get updated
 CFG_BUILD=$(to_llvm_triple $CFG_BUILD)
@@ -621,13 +626,24 @@ case "$CFG_RELEASE_CHANNEL" in
         ;;
 esac
 
-# Continue supporting the old --enable-nightly flag to transition the bots
-# XXX Remove me
-if [ ! -z "$CFG_ENABLE_NIGHTLY" ]
-then
-    CFG_RELEASE_CHANNEL=nightly
+# Adjust perf and debug options for debug mode
+if [ -n "$CFG_ENABLE_DEBUG" ]; then
+    msg "debug mode enabled, setting performance options"
+    CFG_DISABLE_OPTIMIZE=1
+    CFG_DISABLE_OPTIMIZE_CXX=1
+    CFG_ENABLE_LLVM_ASSERTIONS=1
+    CFG_ENABLE_DEBUG_ASSERTIONS=1
+    CFG_ENABLE_DEBUG_JEMALLOC=1
 fi
-putvar CFG_RELEASE_CHANNEL
+
+# OK, now write the debugging options
+if [ -n "$CFG_DISABLE_OPTIMIZE" ]; then putvar CFG_DISABLE_OPTIMIZE; fi
+if [ -n "$CFG_DISABLE_OPTIMIZE_CXX" ]; then putvar CFG_DISABLE_OPTIMIZE_CXX; fi
+if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then putvar CFG_DISABLE_OPTIMIZE_LLVM; fi
+if [ -n "$CFG_ENABLE_LLVM_ASSERTIONS" ]; then putvar CFG_ENABLE_LLVM_ASSERTIONS; fi
+if [ -n "$CFG_ENABLE_DEBUG_ASSERTIONS" ]; then putvar CFG_ENABLE_DEBUG_ASSERTIONS; fi
+if [ -n "$CFG_ENABLE_DEBUGINFO" ]; then putvar CFG_ENABLE_DEBUGINFO; fi
+if [ -n "$CFG_ENABLE_DEBUG_JEMALLOC" ]; then putvar CFG_ENABLE_DEBUG_JEMALLOC; fi
 
 # A magic value that allows the compiler to use unstable features
 # during the bootstrap even when doing so would normally be an error
@@ -1180,7 +1196,7 @@ do
             LLVM_DBG_OPTS="--enable-optimized"
             LLVM_INST_DIR=$LLVM_BUILD_DIR/Release
         fi
-        if [ ! -z "$CFG_DISABLE_LLVM_ASSERTIONS" ]
+        if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ]
         then
             LLVM_ASSERTION_OPTS="--disable-assertions"
         else
@@ -1434,6 +1450,11 @@ move_if_changed config.tmp config.mk
 rm -f config.tmp
 touch config.stamp
 
-step_msg "complete"
+if [ -z "$CFG_ENABLE_DEBUG" ]; then
+    step_msg "configured in release mode. for development consider --enable-debug"
+else
+    step_msg "complete"
+fi
+
 msg "run \`make help\`"
 msg
diff --git a/mk/install.mk b/mk/install.mk
index 8850cd778035f..cabc97a1e4912 100644
--- a/mk/install.mk
+++ b/mk/install.mk
@@ -8,12 +8,6 @@
 # option. This file may not be copied, modified, or distributed
 # except according to those terms.
 
-ifdef CFG_DISABLE_VERIFY_INSTALL
-MAYBE_DISABLE_VERIFY=--disable-verify
-else
-MAYBE_DISABLE_VERIFY=
-endif
-
 install:
 ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
 # Build the dist as the original user
@@ -22,9 +16,9 @@ else
 	$(Q)$(MAKE) prepare_install
 endif
 ifeq ($(CFG_DISABLE_DOCS),)
-	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(DOC_PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
+	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(DOC_PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
 endif
-	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
+	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
 # Remove tmp files because it's a decent amount of disk space
 	$(Q)rm -R tmp/dist
 
diff --git a/mk/main.mk b/mk/main.mk
index b9f2cf1cce89c..ea00444453d00 100644
--- a/mk/main.mk
+++ b/mk/main.mk
@@ -126,11 +126,16 @@ endif
 
 CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS)
 
-ifdef CFG_DISABLE_DEBUG
-  CFG_RUSTC_FLAGS += --cfg ndebug
-else
-  $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG))
+ifdef CFG_ENABLE_DEBUG_ASSERTIONS
+  $(info cfg: enabling debug assertions (CFG_ENABLE_DEBUG_ASSERTIONS))
   CFG_RUSTC_FLAGS += --cfg debug -C debug-assertions=on
+else
+  CFG_RUSTC_FLAGS += --cfg ndebug
+endif
+
+ifdef CFG_ENABLE_DEBUGINFO
+  $(info cfg: enabling debuginfo (CFG_ENABLE_DEBUGINFO))
+  CFG_RUSTC_FLAGS += -g
 endif
 
 ifdef SAVE_TEMPS
diff --git a/mk/rt.mk b/mk/rt.mk
index 527485c502936..70abce8b46067 100644
--- a/mk/rt.mk
+++ b/mk/rt.mk
@@ -143,6 +143,10 @@ else ifeq ($(findstring android, $(OSTYPE_$(1))), android)
   JEMALLOC_ARGS_$(1) := --disable-tls
 endif
 
+ifdef CFG_ENABLE_DEBUG_JEMALLOC
+  JEMALLOC_ARGS_$(1) += --enable-debug --enable-fill
+endif
+
 ################################################################################
 # jemalloc
 ################################################################################
diff --git a/src/doc/trpl/associated-types.md b/src/doc/trpl/associated-types.md
index 7161cd33f89be..d59239016d881 100644
--- a/src/doc/trpl/associated-types.md
+++ b/src/doc/trpl/associated-types.md
@@ -198,5 +198,5 @@ let obj = Box::new(graph) as Box<Graph<N=Node, E=Edge>>;
 ```
 
 The `N=Node` syntax allows us to provide a concrete type, `Node`, for the `N`
-type parameter. Same with `E=Edge`. If we didn’t proide this constraint, we
+type parameter. Same with `E=Edge`. If we didn’t provide this constraint, we
 couldn’t be sure which `impl` to match this trait object to.
diff --git a/src/etc/rustup.sh b/src/etc/rustup.sh
index 918c0c66f76df..7c207385393c9 100755
--- a/src/etc/rustup.sh
+++ b/src/etc/rustup.sh
@@ -286,7 +286,7 @@ BOOL_OPTIONS=""
 VAL_OPTIONS=""
 
 flag uninstall "only uninstall from the installation prefix"
-valopt prefix "" "set installation prefix"
+valopt prefix "${RUSTUP_PREFIX}" "set installation prefix"
 valopt date "" "use the YYYY-MM-DD nightly instead of the current nightly"
 valopt channel "beta" "use the selected release channel [beta]"
 flag save "save the downloaded nightlies to ~/.rustup"
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 68bde1476118d..ff176d815916b 100644
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -668,6 +668,13 @@ impl<T: fmt::Debug> fmt::Debug for Arc<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> fmt::Pointer for Arc<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Pointer::fmt(&*self._ptr, f)
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Default + Sync + Send> Default for Arc<T> {
     #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 2801cf38cb755..4468e425a852d 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -275,6 +275,16 @@ impl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> fmt::Pointer for Box<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // It's not possible to extract the inner Uniq directly from the Box,
+        // instead we cast it to a *const which aliases the Unique
+        let ptr: *const T = &**self;
+        fmt::Pointer::fmt(&ptr, f)
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized> Deref for Box<T> {
     type Target = T;
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index 56822cfe28a35..67805d10a4a63 100644
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -634,6 +634,13 @@ impl<T: fmt::Debug> fmt::Debug for Rc<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> fmt::Pointer for Rc<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Pointer::fmt(&*self._ptr, f)
+    }
+}
+
 /// A weak version of `Rc<T>`.
 ///
 /// Weak references do not count when determining if the inner value should be
diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index 85e5bde48598e..311901b43d400 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -44,8 +44,7 @@ pub trait Clone : Sized {
     /// but can be overridden to reuse the resources of `a` to avoid unnecessary
     /// allocations.
     #[inline(always)]
-    #[unstable(feature = "core",
-               reason = "this function is rarely used")]
+    #[stable(feature = "rust1", since = "1.0.0")]
     fn clone_from(&mut self, source: &Self) {
         *self = source.clone()
     }
@@ -97,6 +96,27 @@ macro_rules! extern_fn_clone {
             #[inline]
             fn clone(&self) -> extern "Rust" fn($($A),*) -> ReturnType { *self }
         }
+
+        #[unstable(feature = "core", reason = "brand new")]
+        impl<$($A,)* ReturnType> Clone for extern "C" fn($($A),*) -> ReturnType {
+            /// Return a copy of a function pointer
+            #[inline]
+            fn clone(&self) -> extern "C" fn($($A),*) -> ReturnType { *self }
+        }
+
+        #[unstable(feature = "core", reason = "brand new")]
+        impl<$($A,)* ReturnType> Clone for unsafe extern "Rust" fn($($A),*) -> ReturnType {
+            /// Return a copy of a function pointer
+            #[inline]
+            fn clone(&self) -> unsafe extern "Rust" fn($($A),*) -> ReturnType { *self }
+        }
+
+        #[unstable(feature = "core", reason = "brand new")]
+        impl<$($A,)* ReturnType> Clone for unsafe extern "C" fn($($A),*) -> ReturnType {
+            /// Return a copy of a function pointer
+            #[inline]
+            fn clone(&self) -> unsafe extern "C" fn($($A),*) -> ReturnType { *self }
+        }
     )
 }
 
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index ff51e25fcbf25..36b33e7581dd9 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -94,6 +94,7 @@ use mem;
 use clone::Clone;
 use intrinsics;
 use ops::Deref;
+use core::fmt;
 use option::Option::{self, Some, None};
 use marker::{PhantomData, Send, Sized, Sync};
 use nonzero::NonZero;
@@ -570,3 +571,10 @@ impl<T:?Sized> Deref for Unique<T> {
         unsafe { mem::transmute(&*self.pointer) }
     }
 }
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> fmt::Pointer for Unique<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Pointer::fmt(&*self.pointer, f)
+    }
+}
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
index ce011f2561b79..ee9d1e015539e 100644
--- a/src/librustc/middle/check_const.rs
+++ b/src/librustc/middle/check_const.rs
@@ -662,7 +662,19 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'tcx> {
               cmt: mc::cmt<'tcx>,
               _loan_region: ty::Region,
               bk: ty::BorrowKind,
-              loan_cause: euv::LoanCause) {
+              loan_cause: euv::LoanCause)
+    {
+        // Kind of hacky, but we allow Unsafe coercions in constants.
+        // These occur when we convert a &T or *T to a *U, as well as
+        // when making a thin pointer (e.g., `*T`) into a fat pointer
+        // (e.g., `*Trait`).
+        match loan_cause {
+            euv::LoanCause::AutoUnsafe => {
+                return;
+            }
+            _ => { }
+        }
+
         let mut cur = &cmt;
         let mut is_interior = false;
         loop {
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
index 2fa9c7c8fbebb..18e634a2dd630 100644
--- a/src/librustc/middle/expr_use_visitor.rs
+++ b/src/librustc/middle/expr_use_visitor.rs
@@ -99,6 +99,7 @@ pub enum LoanCause {
     ClosureCapture(Span),
     AddrOf,
     AutoRef,
+    AutoUnsafe,
     RefBinding,
     OverloadedOperator,
     ClosureInvocation,
@@ -800,18 +801,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                             return_if_err!(self.mc.cat_expr_unadjusted(expr));
                         self.delegate_consume(expr.id, expr.span, cmt_unadjusted);
                     }
-                    ty::AdjustDerefRef(ty::AutoDerefRef {
-                        autoref: ref opt_autoref,
-                        autoderefs: n
-                    }) => {
-                        self.walk_autoderefs(expr, n);
-
-                        match *opt_autoref {
-                            None => { }
-                            Some(ref r) => {
-                                self.walk_autoref(expr, r, n);
-                            }
-                        }
+                    ty::AdjustDerefRef(ref adj) => {
+                        self.walk_autoderefref(expr, adj);
                     }
                 }
             }
@@ -852,39 +843,165 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
         }
     }
 
+    fn walk_autoderefref(&mut self,
+                         expr: &ast::Expr,
+                         adj: &ty::AutoDerefRef<'tcx>) {
+        debug!("walk_autoderefref expr={} adj={}",
+               expr.repr(self.tcx()),
+               adj.repr(self.tcx()));
+
+        self.walk_autoderefs(expr, adj.autoderefs);
+
+        // Weird hacky special case: AutoUnsizeUniq, which converts
+        // from a ~T to a ~Trait etc, always comes in a stylized
+        // fashion. In particular, we want to consume the ~ pointer
+        // being dereferenced, not the dereferenced content (as the
+        // content is, at least for upcasts, unsized).
+        match adj.autoref {
+            Some(ty::AutoUnsizeUniq(_)) => {
+                assert!(adj.autoderefs == 1,
+                        format!("Expected exactly 1 deref with Uniq AutoRefs, found: {}",
+                                adj.autoderefs));
+                let cmt_unadjusted =
+                    return_if_err!(self.mc.cat_expr_unadjusted(expr));
+                self.delegate_consume(expr.id, expr.span, cmt_unadjusted);
+                return;
+            }
+            _ => { }
+        }
+
+        let autoref = adj.autoref.as_ref();
+        let cmt_derefd = return_if_err!(
+            self.mc.cat_expr_autoderefd(expr, adj.autoderefs));
+        self.walk_autoref(expr, &cmt_derefd, autoref);
+    }
+
+    /// Walks the autoref `opt_autoref` applied to the autoderef'd
+    /// `expr`. `cmt_derefd` is the mem-categorized form of `expr`
+    /// after all relevant autoderefs have occurred. Because AutoRefs
+    /// can be recursive, this function is recursive: it first walks
+    /// deeply all the way down the autoref chain, and then processes
+    /// the autorefs on the way out. At each point, it returns the
+    /// `cmt` for the rvalue that will be produced by introduced an
+    /// autoref.
     fn walk_autoref(&mut self,
                     expr: &ast::Expr,
-                    autoref: &ty::AutoRef,
-                    n: usize) {
-        debug!("walk_autoref expr={}", expr.repr(self.tcx()));
+                    cmt_derefd: &mc::cmt<'tcx>,
+                    opt_autoref: Option<&ty::AutoRef<'tcx>>)
+                    -> mc::cmt<'tcx>
+    {
+        debug!("walk_autoref(expr.id={} cmt_derefd={} opt_autoref={:?})",
+               expr.id,
+               cmt_derefd.repr(self.tcx()),
+               opt_autoref);
+
+        let autoref = match opt_autoref {
+            Some(autoref) => autoref,
+            None => {
+                // No recursive step here, this is a base case.
+                return cmt_derefd.clone();
+            }
+        };
 
         match *autoref {
-            ty::AutoPtr(r, m, _) => {
-                let cmt_derefd = return_if_err!(
-                    self.mc.cat_expr_autoderefd(expr, n));
-                debug!("walk_adjustment: cmt_derefd={}",
-                       cmt_derefd.repr(self.tcx()));
+            ty::AutoPtr(r, m, ref baseref) => {
+                let cmt_base = self.walk_autoref_recursively(expr, cmt_derefd, baseref);
+
+                debug!("walk_autoref: expr.id={} cmt_base={}",
+                       expr.id,
+                       cmt_base.repr(self.tcx()));
 
                 self.delegate.borrow(expr.id,
                                      expr.span,
-                                     cmt_derefd,
+                                     cmt_base,
                                      r,
                                      ty::BorrowKind::from_mutbl(m),
                                      AutoRef);
             }
-            ty::AutoUnsize(_) |
+
+            ty::AutoUnsize(_) => {
+                // Converting a `[T; N]` to `[T]` or `T` to `Trait`
+                // isn't really a borrow, move, etc, in and of itself.
+                // Also, no recursive step here, this is a base case.
+
+                // It may seem a bit odd to return the cmt_derefd
+                // unmodified here, but in fact I think it's the right
+                // thing to do. Essentially the unsize transformation
+                // isn't really relevant to the borrowing rules --
+                // it's best thought of as a kind of side-modifier to
+                // the autoref, adding additional data that is
+                // attached to the pointer that is produced, but not
+                // affecting the data being borrowed in any other
+                // way. To see what I mean, consider this example:
+                //
+                //    fn foo<'a>(&'a self) -> &'a Trait { self }
+                //
+                // This is valid because the underlying `self` value
+                // lives for the lifetime 'a. If we were to treat the
+                // "unsizing" as e.g. producing an rvalue, that would
+                // only be valid for the temporary scope, which isn't
+                // enough to justify the return value, which have the
+                // lifetime 'a.
+                //
+                // Another option would be to add a variant for
+                // categorization (like downcast) that wraps
+                // cmt_derefd and represents the unsizing operation.
+                // But I don't think there is any particular use for
+                // this (yet). -nmatsakis
+                return cmt_derefd.clone();
+            }
+
             ty::AutoUnsizeUniq(_) => {
-                assert!(n == 1, format!("Expected exactly 1 deref with Uniq \
-                                         AutoRefs, found: {}", n));
-                let cmt_unadjusted =
-                    return_if_err!(self.mc.cat_expr_unadjusted(expr));
-                self.delegate_consume(expr.id, expr.span, cmt_unadjusted);
+                // these are handled via special case above
+                self.tcx().sess.span_bug(expr.span, "nexpected AutoUnsizeUniq");
             }
-            ty::AutoUnsafe(..) => {
+
+            ty::AutoUnsafe(m, ref baseref) => {
+                let cmt_base = self.walk_autoref_recursively(expr, cmt_derefd, baseref);
+
+                debug!("walk_autoref: expr.id={} cmt_base={}",
+                       expr.id,
+                       cmt_base.repr(self.tcx()));
+
+                // Converting from a &T to *T (or &mut T to *mut T) is
+                // treated as borrowing it for the enclosing temporary
+                // scope.
+                let r = ty::ReScope(region::CodeExtent::from_node_id(expr.id));
+
+                self.delegate.borrow(expr.id,
+                                     expr.span,
+                                     cmt_base,
+                                     r,
+                                     ty::BorrowKind::from_mutbl(m),
+                                     AutoUnsafe);
             }
         }
+
+        // Construct the categorization for the result of the autoref.
+        // This is always an rvalue, since we are producing a new
+        // (temporary) indirection.
+
+        let adj_ty =
+            ty::adjust_ty_for_autoref(self.tcx(),
+                                      expr.span,
+                                      cmt_derefd.ty,
+                                      opt_autoref);
+
+        self.mc.cat_rvalue_node(expr.id, expr.span, adj_ty)
     }
 
+    fn walk_autoref_recursively(&mut self,
+                                expr: &ast::Expr,
+                                cmt_derefd: &mc::cmt<'tcx>,
+                                autoref: &Option<Box<ty::AutoRef<'tcx>>>)
+                                -> mc::cmt<'tcx>
+    {
+        // Shuffle from a ref to an optional box to an optional ref.
+        let autoref: Option<&ty::AutoRef<'tcx>> = autoref.as_ref().map(|b| &**b);
+        self.walk_autoref(expr, cmt_derefd, autoref)
+    }
+
+
     // When this returns true, it means that the expression *is* a
     // method-call (i.e. via the operator-overload).  This true result
     // also implies that walk_overloaded_operator already took care of
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index 85255d04df432..6c7dc61109fb5 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -833,6 +833,15 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
         ret
     }
 
+    /// Returns the lifetime of a temporary created by expr with id `id`.
+    /// This could be `'static` if `id` is part of a constant expression.
+    pub fn temporary_scope(&self, id: ast::NodeId) -> ty::Region {
+        match self.typer.temporary_scope(id) {
+            Some(scope) => ty::ReScope(scope),
+            None => ty::ReStatic
+        }
+    }
+
     pub fn cat_rvalue_node(&self,
                            id: ast::NodeId,
                            span: Span,
@@ -848,17 +857,12 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
             _ => check_const::NOT_CONST
         };
 
+        // Compute maximum lifetime of this rvalue. This is 'static if
+        // we can promote to a constant, otherwise equal to enclosing temp
+        // lifetime.
         let re = match qualif & check_const::NON_STATIC_BORROWS {
-            check_const::PURE_CONST => {
-                // Constant rvalues get promoted to 'static.
-                ty::ReStatic
-            }
-            _ => {
-                match self.typer.temporary_scope(id) {
-                    Some(scope) => ty::ReScope(scope),
-                    None => ty::ReStatic
-                }
-            }
+            check_const::PURE_CONST => ty::ReStatic,
+            _ => self.temporary_scope(id),
         };
         let ret = self.cat_rvalue(id, span, re, expr_ty);
         debug!("cat_rvalue_node ret {}", ret.repr(self.tcx()));
diff --git a/src/librustc/plugin/registry.rs b/src/librustc/plugin/registry.rs
index a73ed04ac0a41..322b5d3a8cf27 100644
--- a/src/librustc/plugin/registry.rs
+++ b/src/librustc/plugin/registry.rs
@@ -22,6 +22,7 @@ use syntax::ptr::P;
 use syntax::ast;
 
 use std::collections::HashMap;
+use std::borrow::ToOwned;
 
 /// Structure used to register plugins.
 ///
@@ -50,6 +51,9 @@ pub struct Registry<'a> {
 
     #[doc(hidden)]
     pub lint_groups: HashMap<&'static str, Vec<LintId>>,
+
+    #[doc(hidden)]
+    pub llvm_passes: Vec<String>,
 }
 
 impl<'a> Registry<'a> {
@@ -62,6 +66,7 @@ impl<'a> Registry<'a> {
             syntax_exts: vec!(),
             lint_passes: vec!(),
             lint_groups: HashMap::new(),
+            llvm_passes: vec!(),
         }
     }
 
@@ -116,4 +121,13 @@ impl<'a> Registry<'a> {
     pub fn register_lint_group(&mut self, name: &'static str, to: Vec<&'static Lint>) {
         self.lint_groups.insert(name, to.into_iter().map(|x| LintId::of(x)).collect());
     }
+
+    /// Register an LLVM pass.
+    ///
+    /// Registration with LLVM itself is handled through static C++ objects with
+    /// constructors. This method simply adds a name to the list of passes to
+    /// execute.
+    pub fn register_llvm_pass(&mut self, name: &str) {
+        self.llvm_passes.push(name.to_owned());
+    }
 }
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index 452840310aa41..148f484b0ed5c 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -52,6 +52,7 @@ pub struct Session {
     pub working_dir: PathBuf,
     pub lint_store: RefCell<lint::LintStore>,
     pub lints: RefCell<NodeMap<Vec<(lint::LintId, codemap::Span, String)>>>,
+    pub plugin_llvm_passes: RefCell<Vec<String>>,
     pub crate_types: RefCell<Vec<config::CrateType>>,
     pub crate_metadata: RefCell<Vec<String>>,
     pub features: RefCell<feature_gate::Features>,
@@ -391,6 +392,7 @@ pub fn build_session_(sopts: config::Options,
         working_dir: env::current_dir().unwrap(),
         lint_store: RefCell::new(lint::LintStore::new()),
         lints: RefCell::new(NodeMap()),
+        plugin_llvm_passes: RefCell::new(Vec::new()),
         crate_types: RefCell::new(Vec::new()),
         crate_metadata: RefCell::new(Vec::new()),
         features: RefCell::new(feature_gate::Features::new()),
diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs
index ce7b492c51af1..9776538de3fed 100644
--- a/src/librustc_borrowck/borrowck/check_loans.rs
+++ b/src/librustc_borrowck/borrowck/check_loans.rs
@@ -542,6 +542,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 euv::OverloadedOperator(..) |
                 euv::AddrOf(..) |
                 euv::AutoRef(..) |
+                euv::AutoUnsafe(..) |
                 euv::ClosureInvocation(..) |
                 euv::ForLoop(..) |
                 euv::RefBinding(..) |
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
index f8da075e4bdc2..c57cbcb929fbc 100644
--- a/src/librustc_borrowck/borrowck/mod.rs
+++ b/src/librustc_borrowck/borrowck/mod.rs
@@ -775,6 +775,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                     euv::AddrOf |
                     euv::RefBinding |
                     euv::AutoRef |
+                    euv::AutoUnsafe |
                     euv::ForLoop |
                     euv::MatchDiscriminant => {
                         format!("cannot borrow {} as mutable", descr)
@@ -822,6 +823,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             BorrowViolation(euv::OverloadedOperator) |
             BorrowViolation(euv::AddrOf) |
             BorrowViolation(euv::AutoRef) |
+            BorrowViolation(euv::AutoUnsafe) |
             BorrowViolation(euv::RefBinding) |
             BorrowViolation(euv::MatchDiscriminant) => {
                 "cannot borrow data mutably"
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
index fe05b489229ad..e310798b20ab7 100644
--- a/src/librustc_driver/driver.rs
+++ b/src/librustc_driver/driver.rs
@@ -438,7 +438,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         }
     });
 
-    let Registry { syntax_exts, lint_passes, lint_groups, .. } = registry;
+    let Registry { syntax_exts, lint_passes, lint_groups, llvm_passes, .. } = registry;
 
     {
         let mut ls = sess.lint_store.borrow_mut();
@@ -449,6 +449,8 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         for (name, to) in lint_groups {
             ls.register_group(Some(sess), true, name, to);
         }
+
+        *sess.plugin_llvm_passes.borrow_mut() = llvm_passes;
     }
 
     // Lint plugins are registered; now we can process command line flags.
diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs
index cc588a365f6e6..de21d62651499 100644
--- a/src/librustc_trans/back/write.rs
+++ b/src/librustc_trans/back/write.rs
@@ -319,6 +319,8 @@ struct CodegenContext<'a> {
     lto_ctxt: Option<(&'a Session, &'a [String])>,
     // Handler to use for diagnostics produced during codegen.
     handler: &'a Handler,
+    // LLVM passes added by plugins.
+    plugin_passes: Vec<String>,
     // LLVM optimizations for which we want to print remarks.
     remark: Passes,
 }
@@ -328,6 +330,7 @@ impl<'a> CodegenContext<'a> {
         CodegenContext {
             lto_ctxt: Some((sess, reachable)),
             handler: sess.diagnostic().handler(),
+            plugin_passes: sess.plugin_llvm_passes.borrow().clone(),
             remark: sess.opts.cg.remark.clone(),
         }
     }
@@ -461,6 +464,16 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext,
                 }
             }
 
+            for pass in &cgcx.plugin_passes {
+                let pass = CString::new(pass.clone()).unwrap();
+                if !llvm::LLVMRustAddPass(mpm, pass.as_ptr()) {
+                    cgcx.handler.err(&format!("a plugin asked for LLVM pass {:?} but LLVM \
+                                               does not recognize it", pass));
+                }
+            }
+
+            cgcx.handler.abort_if_errors();
+
             // Finally, run the actual optimization passes
             time(config.time_passes, "llvm function passes", (), |()|
                  llvm::LLVMRustRunFunctionPassManager(fpm, llmod));
@@ -907,6 +920,7 @@ fn run_work_multithreaded(sess: &Session,
     for i in 0..num_workers {
         let work_items_arc = work_items_arc.clone();
         let diag_emitter = diag_emitter.clone();
+        let plugin_passes = sess.plugin_llvm_passes.borrow().clone();
         let remark = sess.opts.cg.remark.clone();
 
         let (tx, rx) = channel();
@@ -921,6 +935,7 @@ fn run_work_multithreaded(sess: &Session,
             let cgcx = CodegenContext {
                 lto_ctxt: None,
                 handler: &diag_handler,
+                plugin_passes: plugin_passes,
                 remark: remark,
             };
 
diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs
new file mode 100644
index 0000000000000..3773ff7078e9c
--- /dev/null
+++ b/src/librustc_typeck/check/cast.rs
@@ -0,0 +1,190 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Code for type-checking cast expressions.
+
+use super::coercion;
+use super::demand;
+use super::FnCtxt;
+use super::structurally_resolved_type;
+
+use lint;
+use middle::infer;
+use middle::ty;
+use middle::ty::Ty;
+use syntax::ast;
+use syntax::codemap::Span;
+
+/// Reifies a cast check to be checked once we have full type information for
+/// a function context.
+pub struct CastCheck<'tcx> {
+    expr: ast::Expr,
+    expr_ty: Ty<'tcx>,
+    cast_ty: Ty<'tcx>,
+    span: Span,
+}
+
+impl<'tcx> CastCheck<'tcx> {
+    pub fn new(expr: ast::Expr, expr_ty: Ty<'tcx>, cast_ty: Ty<'tcx>, span: Span)
+               -> CastCheck<'tcx> {
+        CastCheck {
+            expr: expr,
+            expr_ty: expr_ty,
+            cast_ty: cast_ty,
+            span: span,
+        }
+    }
+}
+
+pub fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) {
+    fn cast_through_integer_err<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+                                          span: Span,
+                                          t_1: Ty<'tcx>,
+                                          t_e: Ty<'tcx>) {
+        fcx.type_error_message(span, |actual| {
+            format!("illegal cast; cast through an \
+                    integer first: `{}` as `{}`",
+                    actual,
+                    fcx.infcx().ty_to_string(t_1))
+        }, t_e, None);
+    }
+
+    let span = cast.span;
+    let e = &cast.expr;
+    let t_e = structurally_resolved_type(fcx, span, cast.expr_ty);
+    let t_1 = structurally_resolved_type(fcx, span, cast.cast_ty);
+
+    // Check for trivial casts.
+    if !ty::type_has_ty_infer(t_1) {
+        if let Ok(()) = coercion::mk_assignty(fcx, e, t_e, t_1) {
+            if ty::type_is_numeric(t_1) && ty::type_is_numeric(t_e) {
+                fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_NUMERIC_CASTS,
+                                        e.id,
+                                        span,
+                                        format!("trivial numeric cast: `{}` as `{}`. Cast can be \
+                                                 replaced by coercion, this might require type \
+                                                 ascription or a temporary variable",
+                                                fcx.infcx().ty_to_string(t_e),
+                                                fcx.infcx().ty_to_string(t_1)));
+            } else {
+                fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_CASTS,
+                                        e.id,
+                                        span,
+                                        format!("trivial cast: `{}` as `{}`. Cast can be \
+                                                 replaced by coercion, this might require type \
+                                                 ascription or a temporary variable",
+                                                fcx.infcx().ty_to_string(t_e),
+                                                fcx.infcx().ty_to_string(t_1)));
+            }
+            return;
+        }
+    }
+
+    let t_e_is_bare_fn_item = ty::type_is_bare_fn_item(t_e);
+    let t_e_is_scalar = ty::type_is_scalar(t_e);
+    let t_e_is_integral = ty::type_is_integral(t_e);
+    let t_e_is_float = ty::type_is_floating_point(t_e);
+    let t_e_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_e);
+
+    let t_1_is_scalar = ty::type_is_scalar(t_1);
+    let t_1_is_integral = ty::type_is_integral(t_1);
+    let t_1_is_char = ty::type_is_char(t_1);
+    let t_1_is_bare_fn = ty::type_is_bare_fn(t_1);
+    let t_1_is_float = ty::type_is_floating_point(t_1);
+    let t_1_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_1);
+
+    // casts to scalars other than `char` and `bare fn` are trivial
+    let t_1_is_trivial = t_1_is_scalar && !t_1_is_char && !t_1_is_bare_fn;
+
+    if t_e_is_bare_fn_item && t_1_is_bare_fn {
+        demand::coerce(fcx, e.span, t_1, &e);
+    } else if t_1_is_char {
+        let t_e = fcx.infcx().shallow_resolve(t_e);
+        if t_e.sty != ty::ty_uint(ast::TyU8) {
+            fcx.type_error_message(span, |actual| {
+                format!("only `u8` can be cast as `char`, not `{}`", actual)
+            }, t_e, None);
+        }
+    } else if t_1.sty == ty::ty_bool {
+        span_err!(fcx.tcx().sess, span, E0054,
+                  "cannot cast as `bool`, compare with zero instead");
+    } else if t_e_is_float && (t_1_is_scalar || t_1_is_c_enum) &&
+        !(t_1_is_integral || t_1_is_float) {
+        // Casts from float must go through an integer
+        cast_through_integer_err(fcx, span, t_1, t_e)
+    } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) &&
+        !(t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) {
+        // Casts to float must go through an integer or boolean
+        cast_through_integer_err(fcx, span, t_1, t_e)
+    } else if t_e_is_c_enum && t_1_is_trivial {
+        if ty::type_is_unsafe_ptr(t_1) {
+            // ... and likewise with C enum -> *T
+            cast_through_integer_err(fcx, span, t_1, t_e)
+        }
+        // casts from C-like enums are allowed
+    } else if ty::type_is_region_ptr(t_e) && ty::type_is_unsafe_ptr(t_1) {
+        fn types_compatible<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span,
+                                      t1: Ty<'tcx>, t2: Ty<'tcx>) -> bool {
+            match t1.sty {
+                ty::ty_vec(_, Some(_)) => {}
+                _ => return false
+            }
+            if ty::type_needs_infer(t2) {
+                // This prevents this special case from going off when casting
+                // to a type that isn't fully specified; e.g. `as *_`. (Issue
+                // #14893.)
+                return false
+            }
+
+            let el = ty::sequence_element_type(fcx.tcx(), t1);
+            infer::mk_eqty(fcx.infcx(),
+                           false,
+                           infer::Misc(sp),
+                           el,
+                           t2).is_ok()
+        }
+
+        // Due to the limitations of LLVM global constants,
+        // region pointers end up pointing at copies of
+        // vector elements instead of the original values.
+        // To allow unsafe pointers to work correctly, we
+        // need to special-case obtaining an unsafe pointer
+        // from a region pointer to a vector.
+
+        /* this cast is only allowed from &[T, ..n] to *T or
+        &T to *T. */
+        match (&t_e.sty, &t_1.sty) {
+            (&ty::ty_rptr(_, ty::mt { ty: mt1, mutbl: ast::MutImmutable }),
+             &ty::ty_ptr(ty::mt { ty: mt2, mutbl: ast::MutImmutable }))
+            if types_compatible(fcx, e.span, mt1, mt2) => {
+                /* this case is allowed */
+            }
+            _ => {
+                demand::coerce(fcx, e.span, t_1, &e);
+            }
+        }
+    } else if fcx.type_is_fat_ptr(t_e, span) && !fcx.type_is_fat_ptr(t_1, span) {
+        fcx.type_error_message(span, |actual| {
+            format!("illegal cast; cast from fat pointer: `{}` as `{}`",
+                    actual, fcx.infcx().ty_to_string(t_1))
+        }, t_e, None);
+    } else if !(t_e_is_scalar && t_1_is_trivial) {
+        /*
+        If more type combinations should be supported than are
+        supported here, then file an enhancement issue and
+        record the issue number in this comment.
+        */
+        fcx.type_error_message(span, |actual| {
+            format!("non-scalar cast: `{}` as `{}`",
+                    actual,
+                    fcx.infcx().ty_to_string(t_1))
+        }, t_e, None);
+    }
+}
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index ce1227608cf31..f7bbc693ce59b 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -139,6 +139,7 @@ pub mod demand;
 pub mod method;
 mod upvar;
 pub mod wf;
+mod cast;
 mod closure;
 mod callee;
 mod compare_method;
@@ -185,7 +186,7 @@ pub struct Inherited<'a, 'tcx: 'a> {
     // back and process them.
     deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolutionHandler<'tcx>>>>,
 
-    deferred_cast_checks: RefCell<Vec<CastCheck<'tcx>>>,
+    deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
 }
 
 trait DeferredCallResolution<'tcx> {
@@ -194,15 +195,6 @@ trait DeferredCallResolution<'tcx> {
 
 type DeferredCallResolutionHandler<'tcx> = Box<DeferredCallResolution<'tcx>+'tcx>;
 
-/// Reifies a cast check to be checked once we have full type information for
-/// a function context.
-struct CastCheck<'tcx> {
-    expr: ast::Expr,
-    expr_ty: Ty<'tcx>,
-    cast_ty: Ty<'tcx>,
-    span: Span,
-}
-
 /// When type-checking an expression, we propagate downward
 /// whatever type hint we are able in the form of an `Expectation`.
 #[derive(Copy, Clone)]
@@ -1071,141 +1063,6 @@ fn report_cast_to_unsized_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 }
 
 
-fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) {
-    fn cast_through_integer_err<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-                                          span: Span,
-                                          t_1: Ty<'tcx>,
-                                          t_e: Ty<'tcx>) {
-        fcx.type_error_message(span, |actual| {
-            format!("illegal cast; cast through an \
-                    integer first: `{}` as `{}`",
-                    actual,
-                    fcx.infcx().ty_to_string(t_1))
-        }, t_e, None);
-    }
-
-    let span = cast.span;
-    let e = &cast.expr;
-    let t_e = structurally_resolved_type(fcx, span, cast.expr_ty);
-    let t_1 = structurally_resolved_type(fcx, span, cast.cast_ty);
-
-    // Check for trivial casts.
-    if !ty::type_has_ty_infer(t_1) {
-        if let Ok(()) = coercion::mk_assignty(fcx, e, t_e, t_1) {
-            if ty::type_is_numeric(t_1) && ty::type_is_numeric(t_e) {
-                fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_NUMERIC_CASTS,
-                                        e.id,
-                                        span,
-                                        format!("trivial numeric cast: `{}` as `{}`. Cast can be \
-                                                 replaced by coercion, this might require type \
-                                                 ascription or a temporary variable",
-                                                fcx.infcx().ty_to_string(t_e),
-                                                fcx.infcx().ty_to_string(t_1)));
-            } else {
-                fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_CASTS,
-                                        e.id,
-                                        span,
-                                        format!("trivial cast: `{}` as `{}`. Cast can be \
-                                                 replaced by coercion, this might require type \
-                                                 ascription or a temporary variable",
-                                                fcx.infcx().ty_to_string(t_e),
-                                                fcx.infcx().ty_to_string(t_1)));
-            }
-            return;
-        }
-    }
-
-    let t_e_is_bare_fn_item = ty::type_is_bare_fn_item(t_e);
-    let t_e_is_scalar = ty::type_is_scalar(t_e);
-    let t_e_is_integral = ty::type_is_integral(t_e);
-    let t_e_is_float = ty::type_is_floating_point(t_e);
-    let t_e_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_e);
-
-    let t_1_is_scalar = ty::type_is_scalar(t_1);
-    let t_1_is_char = ty::type_is_char(t_1);
-    let t_1_is_bare_fn = ty::type_is_bare_fn(t_1);
-    let t_1_is_float = ty::type_is_floating_point(t_1);
-
-    // casts to scalars other than `char` and `bare fn` are trivial
-    let t_1_is_trivial = t_1_is_scalar && !t_1_is_char && !t_1_is_bare_fn;
-
-    if t_e_is_bare_fn_item && t_1_is_bare_fn {
-        demand::coerce(fcx, e.span, t_1, &e);
-    } else if t_1_is_char {
-        let t_e = fcx.infcx().shallow_resolve(t_e);
-        if t_e.sty != ty::ty_uint(ast::TyU8) {
-            fcx.type_error_message(span, |actual| {
-                format!("only `u8` can be cast as `char`, not `{}`", actual)
-            }, t_e, None);
-        }
-    } else if t_1.sty == ty::ty_bool {
-        span_err!(fcx.tcx().sess, span, E0054,
-                  "cannot cast as `bool`, compare with zero instead");
-    } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) && !(
-        t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) {
-        // Casts to float must go through an integer or boolean
-        cast_through_integer_err(fcx, span, t_1, t_e)
-    } else if t_e_is_c_enum && t_1_is_trivial {
-        if ty::type_is_unsafe_ptr(t_1) {
-            // ... and likewise with C enum -> *T
-            cast_through_integer_err(fcx, span, t_1, t_e)
-        }
-        // casts from C-like enums are allowed
-    } else if ty::type_is_region_ptr(t_e) && ty::type_is_unsafe_ptr(t_1) {
-        fn types_compatible<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span,
-                                      t1: Ty<'tcx>, t2: Ty<'tcx>) -> bool {
-            match t1.sty {
-                ty::ty_vec(_, Some(_)) => {}
-                _ => return false
-            }
-            if ty::type_needs_infer(t2) {
-                // This prevents this special case from going off when casting
-                // to a type that isn't fully specified; e.g. `as *_`. (Issue
-                // #14893.)
-                return false
-            }
-
-            let el = ty::sequence_element_type(fcx.tcx(), t1);
-            infer::mk_eqty(fcx.infcx(),
-                           false,
-                           infer::Misc(sp),
-                           el,
-                           t2).is_ok()
-        }
-
-        // Due to the limitations of LLVM global constants,
-        // region pointers end up pointing at copies of
-        // vector elements instead of the original values.
-        // To allow unsafe pointers to work correctly, we
-        // need to special-case obtaining an unsafe pointer
-        // from a region pointer to a vector.
-
-        /* this cast is only allowed from &[T, ..n] to *T or
-        &T to *T. */
-        match (&t_e.sty, &t_1.sty) {
-            (&ty::ty_rptr(_, ty::mt { ty: mt1, mutbl: ast::MutImmutable }),
-             &ty::ty_ptr(ty::mt { ty: mt2, mutbl: ast::MutImmutable }))
-            if types_compatible(fcx, e.span, mt1, mt2) => {
-                /* this case is allowed */
-            }
-            _ => {
-                demand::coerce(fcx, e.span, t_1, &e);
-            }
-        }
-    } else if !(t_e_is_scalar && t_1_is_trivial) {
-        /*
-        If more type combinations should be supported than are
-        supported here, then file an enhancement issue and
-        record the issue number in this comment.
-        */
-        fcx.type_error_message(span, |actual| {
-            format!("non-scalar cast: `{}` as `{}`",
-                    actual,
-                    fcx.infcx().ty_to_string(t_1))
-        }, t_e, None);
-    }
-}
-
 impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
     fn tcx(&self) -> &ty::ctxt<'tcx> { self.ccx.tcx }
 
@@ -1702,6 +1559,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                                  span)
     }
 
+    pub fn type_is_fat_ptr(&self, ty: Ty<'tcx>, span: Span) -> bool {
+        if let Some(mt) = ty::deref(ty, true) {
+            return !self.type_is_known_to_be_sized(mt.ty, span);
+        }
+        false
+    }
+
     pub fn register_builtin_bound(&self,
                                   ty: Ty<'tcx>,
                                   builtin_bound: ty::BuiltinBound,
@@ -1925,7 +1789,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn check_casts(&self) {
         let mut deferred_cast_checks = self.inh.deferred_cast_checks.borrow_mut();
         for check in deferred_cast_checks.iter() {
-            check_cast(self, check);
+            cast::check_cast(self, check);
         }
 
         deferred_cast_checks.clear();
@@ -3537,12 +3401,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
 
             // Defer other checks until we're done type checking.
             let mut deferred_cast_checks = fcx.inh.deferred_cast_checks.borrow_mut();
-            deferred_cast_checks.push(CastCheck {
-                expr: (**e).clone(),
-                expr_ty: t_e,
-                cast_ty: t_1,
-                span: expr.span,
-            });
+            let cast_check = cast::CastCheck::new((**e).clone(), t_e, t_1, expr.span);
+            deferred_cast_checks.push(cast_check);
         }
       }
       ast::ExprVec(ref args) => {
diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs
index 49e88dc1483eb..7c1fea4e60f6e 100644
--- a/src/librustc_typeck/check/op.rs
+++ b/src/librustc_typeck/check/op.rs
@@ -20,7 +20,6 @@ use super::{
     PreferMutLvalue,
     structurally_resolved_type,
 };
-use middle::infer;
 use middle::traits;
 use middle::ty::{self, Ty};
 use syntax::ast;
@@ -314,36 +313,9 @@ fn lookup_op_method<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
 
     let method = match trait_did {
         Some(trait_did) => {
-            // We do eager coercions to make using operators
-            // more ergonomic:
-            //
-            // - If the input is of type &'a T (resp. &'a mut T),
-            //   then reborrow it to &'b T (resp. &'b mut T) where
-            //   'b <= 'a.  This makes things like `x == y`, where
-            //   `x` and `y` are both region pointers, work.  We
-            //   could also solve this with variance or different
-            //   traits that don't force left and right to have same
-            //   type.
-            let (adj_ty, adjustment) = match lhs_ty.sty {
-                ty::ty_rptr(r_in, mt) => {
-                    let r_adj = fcx.infcx().next_region_var(infer::Autoref(lhs_expr.span));
-                    fcx.mk_subr(infer::Reborrow(lhs_expr.span), r_adj, *r_in);
-                    let adjusted_ty = ty::mk_rptr(fcx.tcx(), fcx.tcx().mk_region(r_adj), mt);
-                    let autoptr = ty::AutoPtr(r_adj, mt.mutbl, None);
-                    let adjustment = ty::AutoDerefRef { autoderefs: 1, autoref: Some(autoptr) };
-                    (adjusted_ty, adjustment)
-                }
-                _ => {
-                    (lhs_ty, ty::AutoDerefRef { autoderefs: 0, autoref: None })
-                }
-            };
-
-            debug!("adjusted_ty={} adjustment={:?}",
-                   adj_ty.repr(fcx.tcx()),
-                   adjustment);
-
+            let noop = ty::AutoDerefRef { autoderefs: 0, autoref: None };
             method::lookup_in_trait_adjusted(fcx, expr.span, Some(lhs_expr), opname,
-                                             trait_did, adjustment, adj_ty, Some(other_tys))
+                                             trait_did, noop, lhs_ty, Some(other_tys))
         }
         None => None
     };
diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs
index 9171367468026..9554e6ad8aad3 100644
--- a/src/librustc_typeck/check/regionck.rs
+++ b/src/librustc_typeck/check/regionck.rs
@@ -1119,8 +1119,8 @@ fn link_pattern<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
 fn link_autoref(rcx: &Rcx,
                 expr: &ast::Expr,
                 autoderefs: usize,
-                autoref: &ty::AutoRef) {
-
+                autoref: &ty::AutoRef)
+{
     debug!("link_autoref(autoref={:?})", autoref);
     let mc = mc::MemCategorizationContext::new(rcx.fcx);
     let expr_cmt = ignore_err!(mc.cat_expr_autoderefd(expr, autoderefs));
@@ -1128,11 +1128,15 @@ fn link_autoref(rcx: &Rcx,
 
     match *autoref {
         ty::AutoPtr(r, m, _) => {
-            link_region(rcx, expr.span, r,
-                ty::BorrowKind::from_mutbl(m), expr_cmt);
+            link_region(rcx, expr.span, r, ty::BorrowKind::from_mutbl(m), expr_cmt);
+        }
+
+        ty::AutoUnsafe(m, _) => {
+            let r = ty::ReScope(CodeExtent::from_node_id(expr.id));
+            link_region(rcx, expr.span, r, ty::BorrowKind::from_mutbl(m), expr_cmt);
         }
 
-        ty::AutoUnsafe(..) | ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) => {}
+        ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) => {}
     }
 }
 
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 6fe35614a85b6..bd44a9547b496 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -18,7 +18,7 @@ use io::prelude::*;
 use cmp;
 use error;
 use fmt;
-use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind};
+use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom};
 use ptr;
 use iter;
 
@@ -120,6 +120,52 @@ impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
     }
 }
 
+#[unstable(feature = "buf_seek", reason = "recently added")]
+impl<R: Seek> Seek for BufReader<R> {
+    /// Seek to an offset, in bytes, in the underlying reader.
+    ///
+    /// The position used for seeking with `SeekFrom::Current(_)` is the
+    /// position the underlying reader would be at if the `BufReader` had no
+    /// internal buffer.
+    ///
+    /// Seeking always discards the internal buffer, even if the seek position
+    /// would otherwise fall within it. This guarantees that calling
+    /// `.unwrap()` immediately after a seek yields the underlying reader at
+    /// the same position.
+    ///
+    /// See `std::io::Seek` for more details.
+    ///
+    /// Note: In the edge case where you're seeking with `SeekFrom::Current(n)`
+    /// where `n` minus the internal buffer length underflows an `i64`, two
+    /// seeks will be performed instead of one. If the second seek returns
+    /// `Err`, the underlying reader will be left at the same position it would
+    /// have if you seeked to `SeekFrom::Current(0)`.
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        let result: u64;
+        if let SeekFrom::Current(n) = pos {
+            let remainder = (self.cap - self.pos) as i64;
+            // it should be safe to assume that remainder fits within an i64 as the alternative
+            // means we managed to allocate 8 ebibytes and that's absurd.
+            // But it's not out of the realm of possibility for some weird underlying reader to
+            // support seeking by i64::min_value() so we need to handle underflow when subtracting
+            // remainder.
+            if let Some(offset) = n.checked_sub(remainder) {
+                result = try!(self.inner.seek(SeekFrom::Current(offset)));
+            } else {
+                // seek backwards by our remainder, and then by the offset
+                try!(self.inner.seek(SeekFrom::Current(-remainder)));
+                self.pos = self.cap; // empty the buffer
+                result = try!(self.inner.seek(SeekFrom::Current(n)));
+            }
+        } else {
+            // Seeking with Start/End doesn't care about our buffer length.
+            result = try!(self.inner.seek(pos));
+        }
+        self.pos = self.cap; // empty the buffer
+        Ok(result)
+    }
+}
+
 /// Wraps a Writer and buffers output to it
 ///
 /// It can be excessively inefficient to work directly with a `Write`. For
@@ -238,6 +284,16 @@ impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
     }
 }
 
+#[unstable(feature = "buf_seek", reason = "recently added")]
+impl<W: Write+Seek> Seek for BufWriter<W> {
+    /// Seek to the offset, in bytes, in the underlying writer.
+    ///
+    /// Seeking always writes out the internal buffer before seeking.
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        self.flush_buf().and_then(|_| self.get_mut().seek(pos))
+    }
+}
+
 #[unsafe_destructor]
 impl<W: Write> Drop for BufWriter<W> {
     fn drop(&mut self) {
@@ -478,7 +534,7 @@ impl<S: Write> fmt::Debug for BufStream<S> where S: fmt::Debug {
 mod tests {
     use prelude::v1::*;
     use io::prelude::*;
-    use io::{self, BufReader, BufWriter, BufStream, Cursor, LineWriter};
+    use io::{self, BufReader, BufWriter, BufStream, Cursor, LineWriter, SeekFrom};
     use test;
 
     /// A dummy reader intended at testing short-reads propagation.
@@ -533,6 +589,67 @@ mod tests {
         assert_eq!(reader.read(&mut buf).unwrap(), 0);
     }
 
+    #[test]
+    fn test_buffered_reader_seek() {
+        let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
+        let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
+
+        assert_eq!(reader.seek(SeekFrom::Start(3)).ok(), Some(3));
+        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
+        assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(3));
+        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
+        assert_eq!(reader.seek(SeekFrom::Current(1)).ok(), Some(4));
+        assert_eq!(reader.fill_buf().ok(), Some(&[1, 2][..]));
+        reader.consume(1);
+        assert_eq!(reader.seek(SeekFrom::Current(-2)).ok(), Some(3));
+    }
+
+    #[test]
+    fn test_buffered_reader_seek_underflow() {
+        // gimmick reader that yields its position modulo 256 for each byte
+        struct PositionReader {
+            pos: u64
+        }
+        impl Read for PositionReader {
+            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+                let len = buf.len();
+                for x in buf {
+                    *x = self.pos as u8;
+                    self.pos = self.pos.wrapping_add(1);
+                }
+                Ok(len)
+            }
+        }
+        impl Seek for PositionReader {
+            fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+                match pos {
+                    SeekFrom::Start(n) => {
+                        self.pos = n;
+                    }
+                    SeekFrom::Current(n) => {
+                        self.pos = self.pos.wrapping_add(n as u64);
+                    }
+                    SeekFrom::End(n) => {
+                        self.pos = u64::max_value().wrapping_add(n as u64);
+                    }
+                }
+                Ok(self.pos)
+            }
+        }
+
+        let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 });
+        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));
+        assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5));
+        assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
+        // the following seek will require two underlying seeks
+        let expected = 9223372036854775802;
+        assert_eq!(reader.seek(SeekFrom::Current(i64::min_value())).ok(), Some(expected));
+        assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
+        // seeking to 0 should empty the buffer.
+        assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(expected));
+        assert_eq!(reader.get_ref().pos, expected);
+    }
+
     #[test]
     fn test_buffered_writer() {
         let inner = Vec::new();
@@ -576,6 +693,18 @@ mod tests {
         assert_eq!(w, [0, 1]);
     }
 
+    #[test]
+    fn test_buffered_writer_seek() {
+        let mut w = BufWriter::with_capacity(3, io::Cursor::new(Vec::new()));
+        w.write_all(&[0, 1, 2, 3, 4, 5]).unwrap();
+        w.write_all(&[6, 7]).unwrap();
+        assert_eq!(w.seek(SeekFrom::Current(0)).ok(), Some(8));
+        assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);
+        assert_eq!(w.seek(SeekFrom::Start(2)).ok(), Some(2));
+        w.write_all(&[8, 9]).unwrap();
+        assert_eq!(&w.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
+    }
+
     // This is just here to make sure that we don't infinite loop in the
     // newtype struct autoderef weirdness
     #[test]
diff --git a/src/libstd/io/error.rs b/src/libstd/io/error.rs
index b84dcb8fb6206..7428d0a8e35ef 100644
--- a/src/libstd/io/error.rs
+++ b/src/libstd/io/error.rs
@@ -163,12 +163,18 @@ impl Error {
     /// `Error` for the error code.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn last_os_error() -> Error {
-        Error::from_os_error(sys::os::errno() as i32)
+        Error::from_raw_os_error(sys::os::errno() as i32)
     }
 
     /// Creates a new instance of an `Error` from a particular OS error code.
-    #[unstable(feature = "io",
-               reason = "unclear whether this function is necessary")]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn from_raw_os_error(code: i32) -> Error {
+        Error { repr: Repr::Os(code) }
+    }
+
+    /// Creates a new instance of an `Error` from a particular OS error code.
+    #[unstable(feature = "io", reason = "deprecated")]
+    #[deprecated(since = "1.0.0", reason = "renamed to from_raw_os_error")]
     pub fn from_os_error(code: i32) -> Error {
         Error { repr: Repr::Os(code) }
     }
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index b3d1adb44218a..3d10c151f80d6 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -37,6 +37,7 @@
 /// ```
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow_internal_unstable]
 macro_rules! panic {
     () => ({
         panic!("explicit panic")
diff --git a/src/libstd/net/addr.rs b/src/libstd/net/addr.rs
index 886f252fb1926..18d8fcc8a5288 100644
--- a/src/libstd/net/addr.rs
+++ b/src/libstd/net/addr.rs
@@ -750,8 +750,9 @@ mod tests {
         assert!(tsa("localhost:23924").unwrap().contains(&a));
     }
 
+    // FIXME: figure out why this fails on bitrig and fix it
     #[test]
-    #[cfg(not(windows))]
+    #[cfg(not(any(windows, target_os = "bitrig")))]
     fn to_socket_addr_str_bad() {
         assert!(tsa("1200::AB00:1234::2552:7777:1313:34300").is_err());
     }
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index f71811b1eadf6..2f58a437eb472 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -495,7 +495,6 @@ pub extern fn rust_begin_unwind(msg: fmt::Arguments,
 /// on (e.g.) the inlining of other functions as possible), by moving
 /// the actual formatting into this shared place.
 #[inline(never)] #[cold]
-#[stable(since = "1.0.0", feature = "rust1")]
 pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, usize)) -> ! {
     use fmt::Write;
 
@@ -511,7 +510,6 @@ pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, usize))
 
 /// This is the entry point of unwinding for panic!() and assert!().
 #[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
-#[stable(since = "1.0.0", feature = "rust1")]
 pub fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, usize)) -> ! {
     // Note that this should be the only allocation performed in this code path.
     // Currently this means that panic!() on OOM will invoke this code path,
@@ -598,7 +596,6 @@ fn begin_unwind_inner(msg: Box<Any + Send>,
 /// Only a limited number of callbacks can be registered, and this function
 /// returns whether the callback was successfully registered or not. It is not
 /// currently possible to unregister a callback once it has been registered.
-#[unstable(feature = "std_misc")]
 pub unsafe fn register(f: Callback) -> bool {
     match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) {
         // The invocation code has knowledge of this window where the count has
diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process2.rs
index c2a8b26aef4eb..60f00c80b4abd 100644
--- a/src/libstd/sys/unix/process2.rs
+++ b/src/libstd/sys/unix/process2.rs
@@ -193,7 +193,7 @@ impl Process {
                                 let errno = combine(&bytes[0.. 4]);
                                 assert!(p.wait().is_ok(),
                                         "wait() should either return Ok or panic");
-                                return Err(Error::from_os_error(errno))
+                                return Err(Error::from_raw_os_error(errno))
                             }
                             Ok(0) => return Ok(p),
                             Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
diff --git a/src/libstd/sys/unix/thread.rs b/src/libstd/sys/unix/thread.rs
index eb61f21aacd5d..73d6cd73621ad 100644
--- a/src/libstd/sys/unix/thread.rs
+++ b/src/libstd/sys/unix/thread.rs
@@ -212,7 +212,7 @@ pub unsafe fn create(stack: usize, p: Thunk) -> io::Result<rust_thread> {
     assert_eq!(pthread_attr_destroy(&mut attr), 0);
 
     return if ret != 0 {
-        Err(io::Error::from_os_error(ret))
+        Err(io::Error::from_raw_os_error(ret))
     } else {
         mem::forget(p); // ownership passed to pthread_create
         Ok(native)
diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs
index 12a8ef99d764a..5ced8863e62a9 100644
--- a/src/libstd/sys/windows/net.rs
+++ b/src/libstd/sys/windows/net.rs
@@ -43,7 +43,7 @@ pub fn init() {
 
 /// Returns the last error from the Windows socket interface.
 fn last_error() -> io::Error {
-    io::Error::from_os_error(unsafe { c::WSAGetLastError() })
+    io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() })
 }
 
 /// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1)
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index b563a5e7d6e84..56af43474a615 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -26,6 +26,8 @@ use std::num::ToPrimitive;
 use std::ops::{Add, Sub};
 use std::rc::Rc;
 
+use std::fmt;
+
 use libc::c_uint;
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
@@ -199,6 +201,7 @@ pub fn original_sp(cm: &CodeMap, sp: Span, enclosing_sp: Span) -> Span {
 //
 
 /// A source code location used for error reporting
+#[derive(Debug)]
 pub struct Loc {
     /// Information about the original source
     pub file: Rc<FileMap>,
@@ -211,6 +214,7 @@ pub struct Loc {
 /// A source code location used as the result of lookup_char_pos_adj
 // Actually, *none* of the clients use the filename *or* file field;
 // perhaps they should just be removed.
+#[derive(Debug)]
 pub struct LocWithOpt {
     pub filename: FileName,
     pub line: usize,
@@ -219,7 +223,9 @@ pub struct LocWithOpt {
 }
 
 // used to be structural records. Better names, anyone?
+#[derive(Debug)]
 pub struct FileMapAndLine { pub fm: Rc<FileMap>, pub line: usize }
+#[derive(Debug)]
 pub struct FileMapAndBytePos { pub fm: Rc<FileMap>, pub pos: BytePos }
 
 
@@ -449,6 +455,12 @@ impl Decodable for FileMap {
     }
 }
 
+impl fmt::Debug for FileMap {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "FileMap({})", self.name)
+    }
+}
+
 impl FileMap {
     /// EFFECT: register a start-of-line offset in the
     /// table of line-beginnings.
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 272bb5f650676..3cc16006b1b9c 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2880,7 +2880,7 @@ impl<'a> Parser<'a> {
         try!(self.expect_keyword(keywords::In));
         let expr = try!(self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL));
         let loop_block = try!(self.parse_block());
-        let hi = self.span.hi;
+        let hi = self.last_span.hi;
 
         Ok(self.mk_expr(lo, hi, ExprForLoop(pat, expr, loop_block, opt_ident)))
     }
diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs
index 7e0bcd3e1dc3f..5032cd57eeb37 100644
--- a/src/libsyntax/ptr.rs
+++ b/src/libsyntax/ptr.rs
@@ -111,6 +111,13 @@ impl<T: Display> Display for P<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> fmt::Pointer for P<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Pointer::fmt(&self.ptr, f)
+    }
+}
+
 impl<T: Hash> Hash for P<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         (**self).hash(state);
diff --git a/src/test/auxiliary/llvm_pass_plugin.rs b/src/test/auxiliary/llvm_pass_plugin.rs
new file mode 100644
index 0000000000000..d61f47fd7ef27
--- /dev/null
+++ b/src/test/auxiliary/llvm_pass_plugin.rs
@@ -0,0 +1,28 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// force-host
+
+#![feature(plugin_registrar)]
+#![feature(rustc_private)]
+
+extern crate rustc;
+
+use rustc::plugin::Registry;
+
+#[plugin_registrar]
+pub fn plugin_registrar(reg: &mut Registry) {
+    // This pass is built in to LLVM.
+    //
+    // Normally, we would name a pass that was registered through
+    // C++ static object constructors in the same .so file as the
+    // plugin registrar.
+    reg.register_llvm_pass("inline");
+}
diff --git a/src/test/compile-fail/bad-mid-path-type-params.rs b/src/test/compile-fail/bad-mid-path-type-params.rs
index 7a7406115d393..20ac757354faf 100644
--- a/src/test/compile-fail/bad-mid-path-type-params.rs
+++ b/src/test/compile-fail/bad-mid-path-type-params.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
-
 struct S<T> {
     contents: T,
 }
diff --git a/src/test/compile-fail/bad-sized.rs b/src/test/compile-fail/bad-sized.rs
index 1944acbe1f345..5878e9a9f649b 100644
--- a/src/test/compile-fail/bad-sized.rs
+++ b/src/test/compile-fail/bad-sized.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
-
 use std::cell::RefCell;
 
 trait Trait : ::std::marker::MarkerTrait {}
diff --git a/src/test/compile-fail/borrowck-use-uninitialized-in-cast-trait.rs b/src/test/compile-fail/borrowck-use-uninitialized-in-cast-trait.rs
new file mode 100644
index 0000000000000..796b455f5c70a
--- /dev/null
+++ b/src/test/compile-fail/borrowck-use-uninitialized-in-cast-trait.rs
@@ -0,0 +1,20 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Variation on `borrowck-use-uninitialized-in-cast` in which we do a
+// trait cast from an uninitialized source. Issue #20791.
+
+trait Foo { fn dummy(&self) { } }
+impl Foo for i32 { }
+
+fn main() {
+    let x: &i32;
+    let y = x as *const Foo; //~ ERROR use of possibly uninitialized variable: `*x`
+}
diff --git a/src/test/compile-fail/borrowck-use-uninitialized-in-cast.rs b/src/test/compile-fail/borrowck-use-uninitialized-in-cast.rs
new file mode 100644
index 0000000000000..a3d5af80b533b
--- /dev/null
+++ b/src/test/compile-fail/borrowck-use-uninitialized-in-cast.rs
@@ -0,0 +1,20 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Check that we detect unused values that are cast to other things.
+// The problem was specified to casting to `*`, as creating unsafe
+// pointers was not being fully checked. Issue #20791.
+
+// pretty-expanded FIXME #23616
+
+fn main() {
+    let x: &i32;
+    let y = x as *const i32; //~ ERROR use of possibly uninitialized variable: `*x`
+}
diff --git a/src/test/compile-fail/coherence-default-trait-impl.rs b/src/test/compile-fail/coherence-default-trait-impl.rs
index a5b317307379e..062a4a43b694b 100644
--- a/src/test/compile-fail/coherence-default-trait-impl.rs
+++ b/src/test/compile-fail/coherence-default-trait-impl.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
-
 #![feature(optin_builtin_traits)]
 
 use std::marker::MarkerTrait;
diff --git a/src/test/compile-fail/coherence-orphan.rs b/src/test/compile-fail/coherence-orphan.rs
index 2243a0507f2d1..78435f1a78a16 100644
--- a/src/test/compile-fail/coherence-orphan.rs
+++ b/src/test/compile-fail/coherence-orphan.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
 // aux-build:coherence_orphan_lib.rs
 
 #![feature(optin_builtin_traits)]
diff --git a/src/test/compile-fail/fat-ptr-cast.rs b/src/test/compile-fail/fat-ptr-cast.rs
new file mode 100644
index 0000000000000..ac5969410fc01
--- /dev/null
+++ b/src/test/compile-fail/fat-ptr-cast.rs
@@ -0,0 +1,19 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let a: &[i32] = &[1, 2, 3];
+    let b: Box<[i32]> = Box::new([1, 2, 3]);
+    let p = a as *const [i32];
+
+    a as usize; //~ ERROR cast from fat pointer
+    b as usize; //~ ERROR cast from fat pointer
+    p as usize; //~ ERROR cast from fat pointer
+}
diff --git a/src/test/compile-fail/issue-22289.rs b/src/test/compile-fail/issue-22289.rs
new file mode 100644
index 0000000000000..f4f6aaa94fe29
--- /dev/null
+++ b/src/test/compile-fail/issue-22289.rs
@@ -0,0 +1,13 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    0 as &std::any::Any; //~ ERROR non-scalar cast: `i32` as `&core::any::Any`
+}
diff --git a/src/test/compile-fail/issue-22370.rs b/src/test/compile-fail/issue-22370.rs
new file mode 100644
index 0000000000000..4c6652d812c8c
--- /dev/null
+++ b/src/test/compile-fail/issue-22370.rs
@@ -0,0 +1,18 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-tidy-linelength
+
+trait A<T=Self> {}
+
+fn f(a: &A) {}
+//~^ ERROR the type parameter `T` must be explicitly specified in an object type because its default value `Self` references the type `Self`
+
+fn main() {}
diff --git a/src/test/compile-fail/issue-22384.rs b/src/test/compile-fail/issue-22384.rs
new file mode 100644
index 0000000000000..368e2483533a4
--- /dev/null
+++ b/src/test/compile-fail/issue-22384.rs
@@ -0,0 +1,18 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+trait Trait {
+    fn foo();
+}
+
+fn main() {
+    <<i32 as Copy>::foobar as Trait>::foo();
+    //~^ ERROR use of undeclared associated type `Copy::foobar`
+}
diff --git a/src/test/compile-fail/issue-8767.rs b/src/test/compile-fail/issue-8767.rs
index 9abd8c9e3fcda..96c8ec4505856 100644
--- a/src/test/compile-fail/issue-8767.rs
+++ b/src/test/compile-fail/issue-8767.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
-
 impl B { //~ ERROR use of undeclared type name `B`
 }
 
diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs
index 391b49e10686e..16f195b4ea268 100644
--- a/src/test/compile-fail/lint-stability.rs
+++ b/src/test/compile-fail/lint-stability.rs
@@ -12,7 +12,6 @@
 // aux-build:inherited_stability.rs
 // aux-build:stability_cfg1.rs
 // aux-build:stability_cfg2.rs
-// ignore-tidy-linelength
 
 #![deny(deprecated)]
 #![allow(dead_code)]
diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs
index 517be0eb8acd9..1615af400713c 100644
--- a/src/test/compile-fail/lint-uppercase-variables.rs
+++ b/src/test/compile-fail/lint-uppercase-variables.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
-
 #![allow(dead_code)]
 #![deny(non_snake_case)]
 
diff --git a/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs b/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs
index a345bd1b65c0e..09b97dfb30f24 100644
--- a/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs
+++ b/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
-
 #![feature(optin_builtin_traits)]
 
 impl Copy for .. {}
diff --git a/src/test/compile-fail/unsupported-cast.rs b/src/test/compile-fail/unsupported-cast.rs
index ca17c898ec37c..b4246f2ed87f3 100644
--- a/src/test/compile-fail/unsupported-cast.rs
+++ b/src/test/compile-fail/unsupported-cast.rs
@@ -8,8 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-test FIXME: #13993
-// error-pattern:unsupported cast
+// error-pattern:illegal cast
+
+#![feature(libc)]
 
 extern crate libc;
 
diff --git a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
index 26d22b072eb48..addc572175231 100644
--- a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
+++ b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-tidy-linelength
-
 #![feature(box_syntax)]
 
 use std::fmt;
diff --git a/src/test/debuginfo/gdb-pretty-std.rs b/src/test/debuginfo/gdb-pretty-std.rs
index dbf80a9bccce8..1da9a06b0eea4 100644
--- a/src/test/debuginfo/gdb-pretty-std.rs
+++ b/src/test/debuginfo/gdb-pretty-std.rs
@@ -10,7 +10,6 @@
 
 // ignore-windows failing on win32 bot
 // ignore-freebsd: gdb package too new
-// ignore-tidy-linelength
 // ignore-lldb
 // ignore-android: FIXME(#10381)
 // compile-flags:-g
diff --git a/src/test/run-pass-fulldeps/llvm-pass-plugin.rs b/src/test/run-pass-fulldeps/llvm-pass-plugin.rs
new file mode 100644
index 0000000000000..5dfef636f9f36
--- /dev/null
+++ b/src/test/run-pass-fulldeps/llvm-pass-plugin.rs
@@ -0,0 +1,17 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:llvm_pass_plugin.rs
+// ignore-stage1
+
+#![feature(plugin)]
+#![plugin(llvm_pass_plugin)]
+
+pub fn main() { }
diff --git a/src/test/run-pass-fulldeps/rename-directory.rs b/src/test/run-pass-fulldeps/rename-directory.rs
index a1e016bf2eaba..a0644e513a6e9 100644
--- a/src/test/run-pass-fulldeps/rename-directory.rs
+++ b/src/test/run-pass-fulldeps/rename-directory.rs
@@ -12,7 +12,6 @@
 // because it needs TempDir, which is in extra
 
 // ignore-android
-// pretty-expanded FIXME #23616
 
 #![feature(rustc_private, path_ext)]
 
diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs
index 7101cfb557967..d2a595804a4b2 100644
--- a/src/test/run-pass/argument-passing.rs
+++ b/src/test/run-pass/argument-passing.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 struct X {
     x: isize
diff --git a/src/test/run-pass/arith-2.rs b/src/test/run-pass/arith-2.rs
index 0f4523c681884..c93049b87a764 100644
--- a/src/test/run-pass/arith-2.rs
+++ b/src/test/run-pass/arith-2.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let i32_c: isize = 0x10101010;
diff --git a/src/test/run-pass/arith-unsigned.rs b/src/test/run-pass/arith-unsigned.rs
index 8a0fc8adc1895..e5ff97e3cdbd2 100644
--- a/src/test/run-pass/arith-unsigned.rs
+++ b/src/test/run-pass/arith-unsigned.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(type_limits)]
 
diff --git a/src/test/run-pass/artificial-block.rs b/src/test/run-pass/artificial-block.rs
index 3348a6754ee82..53eec3c28c0de 100644
--- a/src/test/run-pass/artificial-block.rs
+++ b/src/test/run-pass/artificial-block.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn f() -> isize { { return 3; } }
 
diff --git a/src/test/run-pass/as-precedence.rs b/src/test/run-pass/as-precedence.rs
index 8e38128975bb9..d89607077dcbe 100644
--- a/src/test/run-pass/as-precedence.rs
+++ b/src/test/run-pass/as-precedence.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     assert_eq!(3 as usize * 3, 9);
diff --git a/src/test/run-pass/asm-in-out-operand.rs b/src/test/run-pass/asm-in-out-operand.rs
index 32924bcf74451..3eebc7acb0fd5 100644
--- a/src/test/run-pass/asm-in-out-operand.rs
+++ b/src/test/run-pass/asm-in-out-operand.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(asm)]
 
diff --git a/src/test/run-pass/asm-out-assign.rs b/src/test/run-pass/asm-out-assign.rs
index 3cb7f6400daf4..d7913b473f85a 100644
--- a/src/test/run-pass/asm-out-assign.rs
+++ b/src/test/run-pass/asm-out-assign.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(asm)]
 
diff --git a/src/test/run-pass/assign-assign.rs b/src/test/run-pass/assign-assign.rs
index 110f4720ceb68..186f91da07ccb 100644
--- a/src/test/run-pass/assign-assign.rs
+++ b/src/test/run-pass/assign-assign.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // Issue 483 - Assignment expressions result in nil
-// pretty-expanded FIXME #23616
 
 fn test_assign() {
     let mut x: isize;
diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs
index 473f744a3ff61..f05a1520b8ef8 100644
--- a/src/test/run-pass/assignability-trait.rs
+++ b/src/test/run-pass/assignability-trait.rs
@@ -12,7 +12,6 @@
 // making method calls, but only if there aren't any matches without
 // it.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/associated-types-basic.rs b/src/test/run-pass/associated-types-basic.rs
index d4ed2ee2d6e55..06521e0ec78e8 100644
--- a/src/test/run-pass/associated-types-basic.rs
+++ b/src/test/run-pass/associated-types-basic.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/associated-types-binding-in-trait.rs b/src/test/run-pass/associated-types-binding-in-trait.rs
index 39fc224148e8e..d82ba6add75c7 100644
--- a/src/test/run-pass/associated-types-binding-in-trait.rs
+++ b/src/test/run-pass/associated-types-binding-in-trait.rs
@@ -11,7 +11,6 @@
 // Test a case where the associated type binding (to `bool`, in this
 // case) is derived from the trait definition. Issue #21636.
 
-// pretty-expanded FIXME #23616
 
 use std::vec;
 
diff --git a/src/test/run-pass/associated-types-bound.rs b/src/test/run-pass/associated-types-bound.rs
index 2301821f66358..4eacd120bc690 100644
--- a/src/test/run-pass/associated-types-bound.rs
+++ b/src/test/run-pass/associated-types-bound.rs
@@ -10,7 +10,6 @@
 
 // Test equality constrai32s on associated types in a where clause.
 
-// pretty-expanded FIXME #23616
 
 pub trait ToI32 {
     fn to_i32(&self) -> i32;
diff --git a/src/test/run-pass/associated-types-constant-type.rs b/src/test/run-pass/associated-types-constant-type.rs
index 5729fab475b78..77ab616ca918b 100644
--- a/src/test/run-pass/associated-types-constant-type.rs
+++ b/src/test/run-pass/associated-types-constant-type.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait SignedUnsigned {
     type Opposite;
diff --git a/src/test/run-pass/associated-types-doubleendediterator-object.rs b/src/test/run-pass/associated-types-doubleendediterator-object.rs
index 5dc289194ff3b..1661812520b3e 100644
--- a/src/test/run-pass/associated-types-doubleendediterator-object.rs
+++ b/src/test/run-pass/associated-types-doubleendediterator-object.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/associated-types-enum-field-named.rs b/src/test/run-pass/associated-types-enum-field-named.rs
index 8cf97fe62fea5..7014cc59b71db 100644
--- a/src/test/run-pass/associated-types-enum-field-named.rs
+++ b/src/test/run-pass/associated-types-enum-field-named.rs
@@ -10,7 +10,6 @@
 
 // Test associated types appearing in struct-like enum variants.
 
-// pretty-expanded FIXME #23616
 
 use self::VarValue::*;
 
diff --git a/src/test/run-pass/associated-types-enum-field-numbered.rs b/src/test/run-pass/associated-types-enum-field-numbered.rs
index 3c57da6b4a3eb..c983fdefc0e35 100644
--- a/src/test/run-pass/associated-types-enum-field-numbered.rs
+++ b/src/test/run-pass/associated-types-enum-field-numbered.rs
@@ -10,7 +10,6 @@
 
 // Test associated types appearing in tuple-like enum variants.
 
-// pretty-expanded FIXME #23616
 
 use self::VarValue::*;
 
diff --git a/src/test/run-pass/associated-types-in-default-method.rs b/src/test/run-pass/associated-types-in-default-method.rs
index 2a1b9bdd2faf6..74199f57fb634 100644
--- a/src/test/run-pass/associated-types-in-default-method.rs
+++ b/src/test/run-pass/associated-types-in-default-method.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Get {
     type Value;
diff --git a/src/test/run-pass/associated-types-in-fn.rs b/src/test/run-pass/associated-types-in-fn.rs
index 40b10fbfcaca6..dcd7895fa99e6 100644
--- a/src/test/run-pass/associated-types-in-fn.rs
+++ b/src/test/run-pass/associated-types-in-fn.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Get {
     type Value;
diff --git a/src/test/run-pass/associated-types-in-impl-generics.rs b/src/test/run-pass/associated-types-in-impl-generics.rs
index 99a9b7c23febd..5b81ac7090876 100644
--- a/src/test/run-pass/associated-types-in-impl-generics.rs
+++ b/src/test/run-pass/associated-types-in-impl-generics.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Get {
     type Value;
diff --git a/src/test/run-pass/associated-types-in-inherent-method.rs b/src/test/run-pass/associated-types-in-inherent-method.rs
index 0012d9d759632..5eaf4c2bc8396 100644
--- a/src/test/run-pass/associated-types-in-inherent-method.rs
+++ b/src/test/run-pass/associated-types-in-inherent-method.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Get {
     type Value;
diff --git a/src/test/run-pass/associated-types-issue-20220.rs b/src/test/run-pass/associated-types-issue-20220.rs
index 718ea542799bb..31336787e4c13 100644
--- a/src/test/run-pass/associated-types-issue-20220.rs
+++ b/src/test/run-pass/associated-types-issue-20220.rs
@@ -10,7 +10,6 @@
 
 // Test references to `Self::Item` in the trait. Issue #20220.
 
-// pretty-expanded FIXME #23616
 
 use std::vec;
 
diff --git a/src/test/run-pass/associated-types-issue-21212.rs b/src/test/run-pass/associated-types-issue-21212.rs
index 057677a008785..cf4b82721112c 100644
--- a/src/test/run-pass/associated-types-issue-21212.rs
+++ b/src/test/run-pass/associated-types-issue-21212.rs
@@ -13,7 +13,6 @@
 // where clauses in the environment which in turn required normalizing
 // `Self::Input`.
 
-// pretty-expanded FIXME #23616
 
 pub trait Parser {
     type Input;
diff --git a/src/test/run-pass/associated-types-iterator-binding.rs b/src/test/run-pass/associated-types-iterator-binding.rs
index 24c5a3e9a8375..181ce52eb4baf 100644
--- a/src/test/run-pass/associated-types-iterator-binding.rs
+++ b/src/test/run-pass/associated-types-iterator-binding.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn pairwise_sub<T:DoubleEndedIterator<Item=isize>>(mut t: T) -> isize {
     let mut result = 0;
diff --git a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs
index 151a9da948e83..dfd468884a167 100644
--- a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs
+++ b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs
@@ -12,7 +12,6 @@
 // `Item` originates in a where-clause, not the declaration of
 // `T`. Issue #20300.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs b/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs
index 2518ccf1cb474..8054b3aa52a1d 100644
--- a/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs
+++ b/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs
@@ -10,7 +10,6 @@
 
 // Test where the impl self type uses a projection from a constant type.
 
-// pretty-expanded FIXME #23616
 
 trait Int
 {
diff --git a/src/test/run-pass/associated-types-projection-in-supertrait.rs b/src/test/run-pass/associated-types-projection-in-supertrait.rs
index dbc2164c93a69..70c7602ffceb1 100644
--- a/src/test/run-pass/associated-types-projection-in-supertrait.rs
+++ b/src/test/run-pass/associated-types-projection-in-supertrait.rs
@@ -11,7 +11,6 @@
 // Test that we are handle to correctly handle a projection type
 // that appears in a supertrait bound. Issue #20559.
 
-// pretty-expanded FIXME #23616
 
 trait A
 {
diff --git a/src/test/run-pass/associated-types-ref-in-struct-literal.rs b/src/test/run-pass/associated-types-ref-in-struct-literal.rs
index 945340008d876..3b7fb65a8b4aa 100644
--- a/src/test/run-pass/associated-types-ref-in-struct-literal.rs
+++ b/src/test/run-pass/associated-types-ref-in-struct-literal.rs
@@ -10,7 +10,6 @@
 
 // Test associated type references in a struct literal. Issue #20535.
 
-// pretty-expanded FIXME #23616
 
 pub trait Foo {
     type Bar;
diff --git a/src/test/run-pass/associated-types-return.rs b/src/test/run-pass/associated-types-return.rs
index f190e81d8a6ad..5bba54e57b477 100644
--- a/src/test/run-pass/associated-types-return.rs
+++ b/src/test/run-pass/associated-types-return.rs
@@ -10,7 +10,6 @@
 
 // Test equality constraints on associated types in a where clause.
 
-// pretty-expanded FIXME #23616
 
 pub trait Foo {
     type A;
diff --git a/src/test/run-pass/associated-types-simple.rs b/src/test/run-pass/associated-types-simple.rs
index 5a2761365bf30..776b2183d3908 100644
--- a/src/test/run-pass/associated-types-simple.rs
+++ b/src/test/run-pass/associated-types-simple.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Get {
     type Value;
diff --git a/src/test/run-pass/associated-types-stream.rs b/src/test/run-pass/associated-types-stream.rs
index a2b7cf2106eb7..6adfaabcc23b4 100644
--- a/src/test/run-pass/associated-types-stream.rs
+++ b/src/test/run-pass/associated-types-stream.rs
@@ -11,7 +11,6 @@
 // Test references to the trait `Stream` in the bounds for associated
 // types defined on `Stream`. Issue #20551.
 
-// pretty-expanded FIXME #23616
 
 trait Stream {
     type Car;
diff --git a/src/test/run-pass/associated-types-struct-field-named.rs b/src/test/run-pass/associated-types-struct-field-named.rs
index d1872e4fb55f4..00746c32e1c31 100644
--- a/src/test/run-pass/associated-types-struct-field-named.rs
+++ b/src/test/run-pass/associated-types-struct-field-named.rs
@@ -11,7 +11,6 @@
 // Test that we correctly normalize the type of a struct field
 // which has an associated type.
 
-// pretty-expanded FIXME #23616
 
 pub trait UnifyKey {
     type Value;
diff --git a/src/test/run-pass/associated-types-struct-field-numbered.rs b/src/test/run-pass/associated-types-struct-field-numbered.rs
index 3d97c503dca5f..25e89892a29af 100644
--- a/src/test/run-pass/associated-types-struct-field-numbered.rs
+++ b/src/test/run-pass/associated-types-struct-field-numbered.rs
@@ -11,7 +11,6 @@
 // Test that we correctly normalize the type of a struct field
 // which has an associated type.
 
-// pretty-expanded FIXME #23616
 
 pub trait UnifyKey {
     type Value;
diff --git a/src/test/run-pass/associated-types-sugar-path.rs b/src/test/run-pass/associated-types-sugar-path.rs
index 353b49b49cedf..1432369f7143d 100644
--- a/src/test/run-pass/associated-types-sugar-path.rs
+++ b/src/test/run-pass/associated-types-sugar-path.rs
@@ -10,7 +10,6 @@
 
 // Test paths to associated types using the type-parameter-only sugar.
 
-// pretty-expanded FIXME #23616
 
 pub trait Foo {
     type A;
diff --git a/src/test/run-pass/attr-main-2.rs b/src/test/run-pass/attr-main-2.rs
index 4680f47fad6ce..b3c9ea541b712 100644
--- a/src/test/run-pass/attr-main-2.rs
+++ b/src/test/run-pass/attr-main-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(main)]
 
diff --git a/src/test/run-pass/attr-no-drop-flag-size.rs b/src/test/run-pass/attr-no-drop-flag-size.rs
index af8e4b7d4a1a7..893fb85b529a7 100644
--- a/src/test/run-pass/attr-no-drop-flag-size.rs
+++ b/src/test/run-pass/attr-no-drop-flag-size.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 #![feature(unsafe_no_drop_flag)]
diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs
index 2e79183755a18..babc0db4c3190 100644
--- a/src/test/run-pass/auto-loop.rs
+++ b/src/test/run-pass/auto-loop.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut sum = 0;
diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs
index 6dab0e5197138..5b12edb427562 100644
--- a/src/test/run-pass/auto-ref-sliceable.rs
+++ b/src/test/run-pass/auto-ref-sliceable.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait Pushable<T> {
     fn push_val(&mut self, t: T);
diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs
index 7d30b549ebea4..1f3d17ad55c08 100644
--- a/src/test/run-pass/autobind.rs
+++ b/src/test/run-pass/autobind.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn f<T>(x: Vec<T>) -> T { return x.into_iter().next().unwrap(); }
 
diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs
index d7eee85f50273..582fd020dd061 100644
--- a/src/test/run-pass/autoderef-method-on-trait.rs
+++ b/src/test/run-pass/autoderef-method-on-trait.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs
index 6c52035b708de..c80a92a185a2e 100644
--- a/src/test/run-pass/autoderef-method-priority.rs
+++ b/src/test/run-pass/autoderef-method-priority.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
index 809ab0a3521dd..2a782cfa176ee 100644
--- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
+++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs
index 9c7828c893895..a1bcf65ab75fa 100644
--- a/src/test/run-pass/autoderef-method-twice.rs
+++ b/src/test/run-pass/autoderef-method-twice.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs
index e63dd07eb0752..326218674ae3f 100644
--- a/src/test/run-pass/autoderef-method.rs
+++ b/src/test/run-pass/autoderef-method.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
index 0f935776fc554..05f12fd089ad4 100644
--- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
+++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/big-literals.rs b/src/test/run-pass/big-literals.rs
index ab9d892ce2b60..19c0e7baaa0a1 100644
--- a/src/test/run-pass/big-literals.rs
+++ b/src/test/run-pass/big-literals.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/binary-minus-without-space.rs b/src/test/run-pass/binary-minus-without-space.rs
index 1fe9dde844a4f..01a9ec8093973 100644
--- a/src/test/run-pass/binary-minus-without-space.rs
+++ b/src/test/run-pass/binary-minus-without-space.rs
@@ -10,7 +10,6 @@
 
 // Check that issue #954 stays fixed
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     match -1 { -1 => {}, _ => panic!("wat") }
diff --git a/src/test/run-pass/bind-by-move.rs b/src/test/run-pass/bind-by-move.rs
index 5a6e801501fcf..9be7d63ab951d 100644
--- a/src/test/run-pass/bind-by-move.rs
+++ b/src/test/run-pass/bind-by-move.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::Arc;
 fn dispose(_x: Arc<bool>) { }
diff --git a/src/test/run-pass/bind-field-short-with-modifiers.rs b/src/test/run-pass/bind-field-short-with-modifiers.rs
index e61ff61a21622..b4c38bf450b1b 100644
--- a/src/test/run-pass/bind-field-short-with-modifiers.rs
+++ b/src/test/run-pass/bind-field-short-with-modifiers.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     struct Foo { x: isize, y: isize }
diff --git a/src/test/run-pass/block-arg-call-as.rs b/src/test/run-pass/block-arg-call-as.rs
index 5944438e20d9a..73cba2e4e0a7c 100644
--- a/src/test/run-pass/block-arg-call-as.rs
+++ b/src/test/run-pass/block-arg-call-as.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn asBlock<F>(f: F) -> usize where F: FnOnce() -> usize {
    return f();
diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs
index 01bd8ce10cd09..ac8f501257361 100644
--- a/src/test/run-pass/block-expr-precedence.rs
+++ b/src/test/run-pass/block-expr-precedence.rs
@@ -13,7 +13,6 @@
 
 // no-reformat
 
-// pretty-expanded FIXME #23616
 
 /*
  *
diff --git a/src/test/run-pass/block-fn-coerce.rs b/src/test/run-pass/block-fn-coerce.rs
index 0addd33c1e4a3..3e6109da39a26 100644
--- a/src/test/run-pass/block-fn-coerce.rs
+++ b/src/test/run-pass/block-fn-coerce.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn force<F>(f: F) -> isize where F: FnOnce() -> isize { return f(); }
 
diff --git a/src/test/run-pass/bool-not.rs b/src/test/run-pass/bool-not.rs
index c46684af6efda..fa0b86d0a0246 100644
--- a/src/test/run-pass/bool-not.rs
+++ b/src/test/run-pass/bool-not.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     if !false { assert!((true)); } else { assert!((false)); }
diff --git a/src/test/run-pass/bool.rs b/src/test/run-pass/bool.rs
index a2b19d32054a5..53b568b06b5b6 100644
--- a/src/test/run-pass/bool.rs
+++ b/src/test/run-pass/bool.rs
@@ -10,7 +10,6 @@
 
 // Basic boolean tests
 
-// pretty-expanded FIXME #23616
 
 use std::cmp::Ordering::{Equal, Greater, Less};
 use std::ops::{BitAnd, BitOr, BitXor};
diff --git a/src/test/run-pass/borrow-tuple-fields.rs b/src/test/run-pass/borrow-tuple-fields.rs
index 7cf61bd569dfb..f0d09688192c6 100644
--- a/src/test/run-pass/borrow-tuple-fields.rs
+++ b/src/test/run-pass/borrow-tuple-fields.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Foo(isize, isize);
 
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index 24c7285b1fb6f..7fdc65a96e238 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/borrowck-closures-two-imm.rs b/src/test/run-pass/borrowck-closures-two-imm.rs
index 6ccb2203bca8e..5b15c8f0797fa 100644
--- a/src/test/run-pass/borrowck-closures-two-imm.rs
+++ b/src/test/run-pass/borrowck-closures-two-imm.rs
@@ -14,7 +14,6 @@
 // that the main function can read the variable too while
 // the closures are in scope. Issue #6801.
 
-// pretty-expanded FIXME #23616
 
 fn a() -> i32 {
     let mut x = 3;
diff --git a/src/test/run-pass/borrowck-fixed-length-vecs.rs b/src/test/run-pass/borrowck-fixed-length-vecs.rs
index 3f38a8df04c57..0e33351894d14 100644
--- a/src/test/run-pass/borrowck-fixed-length-vecs.rs
+++ b/src/test/run-pass/borrowck-fixed-length-vecs.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = [22];
diff --git a/src/test/run-pass/borrowck-freeze-frozen-mut.rs b/src/test/run-pass/borrowck-freeze-frozen-mut.rs
index eaa78553d85c5..380bd398a7cb2 100644
--- a/src/test/run-pass/borrowck-freeze-frozen-mut.rs
+++ b/src/test/run-pass/borrowck-freeze-frozen-mut.rs
@@ -10,7 +10,6 @@
 
 // Test that a `&mut` inside of an `&` is freezable.
 
-// pretty-expanded FIXME #23616
 
 struct MutSlice<'a, T:'a> {
     data: &'a mut [T]
diff --git a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
index b40504f37d4d9..fb30c85e70963 100644
--- a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
+++ b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
@@ -11,7 +11,6 @@
 // Check that we do not ICE when compiling this
 // macro, which reuses the expression `$id`
 
-// pretty-expanded FIXME #23616
 
 #![feature(box_patterns)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/borrowck-move-by-capture-ok.rs b/src/test/run-pass/borrowck-move-by-capture-ok.rs
index 7c03c6a9a489c..bbc668f5cabfe 100644
--- a/src/test/run-pass/borrowck-move-by-capture-ok.rs
+++ b/src/test/run-pass/borrowck-move-by-capture-ok.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
index 4d37bcb5a4896..d55517c65d667 100644
--- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
+++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn want_slice(v: &[isize]) -> isize {
     let mut sum = 0;
diff --git a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs
index c3b69333dc555..e0a5db678d2f4 100644
--- a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs
+++ b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut x = None;
diff --git a/src/test/run-pass/borrowck-rvalues-mutable.rs b/src/test/run-pass/borrowck-rvalues-mutable.rs
index 1b20f6c706162..045e8d952adaa 100644
--- a/src/test/run-pass/borrowck-rvalues-mutable.rs
+++ b/src/test/run-pass/borrowck-rvalues-mutable.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Counter {
     value: usize
diff --git a/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs b/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs
index 36a84a62d48fb..59a5fea769a6f 100644
--- a/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs
+++ b/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs
@@ -12,7 +12,6 @@
 // limited to the deref operation itself, and does not infect the
 // block as a whole.
 
-// pretty-expanded FIXME #23616
 
 struct Box {
     x: usize
diff --git a/src/test/run-pass/borrowck-univariant-enum.rs b/src/test/run-pass/borrowck-univariant-enum.rs
index a5c68c5ecf976..2e8ddb0806472 100644
--- a/src/test/run-pass/borrowck-univariant-enum.rs
+++ b/src/test/run-pass/borrowck-univariant-enum.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 use std::cell::Cell;
 
diff --git a/src/test/run-pass/borrowed-ptr-pattern-2.rs b/src/test/run-pass/borrowed-ptr-pattern-2.rs
index aaf962577ff24..3e47764ba0264 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-2.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn foo(s: &String) -> bool {
     match &**s {
diff --git a/src/test/run-pass/borrowed-ptr-pattern-3.rs b/src/test/run-pass/borrowed-ptr-pattern-3.rs
index c8cc29b9bdacb..91228efb9c1cb 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-3.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-3.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn foo<'r>(s: &'r usize) -> bool {
     match s {
diff --git a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
index 69cb27dcf899e..6656eb41f2e3a 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let (&x, &y) = (&3, &'a');
diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs
index 14b6c32a11e51..e1e9381eeb8e7 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-option.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-option.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn select<'r>(x: &'r Option<isize>, y: &'r Option<isize>) -> &'r Option<isize> {
     match (x, y) {
diff --git a/src/test/run-pass/borrowed-ptr-pattern.rs b/src/test/run-pass/borrowed-ptr-pattern.rs
index 52322c41236b8..3042ff7743b70 100644
--- a/src/test/run-pass/borrowed-ptr-pattern.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn foo<T:Clone>(x: &T) -> T{
     match x {
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index 80934c48515dc..ea136e2dc4854 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut i = 0;
diff --git a/src/test/run-pass/bug-7183-generics.rs b/src/test/run-pass/bug-7183-generics.rs
index 5467ed10e98ea..80fd09114fc95 100644
--- a/src/test/run-pass/bug-7183-generics.rs
+++ b/src/test/run-pass/bug-7183-generics.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Speak : Sized {
     fn say(&self, s:&str) -> String;
diff --git a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
index eb6d1028331be..c5064d56ca123 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
@@ -14,7 +14,6 @@
 // a Send. Basically this just makes sure rustc is using
 // each_bound_trait_and_supertraits in type_contents correctly.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::mpsc::{channel, Sender};
 
diff --git a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
index 082f5944fd3da..183e6fe232cd3 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
@@ -14,7 +14,6 @@
 // Tests "capabilities" granted by traits with super-builtin-kinds,
 // even when using them cross-crate.
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_superkinds_in_metadata;
 
diff --git a/src/test/run-pass/builtin-superkinds-capabilities.rs b/src/test/run-pass/builtin-superkinds-capabilities.rs
index 594fb5ec70780..a4d5c943b1f68 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities.rs
@@ -12,7 +12,6 @@
 // builtin-kinds, e.g., if a trait requires Send to implement, then
 // at usage site of that trait, we know we have the Send capability.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::mpsc::{channel, Sender, Receiver};
 
diff --git a/src/test/run-pass/builtin-superkinds-self-type.rs b/src/test/run-pass/builtin-superkinds-self-type.rs
index 924a8c023f8b6..c4dc7d78b06d5 100644
--- a/src/test/run-pass/builtin-superkinds-self-type.rs
+++ b/src/test/run-pass/builtin-superkinds-self-type.rs
@@ -11,7 +11,6 @@
 // Tests the ability for the Self type in default methods to use
 // capabilities granted by builtin kinds as supertraits.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::mpsc::{Sender, channel};
 
diff --git a/src/test/run-pass/by-value-self-in-mut-slot.rs b/src/test/run-pass/by-value-self-in-mut-slot.rs
index 464c24fc8b032..5bbdec95b1576 100644
--- a/src/test/run-pass/by-value-self-in-mut-slot.rs
+++ b/src/test/run-pass/by-value-self-in-mut-slot.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct X {
     a: isize
diff --git a/src/test/run-pass/call-closure-from-overloaded-op.rs b/src/test/run-pass/call-closure-from-overloaded-op.rs
index e3ee282ec2a4e..e35398a22917f 100644
--- a/src/test/run-pass/call-closure-from-overloaded-op.rs
+++ b/src/test/run-pass/call-closure-from-overloaded-op.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn foo() -> isize { 22 }
 
diff --git a/src/test/run-pass/capture-clauses-boxed-closures.rs b/src/test/run-pass/capture-clauses-boxed-closures.rs
index 5bf6f5fb04891..45cec79e1a30e 100644
--- a/src/test/run-pass/capture-clauses-boxed-closures.rs
+++ b/src/test/run-pass/capture-clauses-boxed-closures.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn each<T, F>(x: &[T], mut f: F) where F: FnMut(&T) {
     for val in x {
diff --git a/src/test/run-pass/capture-clauses-unboxed-closures.rs b/src/test/run-pass/capture-clauses-unboxed-closures.rs
index 448ed76fe96b9..5e7d5aacb8d0d 100644
--- a/src/test/run-pass/capture-clauses-unboxed-closures.rs
+++ b/src/test/run-pass/capture-clauses-unboxed-closures.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs
index 03a73555f856a..bb60626a4bf02 100644
--- a/src/test/run-pass/cast.rs
+++ b/src/test/run-pass/cast.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let i: isize = 'Q' as isize;
diff --git a/src/test/run-pass/cci_nested_exe.rs b/src/test/run-pass/cci_nested_exe.rs
index 665469883043c..e4f4a4f3a576c 100644
--- a/src/test/run-pass/cci_nested_exe.rs
+++ b/src/test/run-pass/cci_nested_exe.rs
@@ -10,7 +10,6 @@
 
 // aux-build:cci_nested_lib.rs
 
-// pretty-expanded FIXME #23616
 
 #![feature(globs)]
 
diff --git a/src/test/run-pass/cell-does-not-clone.rs b/src/test/run-pass/cell-does-not-clone.rs
index c87a3e8bb93d6..c1fcf49654626 100644
--- a/src/test/run-pass/cell-does-not-clone.rs
+++ b/src/test/run-pass/cell-does-not-clone.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::cell::Cell;
 
diff --git a/src/test/run-pass/cfg-macros-foo.rs b/src/test/run-pass/cfg-macros-foo.rs
index 5fa1bc47f877a..36b9ce1585cf8 100644
--- a/src/test/run-pass/cfg-macros-foo.rs
+++ b/src/test/run-pass/cfg-macros-foo.rs
@@ -13,7 +13,6 @@
 // check that cfg correctly chooses between the macro impls (see also
 // cfg-macros-notfoo.rs)
 
-// pretty-expanded FIXME #23616
 
 #[cfg(foo)]
 #[macro_use]
diff --git a/src/test/run-pass/cfg-macros-notfoo.rs b/src/test/run-pass/cfg-macros-notfoo.rs
index 7cddac160319f..4e1b833add017 100644
--- a/src/test/run-pass/cfg-macros-notfoo.rs
+++ b/src/test/run-pass/cfg-macros-notfoo.rs
@@ -13,7 +13,6 @@
 // check that cfg correctly chooses between the macro impls (see also
 // cfg-macros-foo.rs)
 
-// pretty-expanded FIXME #23616
 
 #[cfg(foo)]
 #[macro_use]
diff --git a/src/test/run-pass/cfgs-on-items.rs b/src/test/run-pass/cfgs-on-items.rs
index 5c22d5c869042..1b692d8bd51f4 100644
--- a/src/test/run-pass/cfgs-on-items.rs
+++ b/src/test/run-pass/cfgs-on-items.rs
@@ -11,7 +11,6 @@
 // compile-flags: --cfg fooA --cfg fooB
 
 // fooA AND !bar
-// pretty-expanded FIXME #23616
 
 #[cfg(all(fooA, not(bar)))]
 fn foo1() -> isize { 1 }
diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs
index 801b01918e103..d63512f8066cb 100644
--- a/src/test/run-pass/char.rs
+++ b/src/test/run-pass/char.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let c: char = 'x';
diff --git a/src/test/run-pass/check-static-mut-slices.rs b/src/test/run-pass/check-static-mut-slices.rs
index 19c3458ef7b28..5959dd4c389c8 100644
--- a/src/test/run-pass/check-static-mut-slices.rs
+++ b/src/test/run-pass/check-static-mut-slices.rs
@@ -10,7 +10,6 @@
 
 // Checks that mutable static items can have mutable slices
 
-// pretty-expanded FIXME #23616
 
 static mut TEST: &'static mut [isize] = &mut [1];
 
diff --git a/src/test/run-pass/check-static-slice.rs b/src/test/run-pass/check-static-slice.rs
index 8a7ae1de9bc70..8408597f35409 100644
--- a/src/test/run-pass/check-static-slice.rs
+++ b/src/test/run-pass/check-static-slice.rs
@@ -11,7 +11,6 @@
 // Check that the various ways of getting to a reference to a vec (both sized
 // and unsized) work properly.
 
-// pretty-expanded FIXME #23616
 
 const aa: [isize; 3] = [1, 2, 3];
 const ab: &'static [isize; 3] = &aa;
diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs
index 675acf1dd62e0..6783609b256c9 100644
--- a/src/test/run-pass/class-exports.rs
+++ b/src/test/run-pass/class-exports.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 /* Test that exporting a class also exports its
    public fields and methods */
diff --git a/src/test/run-pass/class-method-cross-crate.rs b/src/test/run-pass/class-method-cross-crate.rs
index a5c60e3a7b53c..6ab158dc37ca5 100644
--- a/src/test/run-pass/class-method-cross-crate.rs
+++ b/src/test/run-pass/class-method-cross-crate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:cci_class_2.rs
-// pretty-expanded FIXME #23616
 
 extern crate cci_class_2;
 use cci_class_2::kitties::cat;
diff --git a/src/test/run-pass/class-methods-cross-crate.rs b/src/test/run-pass/class-methods-cross-crate.rs
index 73abaf7d34bb8..666571007595c 100644
--- a/src/test/run-pass/class-methods-cross-crate.rs
+++ b/src/test/run-pass/class-methods-cross-crate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:cci_class_3.rs
-// pretty-expanded FIXME #23616
 
 extern crate cci_class_3;
 use cci_class_3::kitties::cat;
diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs
index d454bdd73a1ac..93af906bd5a6c 100644
--- a/src/test/run-pass/class-methods.rs
+++ b/src/test/run-pass/class-methods.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct cat {
   meows : usize,
diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs
index 6537a931fa615..4d247bde190de 100644
--- a/src/test/run-pass/class-poly-methods-cross-crate.rs
+++ b/src/test/run-pass/class-poly-methods-cross-crate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:cci_class_6.rs
-// pretty-expanded FIXME #23616
 
 extern crate cci_class_6;
 use cci_class_6::kitties::cat;
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index 27f872d532c79..2528ff5128f9c 100644
--- a/src/test/run-pass/class-poly-methods.rs
+++ b/src/test/run-pass/class-poly-methods.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 struct cat<U> {
     info : Vec<U> ,
diff --git a/src/test/run-pass/classes-cross-crate.rs b/src/test/run-pass/classes-cross-crate.rs
index 36d7bd6b3ca48..3d99aa1ef1d08 100644
--- a/src/test/run-pass/classes-cross-crate.rs
+++ b/src/test/run-pass/classes-cross-crate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:cci_class_4.rs
-// pretty-expanded FIXME #23616
 
 extern crate cci_class_4;
 use cci_class_4::kitties::cat;
diff --git a/src/test/run-pass/classes-simple-cross-crate.rs b/src/test/run-pass/classes-simple-cross-crate.rs
index cfa13dbe622f7..db15001c62f19 100644
--- a/src/test/run-pass/classes-simple-cross-crate.rs
+++ b/src/test/run-pass/classes-simple-cross-crate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:cci_class.rs
-// pretty-expanded FIXME #23616
 
 extern crate cci_class;
 use cci_class::kitties::cat;
diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs
index 0d9f859d2d14d..64ec2ea7e71ae 100644
--- a/src/test/run-pass/classes-simple-method.rs
+++ b/src/test/run-pass/classes-simple-method.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct cat {
     meows : usize,
diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs
index f520623a75ab5..c475fb2cff945 100644
--- a/src/test/run-pass/classes-simple.rs
+++ b/src/test/run-pass/classes-simple.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct cat {
     meows : usize,
diff --git a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
index 1d0030fd3d362..d813a6d810236 100644
--- a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
+++ b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
@@ -12,7 +12,6 @@
 // This test verifies that temporaries created for `while`'s and `if`
 // conditions are dropped after the condition is evaluated.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
index 3b5421e5aff4c..344ea63c7c74d 100644
--- a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
+++ b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
@@ -24,7 +24,6 @@
 // It's unclear how likely such a bug is to recur, but it seems like a
 // scenario worth testing.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/closure-inference.rs b/src/test/run-pass/closure-inference.rs
index 06b6e1b5abedd..630a510ca651e 100644
--- a/src/test/run-pass/closure-inference.rs
+++ b/src/test/run-pass/closure-inference.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn foo(i: isize) -> isize { i + 1 }
 
diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs
index 328a27b3f1e8a..2f24cd4ce4043 100644
--- a/src/test/run-pass/closure-inference2.rs
+++ b/src/test/run-pass/closure-inference2.rs
@@ -10,7 +10,6 @@
 
 // Test a rather underspecified example:
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let f = {|i| i};
diff --git a/src/test/run-pass/cmp-default.rs b/src/test/run-pass/cmp-default.rs
index 2b7557c7bc563..cd3f556864e64 100644
--- a/src/test/run-pass/cmp-default.rs
+++ b/src/test/run-pass/cmp-default.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::cmp::Ordering;
 
diff --git a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs
index 6000b358acf26..5258ad1af5150 100644
--- a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct SpeechMaker {
     speeches: usize
diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
index 2e41ff3a56041..4e116ae146691 100644
--- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn bar(v: &mut [usize]) -> Vec<usize> {
     v.to_vec()
diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
index 803f86e0fb101..ce0bc33905fe5 100644
--- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
+++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn reverse(v: &mut [usize]) {
     v.reverse();
diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
index a5fac127356c8..066b33e007b89 100644
--- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn bar(v: &mut [usize]) {
     v.reverse();
diff --git a/src/test/run-pass/compare-generic-enums.rs b/src/test/run-pass/compare-generic-enums.rs
index 69945584876d0..228a73326e117 100644
--- a/src/test/run-pass/compare-generic-enums.rs
+++ b/src/test/run-pass/compare-generic-enums.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 type an_int = isize;
 
diff --git a/src/test/run-pass/concat.rs b/src/test/run-pass/concat.rs
index 7441d1f21b0f9..9a2390a9e68d3 100644
--- a/src/test/run-pass/concat.rs
+++ b/src/test/run-pass/concat.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert_eq!(format!(concat!("foo", "bar", "{}"), "baz"), "foobarbaz".to_string());
diff --git a/src/test/run-pass/conditional-compile.rs b/src/test/run-pass/conditional-compile.rs
index e6660bb9ae880..5891d9f1aa019 100644
--- a/src/test/run-pass/conditional-compile.rs
+++ b/src/test/run-pass/conditional-compile.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // Crate use statements
-// pretty-expanded FIXME #23616
 
 #[cfg(bogus)]
 use flippity;
diff --git a/src/test/run-pass/conditional-debug-macro-off.rs b/src/test/run-pass/conditional-debug-macro-off.rs
index 192e647f5cb20..c6beb5ba35875 100644
--- a/src/test/run-pass/conditional-debug-macro-off.rs
+++ b/src/test/run-pass/conditional-debug-macro-off.rs
@@ -11,7 +11,6 @@
 // compile-flags: -C debug-assertions=no
 // exec-env:RUST_LOG=conditional-debug-macro-off=4
 
-// pretty-expanded FIXME #23616
 
 #![feature(rustc_private)]
 
diff --git a/src/test/run-pass/const-autoderef.rs b/src/test/run-pass/const-autoderef.rs
index 1349b7f814bb0..69173e35e2ce3 100644
--- a/src/test/run-pass/const-autoderef.rs
+++ b/src/test/run-pass/const-autoderef.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 static A: [u8; 1] = ['h' as u8];
 static B: u8 = (&A)[0];
diff --git a/src/test/run-pass/const-big-enum.rs b/src/test/run-pass/const-big-enum.rs
index 158c695c548d2..125aefe036dc6 100644
--- a/src/test/run-pass/const-big-enum.rs
+++ b/src/test/run-pass/const-big-enum.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum Foo {
     Bar(u32),
diff --git a/src/test/run-pass/const-binops.rs b/src/test/run-pass/const-binops.rs
index 1a95220cda59c..4b32ee352311d 100644
--- a/src/test/run-pass/const-binops.rs
+++ b/src/test/run-pass/const-binops.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! assert_approx_eq {
     ($a:expr, $b:expr) => ({
diff --git a/src/test/run-pass/const-block-cross-crate-fn.rs b/src/test/run-pass/const-block-cross-crate-fn.rs
index 853e8dc62bb70..6fa6feffbfa00 100644
--- a/src/test/run-pass/const-block-cross-crate-fn.rs
+++ b/src/test/run-pass/const-block-cross-crate-fn.rs
@@ -10,7 +10,6 @@
 
 // aux-build:cci_const_block.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate cci_const_block;
 
diff --git a/src/test/run-pass/const-block-item-macro-codegen.rs b/src/test/run-pass/const-block-item-macro-codegen.rs
index b9e8dbf41d77f..8a4b220a3763c 100644
--- a/src/test/run-pass/const-block-item-macro-codegen.rs
+++ b/src/test/run-pass/const-block-item-macro-codegen.rs
@@ -11,7 +11,6 @@
 // General test that function items in static blocks
 // can be generated with a macro.
 
-// pretty-expanded FIXME #23616
 
 struct MyType {
     desc: &'static str,
diff --git a/src/test/run-pass/const-block-item.rs b/src/test/run-pass/const-block-item.rs
index 897e53822614d..b616b1f610325 100644
--- a/src/test/run-pass/const-block-item.rs
+++ b/src/test/run-pass/const-block-item.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod foo {
     pub trait Value {
diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs
index 1337a91fe05d6..e56d01d7ba8ce 100644
--- a/src/test/run-pass/const-block.rs
+++ b/src/test/run-pass/const-block.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_code)]
 #![allow(unused_unsafe)]
diff --git a/src/test/run-pass/const-cast-ptr-int.rs b/src/test/run-pass/const-cast-ptr-int.rs
index bbe3020ea1c65..e7674f893d377 100644
--- a/src/test/run-pass/const-cast-ptr-int.rs
+++ b/src/test/run-pass/const-cast-ptr-int.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::ptr;
 
diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs
index f660dc5fa450e..411df2b3e0759 100644
--- a/src/test/run-pass/const-cast.rs
+++ b/src/test/run-pass/const-cast.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(libc)]
 
diff --git a/src/test/run-pass/const-const.rs b/src/test/run-pass/const-const.rs
index d75a5a7eb1c3b..b28017b85ad61 100644
--- a/src/test/run-pass/const-const.rs
+++ b/src/test/run-pass/const-const.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const a: isize = 1;
 const b: isize = a + 2;
diff --git a/src/test/run-pass/const-contents.rs b/src/test/run-pass/const-contents.rs
index 2dfb88dee0bb8..0d9d0e0e0aa73 100644
--- a/src/test/run-pass/const-contents.rs
+++ b/src/test/run-pass/const-contents.rs
@@ -10,7 +10,6 @@
 
 // Issue #570
 
-// pretty-expanded FIXME #23616
 
 static lsl : isize = 1 << 2;
 static add : isize = 1 + 2;
diff --git a/src/test/run-pass/const-cross-crate-const.rs b/src/test/run-pass/const-cross-crate-const.rs
index e36a55361ec28..d66c335db2e87 100644
--- a/src/test/run-pass/const-cross-crate-const.rs
+++ b/src/test/run-pass/const-cross-crate-const.rs
@@ -10,7 +10,6 @@
 
 // aux-build:cci_const.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate cci_const;
 static foo: &'static str = cci_const::foopy;
diff --git a/src/test/run-pass/const-cross-crate-extern.rs b/src/test/run-pass/const-cross-crate-extern.rs
index 98f42f91245cd..bbe31ceed33cf 100644
--- a/src/test/run-pass/const-cross-crate-extern.rs
+++ b/src/test/run-pass/const-cross-crate-extern.rs
@@ -10,7 +10,6 @@
 
 // aux-build:cci_const.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate cci_const;
 use cci_const::bar;
diff --git a/src/test/run-pass/const-deref.rs b/src/test/run-pass/const-deref.rs
index 1648332fe2c39..f5407f0c81523 100644
--- a/src/test/run-pass/const-deref.rs
+++ b/src/test/run-pass/const-deref.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const C: &'static isize = &1000;
 static D: isize = *C;
diff --git a/src/test/run-pass/const-enum-byref-self.rs b/src/test/run-pass/const-enum-byref-self.rs
index e99e1aac8afdb..57470c4a67e26 100644
--- a/src/test/run-pass/const-enum-byref-self.rs
+++ b/src/test/run-pass/const-enum-byref-self.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V, VV(isize) }
 static C: E = E::V;
diff --git a/src/test/run-pass/const-enum-byref.rs b/src/test/run-pass/const-enum-byref.rs
index 4905eaace6820..e3f1d5d35320c 100644
--- a/src/test/run-pass/const-enum-byref.rs
+++ b/src/test/run-pass/const-enum-byref.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V, VV(isize) }
 static C: E = E::V;
diff --git a/src/test/run-pass/const-enum-cast.rs b/src/test/run-pass/const-enum-cast.rs
index 3d73933c6f638..38f21f7e95962 100644
--- a/src/test/run-pass/const-enum-cast.rs
+++ b/src/test/run-pass/const-enum-cast.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum A { A1, A2 }
 enum B { B1=0, B2=2 }
diff --git a/src/test/run-pass/const-enum-ptr.rs b/src/test/run-pass/const-enum-ptr.rs
index d34b5381df9bf..40a1c99e987db 100644
--- a/src/test/run-pass/const-enum-ptr.rs
+++ b/src/test/run-pass/const-enum-ptr.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V0, V1(isize) }
 static C: &'static E = &E::V0;
diff --git a/src/test/run-pass/const-enum-struct.rs b/src/test/run-pass/const-enum-struct.rs
index 71a9703ec311a..46c4f82eb98e1 100644
--- a/src/test/run-pass/const-enum-struct.rs
+++ b/src/test/run-pass/const-enum-struct.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V16(u16), V32(u32) }
 struct S { a: E, b: u16, c: u16 }
diff --git a/src/test/run-pass/const-enum-struct2.rs b/src/test/run-pass/const-enum-struct2.rs
index ca56cb5b01a99..e356ecb385b98 100644
--- a/src/test/run-pass/const-enum-struct2.rs
+++ b/src/test/run-pass/const-enum-struct2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V0, V16(u16) }
 struct S { a: E, b: u16, c: u16 }
diff --git a/src/test/run-pass/const-enum-structlike.rs b/src/test/run-pass/const-enum-structlike.rs
index 113f20e21e1df..6c8786dee6782 100644
--- a/src/test/run-pass/const-enum-structlike.rs
+++ b/src/test/run-pass/const-enum-structlike.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E {
     S0 { s: String },
diff --git a/src/test/run-pass/const-enum-tuple.rs b/src/test/run-pass/const-enum-tuple.rs
index 2ab28f5fb2377..476defaa524a0 100644
--- a/src/test/run-pass/const-enum-tuple.rs
+++ b/src/test/run-pass/const-enum-tuple.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V16(u16), V32(u32) }
 static C: (E, u16, u16) = (E::V16(0xDEAD), 0x600D, 0xBAD);
diff --git a/src/test/run-pass/const-enum-tuple2.rs b/src/test/run-pass/const-enum-tuple2.rs
index fe1b2e051c479..61043ef75a4c5 100644
--- a/src/test/run-pass/const-enum-tuple2.rs
+++ b/src/test/run-pass/const-enum-tuple2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V0, V16(u16) }
 static C: (E, u16, u16) = (E::V0, 0x600D, 0xBAD);
diff --git a/src/test/run-pass/const-enum-tuplestruct.rs b/src/test/run-pass/const-enum-tuplestruct.rs
index 7f9de49404d3a..f574508522b26 100644
--- a/src/test/run-pass/const-enum-tuplestruct.rs
+++ b/src/test/run-pass/const-enum-tuplestruct.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V16(u16), V32(u32) }
 struct S(E, u16, u16);
diff --git a/src/test/run-pass/const-enum-tuplestruct2.rs b/src/test/run-pass/const-enum-tuplestruct2.rs
index 3d7b6c9f49f78..88cfc0dec7028 100644
--- a/src/test/run-pass/const-enum-tuplestruct2.rs
+++ b/src/test/run-pass/const-enum-tuplestruct2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V0, V16(u16) }
 struct S(E, u16, u16);
diff --git a/src/test/run-pass/const-enum-vec-index.rs b/src/test/run-pass/const-enum-vec-index.rs
index fcaf8b8844b07..2f1cd8dbf9b12 100644
--- a/src/test/run-pass/const-enum-vec-index.rs
+++ b/src/test/run-pass/const-enum-vec-index.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V1(isize), V0 }
 const C: &'static [E] = &[E::V0, E::V1(0xDEADBEE)];
diff --git a/src/test/run-pass/const-enum-vec-ptr.rs b/src/test/run-pass/const-enum-vec-ptr.rs
index 936d72ac65e2f..de94527a60486 100644
--- a/src/test/run-pass/const-enum-vec-ptr.rs
+++ b/src/test/run-pass/const-enum-vec-ptr.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V1(isize), V0 }
 static C: &'static [E] = &[E::V0, E::V1(0xDEADBEE), E::V0];
diff --git a/src/test/run-pass/const-enum-vector.rs b/src/test/run-pass/const-enum-vector.rs
index 6fdf0c3948fa0..8d43a76bc28c3 100644
--- a/src/test/run-pass/const-enum-vector.rs
+++ b/src/test/run-pass/const-enum-vector.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E { V1(isize), V0 }
 static C: [E; 3] = [E::V0, E::V1(0xDEADBEE), E::V0];
diff --git a/src/test/run-pass/const-extern-function.rs b/src/test/run-pass/const-extern-function.rs
index ff829711a4c6c..214b0400e8631 100644
--- a/src/test/run-pass/const-extern-function.rs
+++ b/src/test/run-pass/const-extern-function.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 extern fn foopy() {}
 
diff --git a/src/test/run-pass/const-fn-val.rs b/src/test/run-pass/const-fn-val.rs
index 3e1058dc27d99..85c92dda434a6 100644
--- a/src/test/run-pass/const-fn-val.rs
+++ b/src/test/run-pass/const-fn-val.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn foo() -> isize {
     return 0xca7f000d;
diff --git a/src/test/run-pass/const-negative.rs b/src/test/run-pass/const-negative.rs
index 59b2c3e36aaf9..7f26a9773396d 100644
--- a/src/test/run-pass/const-negative.rs
+++ b/src/test/run-pass/const-negative.rs
@@ -10,7 +10,6 @@
 
 // Issue #358
 
-// pretty-expanded FIXME #23616
 
 static toplevel_mod: isize = -1;
 
diff --git a/src/test/run-pass/const-nullary-enum.rs b/src/test/run-pass/const-nullary-enum.rs
index fcad89470d7c5..b3f6549ef0167 100644
--- a/src/test/run-pass/const-nullary-enum.rs
+++ b/src/test/run-pass/const-nullary-enum.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum Foo {
     Bar,
diff --git a/src/test/run-pass/const-nullary-univariant-enum.rs b/src/test/run-pass/const-nullary-univariant-enum.rs
index 51926ececc2b1..b1b7f782cd04a 100644
--- a/src/test/run-pass/const-nullary-univariant-enum.rs
+++ b/src/test/run-pass/const-nullary-univariant-enum.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 enum Foo {
diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs
index 8932853fbf485..9a1f747ce59fb 100644
--- a/src/test/run-pass/const-region-ptrs-noncopy.rs
+++ b/src/test/run-pass/const-region-ptrs-noncopy.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 type Big = [u64; 8];
 struct Pair<'a> { a: isize, b: &'a Big }
diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs
index c5ff134ff0e9b..1cdb98a8bc05b 100644
--- a/src/test/run-pass/const-str-ptr.rs
+++ b/src/test/run-pass/const-str-ptr.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::{str, string};
 
diff --git a/src/test/run-pass/const-tuple-struct.rs b/src/test/run-pass/const-tuple-struct.rs
index ccf1b06bacb5f..ddc50fc6646f2 100644
--- a/src/test/run-pass/const-tuple-struct.rs
+++ b/src/test/run-pass/const-tuple-struct.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Bar(isize, isize);
 
diff --git a/src/test/run-pass/consts-in-patterns.rs b/src/test/run-pass/consts-in-patterns.rs
index c2f7cf4d62568..36e6e160a3bd2 100644
--- a/src/test/run-pass/consts-in-patterns.rs
+++ b/src/test/run-pass/consts-in-patterns.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const FOO: isize = 10;
 const BAR: isize = 3;
diff --git a/src/test/run-pass/cross-crate-newtype-struct-pat.rs b/src/test/run-pass/cross-crate-newtype-struct-pat.rs
index 986108c5d8fa6..7eae9017420d7 100644
--- a/src/test/run-pass/cross-crate-newtype-struct-pat.rs
+++ b/src/test/run-pass/cross-crate-newtype-struct-pat.rs
@@ -10,7 +10,6 @@
 
 // aux-build:newtype_struct_xc.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate newtype_struct_xc;
 
diff --git a/src/test/run-pass/deep.rs b/src/test/run-pass/deep.rs
index 16636fadbf8dc..f8e690cf29e07 100644
--- a/src/test/run-pass/deep.rs
+++ b/src/test/run-pass/deep.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 fn f(x: isize) -> isize {
     if x == 1 { return 1; } else { let y: isize = 1 + f(x - 1); return y; }
diff --git a/src/test/run-pass/deref-mut-on-ref.rs b/src/test/run-pass/deref-mut-on-ref.rs
index 8820003d3b24d..98441d7daaad7 100644
--- a/src/test/run-pass/deref-mut-on-ref.rs
+++ b/src/test/run-pass/deref-mut-on-ref.rs
@@ -10,7 +10,6 @@
 
 // Test that `&mut T` implements `DerefMut<T>`
 
-// pretty-expanded FIXME #23616
 
 use std::ops::{Deref, DerefMut};
 
diff --git a/src/test/run-pass/deref-on-ref.rs b/src/test/run-pass/deref-on-ref.rs
index 84bfbd82297a7..383c8197f9473 100644
--- a/src/test/run-pass/deref-on-ref.rs
+++ b/src/test/run-pass/deref-on-ref.rs
@@ -10,7 +10,6 @@
 
 // Test that `&T` and `&mut T` implement `Deref<T>`
 
-// pretty-expanded FIXME #23616
 
 use std::ops::Deref;
 
diff --git a/src/test/run-pass/deref-rc.rs b/src/test/run-pass/deref-rc.rs
index 761b29258f2af..b84d78b4f4fbd 100644
--- a/src/test/run-pass/deref-rc.rs
+++ b/src/test/run-pass/deref-rc.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::rc::Rc;
 
diff --git a/src/test/run-pass/deriving-cmp-generic-enum.rs b/src/test/run-pass/deriving-cmp-generic-enum.rs
index 07ad8f706eb5c..b1cd1877a7667 100644
--- a/src/test/run-pass/deriving-cmp-generic-enum.rs
+++ b/src/test/run-pass/deriving-cmp-generic-enum.rs
@@ -10,7 +10,6 @@
 
 // no-pretty-expanded FIXME #15189
 
-// pretty-expanded FIXME #23616
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 enum E<T> {
diff --git a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
index 5f7d184f1949d..14f7862ef21fc 100644
--- a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
+++ b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
@@ -10,7 +10,6 @@
 
 // no-pretty-expanded FIXME #15189
 
-// pretty-expanded FIXME #23616
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 enum ES<T> {
diff --git a/src/test/run-pass/deriving-cmp-generic-struct.rs b/src/test/run-pass/deriving-cmp-generic-struct.rs
index ea0017380b275..5c7d806f519d1 100644
--- a/src/test/run-pass/deriving-cmp-generic-struct.rs
+++ b/src/test/run-pass/deriving-cmp-generic-struct.rs
@@ -10,7 +10,6 @@
 
 // no-pretty-expanded FIXME #15189
 
-// pretty-expanded FIXME #23616
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 struct S<T> {
diff --git a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
index 702071676b90e..b7bfb91b278a0 100644
--- a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
+++ b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
@@ -10,7 +10,6 @@
 
 // no-pretty-expanded FIXME #15189
 
-// pretty-expanded FIXME #23616
 
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 struct TS<T>(T,T);
diff --git a/src/test/run-pass/deriving-cmp-shortcircuit.rs b/src/test/run-pass/deriving-cmp-shortcircuit.rs
index 1669f3fdd3d9a..e22e4767d521f 100644
--- a/src/test/run-pass/deriving-cmp-shortcircuit.rs
+++ b/src/test/run-pass/deriving-cmp-shortcircuit.rs
@@ -12,7 +12,6 @@
 // where possible, by having a type that panics when compared as the
 // second element, so this passes iff the instances shortcircuit.
 
-// pretty-expanded FIXME #23616
 
 use std::cmp::Ordering;
 
diff --git a/src/test/run-pass/deriving-default-box.rs b/src/test/run-pass/deriving-default-box.rs
index 574a620ef0290..dc31e71aad873 100644
--- a/src/test/run-pass/deriving-default-box.rs
+++ b/src/test/run-pass/deriving-default-box.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/deriving-encodable-decodable-box.rs b/src/test/run-pass/deriving-encodable-decodable-box.rs
index 6ccedb0ad982f..db5a1f3f000a8 100644
--- a/src/test/run-pass/deriving-encodable-decodable-box.rs
+++ b/src/test/run-pass/deriving-encodable-decodable-box.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs
index d216062bb2da3..7cc59edfcab0e 100644
--- a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs
+++ b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs
@@ -11,7 +11,6 @@
 // This briefly tests the capability of `Cell` and `RefCell` to implement the
 // `Encodable` and `Decodable` traits via `#[derive(Encodable, Decodable)]`
 
-// pretty-expanded FIXME #23616
 
 #![feature(rustc_private)]
 
diff --git a/src/test/run-pass/deriving-hash.rs b/src/test/run-pass/deriving-hash.rs
index ce7ba9f25eb07..287750e5051c7 100644
--- a/src/test/run-pass/deriving-hash.rs
+++ b/src/test/run-pass/deriving-hash.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(hash)]
 
diff --git a/src/test/run-pass/deriving-rand.rs b/src/test/run-pass/deriving-rand.rs
index b960c2ddd4a43..bc11b55d3105f 100644
--- a/src/test/run-pass/deriving-rand.rs
+++ b/src/test/run-pass/deriving-rand.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(rand)]
 
diff --git a/src/test/run-pass/destructure-array-1.rs b/src/test/run-pass/destructure-array-1.rs
index e2c96085714ba..0d24f0bd0d7b3 100644
--- a/src/test/run-pass/destructure-array-1.rs
+++ b/src/test/run-pass/destructure-array-1.rs
@@ -11,7 +11,6 @@
 // Ensure that we can do a destructuring bind of a fixed-size array,
 // even when the element type has a destructor.
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]
 
diff --git a/src/test/run-pass/die-macro.rs b/src/test/run-pass/die-macro.rs
index 6a81ebe67ba80..0816e258e84a0 100644
--- a/src/test/run-pass/die-macro.rs
+++ b/src/test/run-pass/die-macro.rs
@@ -10,7 +10,6 @@
 
 // Just testing that panic!() type checks in statement or expr
 
-// pretty-expanded FIXME #23616
 
 #![allow(unreachable_code)]
 
diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs
index 237cfe19dc49b..b6cae71df865d 100644
--- a/src/test/run-pass/div-mod.rs
+++ b/src/test/run-pass/div-mod.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x: isize = 15;
diff --git a/src/test/run-pass/drop-struct-as-object.rs b/src/test/run-pass/drop-struct-as-object.rs
index efb98160a3e61..33d5c72772c57 100644
--- a/src/test/run-pass/drop-struct-as-object.rs
+++ b/src/test/run-pass/drop-struct-as-object.rs
@@ -11,7 +11,6 @@
 // Test that destructor on a struct runs successfully after the struct
 // is boxed and converted to an object.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/drop-with-type-ascription-1.rs b/src/test/run-pass/drop-with-type-ascription-1.rs
index ea9edff4945fe..9dd458344cb5a 100644
--- a/src/test/run-pass/drop-with-type-ascription-1.rs
+++ b/src/test/run-pass/drop-with-type-ascription-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(str_words)]
 
diff --git a/src/test/run-pass/drop-with-type-ascription-2.rs b/src/test/run-pass/drop-with-type-ascription-2.rs
index 3d4af80e30bb5..cb3712dea3224 100644
--- a/src/test/run-pass/drop-with-type-ascription-2.rs
+++ b/src/test/run-pass/drop-with-type-ascription-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections)]
 
diff --git a/src/test/run-pass/dropck_tarena_sound_drop.rs b/src/test/run-pass/dropck_tarena_sound_drop.rs
index df29b8e10c7aa..6ccf6c2fd644d 100644
--- a/src/test/run-pass/dropck_tarena_sound_drop.rs
+++ b/src/test/run-pass/dropck_tarena_sound_drop.rs
@@ -16,7 +16,6 @@
 // shows a similar setup, but restricts `f` so that the struct `C<'a>`
 // is force-fed a lifetime equal to that of the borrowed arena.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unstable)]
 #![feature(unsafe_destructor, rustc_private)]
diff --git a/src/test/run-pass/dst-deref-mut.rs b/src/test/run-pass/dst-deref-mut.rs
index 3b2b7493fd0fa..b031c82a07f3d 100644
--- a/src/test/run-pass/dst-deref-mut.rs
+++ b/src/test/run-pass/dst-deref-mut.rs
@@ -10,7 +10,6 @@
 
 // Test that a custom deref with a fat pointer return type does not ICE
 
-// pretty-expanded FIXME #23616
 
 use std::ops::{Deref, DerefMut};
 
diff --git a/src/test/run-pass/dst-deref.rs b/src/test/run-pass/dst-deref.rs
index c8e658beef81b..c4666d05fbfe3 100644
--- a/src/test/run-pass/dst-deref.rs
+++ b/src/test/run-pass/dst-deref.rs
@@ -10,7 +10,6 @@
 
 // Test that a custom deref with a fat pointer return type does not ICE
 
-// pretty-expanded FIXME #23616
 
 use std::ops::Deref;
 
diff --git a/src/test/run-pass/dst-index.rs b/src/test/run-pass/dst-index.rs
index df4cd74740cdd..34a187fa6f2d2 100644
--- a/src/test/run-pass/dst-index.rs
+++ b/src/test/run-pass/dst-index.rs
@@ -11,7 +11,6 @@
 // Test that overloaded index expressions with DST result types
 // work and don't ICE.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/dst-raw.rs b/src/test/run-pass/dst-raw.rs
index 5e0e5bd03fe6f..d899de9164071 100644
--- a/src/test/run-pass/dst-raw.rs
+++ b/src/test/run-pass/dst-raw.rs
@@ -10,7 +10,6 @@
 
 // Test DST raw pointers
 
-// pretty-expanded FIXME #23616
 
 trait Trait {
     fn foo(&self) -> isize;
diff --git a/src/test/run-pass/dst-struct-sole.rs b/src/test/run-pass/dst-struct-sole.rs
index 9bf286c434219..d440fb2a216ec 100644
--- a/src/test/run-pass/dst-struct-sole.rs
+++ b/src/test/run-pass/dst-struct-sole.rs
@@ -10,7 +10,6 @@
 
 // As dst-struct.rs, but the unsized field is the only field in the struct.
 
-// pretty-expanded FIXME #23616
 
 struct Fat<T: ?Sized> {
     ptr: T
diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs
index 5198dd43d6db8..8b6db23026b8a 100644
--- a/src/test/run-pass/dst-struct.rs
+++ b/src/test/run-pass/dst-struct.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/dst-trait.rs b/src/test/run-pass/dst-trait.rs
index 370bc2882271f..4d2b50c08e2f5 100644
--- a/src/test/run-pass/dst-trait.rs
+++ b/src/test/run-pass/dst-trait.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs
index 79c2f45067884..afc1d200b274b 100644
--- a/src/test/run-pass/else-if.rs
+++ b/src/test/run-pass/else-if.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     if 1 == 2 {
diff --git a/src/test/run-pass/empty-allocation-non-null.rs b/src/test/run-pass/empty-allocation-non-null.rs
index cec528fa0401c..af6e321e40aa6 100644
--- a/src/test/run-pass/empty-allocation-non-null.rs
+++ b/src/test/run-pass/empty-allocation-non-null.rs
@@ -10,7 +10,6 @@
 
 // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert!(Some(Box::new(())).is_some());
diff --git a/src/test/run-pass/enum-alignment.rs b/src/test/run-pass/enum-alignment.rs
index df779d0d713fd..827894f8f32c9 100644
--- a/src/test/run-pass/enum-alignment.rs
+++ b/src/test/run-pass/enum-alignment.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/enum-clike-ffi-as-int.rs b/src/test/run-pass/enum-clike-ffi-as-int.rs
index f129a51534143..8be3634c88add 100644
--- a/src/test/run-pass/enum-clike-ffi-as-int.rs
+++ b/src/test/run-pass/enum-clike-ffi-as-int.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 /*!
  * C-like enums have to be represented as LLVM ints, not wrapped in a
diff --git a/src/test/run-pass/enum-discr.rs b/src/test/run-pass/enum-discr.rs
index 5c01d544cf533..1ff6370136076 100644
--- a/src/test/run-pass/enum-discr.rs
+++ b/src/test/run-pass/enum-discr.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum Animal {
     Cat = 0,
diff --git a/src/test/run-pass/enum-discrim-autosizing.rs b/src/test/run-pass/enum-discrim-autosizing.rs
index 239f9821b925b..99e44735d0f03 100644
--- a/src/test/run-pass/enum-discrim-autosizing.rs
+++ b/src/test/run-pass/enum-discrim-autosizing.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::size_of;
 
diff --git a/src/test/run-pass/enum-discrim-manual-sizing.rs b/src/test/run-pass/enum-discrim-manual-sizing.rs
index b23cfa9f32b8e..edad5cc1652da 100644
--- a/src/test/run-pass/enum-discrim-manual-sizing.rs
+++ b/src/test/run-pass/enum-discrim-manual-sizing.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::size_of;
 
diff --git a/src/test/run-pass/enum-disr-val-pretty.rs b/src/test/run-pass/enum-disr-val-pretty.rs
index 9a2f45d00790e..cf66725178011 100644
--- a/src/test/run-pass/enum-disr-val-pretty.rs
+++ b/src/test/run-pass/enum-disr-val-pretty.rs
@@ -10,7 +10,6 @@
 
 // pp-exact
 
-// pretty-expanded FIXME #23616
 
 enum color { red = 1, green, blue, imaginary = -1, }
 
diff --git a/src/test/run-pass/enum-null-pointer-opt.rs b/src/test/run-pass/enum-null-pointer-opt.rs
index 9fc799a97f6b9..499d131947a38 100644
--- a/src/test/run-pass/enum-null-pointer-opt.rs
+++ b/src/test/run-pass/enum-null-pointer-opt.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/enum-nullable-const-null-with-fields.rs b/src/test/run-pass/enum-nullable-const-null-with-fields.rs
index 3a7c7ea9a714b..1342c4e104de5 100644
--- a/src/test/run-pass/enum-nullable-const-null-with-fields.rs
+++ b/src/test/run-pass/enum-nullable-const-null-with-fields.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::result::Result;
 use std::result::Result::Ok;
diff --git a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
index 99554aafb0427..c8a1047cfa818 100644
--- a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
+++ b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/env-home-dir.rs b/src/test/run-pass/env-home-dir.rs
index 7fb96112125af..efe72729817e8 100644
--- a/src/test/run-pass/env-home-dir.rs
+++ b/src/test/run-pass/env-home-dir.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(path)]
 
diff --git a/src/test/run-pass/env-vars.rs b/src/test/run-pass/env-vars.rs
index 33bc6c596dbd0..d86f63c9cb91d 100644
--- a/src/test/run-pass/env-vars.rs
+++ b/src/test/run-pass/env-vars.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::env::*;
 
diff --git a/src/test/run-pass/eq-multidispatch.rs b/src/test/run-pass/eq-multidispatch.rs
index 3ca254021e5b9..bf8b089a830c2 100644
--- a/src/test/run-pass/eq-multidispatch.rs
+++ b/src/test/run-pass/eq-multidispatch.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(PartialEq)]
 struct Bar;
diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs
index 0b24658a8f331..4dfb15418405d 100644
--- a/src/test/run-pass/estr-uniq.rs
+++ b/src/test/run-pass/estr-uniq.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_assignment)]
 
diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs
index a24930732474f..d17056e6d799d 100644
--- a/src/test/run-pass/exec-env.rs
+++ b/src/test/run-pass/exec-env.rs
@@ -10,7 +10,6 @@
 
 // exec-env:TEST_EXEC_ENV=22
 
-// pretty-expanded FIXME #23616
 
 use std::env;
 
diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs
index ee50d3bdf0ee8..1b50d3028b1e2 100644
--- a/src/test/run-pass/explicit-self-generic.rs
+++ b/src/test/run-pass/explicit-self-generic.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs
index 08ea638f93a56..4021ae89e3629 100644
--- a/src/test/run-pass/explicit-self-objects-uniq.rs
+++ b/src/test/run-pass/explicit-self-objects-uniq.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs
index b81090555ea64..d2a0d60eb6614 100644
--- a/src/test/run-pass/explicit-self.rs
+++ b/src/test/run-pass/explicit-self.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/expr-block-fn.rs b/src/test/run-pass/expr-block-fn.rs
index c88721471b64c..67e41aad6971b 100644
--- a/src/test/run-pass/expr-block-fn.rs
+++ b/src/test/run-pass/expr-block-fn.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 fn test_fn() {
     fn ten() -> isize { return 10; }
diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs
index bd2936773953b..5477a9227aa1d 100644
--- a/src/test/run-pass/expr-block-generic-unique2.rs
+++ b/src/test/run-pass/expr-block-generic-unique2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs
index d26c6e62f536e..8795962bebdd8 100644
--- a/src/test/run-pass/expr-block-generic.rs
+++ b/src/test/run-pass/expr-block-generic.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn test_generic<T: Clone, F>(expected: T, eq: F) where F: FnOnce(T, T) -> bool {
     let actual: T = { expected.clone() };
diff --git a/src/test/run-pass/expr-block-slot.rs b/src/test/run-pass/expr-block-slot.rs
index 57b5a426f5c5c..d9b4c95bc24d1 100644
--- a/src/test/run-pass/expr-block-slot.rs
+++ b/src/test/run-pass/expr-block-slot.rs
@@ -10,7 +10,6 @@
 
 // Regression test for issue #377
 
-// pretty-expanded FIXME #23616
 
 struct A { a: isize }
 struct V { v: isize }
diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs
index 496a575c6c8b5..7ad024186015b 100644
--- a/src/test/run-pass/expr-block-unique.rs
+++ b/src/test/run-pass/expr-block-unique.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs
index 64f86237ab3bb..38be041938b3c 100644
--- a/src/test/run-pass/expr-block.rs
+++ b/src/test/run-pass/expr-block.rs
@@ -13,7 +13,6 @@
 
 
 // Tests for standalone blocks as expressions
-// pretty-expanded FIXME #23616
 
 fn test_basic() { let rs: bool = { true }; assert!((rs)); }
 
diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs
index ca394f991f29b..99e74a6b8564d 100644
--- a/src/test/run-pass/expr-copy.rs
+++ b/src/test/run-pass/expr-copy.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn f(arg: &mut A) {
     arg.a = 100;
diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs
index 0c9151cec7df4..aeca388d317b6 100644
--- a/src/test/run-pass/expr-fn.rs
+++ b/src/test/run-pass/expr-fn.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn test_int() {
     fn f() -> isize { 10 }
diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs
index 47e79de6b1124..94c6b70bb62f3 100644
--- a/src/test/run-pass/expr-if-generic.rs
+++ b/src/test/run-pass/expr-if-generic.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn test_generic<T, F>(expected: T, not_expected: T, eq: F) where
     T: Clone,
diff --git a/src/test/run-pass/expr-if-panic-all.rs b/src/test/run-pass/expr-if-panic-all.rs
index 1e631c204798a..43110533b6dc6 100644
--- a/src/test/run-pass/expr-if-panic-all.rs
+++ b/src/test/run-pass/expr-if-panic-all.rs
@@ -10,7 +10,6 @@
 
 // When all branches of an if expression result in panic, the entire if
 // expression results in panic.
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let _x = if true {
diff --git a/src/test/run-pass/expr-if-panic.rs b/src/test/run-pass/expr-if-panic.rs
index e8594db80393b..c7f10b66ca3c7 100644
--- a/src/test/run-pass/expr-if-panic.rs
+++ b/src/test/run-pass/expr-if-panic.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn test_if_panic() {
     let x = if false { panic!() } else { 10 };
diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs
index 99c5053588b1c..12000fd54e7e7 100644
--- a/src/test/run-pass/expr-if-unique.rs
+++ b/src/test/run-pass/expr-if-unique.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/expr-if.rs b/src/test/run-pass/expr-if.rs
index 345f17707c408..e8458e320113b 100644
--- a/src/test/run-pass/expr-if.rs
+++ b/src/test/run-pass/expr-if.rs
@@ -13,7 +13,6 @@
 
 
 // Tests for if as expressions
-// pretty-expanded FIXME #23616
 
 fn test_if() { let rs: bool = if true { true } else { false }; assert!((rs)); }
 
diff --git a/src/test/run-pass/expr-match-generic-unique1.rs b/src/test/run-pass/expr-match-generic-unique1.rs
index 7cd0f6a758999..738fcecb2e0db 100644
--- a/src/test/run-pass/expr-match-generic-unique1.rs
+++ b/src/test/run-pass/expr-match-generic-unique1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/expr-match-generic-unique2.rs b/src/test/run-pass/expr-match-generic-unique2.rs
index 95f47d005d3d6..88ea241524109 100644
--- a/src/test/run-pass/expr-match-generic-unique2.rs
+++ b/src/test/run-pass/expr-match-generic-unique2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/expr-match-generic.rs b/src/test/run-pass/expr-match-generic.rs
index f8e82de9a0a36..509106289d079 100644
--- a/src/test/run-pass/expr-match-generic.rs
+++ b/src/test/run-pass/expr-match-generic.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 type compare<T> = extern "Rust" fn(T, T) -> bool;
 
diff --git a/src/test/run-pass/expr-match-panic-all.rs b/src/test/run-pass/expr-match-panic-all.rs
index 664ead10aae09..e712d552a8107 100644
--- a/src/test/run-pass/expr-match-panic-all.rs
+++ b/src/test/run-pass/expr-match-panic-all.rs
@@ -13,7 +13,6 @@
 
 // When all branches of a match expression result in panic, the entire
 // match expression results in panic.
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let _x =
diff --git a/src/test/run-pass/expr-match-panic.rs b/src/test/run-pass/expr-match-panic.rs
index 40e7a6175cf86..89dc7b09c7b15 100644
--- a/src/test/run-pass/expr-match-panic.rs
+++ b/src/test/run-pass/expr-match-panic.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn test_simple() {
     let r = match true { true => { true } false => { panic!() } };
diff --git a/src/test/run-pass/expr-match-unique.rs b/src/test/run-pass/expr-match-unique.rs
index 51eda4c7663a8..e752c20a51242 100644
--- a/src/test/run-pass/expr-match-unique.rs
+++ b/src/test/run-pass/expr-match-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/expr-match.rs b/src/test/run-pass/expr-match.rs
index 2282391ef6fb4..580ee52ed3645 100644
--- a/src/test/run-pass/expr-match.rs
+++ b/src/test/run-pass/expr-match.rs
@@ -13,7 +13,6 @@
 
 
 // Tests for using match as an expression
-// pretty-expanded FIXME #23616
 
 fn test_basic() {
     let mut rs: bool = match true { true => { true } false => { false } };
diff --git a/src/test/run-pass/ext-expand-inner-exprs.rs b/src/test/run-pass/ext-expand-inner-exprs.rs
index 46cd73e11527c..90ca31e80be3a 100644
--- a/src/test/run-pass/ext-expand-inner-exprs.rs
+++ b/src/test/run-pass/ext-expand-inner-exprs.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 static FOO : &'static str = concat!(concat!("hel", "lo"), "world");
 
diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs
index 9a039e8bc3539..3474e2eefb7c7 100644
--- a/src/test/run-pass/exterior.rs
+++ b/src/test/run-pass/exterior.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 use std::cell::Cell;
 
diff --git a/src/test/run-pass/extern-call-direct.rs b/src/test/run-pass/extern-call-direct.rs
index 38cd4a8d79d0d..ec6b6c8d39fad 100644
--- a/src/test/run-pass/extern-call-direct.rs
+++ b/src/test/run-pass/extern-call-direct.rs
@@ -10,7 +10,6 @@
 
 // Test direct calls to extern fns.
 
-// pretty-expanded FIXME #23616
 
 extern fn f(x: usize) -> usize { x * 2 }
 
diff --git a/src/test/run-pass/extern-compare-with-return-type.rs b/src/test/run-pass/extern-compare-with-return-type.rs
index 09411c9c6eb29..6535ae2fca946 100644
--- a/src/test/run-pass/extern-compare-with-return-type.rs
+++ b/src/test/run-pass/extern-compare-with-return-type.rs
@@ -10,7 +10,6 @@
 
 // Tests that we can compare various kinds of extern fn signatures.
 
-// pretty-expanded FIXME #23616
 
 extern fn voidret1() {}
 extern fn voidret2() {}
diff --git a/src/test/run-pass/extern-methods.rs b/src/test/run-pass/extern-methods.rs
index 246f65931b70e..28a076113d1f0 100644
--- a/src/test/run-pass/extern-methods.rs
+++ b/src/test/run-pass/extern-methods.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/extern-pass-char.rs b/src/test/run-pass/extern-pass-char.rs
index bbdf5cf64a127..e75aa2d72c925 100644
--- a/src/test/run-pass/extern-pass-char.rs
+++ b/src/test/run-pass/extern-pass-char.rs
@@ -10,7 +10,6 @@
 
 // Test a function that takes/returns a u8.
 
-// pretty-expanded FIXME #23616
 
 #[link(name = "rust_test_helpers")]
 extern {
diff --git a/src/test/run-pass/extern-pass-double.rs b/src/test/run-pass/extern-pass-double.rs
index 24c461f43adf8..e92f9b6a1a172 100644
--- a/src/test/run-pass/extern-pass-double.rs
+++ b/src/test/run-pass/extern-pass-double.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[link(name = "rust_test_helpers")]
 extern {
diff --git a/src/test/run-pass/extern-pass-u32.rs b/src/test/run-pass/extern-pass-u32.rs
index f93d7a3ff9614..0753ea1bcfead 100644
--- a/src/test/run-pass/extern-pass-u32.rs
+++ b/src/test/run-pass/extern-pass-u32.rs
@@ -10,7 +10,6 @@
 
 // Test a function that takes/returns a u32.
 
-// pretty-expanded FIXME #23616
 
 #[link(name = "rust_test_helpers")]
 extern {
diff --git a/src/test/run-pass/extern-pass-u64.rs b/src/test/run-pass/extern-pass-u64.rs
index 961a3dce16813..89faa3bb47141 100644
--- a/src/test/run-pass/extern-pass-u64.rs
+++ b/src/test/run-pass/extern-pass-u64.rs
@@ -10,7 +10,6 @@
 
 // Test a call to a function that takes/returns a u64.
 
-// pretty-expanded FIXME #23616
 
 #[link(name = "rust_test_helpers")]
 extern {
diff --git a/src/test/run-pass/extern-return-TwoU16s.rs b/src/test/run-pass/extern-return-TwoU16s.rs
index f149a1346229a..3c58646e0c302 100644
--- a/src/test/run-pass/extern-return-TwoU16s.rs
+++ b/src/test/run-pass/extern-return-TwoU16s.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub struct TwoU16s {
     one: u16, two: u16
diff --git a/src/test/run-pass/extern-return-TwoU32s.rs b/src/test/run-pass/extern-return-TwoU32s.rs
index 4e9c44ef75eec..0eb6be2d687a4 100644
--- a/src/test/run-pass/extern-return-TwoU32s.rs
+++ b/src/test/run-pass/extern-return-TwoU32s.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub struct TwoU32s {
     one: u32, two: u32
diff --git a/src/test/run-pass/extern-return-TwoU64s.rs b/src/test/run-pass/extern-return-TwoU64s.rs
index fffd77fa89735..d5eab86351e10 100644
--- a/src/test/run-pass/extern-return-TwoU64s.rs
+++ b/src/test/run-pass/extern-return-TwoU64s.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub struct TwoU64s {
     one: u64, two: u64
diff --git a/src/test/run-pass/extern-return-TwoU8s.rs b/src/test/run-pass/extern-return-TwoU8s.rs
index fdf43d4332a9d..d8f476bcd0cbb 100644
--- a/src/test/run-pass/extern-return-TwoU8s.rs
+++ b/src/test/run-pass/extern-return-TwoU8s.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub struct TwoU8s {
     one: u8, two: u8
diff --git a/src/test/run-pass/extern-take-value.rs b/src/test/run-pass/extern-take-value.rs
index c016e4e62f56f..7ef87b9409d51 100644
--- a/src/test/run-pass/extern-take-value.rs
+++ b/src/test/run-pass/extern-take-value.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 extern fn f() {
 }
diff --git a/src/test/run-pass/extoption_env-not-defined.rs b/src/test/run-pass/extoption_env-not-defined.rs
index aaa8f6cf26f1d..352f68da9854f 100644
--- a/src/test/run-pass/extoption_env-not-defined.rs
+++ b/src/test/run-pass/extoption_env-not-defined.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert!(option_env!("__HOPEFULLY_DOESNT_EXIST__").is_none());
diff --git a/src/test/run-pass/field-destruction-order.rs b/src/test/run-pass/field-destruction-order.rs
index aab32a7e7bd37..624167db36da3 100644
--- a/src/test/run-pass/field-destruction-order.rs
+++ b/src/test/run-pass/field-destruction-order.rs
@@ -21,7 +21,6 @@
 // declarations, but we currently run them top-to-bottom. I don't think the
 // order really matters that much as long as we define what it is.
 
-// pretty-expanded FIXME #23616
 
 struct A;
 struct B;
diff --git a/src/test/run-pass/fixed_length_copy.rs b/src/test/run-pass/fixed_length_copy.rs
index 019537a2ab8b0..eefd94475358c 100644
--- a/src/test/run-pass/fixed_length_copy.rs
+++ b/src/test/run-pass/fixed_length_copy.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let arr = [1,2,3];
diff --git a/src/test/run-pass/float2.rs b/src/test/run-pass/float2.rs
index f84cbe5235467..e9f6e0f51b4ec 100644
--- a/src/test/run-pass/float2.rs
+++ b/src/test/run-pass/float2.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let a = 1.5e6f64;
diff --git a/src/test/run-pass/floatlits.rs b/src/test/run-pass/floatlits.rs
index d45c689bfdaa7..d133f3463a3f2 100644
--- a/src/test/run-pass/floatlits.rs
+++ b/src/test/run-pass/floatlits.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let f = 4.999999999999f64;
diff --git a/src/test/run-pass/fmt-pointer-trait.rs b/src/test/run-pass/fmt-pointer-trait.rs
new file mode 100644
index 0000000000000..be8ecde67836e
--- /dev/null
+++ b/src/test/run-pass/fmt-pointer-trait.rs
@@ -0,0 +1,28 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(libc)]
+extern crate libc;
+use std::ptr;
+use std::rc::Rc;
+use std::sync::Arc;
+
+fn main() {
+    let p: *const libc::c_void = ptr::null();
+    let rc = Rc::new(1usize);
+    let arc = Arc::new(1usize);
+    let b = Box::new("hi");
+
+    let _ = format!("{:p}{:p}{:p}",
+                    rc, arc, b);
+
+    assert_eq!(format!("{:p}", p),
+               "0x0");
+}
diff --git a/src/test/run-pass/fn-bare-assign.rs b/src/test/run-pass/fn-bare-assign.rs
index d83dc7858056f..2d3d4cbffd00d 100644
--- a/src/test/run-pass/fn-bare-assign.rs
+++ b/src/test/run-pass/fn-bare-assign.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn f(i: isize, called: &mut bool) {
     assert_eq!(i, 10);
diff --git a/src/test/run-pass/fn-bare-size.rs b/src/test/run-pass/fn-bare-size.rs
index 117cf13584f18..3ed4f103af081 100644
--- a/src/test/run-pass/fn-bare-size.rs
+++ b/src/test/run-pass/fn-bare-size.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs
index 0a3c891627068..e6ee77cb62bb6 100644
--- a/src/test/run-pass/fn-bare-spawn.rs
+++ b/src/test/run-pass/fn-bare-spawn.rs
@@ -10,7 +10,6 @@
 
 // This is what the signature to spawn should look like with bare functions
 
-// pretty-expanded FIXME #23616
 
 fn spawn<T:Send>(val: T, f: fn(T)) {
     f(val);
diff --git a/src/test/run-pass/fn-item-type-cast.rs b/src/test/run-pass/fn-item-type-cast.rs
index f8b1582c51577..9a8a8d4782ed5 100644
--- a/src/test/run-pass/fn-item-type-cast.rs
+++ b/src/test/run-pass/fn-item-type-cast.rs
@@ -10,7 +10,6 @@
 
 // Test explicit coercions from a fn item type to a fn pointer type.
 
-// pretty-expanded FIXME #23616
 
 fn foo(x: isize) -> isize { x * 2 }
 fn bar(x: isize) -> isize { x * 4 }
diff --git a/src/test/run-pass/fn-pattern-expected-type.rs b/src/test/run-pass/fn-pattern-expected-type.rs
index 352d0b13c6407..2e9607602fd62 100644
--- a/src/test/run-pass/fn-pattern-expected-type.rs
+++ b/src/test/run-pass/fn-pattern-expected-type.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let f = |(x, y): (isize, isize)| {
diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs
index 9d8c432e98209..963d34a2d2fbd 100644
--- a/src/test/run-pass/for-destruct.rs
+++ b/src/test/run-pass/for-destruct.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Pair { x: isize, y: isize }
 
diff --git a/src/test/run-pass/for-loop-goofiness.rs b/src/test/run-pass/for-loop-goofiness.rs
index 4b6b6dcf1d555..411183e4f74a7 100644
--- a/src/test/run-pass/for-loop-goofiness.rs
+++ b/src/test/run-pass/for-loop-goofiness.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum BogusOption<T> {
     None,
diff --git a/src/test/run-pass/for-loop-into-iterator.rs b/src/test/run-pass/for-loop-into-iterator.rs
index 109ca26056fff..7efd15f222e37 100644
--- a/src/test/run-pass/for-loop-into-iterator.rs
+++ b/src/test/run-pass/for-loop-into-iterator.rs
@@ -10,7 +10,6 @@
 
 // Test that for loops can do what RFC #235 claims
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let mut v = vec![1];
diff --git a/src/test/run-pass/for-loop-panic.rs b/src/test/run-pass/for-loop-panic.rs
index 908932fe396be..001ca1a02f632 100644
--- a/src/test/run-pass/for-loop-panic.rs
+++ b/src/test/run-pass/for-loop-panic.rs
@@ -9,6 +9,5 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() { let x: Vec<isize> = Vec::new(); for _ in &x { panic!("moop"); } }
diff --git a/src/test/run-pass/foreach-external-iterators-break.rs b/src/test/run-pass/foreach-external-iterators-break.rs
index bc041259895f9..bfc0d6cf9d542 100644
--- a/src/test/run-pass/foreach-external-iterators-break.rs
+++ b/src/test/run-pass/foreach-external-iterators-break.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = [1; 100];
diff --git a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs
index cc02ee1459b5e..cedb960143146 100644
--- a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs
+++ b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections)]
 
diff --git a/src/test/run-pass/foreach-external-iterators-hashmap.rs b/src/test/run-pass/foreach-external-iterators-hashmap.rs
index 065e4cfb7682b..79304fce5c166 100644
--- a/src/test/run-pass/foreach-external-iterators-hashmap.rs
+++ b/src/test/run-pass/foreach-external-iterators-hashmap.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections)]
 
diff --git a/src/test/run-pass/foreach-external-iterators-loop.rs b/src/test/run-pass/foreach-external-iterators-loop.rs
index 60cfc9be0787a..7248537d6a1b6 100644
--- a/src/test/run-pass/foreach-external-iterators-loop.rs
+++ b/src/test/run-pass/foreach-external-iterators-loop.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = [1; 100];
diff --git a/src/test/run-pass/foreach-external-iterators-nested.rs b/src/test/run-pass/foreach-external-iterators-nested.rs
index a075c08b737e0..87aa3d84003c5 100644
--- a/src/test/run-pass/foreach-external-iterators-nested.rs
+++ b/src/test/run-pass/foreach-external-iterators-nested.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = [1; 100];
diff --git a/src/test/run-pass/foreach-external-iterators.rs b/src/test/run-pass/foreach-external-iterators.rs
index 2248132d828d1..d1fe98f5431f7 100644
--- a/src/test/run-pass/foreach-external-iterators.rs
+++ b/src/test/run-pass/foreach-external-iterators.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = [1; 100];
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index 075539b621ac7..60068185f5a52 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn two<F>(mut it: F) where F: FnMut(isize) { it(0); it(1); }
 
diff --git a/src/test/run-pass/foreign-fn-with-byval.rs b/src/test/run-pass/foreign-fn-with-byval.rs
index 7883c22f909dd..d3d872620c38b 100644
--- a/src/test/run-pass/foreign-fn-with-byval.rs
+++ b/src/test/run-pass/foreign-fn-with-byval.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 pub struct S {
diff --git a/src/test/run-pass/format-nan.rs b/src/test/run-pass/format-nan.rs
index bdbbeaa9511cd..9bbd8cdb11d88 100644
--- a/src/test/run-pass/format-nan.rs
+++ b/src/test/run-pass/format-nan.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     use std::f64;
diff --git a/src/test/run-pass/format-ref-cell.rs b/src/test/run-pass/format-ref-cell.rs
index ce26fbd4c00f9..0f16dfa1e8f15 100644
--- a/src/test/run-pass/format-ref-cell.rs
+++ b/src/test/run-pass/format-ref-cell.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::cell::RefCell;
 
diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs
index fecaf279d043d..dd58787a1de90 100644
--- a/src/test/run-pass/fsu-moves-and-copies.rs
+++ b/src/test/run-pass/fsu-moves-and-copies.rs
@@ -11,7 +11,6 @@
 // Issue 4691: Ensure that functional-struct-updates operates
 // correctly and moves rather than copy when appropriate.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax, core)]
diff --git a/src/test/run-pass/fun-call-variants.rs b/src/test/run-pass/fun-call-variants.rs
index 0fe4bbcb7a228..3bb6df33f70a0 100644
--- a/src/test/run-pass/fun-call-variants.rs
+++ b/src/test/run-pass/fun-call-variants.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn ho<F>(f: F) -> isize where F: FnOnce(isize) -> isize { let n: isize = f(3); return n; }
 
diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs
index 48dfcb73da45c..b28c64d06be2f 100644
--- a/src/test/run-pass/fun-indirect-call.rs
+++ b/src/test/run-pass/fun-indirect-call.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 fn f() -> isize { return 42; }
 
diff --git a/src/test/run-pass/func-arg-incomplete-pattern.rs b/src/test/run-pass/func-arg-incomplete-pattern.rs
index 2833723708523..6030da44e4ade 100644
--- a/src/test/run-pass/func-arg-incomplete-pattern.rs
+++ b/src/test/run-pass/func-arg-incomplete-pattern.rs
@@ -11,7 +11,6 @@
 // Test that we do not leak when the arg pattern must drop part of the
 // argument (in this case, the `y` field).
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/func-arg-ref-pattern.rs b/src/test/run-pass/func-arg-ref-pattern.rs
index fcc00afb00bdb..ab565e7abcace 100644
--- a/src/test/run-pass/func-arg-ref-pattern.rs
+++ b/src/test/run-pass/func-arg-ref-pattern.rs
@@ -14,7 +14,6 @@
 // boxes. Make sure that we don't free the box as we match the
 // pattern.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_patterns)]
diff --git a/src/test/run-pass/func-arg-wild-pattern.rs b/src/test/run-pass/func-arg-wild-pattern.rs
index 4f74ca0ff7215..3ab3ee4db2d5b 100644
--- a/src/test/run-pass/func-arg-wild-pattern.rs
+++ b/src/test/run-pass/func-arg-wild-pattern.rs
@@ -11,7 +11,6 @@
 // Test that we can compile code that uses a `_` in function argument
 // patterns.
 
-// pretty-expanded FIXME #23616
 
 fn foo((x, _): (isize, isize)) -> isize {
     x
diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs
index 0e3ce3869bf7b..8dbe6de838869 100644
--- a/src/test/run-pass/generic-exterior-unique.rs
+++ b/src/test/run-pass/generic-exterior-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/generic-extern-mangle.rs b/src/test/run-pass/generic-extern-mangle.rs
index 7a765703e23a0..67aea1f9f8ae8 100644
--- a/src/test/run-pass/generic-extern-mangle.rs
+++ b/src/test/run-pass/generic-extern-mangle.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs
index e01f507372216..181e05183d2ec 100644
--- a/src/test/run-pass/generic-fn-infer.rs
+++ b/src/test/run-pass/generic-fn-infer.rs
@@ -13,7 +13,6 @@
 
 
 // Issue #45: infer type parameters in function applications
-// pretty-expanded FIXME #23616
 
 fn id<T>(x: T) -> T { return x; }
 
diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs
index 44b32f62f9227..0a59a925a5ff6 100644
--- a/src/test/run-pass/generic-object.rs
+++ b/src/test/run-pass/generic-object.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/generic-static-methods.rs b/src/test/run-pass/generic-static-methods.rs
index 49f8d6a3adb52..7a496ebf8ce34 100644
--- a/src/test/run-pass/generic-static-methods.rs
+++ b/src/test/run-pass/generic-static-methods.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait vec_utils<T> {
     fn map_<U, F>(x: &Self, f: F) -> Vec<U> where F: FnMut(&T) -> U;
diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs
index 73fc3a0d80236..8e7a3add34349 100644
--- a/src/test/run-pass/generic-type.rs
+++ b/src/test/run-pass/generic-type.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 struct Pair<T> {x: T, y: T}
 
diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs
index 9cf98364eb993..21e9a9a80d0ae 100644
--- a/src/test/run-pass/generic-unique.rs
+++ b/src/test/run-pass/generic-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/getopts_ref.rs b/src/test/run-pass/getopts_ref.rs
index 52b06ab2928af..c9595d09e21b2 100644
--- a/src/test/run-pass/getopts_ref.rs
+++ b/src/test/run-pass/getopts_ref.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(rustc_private)]
 
diff --git a/src/test/run-pass/global-scope.rs b/src/test/run-pass/global-scope.rs
index 64d9368a88be8..13da404c253b3 100644
--- a/src/test/run-pass/global-scope.rs
+++ b/src/test/run-pass/global-scope.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn f() -> isize { return 1; }
 
diff --git a/src/test/run-pass/guards-not-exhaustive.rs b/src/test/run-pass/guards-not-exhaustive.rs
index f5f80914937d3..53c3eff5b81ee 100644
--- a/src/test/run-pass/guards-not-exhaustive.rs
+++ b/src/test/run-pass/guards-not-exhaustive.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 enum Q { R(Option<usize>) }
diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs
index 11c67b8af8107..d79dbabac2d42 100644
--- a/src/test/run-pass/guards.rs
+++ b/src/test/run-pass/guards.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 struct Pair { x: isize, y: isize }
diff --git a/src/test/run-pass/hrtb-fn-like-trait-object.rs b/src/test/run-pass/hrtb-fn-like-trait-object.rs
index 858179fb5fe76..8e2e21bed0a7c 100644
--- a/src/test/run-pass/hrtb-fn-like-trait-object.rs
+++ b/src/test/run-pass/hrtb-fn-like-trait-object.rs
@@ -10,7 +10,6 @@
 
 // A basic test of using a higher-ranked trait bound.
 
-// pretty-expanded FIXME #23616
 
 trait FnLike<A,R> {
     fn call(&self, arg: A) -> R;
diff --git a/src/test/run-pass/hrtb-fn-like-trait.rs b/src/test/run-pass/hrtb-fn-like-trait.rs
index 8b4c2aec8452b..71e314b513251 100644
--- a/src/test/run-pass/hrtb-fn-like-trait.rs
+++ b/src/test/run-pass/hrtb-fn-like-trait.rs
@@ -10,7 +10,6 @@
 
 // A basic test of using a higher-ranked trait bound.
 
-// pretty-expanded FIXME #23616
 
 trait FnLike<A,R> {
     fn call(&self, arg: A) -> R;
diff --git a/src/test/run-pass/hrtb-trait-object-paren-notation.rs b/src/test/run-pass/hrtb-trait-object-paren-notation.rs
index 7741f1904f6ab..fefbd00476689 100644
--- a/src/test/run-pass/hrtb-trait-object-paren-notation.rs
+++ b/src/test/run-pass/hrtb-trait-object-paren-notation.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs
index 2345bb01d8ae9..f0bb31b8470f1 100644
--- a/src/test/run-pass/huge-largest-array.rs
+++ b/src/test/run-pass/huge-largest-array.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::size_of;
 
diff --git a/src/test/run-pass/hygiene-dodging-1.rs b/src/test/run-pass/hygiene-dodging-1.rs
index e5acc4a2edd68..83f09850f7776 100644
--- a/src/test/run-pass/hygiene-dodging-1.rs
+++ b/src/test/run-pass/hygiene-dodging-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod x {
     pub fn g() -> usize {14}
diff --git a/src/test/run-pass/hygienic-labels.rs b/src/test/run-pass/hygienic-labels.rs
index 2d530275ea21f..df72a5410a2b2 100644
--- a/src/test/run-pass/hygienic-labels.rs
+++ b/src/test/run-pass/hygienic-labels.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! loop_x {
     ($e: expr) => {
diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs
index 2cc4e880bbf5e..075faba2fcb85 100644
--- a/src/test/run-pass/i32-sub.rs
+++ b/src/test/run-pass/i32-sub.rs
@@ -11,6 +11,5 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() { let mut x: i32 = -400; x = 0 - x; assert!((x == 400)); }
diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs
index 5dd53a268b135..242cea264afb1 100644
--- a/src/test/run-pass/i8-incr.rs
+++ b/src/test/run-pass/i8-incr.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut x: i8 = -12;
diff --git a/src/test/run-pass/if-let.rs b/src/test/run-pass/if-let.rs
index c41d02f9b3365..13134abd8fdd9 100644
--- a/src/test/run-pass/if-let.rs
+++ b/src/test/run-pass/if-let.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = Some(3);
diff --git a/src/test/run-pass/impl-inherent-non-conflict.rs b/src/test/run-pass/impl-inherent-non-conflict.rs
index 210bc34bcd1db..0d43f1ca70669 100644
--- a/src/test/run-pass/impl-inherent-non-conflict.rs
+++ b/src/test/run-pass/impl-inherent-non-conflict.rs
@@ -12,7 +12,6 @@
 // with the same name, which can be called on values that have a
 // precise enough type to allow distinguishing between the methods.
 
-// pretty-expanded FIXME #23616
 
 struct Foo<T>(T);
 
diff --git a/src/test/run-pass/impl-inherent-prefer-over-trait.rs b/src/test/run-pass/impl-inherent-prefer-over-trait.rs
index 26f12e9730b2a..f0195976aa832 100644
--- a/src/test/run-pass/impl-inherent-prefer-over-trait.rs
+++ b/src/test/run-pass/impl-inherent-prefer-over-trait.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Foo;
 
diff --git a/src/test/run-pass/impl-not-adjacent-to-type.rs b/src/test/run-pass/impl-not-adjacent-to-type.rs
index 2ba7375d67a64..beba056b72cdc 100644
--- a/src/test/run-pass/impl-not-adjacent-to-type.rs
+++ b/src/test/run-pass/impl-not-adjacent-to-type.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod foo {
     pub struct Point {
diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs
index eb9ec6fe985ac..b2a9b08b01b86 100644
--- a/src/test/run-pass/import-glob-crate.rs
+++ b/src/test/run-pass/import-glob-crate.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_assignment)]
 
diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs
index fcbd4b332318e..22369c77ed33f 100644
--- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs
+++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = 2;
diff --git a/src/test/run-pass/inherent-trait-method-order.rs b/src/test/run-pass/inherent-trait-method-order.rs
index 042268435c7af..5489a61f7d0b9 100644
--- a/src/test/run-pass/inherent-trait-method-order.rs
+++ b/src/test/run-pass/inherent-trait-method-order.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Foo;
 
diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs
index eb50fbed774e4..97b32189d0027 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/inner-attrs-on-impl.rs b/src/test/run-pass/inner-attrs-on-impl.rs
index a807e582ff464..d8d9d5136e2d1 100644
--- a/src/test/run-pass/inner-attrs-on-impl.rs
+++ b/src/test/run-pass/inner-attrs-on-impl.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 struct Foo;
 
diff --git a/src/test/run-pass/inner-static.rs b/src/test/run-pass/inner-static.rs
index 48f2006ed59ba..b93ca943e4714 100644
--- a/src/test/run-pass/inner-static.rs
+++ b/src/test/run-pass/inner-static.rs
@@ -10,7 +10,6 @@
 
 // aux-build:inner_static.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate inner_static;
 
diff --git a/src/test/run-pass/integer-literal-radix.rs b/src/test/run-pass/integer-literal-radix.rs
index b782925fa9357..ba9d22f06a976 100644
--- a/src/test/run-pass/integer-literal-radix.rs
+++ b/src/test/run-pass/integer-literal-radix.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let a = 0xBEEF_isize;
diff --git a/src/test/run-pass/intrinsic-alignment.rs b/src/test/run-pass/intrinsic-alignment.rs
index 44dd191eb3ee3..fa97ef8fcd394 100644
--- a/src/test/run-pass/intrinsic-alignment.rs
+++ b/src/test/run-pass/intrinsic-alignment.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(intrinsics, main)]
 
diff --git a/src/test/run-pass/intrinsic-assume.rs b/src/test/run-pass/intrinsic-assume.rs
index fc886d7e30165..ff7d799f64c5f 100644
--- a/src/test/run-pass/intrinsic-assume.rs
+++ b/src/test/run-pass/intrinsic-assume.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/intrinsic-atomics-cc.rs b/src/test/run-pass/intrinsic-atomics-cc.rs
index c5fe02b9190d4..abb85cc7f1949 100644
--- a/src/test/run-pass/intrinsic-atomics-cc.rs
+++ b/src/test/run-pass/intrinsic-atomics-cc.rs
@@ -10,7 +10,6 @@
 
 // aux-build:cci_intrinsic.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate cci_intrinsic;
 use cci_intrinsic::atomic_xchg;
diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs
index 61a9f6109a3e8..4ccab55e94348 100644
--- a/src/test/run-pass/intrinsic-atomics.rs
+++ b/src/test/run-pass/intrinsic-atomics.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs
index 98f069f77f3f0..2e75f2dccd1ba 100644
--- a/src/test/run-pass/intrinsic-move-val.rs
+++ b/src/test/run-pass/intrinsic-move-val.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/intrinsic-return-address.rs b/src/test/run-pass/intrinsic-return-address.rs
index 1ff910356eb98..63aed3f009fd7 100644
--- a/src/test/run-pass/intrinsic-return-address.rs
+++ b/src/test/run-pass/intrinsic-return-address.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(intrinsics)]
 
diff --git a/src/test/run-pass/intrinsic-unreachable.rs b/src/test/run-pass/intrinsic-unreachable.rs
index 86a370a0942d9..a86fc110ae4eb 100644
--- a/src/test/run-pass/intrinsic-unreachable.rs
+++ b/src/test/run-pass/intrinsic-unreachable.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs
index 15dbe796ef589..f1d731c8b1d7a 100644
--- a/src/test/run-pass/intrinsics-integer.rs
+++ b/src/test/run-pass/intrinsics-integer.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(negate_unsigned)]
 #![feature(intrinsics)]
diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs
index 841ff297a2ac7..8db29ebaa6d3e 100644
--- a/src/test/run-pass/intrinsics-math.rs
+++ b/src/test/run-pass/intrinsics-math.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(intrinsics, core)]
 
diff --git a/src/test/run-pass/issue-10392.rs b/src/test/run-pass/issue-10392.rs
index 2d695c75d3044..1a5f423b0fd8b 100644
--- a/src/test/run-pass/issue-10392.rs
+++ b/src/test/run-pass/issue-10392.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct A { foo: isize }
 struct B { a: isize, b: isize, c: isize }
diff --git a/src/test/run-pass/issue-10734.rs b/src/test/run-pass/issue-10734.rs
index 49694f2755c23..c99cad85ccb39 100644
--- a/src/test/run-pass/issue-10734.rs
+++ b/src/test/run-pass/issue-10734.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_no_drop_flag)]
 
diff --git a/src/test/run-pass/issue-10802.rs b/src/test/run-pass/issue-10802.rs
index bb322635094e5..2256315a379ae 100644
--- a/src/test/run-pass/issue-10802.rs
+++ b/src/test/run-pass/issue-10802.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs
index 3d131b51033dc..72d1a43e88318 100644
--- a/src/test/run-pass/issue-1112.rs
+++ b/src/test/run-pass/issue-1112.rs
@@ -11,7 +11,6 @@
 // Issue #1112
 // Alignment of interior pointers to dynamic-size types
 
-// pretty-expanded FIXME #23616
 
 struct X<T> {
     a: T,
diff --git a/src/test/run-pass/issue-11552.rs b/src/test/run-pass/issue-11552.rs
index 1f91c6aaa4d0a..5193330a45a36 100644
--- a/src/test/run-pass/issue-11552.rs
+++ b/src/test/run-pass/issue-11552.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_patterns)]
diff --git a/src/test/run-pass/issue-11577.rs b/src/test/run-pass/issue-11577.rs
index ecb7a3a3691ca..81588e8ef78db 100644
--- a/src/test/run-pass/issue-11577.rs
+++ b/src/test/run-pass/issue-11577.rs
@@ -1,4 +1,3 @@
-// pretty-expanded FIXME #23616
 
  // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
diff --git a/src/test/run-pass/issue-11677.rs b/src/test/run-pass/issue-11677.rs
index a3eec42831f20..d4244d44439b0 100644
--- a/src/test/run-pass/issue-11677.rs
+++ b/src/test/run-pass/issue-11677.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_code)]
 
diff --git a/src/test/run-pass/issue-11940.rs b/src/test/run-pass/issue-11940.rs
index 8732def0a1a11..186446a345677 100644
--- a/src/test/run-pass/issue-11940.rs
+++ b/src/test/run-pass/issue-11940.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const TEST_STR: &'static str = "abcd";
 
diff --git a/src/test/run-pass/issue-12285.rs b/src/test/run-pass/issue-12285.rs
index 3a5b7e86920d7..fb98909eb9765 100644
--- a/src/test/run-pass/issue-12285.rs
+++ b/src/test/run-pass/issue-12285.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct S;
 
diff --git a/src/test/run-pass/issue-12677.rs b/src/test/run-pass/issue-12677.rs
index 493bdb30e35bc..e83a2e9727d99 100644
--- a/src/test/run-pass/issue-12677.rs
+++ b/src/test/run-pass/issue-12677.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let s = "Hello";
diff --git a/src/test/run-pass/issue-13204.rs b/src/test/run-pass/issue-13204.rs
index ec9d777974bb0..36f606e5d73c9 100644
--- a/src/test/run-pass/issue-13204.rs
+++ b/src/test/run-pass/issue-13204.rs
@@ -11,7 +11,6 @@
 // Test that when instantiating trait default methods, typeck handles
 // lifetime parameters defined on the method bound correctly.
 
-// pretty-expanded FIXME #23616
 
 pub trait Foo {
     fn bar<'a, I: Iterator<Item=&'a ()>>(&self, it: I) -> usize {
diff --git a/src/test/run-pass/issue-13259-windows-tcb-trash.rs b/src/test/run-pass/issue-13259-windows-tcb-trash.rs
index 34960b264567d..9ebbddf5141b7 100644
--- a/src/test/run-pass/issue-13259-windows-tcb-trash.rs
+++ b/src/test/run-pass/issue-13259-windows-tcb-trash.rs
@@ -10,7 +10,7 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(libc)]
+#![feature(libc, std_misc)]
 
 extern crate libc;
 
diff --git a/src/test/run-pass/issue-13323.rs b/src/test/run-pass/issue-13323.rs
index 90d16aaf145af..68c6ce7a7b7ba 100644
--- a/src/test/run-pass/issue-13323.rs
+++ b/src/test/run-pass/issue-13323.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/issue-13507-2.rs b/src/test/run-pass/issue-13507-2.rs
index 0b35ccf26f3f7..91ec3e8540442 100644
--- a/src/test/run-pass/issue-13507-2.rs
+++ b/src/test/run-pass/issue-13507-2.rs
@@ -10,7 +10,6 @@
 
 // aux-build:issue13507.rs
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/issue-13867.rs b/src/test/run-pass/issue-13867.rs
index a902e141bb6ca..e21070e2eafa1 100644
--- a/src/test/run-pass/issue-13867.rs
+++ b/src/test/run-pass/issue-13867.rs
@@ -11,7 +11,6 @@
 // Test that codegen works correctly when there are multiple refutable
 // patterns in match expression.
 
-// pretty-expanded FIXME #23616
 
 enum Foo {
     FooUint(usize),
diff --git a/src/test/run-pass/issue-14308.rs b/src/test/run-pass/issue-14308.rs
index f67d0946e9823..a61cb18faa65a 100644
--- a/src/test/run-pass/issue-14308.rs
+++ b/src/test/run-pass/issue-14308.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct A(isize);
 struct B;
diff --git a/src/test/run-pass/issue-14456.rs b/src/test/run-pass/issue-14456.rs
index ab9633ca1fe90..7e24c8f73ab70 100644
--- a/src/test/run-pass/issue-14456.rs
+++ b/src/test/run-pass/issue-14456.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(io, process_capture)]
 
diff --git a/src/test/run-pass/issue-14865.rs b/src/test/run-pass/issue-14865.rs
index e78736b77fd93..1ec268bb17037 100644
--- a/src/test/run-pass/issue-14865.rs
+++ b/src/test/run-pass/issue-14865.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum X {
     Foo(usize),
diff --git a/src/test/run-pass/issue-14936.rs b/src/test/run-pass/issue-14936.rs
index 2361c385b4148..5f8e7cb8145e6 100644
--- a/src/test/run-pass/issue-14936.rs
+++ b/src/test/run-pass/issue-14936.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(asm)]
 
diff --git a/src/test/run-pass/issue-14940.rs b/src/test/run-pass/issue-14940.rs
index a530384d368c0..b51afc1d02095 100644
--- a/src/test/run-pass/issue-14940.rs
+++ b/src/test/run-pass/issue-14940.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(old_io, io)]
 
diff --git a/src/test/run-pass/issue-15080.rs b/src/test/run-pass/issue-15080.rs
index 4369dc6292c36..ecb83cca6f273 100644
--- a/src/test/run-pass/issue-15080.rs
+++ b/src/test/run-pass/issue-15080.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]
 
diff --git a/src/test/run-pass/issue-15104.rs b/src/test/run-pass/issue-15104.rs
index db04e10cfe383..b55754ee59b35 100644
--- a/src/test/run-pass/issue-15104.rs
+++ b/src/test/run-pass/issue-15104.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]
 
diff --git a/src/test/run-pass/issue-15129.rs b/src/test/run-pass/issue-15129.rs
index 54705c6bf1301..9bcfa6ea40a4e 100644
--- a/src/test/run-pass/issue-15129.rs
+++ b/src/test/run-pass/issue-15129.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub enum T {
     T1(()),
diff --git a/src/test/run-pass/issue-15149.rs b/src/test/run-pass/issue-15149.rs
index ee348d9cb0ccf..f6ffd03c81aee 100644
--- a/src/test/run-pass/issue-15149.rs
+++ b/src/test/run-pass/issue-15149.rs
@@ -10,7 +10,6 @@
 
 // no-prefer-dynamic
 
-// pretty-expanded FIXME #23616
 
 #![feature(fs, process, env, path, rand)]
 
diff --git a/src/test/run-pass/issue-15673.rs b/src/test/run-pass/issue-15673.rs
index c1ecd3eba48bd..c478ca041148a 100644
--- a/src/test/run-pass/issue-15673.rs
+++ b/src/test/run-pass/issue-15673.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/issue-15689-1.rs b/src/test/run-pass/issue-15689-1.rs
index 9fc1cce56b767..e3c16793c19cb 100644
--- a/src/test/run-pass/issue-15689-1.rs
+++ b/src/test/run-pass/issue-15689-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(PartialEq)]
 enum Test<'a> {
diff --git a/src/test/run-pass/issue-15734.rs b/src/test/run-pass/issue-15734.rs
index 67ce6a1c44f0d..7f44c5a84cbaf 100644
--- a/src/test/run-pass/issue-15734.rs
+++ b/src/test/run-pass/issue-15734.rs
@@ -11,7 +11,6 @@
 // If `Index` used an associated type for its output, this test would
 // work more smoothly.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/issue-15793.rs b/src/test/run-pass/issue-15793.rs
index 21baf47ee6610..432174a1f52a0 100644
--- a/src/test/run-pass/issue-15793.rs
+++ b/src/test/run-pass/issue-15793.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum NestedEnum {
     First,
diff --git a/src/test/run-pass/issue-15858.rs b/src/test/run-pass/issue-15858.rs
index 265db3fe1336a..4f084d7891f37 100644
--- a/src/test/run-pass/issue-15858.rs
+++ b/src/test/run-pass/issue-15858.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs b/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs
index 6b75e4e47978e..2ec97e373b29b 100644
--- a/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs
+++ b/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs
@@ -10,7 +10,6 @@
 //
 // regression test for the model lexer handling the DOTDOTDOT syntax (#15877)
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     match 5_usize {
diff --git a/src/test/run-pass/issue-16151.rs b/src/test/run-pass/issue-16151.rs
index 242bcb69be60d..212dfaf3cb6c7 100644
--- a/src/test/run-pass/issue-16151.rs
+++ b/src/test/run-pass/issue-16151.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/issue-16530.rs b/src/test/run-pass/issue-16530.rs
index bf33221431ae0..77ec44161ea72 100644
--- a/src/test/run-pass/issue-16530.rs
+++ b/src/test/run-pass/issue-16530.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(hash)]
 
diff --git a/src/test/run-pass/issue-16560.rs b/src/test/run-pass/issue-16560.rs
index 33842fab6989c..a9f7d86f95ee6 100644
--- a/src/test/run-pass/issue-16560.rs
+++ b/src/test/run-pass/issue-16560.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/issue-16596.rs b/src/test/run-pass/issue-16596.rs
index 743dbbc9b9956..d70158743e720 100644
--- a/src/test/run-pass/issue-16596.rs
+++ b/src/test/run-pass/issue-16596.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait MatrixRow { fn dummy(&self) { }}
 
diff --git a/src/test/run-pass/issue-16648.rs b/src/test/run-pass/issue-16648.rs
index f0ff9ce7554b5..384bd9df7cfed 100644
--- a/src/test/run-pass/issue-16648.rs
+++ b/src/test/run-pass/issue-16648.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]
 
diff --git a/src/test/run-pass/issue-16739.rs b/src/test/run-pass/issue-16739.rs
index 99ddaba4e5514..f8cffdd38ca9b 100644
--- a/src/test/run-pass/issue-16739.rs
+++ b/src/test/run-pass/issue-16739.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs
index 17d0969ce1c02..627717ab1cd14 100644
--- a/src/test/run-pass/issue-16774.rs
+++ b/src/test/run-pass/issue-16774.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/issue-1701.rs b/src/test/run-pass/issue-1701.rs
index b8c51f2cd3112..3a2e46c62b079 100644
--- a/src/test/run-pass/issue-1701.rs
+++ b/src/test/run-pass/issue-1701.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum pattern { tabby, tortoiseshell, calico }
 enum breed { beagle, rottweiler, pug }
diff --git a/src/test/run-pass/issue-17068.rs b/src/test/run-pass/issue-17068.rs
index 55a6d4cdbace7..91264b4ac3f2b 100644
--- a/src/test/run-pass/issue-17068.rs
+++ b/src/test/run-pass/issue-17068.rs
@@ -10,7 +10,6 @@
 
 // Test that regionck creates the right region links in the pattern
 // binding of a for loop
-// pretty-expanded FIXME #23616
 
 fn foo<'a>(v: &'a [usize]) -> &'a usize {
     for &ref x in v { return x; }
diff --git a/src/test/run-pass/issue-17074.rs b/src/test/run-pass/issue-17074.rs
index 08c313ab0a42b..ec2d8f79781cc 100644
--- a/src/test/run-pass/issue-17074.rs
+++ b/src/test/run-pass/issue-17074.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 static X2: u64 = !0 as u16 as u64;
 static Y2: u64 = !0 as u32 as u64;
diff --git a/src/test/run-pass/issue-17216.rs b/src/test/run-pass/issue-17216.rs
index f17834e8d36dc..6a8f7d992a292 100644
--- a/src/test/run-pass/issue-17216.rs
+++ b/src/test/run-pass/issue-17216.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/issue-17233.rs b/src/test/run-pass/issue-17233.rs
index 756822d4f45fa..e9f0c73e29db3 100644
--- a/src/test/run-pass/issue-17233.rs
+++ b/src/test/run-pass/issue-17233.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const X1: &'static [u8] = &[b'1'];
 const X2: &'static [u8] = b"1";
diff --git a/src/test/run-pass/issue-17302.rs b/src/test/run-pass/issue-17302.rs
index 35bd07c896bb6..59625581167d0 100644
--- a/src/test/run-pass/issue-17302.rs
+++ b/src/test/run-pass/issue-17302.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 static mut DROPPED: [bool; 2] = [false, false];
 
diff --git a/src/test/run-pass/issue-17662.rs b/src/test/run-pass/issue-17662.rs
index 36e12b96c8744..320d108cfae74 100644
--- a/src/test/run-pass/issue-17662.rs
+++ b/src/test/run-pass/issue-17662.rs
@@ -10,7 +10,6 @@
 
 // aux-build:issue-17662.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate issue_17662 as i;
 
diff --git a/src/test/run-pass/issue-17718-parse-const.rs b/src/test/run-pass/issue-17718-parse-const.rs
index 1fc8f3274d459..9be92d6597850 100644
--- a/src/test/run-pass/issue-17718-parse-const.rs
+++ b/src/test/run-pass/issue-17718-parse-const.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const FOO: usize = 3;
 
diff --git a/src/test/run-pass/issue-17718.rs b/src/test/run-pass/issue-17718.rs
index 13e082eada884..2b84ce71dd2a2 100644
--- a/src/test/run-pass/issue-17718.rs
+++ b/src/test/run-pass/issue-17718.rs
@@ -10,7 +10,6 @@
 
 // aux-build:issue-17718.rs
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/issue-17734.rs b/src/test/run-pass/issue-17734.rs
index 3cf9c62b40d49..0fc8eea778da9 100644
--- a/src/test/run-pass/issue-17734.rs
+++ b/src/test/run-pass/issue-17734.rs
@@ -10,7 +10,6 @@
 
 // Test that generating drop glue for Box<str> doesn't ICE
 
-// pretty-expanded FIXME #23616
 
 fn f(s: Box<str>) -> Box<str> {
     s
diff --git a/src/test/run-pass/issue-17877.rs b/src/test/run-pass/issue-17877.rs
index 41fab9d9d54e0..6c87e8d35fbf0 100644
--- a/src/test/run-pass/issue-17877.rs
+++ b/src/test/run-pass/issue-17877.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]
 
diff --git a/src/test/run-pass/issue-18352.rs b/src/test/run-pass/issue-18352.rs
index 4e60a7d9b5fbb..cce6ba407a663 100644
--- a/src/test/run-pass/issue-18352.rs
+++ b/src/test/run-pass/issue-18352.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const X: &'static str = "12345";
 
diff --git a/src/test/run-pass/issue-18412.rs b/src/test/run-pass/issue-18412.rs
index 41dacd3320379..1017fab5ae2e0 100644
--- a/src/test/run-pass/issue-18412.rs
+++ b/src/test/run-pass/issue-18412.rs
@@ -11,7 +11,6 @@
 // Test that non-static methods can be assigned to local variables as
 // function pointers.
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn foo(&self) -> usize;
diff --git a/src/test/run-pass/issue-18652.rs b/src/test/run-pass/issue-18652.rs
index a3affb7bf86f0..8ab645e54addc 100644
--- a/src/test/run-pass/issue-18652.rs
+++ b/src/test/run-pass/issue-18652.rs
@@ -12,7 +12,6 @@
 // once closure as an optimization by trans.  This used to hit an
 // incorrect assert.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/issue-18767.rs b/src/test/run-pass/issue-18767.rs
index 8e51a900c0cae..264985b791e7f 100644
--- a/src/test/run-pass/issue-18767.rs
+++ b/src/test/run-pass/issue-18767.rs
@@ -11,7 +11,6 @@
 // Test that regionck uses the right memcat for patterns in for loops
 // and doesn't ICE.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     for &&x in Some(&0_usize).iter() {
diff --git a/src/test/run-pass/issue-18859.rs b/src/test/run-pass/issue-18859.rs
index 16e6c99f0e31d..7c7501d3420d2 100644
--- a/src/test/run-pass/issue-18859.rs
+++ b/src/test/run-pass/issue-18859.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod foo {
     pub mod bar {
diff --git a/src/test/run-pass/issue-19244.rs b/src/test/run-pass/issue-19244.rs
index f25450a891827..92ac2e37b90d2 100644
--- a/src/test/run-pass/issue-19244.rs
+++ b/src/test/run-pass/issue-19244.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct MyStruct { field: usize }
 struct Nested { nested: MyStruct }
diff --git a/src/test/run-pass/issue-19811-escape-unicode.rs b/src/test/run-pass/issue-19811-escape-unicode.rs
index 5b415c63885e6..e6e9bf6e6367f 100644
--- a/src/test/run-pass/issue-19811-escape-unicode.rs
+++ b/src/test/run-pass/issue-19811-escape-unicode.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections)]
 
diff --git a/src/test/run-pass/issue-21058.rs b/src/test/run-pass/issue-21058.rs
index d7a656be7afb0..c384757c5e4fb 100644
--- a/src/test/run-pass/issue-21058.rs
+++ b/src/test/run-pass/issue-21058.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/issue-21306.rs b/src/test/run-pass/issue-21306.rs
index cabda0b500bd5..bc2c7f09374fa 100644
--- a/src/test/run-pass/issue-21306.rs
+++ b/src/test/run-pass/issue-21306.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::Arc;
 
diff --git a/src/test/run-pass/issue-21361.rs b/src/test/run-pass/issue-21361.rs
index ef86634125ebd..b89e07ef31f0b 100644
--- a/src/test/run-pass/issue-21361.rs
+++ b/src/test/run-pass/issue-21361.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let v = vec![1, 2, 3];
diff --git a/src/test/run-pass/issue-21384.rs b/src/test/run-pass/issue-21384.rs
index 41a9ca840b178..e10fcd30b9961 100644
--- a/src/test/run-pass/issue-21384.rs
+++ b/src/test/run-pass/issue-21384.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use ::std::ops::RangeFull;
 
diff --git a/src/test/run-pass/issue-21634.rs b/src/test/run-pass/issue-21634.rs
index fe540e1aabef8..2a146ae8fcf7b 100644
--- a/src/test/run-pass/issue-21634.rs
+++ b/src/test/run-pass/issue-21634.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     if let Ok(x) = "3.1415".parse::<f64>() {
diff --git a/src/test/run-pass/issue-21655.rs b/src/test/run-pass/issue-21655.rs
index cb87770c565c0..bf01873bea5e7 100644
--- a/src/test/run-pass/issue-21655.rs
+++ b/src/test/run-pass/issue-21655.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn test(it: &mut Iterator<Item=i32>) {
     for x in it {
diff --git a/src/test/run-pass/issue-21721.rs b/src/test/run-pass/issue-21721.rs
index c34ab1b0ea7ce..d1fc61ff6a5d4 100644
--- a/src/test/run-pass/issue-21721.rs
+++ b/src/test/run-pass/issue-21721.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     static NONE: Option<((), &'static u8)> = None;
diff --git a/src/test/run-pass/issue-22036.rs b/src/test/run-pass/issue-22036.rs
index e02ce5441a7d4..43fb286f0ec40 100644
--- a/src/test/run-pass/issue-22036.rs
+++ b/src/test/run-pass/issue-22036.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait DigitCollection: Sized {
     type Iter: Iterator<Item = u8>;
diff --git a/src/test/run-pass/issue-2214.rs b/src/test/run-pass/issue-2214.rs
index 38895e1414cee..775cfb0ee4219 100644
--- a/src/test/run-pass/issue-2214.rs
+++ b/src/test/run-pass/issue-2214.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(libc)]
 
diff --git a/src/test/run-pass/issue-22536-copy-mustnt-zero.rs b/src/test/run-pass/issue-22536-copy-mustnt-zero.rs
index 8a0f04a2cf0e4..af99b11c2534f 100644
--- a/src/test/run-pass/issue-22536-copy-mustnt-zero.rs
+++ b/src/test/run-pass/issue-22536-copy-mustnt-zero.rs
@@ -11,7 +11,6 @@
 // Regression test for Issue #22536: If a type implements Copy, then
 // moving it must not zero the original memory.
 
-// pretty-expanded FIXME #23616
 
 trait Resources {
     type Buffer: Copy;
diff --git a/src/test/run-pass/issue-2311-2.rs b/src/test/run-pass/issue-2311-2.rs
index c76bbaf968a65..a47c151255270 100644
--- a/src/test/run-pass/issue-2311-2.rs
+++ b/src/test/run-pass/issue-2311-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait clam<A> {
     fn get(self) -> A;
diff --git a/src/test/run-pass/issue-2312.rs b/src/test/run-pass/issue-2312.rs
index fa056191e671e..6f479c621170e 100644
--- a/src/test/run-pass/issue-2312.rs
+++ b/src/test/run-pass/issue-2312.rs
@@ -10,7 +10,6 @@
 
 // Testing that the B's are resolved
 
-// pretty-expanded FIXME #23616
 
 trait clam<A> { fn get(self) -> A; }
 
diff --git a/src/test/run-pass/issue-24161.rs b/src/test/run-pass/issue-24161.rs
new file mode 100644
index 0000000000000..2445ef17ecf3b
--- /dev/null
+++ b/src/test/run-pass/issue-24161.rs
@@ -0,0 +1,19 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[derive(Copy,Clone)]
+struct Functions {
+    a: fn(u32) -> u32,
+    b: extern "C" fn(u32) -> u32,
+    c: unsafe fn(u32) -> u32,
+    d: unsafe extern "C" fn(u32) -> u32
+}
+
+pub fn main() {}
diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs
index 402eb0349ab23..a07050d4582f0 100644
--- a/src/test/run-pass/issue-2428.rs
+++ b/src/test/run-pass/issue-2428.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let _foo = 100;
diff --git a/src/test/run-pass/issue-2611-3.rs b/src/test/run-pass/issue-2611-3.rs
index 8cf80333e9722..242528dcb1474 100644
--- a/src/test/run-pass/issue-2611-3.rs
+++ b/src/test/run-pass/issue-2611-3.rs
@@ -11,7 +11,6 @@
 // Tests that impls are allowed to have looser, more permissive bounds
 // than the traits require.
 
-// pretty-expanded FIXME #23616
 
 trait A {
   fn b<C:Sync,D>(&self, x: C) -> C;
diff --git a/src/test/run-pass/issue-2735-2.rs b/src/test/run-pass/issue-2735-2.rs
index 1506b2d6bf089..36d7f4583b09f 100644
--- a/src/test/run-pass/issue-2735-2.rs
+++ b/src/test/run-pass/issue-2735-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/issue-2735-3.rs b/src/test/run-pass/issue-2735-3.rs
index 2282334d66d10..f438519b72f3b 100644
--- a/src/test/run-pass/issue-2735-3.rs
+++ b/src/test/run-pass/issue-2735-3.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/issue-2748-b.rs b/src/test/run-pass/issue-2748-b.rs
index 8f30d262f41f5..f1cbf11a347eb 100644
--- a/src/test/run-pass/issue-2748-b.rs
+++ b/src/test/run-pass/issue-2748-b.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn thing<'r>(x: &'r [isize]) -> &'r [isize] { x }
 
diff --git a/src/test/run-pass/issue-2895.rs b/src/test/run-pass/issue-2895.rs
index 3f4c630cc2b0a..93d9300edf634 100644
--- a/src/test/run-pass/issue-2895.rs
+++ b/src/test/run-pass/issue-2895.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/issue-2936.rs b/src/test/run-pass/issue-2936.rs
index 5c63230f5d0ca..c277073a79dc9 100644
--- a/src/test/run-pass/issue-2936.rs
+++ b/src/test/run-pass/issue-2936.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait bar<T> {
     fn get_bar(&self) -> T;
diff --git a/src/test/run-pass/issue-3091.rs b/src/test/run-pass/issue-3091.rs
index 8e59e46fc3c4c..c67399a89e9c6 100644
--- a/src/test/run-pass/issue-3091.rs
+++ b/src/test/run-pass/issue-3091.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = 1;
diff --git a/src/test/run-pass/issue-3290.rs b/src/test/run-pass/issue-3290.rs
index 3fa5b72c348f3..b09820146f5b8 100644
--- a/src/test/run-pass/issue-3290.rs
+++ b/src/test/run-pass/issue-3290.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index b611f11a0a124..592ff0b02a4ad 100644
--- a/src/test/run-pass/issue-333.rs
+++ b/src/test/run-pass/issue-333.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn quux<T>(x: T) -> T { let f = id::<T>; return f(x); }
 
diff --git a/src/test/run-pass/issue-3574.rs b/src/test/run-pass/issue-3574.rs
index 9a521ba376dc2..9aac52fa2f8a1 100644
--- a/src/test/run-pass/issue-3574.rs
+++ b/src/test/run-pass/issue-3574.rs
@@ -10,7 +10,6 @@
 
 // rustc --test match_borrowed_str.rs.rs && ./match_borrowed_str.rs
 
-// pretty-expanded FIXME #23616
 
 fn compare(x: &str, y: &str) -> bool {
     match x {
diff --git a/src/test/run-pass/issue-3895.rs b/src/test/run-pass/issue-3895.rs
index ca6d9faf88f4a..ffe14dab30039 100644
--- a/src/test/run-pass/issue-3895.rs
+++ b/src/test/run-pass/issue-3895.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     enum State { BadChar, BadSyntax }
diff --git a/src/test/run-pass/issue-3935.rs b/src/test/run-pass/issue-3935.rs
index 1e200e01628a5..45ff20fc0a9c3 100644
--- a/src/test/run-pass/issue-3935.rs
+++ b/src/test/run-pass/issue-3935.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(PartialEq)]
 struct Bike {
diff --git a/src/test/run-pass/issue-3979-generics.rs b/src/test/run-pass/issue-3979-generics.rs
index 61708acf7f317..6ba566012c3be 100644
--- a/src/test/run-pass/issue-3979-generics.rs
+++ b/src/test/run-pass/issue-3979-generics.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::ops::Add;
 
diff --git a/src/test/run-pass/issue-3979-xcrate.rs b/src/test/run-pass/issue-3979-xcrate.rs
index 0784877849ad1..acacc48856646 100644
--- a/src/test/run-pass/issue-3979-xcrate.rs
+++ b/src/test/run-pass/issue-3979-xcrate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:issue_3979_traits.rs
-// pretty-expanded FIXME #23616
 
 extern crate issue_3979_traits;
 use issue_3979_traits::{Positioned, Movable};
diff --git a/src/test/run-pass/issue-3979.rs b/src/test/run-pass/issue-3979.rs
index 341866e4982ff..184682255d936 100644
--- a/src/test/run-pass/issue-3979.rs
+++ b/src/test/run-pass/issue-3979.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Positioned {
   fn SetX(&mut self, isize);
diff --git a/src/test/run-pass/issue-4016.rs b/src/test/run-pass/issue-4016.rs
index 122de97c99c1c..bc3fa162e02bd 100644
--- a/src/test/run-pass/issue-4016.rs
+++ b/src/test/run-pass/issue-4016.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(rustc_private)]
 
diff --git a/src/test/run-pass/issue-4107.rs b/src/test/run-pass/issue-4107.rs
index 18025c315c95c..fa5ed26847b57 100644
--- a/src/test/run-pass/issue-4107.rs
+++ b/src/test/run-pass/issue-4107.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let _id: &Mat2<f64> = &Matrix::identity(1.0);
diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs
index d5d3122f6834b..eb411ff441778 100644
--- a/src/test/run-pass/issue-4448.rs
+++ b/src/test/run-pass/issue-4448.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::mpsc::channel;
 use std::thread;
diff --git a/src/test/run-pass/issue-4734.rs b/src/test/run-pass/issue-4734.rs
index 82925852a6a3d..88a3b24d14fc8 100644
--- a/src/test/run-pass/issue-4734.rs
+++ b/src/test/run-pass/issue-4734.rs
@@ -11,7 +11,6 @@
 // Ensures that destructors are run for expressions of the form "e;" where
 // `e` is a type which requires a destructor.
 
-// pretty-expanded FIXME #23616
 
 #![allow(path_statement)]
 
diff --git a/src/test/run-pass/issue-5239-2.rs b/src/test/run-pass/issue-5239-2.rs
index d8491070bd8b5..5e58d76d5e0ff 100644
--- a/src/test/run-pass/issue-5239-2.rs
+++ b/src/test/run-pass/issue-5239-2.rs
@@ -10,7 +10,6 @@
 
 // Regression test for issue #5239
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let _f = |ref x: isize| { *x };
diff --git a/src/test/run-pass/issue-5521.rs b/src/test/run-pass/issue-5521.rs
index 4ad729f1bc60a..136f7aa956c0d 100644
--- a/src/test/run-pass/issue-5521.rs
+++ b/src/test/run-pass/issue-5521.rs
@@ -11,7 +11,6 @@
 // aux-build:issue-5521.rs
 
 
-// pretty-expanded FIXME #23616
 
 extern crate issue_5521 as foo;
 
diff --git a/src/test/run-pass/issue-5530.rs b/src/test/run-pass/issue-5530.rs
index 50b9ca6e797d8..bd7d7af71df85 100644
--- a/src/test/run-pass/issue-5530.rs
+++ b/src/test/run-pass/issue-5530.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum Enum {
     Foo { foo: usize },
diff --git a/src/test/run-pass/issue-5917.rs b/src/test/run-pass/issue-5917.rs
index 7f741182f4223..112ad0185d8cb 100644
--- a/src/test/run-pass/issue-5917.rs
+++ b/src/test/run-pass/issue-5917.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct T (&'static [isize]);
 static t : T = T (&[5, 4, 3]);
diff --git a/src/test/run-pass/issue-5997.rs b/src/test/run-pass/issue-5997.rs
index 48923bc82b4e0..0c41acf04aae6 100644
--- a/src/test/run-pass/issue-5997.rs
+++ b/src/test/run-pass/issue-5997.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn f<T>() -> bool {
     enum E<T> { V(T) }
diff --git a/src/test/run-pass/issue-6128.rs b/src/test/run-pass/issue-6128.rs
index baf829bc269b6..5fb24fe3ef1ac 100644
--- a/src/test/run-pass/issue-6128.rs
+++ b/src/test/run-pass/issue-6128.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax, collections)]
diff --git a/src/test/run-pass/issue-6130.rs b/src/test/run-pass/issue-6130.rs
index 6f158339169cb..f124b851f0925 100644
--- a/src/test/run-pass/issue-6130.rs
+++ b/src/test/run-pass/issue-6130.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![deny(type_limits)]
 
diff --git a/src/test/run-pass/issue-6153.rs b/src/test/run-pass/issue-6153.rs
index c280ea31ebc47..16e7060f4b9f1 100644
--- a/src/test/run-pass/issue-6153.rs
+++ b/src/test/run-pass/issue-6153.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn swap<F>(f: F) -> Vec<isize> where F: FnOnce(Vec<isize>) -> Vec<isize> {
     let x = vec!(1, 2, 3);
diff --git a/src/test/run-pass/issue-6334.rs b/src/test/run-pass/issue-6334.rs
index 2f2dca8fe226c..fca1c296dddcc 100644
--- a/src/test/run-pass/issue-6334.rs
+++ b/src/test/run-pass/issue-6334.rs
@@ -11,7 +11,6 @@
 // Tests that everything still compiles and runs fine even when
 // we reorder the bounds.
 
-// pretty-expanded FIXME #23616
 
 trait A {
     fn a(&self) -> usize;
diff --git a/src/test/run-pass/issue-6449.rs b/src/test/run-pass/issue-6449.rs
index 3b33a0ac86f69..09a4e288404f2 100644
--- a/src/test/run-pass/issue-6449.rs
+++ b/src/test/run-pass/issue-6449.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum Foo {
     Bar(isize),
diff --git a/src/test/run-pass/issue-6892.rs b/src/test/run-pass/issue-6892.rs
index 4469dcc0ced81..75420ad6ff1c5 100644
--- a/src/test/run-pass/issue-6892.rs
+++ b/src/test/run-pass/issue-6892.rs
@@ -11,7 +11,6 @@
 // Ensures that destructors are run for expressions of the form "let _ = e;"
 // where `e` is a type which requires a destructor.
 
-// pretty-expanded FIXME #23616
 
 struct Foo;
 struct Bar { x: isize }
diff --git a/src/test/run-pass/issue-7575.rs b/src/test/run-pass/issue-7575.rs
index 727ed91eadc6c..508ebf3f69d1a 100644
--- a/src/test/run-pass/issue-7575.rs
+++ b/src/test/run-pass/issue-7575.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn new() -> bool { false }
diff --git a/src/test/run-pass/issue-7663.rs b/src/test/run-pass/issue-7663.rs
index 007127aeae186..7aac8d4456334 100644
--- a/src/test/run-pass/issue-7663.rs
+++ b/src/test/run-pass/issue-7663.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unused_imports, dead_code)]
 
diff --git a/src/test/run-pass/issue-7784.rs b/src/test/run-pass/issue-7784.rs
index e2016feeb0ad7..224fe627e32d9 100644
--- a/src/test/run-pass/issue-7784.rs
+++ b/src/test/run-pass/issue-7784.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(advanced_slice_patterns)]
 #![feature(slice_patterns)]
diff --git a/src/test/run-pass/issue-8351-1.rs b/src/test/run-pass/issue-8351-1.rs
index a11e14fb33367..ed78b37604e86 100644
--- a/src/test/run-pass/issue-8351-1.rs
+++ b/src/test/run-pass/issue-8351-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E {
     Foo{f: isize},
diff --git a/src/test/run-pass/issue-8351-2.rs b/src/test/run-pass/issue-8351-2.rs
index 7cf221926a6d3..1ed93915b8a03 100644
--- a/src/test/run-pass/issue-8351-2.rs
+++ b/src/test/run-pass/issue-8351-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E {
     Foo{f: isize, b: bool},
diff --git a/src/test/run-pass/issue-8391.rs b/src/test/run-pass/issue-8391.rs
index bd2e2871bdb49..b832c410443c4 100644
--- a/src/test/run-pass/issue-8391.rs
+++ b/src/test/run-pass/issue-8391.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let x = match Some(1) {
diff --git a/src/test/run-pass/issue-8460.rs b/src/test/run-pass/issue-8460.rs
index 7d8c4ab210d00..2469dec994727 100644
--- a/src/test/run-pass/issue-8460.rs
+++ b/src/test/run-pass/issue-8460.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs
index 825729b1e2a81..fae3352f9cc5f 100644
--- a/src/test/run-pass/issue-8498.rs
+++ b/src/test/run-pass/issue-8498.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     match &[(Box::new(5),Box::new(7))] {
diff --git a/src/test/run-pass/issue-8709.rs b/src/test/run-pass/issue-8709.rs
index 6467262929810..44759cef2864f 100644
--- a/src/test/run-pass/issue-8709.rs
+++ b/src/test/run-pass/issue-8709.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! sty {
     ($t:ty) => (stringify!($t))
diff --git a/src/test/run-pass/issue-8860.rs b/src/test/run-pass/issue-8860.rs
index 8024eaeda83cb..ff562aac1614b 100644
--- a/src/test/run-pass/issue-8860.rs
+++ b/src/test/run-pass/issue-8860.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 static mut DROP: isize = 0;
 static mut DROP_S: isize = 0;
diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs
index a4cad1b263952..065cef2c60d7d 100644
--- a/src/test/run-pass/issue-8898.rs
+++ b/src/test/run-pass/issue-8898.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn assert_repr_eq<T: std::fmt::Debug>(obj : T, expected : String) {
     assert_eq!(expected, format!("{:?}", obj));
diff --git a/src/test/run-pass/issue-9188.rs b/src/test/run-pass/issue-9188.rs
index 0bd8a8e0d9df2..e2272837efb7a 100644
--- a/src/test/run-pass/issue-9188.rs
+++ b/src/test/run-pass/issue-9188.rs
@@ -10,7 +10,6 @@
 
 // aux-build:issue_9188.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate issue_9188;
 
diff --git a/src/test/run-pass/issue-9259.rs b/src/test/run-pass/issue-9259.rs
index 209c6b139612f..996548de81738 100644
--- a/src/test/run-pass/issue-9259.rs
+++ b/src/test/run-pass/issue-9259.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct A<'a> {
     a: &'a [String],
diff --git a/src/test/run-pass/issue-9394-inherited-trait-calls.rs b/src/test/run-pass/issue-9394-inherited-trait-calls.rs
index 148d0760e5c02..7d2c435b38429 100644
--- a/src/test/run-pass/issue-9394-inherited-trait-calls.rs
+++ b/src/test/run-pass/issue-9394-inherited-trait-calls.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Base: Base2 + Base3{
     fn foo(&self) -> String;
diff --git a/src/test/run-pass/issue-979.rs b/src/test/run-pass/issue-979.rs
index 3283dc44f3083..979abcef7b8d2 100644
--- a/src/test/run-pass/issue-979.rs
+++ b/src/test/run-pass/issue-979.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/issue-9918.rs b/src/test/run-pass/issue-9918.rs
index e81a07fa68325..a766e6b707e30 100644
--- a/src/test/run-pass/issue-9918.rs
+++ b/src/test/run-pass/issue-9918.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert_eq!((0 + 0u8) as char, '\0');
diff --git a/src/test/run-pass/iter-cloned-type-inference.rs b/src/test/run-pass/iter-cloned-type-inference.rs
index d1f63564979c8..59f7569d8c62b 100644
--- a/src/test/run-pass/iter-cloned-type-inference.rs
+++ b/src/test/run-pass/iter-cloned-type-inference.rs
@@ -11,7 +11,6 @@
 // Test to see that the element type of .cloned() can be inferred
 // properly. Previously this would fail to deduce the type of `sum`.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs
index 84156385ef438..9df72f4760a1f 100644
--- a/src/test/run-pass/kindck-owned-trait-contains-1.rs
+++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/last-use-in-block.rs b/src/test/run-pass/last-use-in-block.rs
index 28fe3bf0bd1fd..a2b01f29ae127 100644
--- a/src/test/run-pass/last-use-in-block.rs
+++ b/src/test/run-pass/last-use-in-block.rs
@@ -10,7 +10,6 @@
 
 // Issue #1818
 
-// pretty-expanded FIXME #23616
 
 fn lp<T, F>(s: String, mut f: F) -> T where F: FnMut(String) -> T {
     while false {
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index f9c8fe0f2d2d5..f196899f69d68 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -10,7 +10,6 @@
 
 // Make sure #1399 stays fixed
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/let-destruct-ref.rs b/src/test/run-pass/let-destruct-ref.rs
index 0b38d16941bae..c9504f87c4904 100644
--- a/src/test/run-pass/let-destruct-ref.rs
+++ b/src/test/run-pass/let-destruct-ref.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = 3_usize;
diff --git a/src/test/run-pass/let-var-hygiene.rs b/src/test/run-pass/let-var-hygiene.rs
index c1e80aaf2d7b0..d9087f58befe7 100644
--- a/src/test/run-pass/let-var-hygiene.rs
+++ b/src/test/run-pass/let-var-hygiene.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // shouldn't affect evaluation of $ex:
-// pretty-expanded FIXME #23616
 
 macro_rules! bad_macro {
     ($ex:expr) => ({let _x = 9; $ex})
diff --git a/src/test/run-pass/logging-enabled-debug.rs b/src/test/run-pass/logging-enabled-debug.rs
index 59f5b0af35913..3ae4884ce47fc 100644
--- a/src/test/run-pass/logging-enabled-debug.rs
+++ b/src/test/run-pass/logging-enabled-debug.rs
@@ -11,7 +11,6 @@
 // compile-flags:-C debug-assertions=no
 // exec-env:RUST_LOG=logging-enabled-debug=debug
 
-// pretty-expanded FIXME #23616
 
 #![feature(rustc_private)]
 
diff --git a/src/test/run-pass/logging-enabled.rs b/src/test/run-pass/logging-enabled.rs
index 294d4d1217952..2975835a27149 100644
--- a/src/test/run-pass/logging-enabled.rs
+++ b/src/test/run-pass/logging-enabled.rs
@@ -10,7 +10,6 @@
 
 // exec-env:RUST_LOG=logging_enabled=info
 
-// pretty-expanded FIXME #23616
 
 #![feature(rustc_private)]
 
diff --git a/src/test/run-pass/loop-break-cont-1.rs b/src/test/run-pass/loop-break-cont-1.rs
index eaf69dbae00f9..5abac0e65a360 100644
--- a/src/test/run-pass/loop-break-cont-1.rs
+++ b/src/test/run-pass/loop-break-cont-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
   let _i = 0_usize;
diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs
index 70f2830555a4b..0c1e7916cdb18 100644
--- a/src/test/run-pass/loop-scope.rs
+++ b/src/test/run-pass/loop-scope.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = vec!(10, 20, 30);
diff --git a/src/test/run-pass/macro-block-nonterminal.rs b/src/test/run-pass/macro-block-nonterminal.rs
index 496534a5362f3..21b284f420f20 100644
--- a/src/test/run-pass/macro-block-nonterminal.rs
+++ b/src/test/run-pass/macro-block-nonterminal.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! do_block{
     ($val:block) => {$val}
diff --git a/src/test/run-pass/macro-crate-def-only.rs b/src/test/run-pass/macro-crate-def-only.rs
index 58b09fa492192..28be058b9a376 100644
--- a/src/test/run-pass/macro-crate-def-only.rs
+++ b/src/test/run-pass/macro-crate-def-only.rs
@@ -10,7 +10,6 @@
 
 // aux-build:macro_crate_def_only.rs
 
-// pretty-expanded FIXME #23616
 
 #[macro_use] #[no_link]
 extern crate macro_crate_def_only;
diff --git a/src/test/run-pass/macro-crate-use.rs b/src/test/run-pass/macro-crate-use.rs
index 557f982713a17..c7255f67fa684 100644
--- a/src/test/run-pass/macro-crate-use.rs
+++ b/src/test/run-pass/macro-crate-use.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn increment(x: usize) -> usize {
     x + 1
diff --git a/src/test/run-pass/macro-deep_expansion.rs b/src/test/run-pass/macro-deep_expansion.rs
index fd21ed0150ab0..3e8548ff49d2b 100644
--- a/src/test/run-pass/macro-deep_expansion.rs
+++ b/src/test/run-pass/macro-deep_expansion.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! foo2 {
     () => {
diff --git a/src/test/run-pass/macro-interpolation.rs b/src/test/run-pass/macro-interpolation.rs
index e6b5d50b36e6d..6dcd1538ebce2 100644
--- a/src/test/run-pass/macro-interpolation.rs
+++ b/src/test/run-pass/macro-interpolation.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! overly_complicated {
     ($fnname:ident, $arg:ident, $ty:ty, $body:block, $val:expr, $pat:pat, $res:path) =>
diff --git a/src/test/run-pass/macro-method-issue-4621.rs b/src/test/run-pass/macro-method-issue-4621.rs
index cb1540459771b..64648cae5e6cc 100644
--- a/src/test/run-pass/macro-method-issue-4621.rs
+++ b/src/test/run-pass/macro-method-issue-4621.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct A;
 
diff --git a/src/test/run-pass/macro-of-higher-order.rs b/src/test/run-pass/macro-of-higher-order.rs
index ebd58f772284a..52e19b37d7935 100644
--- a/src/test/run-pass/macro-of-higher-order.rs
+++ b/src/test/run-pass/macro-of-higher-order.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! higher_order {
     (subst $lhs:tt => $rhs:tt) => ({
diff --git a/src/test/run-pass/macro-pat.rs b/src/test/run-pass/macro-pat.rs
index 659113d4e0c95..48e521de57e90 100644
--- a/src/test/run-pass/macro-pat.rs
+++ b/src/test/run-pass/macro-pat.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 macro_rules! mypat {
     () => (
diff --git a/src/test/run-pass/macro-path.rs b/src/test/run-pass/macro-path.rs
index 2e8806229778e..7aecc1dc20348 100644
--- a/src/test/run-pass/macro-path.rs
+++ b/src/test/run-pass/macro-path.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod m {
     pub type t = isize;
diff --git a/src/test/run-pass/macro-with-attrs1.rs b/src/test/run-pass/macro-with-attrs1.rs
index 0938c16c30492..99bf71b1f0126 100644
--- a/src/test/run-pass/macro-with-attrs1.rs
+++ b/src/test/run-pass/macro-with-attrs1.rs
@@ -10,7 +10,6 @@
 
 // compile-flags: --cfg foo
 
-// pretty-expanded FIXME #23616
 
 #[cfg(foo)]
 macro_rules! foo { () => (1) }
diff --git a/src/test/run-pass/macro-with-attrs2.rs b/src/test/run-pass/macro-with-attrs2.rs
index cf48c325f1f24..062c8d55d5296 100644
--- a/src/test/run-pass/macro-with-attrs2.rs
+++ b/src/test/run-pass/macro-with-attrs2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[cfg(foo)]
 macro_rules! foo { () => (1) }
diff --git a/src/test/run-pass/match-arm-statics.rs b/src/test/run-pass/match-arm-statics.rs
index 1b4dfb869d413..43ff69fe75e6c 100644
--- a/src/test/run-pass/match-arm-statics.rs
+++ b/src/test/run-pass/match-arm-statics.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct NewBool(bool);
 
diff --git a/src/test/run-pass/match-borrowed_str.rs b/src/test/run-pass/match-borrowed_str.rs
index 574c4b9f00eab..b027e62494c23 100644
--- a/src/test/run-pass/match-borrowed_str.rs
+++ b/src/test/run-pass/match-borrowed_str.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unnecessary_allocation)]
 
diff --git a/src/test/run-pass/match-bot-2.rs b/src/test/run-pass/match-bot-2.rs
index 4fa951b34794b..88c514a724f2f 100644
--- a/src/test/run-pass/match-bot-2.rs
+++ b/src/test/run-pass/match-bot-2.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // n.b. This was only ever failing with optimization disabled.
-// pretty-expanded FIXME #23616
 
 fn a() -> isize { match return 1 { 2 => 3, _ => panic!() } }
 pub fn main() { a(); }
diff --git a/src/test/run-pass/match-enum-struct-0.rs b/src/test/run-pass/match-enum-struct-0.rs
index 06d19cec185bb..1754dc0c960f8 100644
--- a/src/test/run-pass/match-enum-struct-0.rs
+++ b/src/test/run-pass/match-enum-struct-0.rs
@@ -10,7 +10,6 @@
 
 // regression test for issue #5625
 
-// pretty-expanded FIXME #23616
 
 enum E {
     Foo{f : isize},
diff --git a/src/test/run-pass/match-enum-struct-1.rs b/src/test/run-pass/match-enum-struct-1.rs
index e4766f32a57f3..ebf2db36700c3 100644
--- a/src/test/run-pass/match-enum-struct-1.rs
+++ b/src/test/run-pass/match-enum-struct-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum E {
     Foo{f : isize},
diff --git a/src/test/run-pass/match-implicit-copy-unique.rs b/src/test/run-pass/match-implicit-copy-unique.rs
index d481c02eb410a..d75bdaf4da8ea 100644
--- a/src/test/run-pass/match-implicit-copy-unique.rs
+++ b/src/test/run-pass/match-implicit-copy-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/match-in-macro.rs b/src/test/run-pass/match-in-macro.rs
index 27bbbc936ae5c..e096c97e16f16 100644
--- a/src/test/run-pass/match-in-macro.rs
+++ b/src/test/run-pass/match-in-macro.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum Foo {
     B { b1: isize, bb1: isize},
diff --git a/src/test/run-pass/match-pattern-bindings.rs b/src/test/run-pass/match-pattern-bindings.rs
index d230f18f2bd84..9f687ab99e800 100644
--- a/src/test/run-pass/match-pattern-bindings.rs
+++ b/src/test/run-pass/match-pattern-bindings.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let value = Some(1);
diff --git a/src/test/run-pass/match-pipe-binding.rs b/src/test/run-pass/match-pipe-binding.rs
index 70d3639a785fa..bda90d3aaecb4 100644
--- a/src/test/run-pass/match-pipe-binding.rs
+++ b/src/test/run-pass/match-pipe-binding.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn test1() {
     // from issue 6338
diff --git a/src/test/run-pass/match-ref-binding-in-guard-3256.rs b/src/test/run-pass/match-ref-binding-in-guard-3256.rs
index 1e2ebf42a9911..dc3c759078f3d 100644
--- a/src/test/run-pass/match-ref-binding-in-guard-3256.rs
+++ b/src/test/run-pass/match-ref-binding-in-guard-3256.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::Mutex;
 
diff --git a/src/test/run-pass/match-ref-binding-mut-option.rs b/src/test/run-pass/match-ref-binding-mut-option.rs
index 41f00e58ff769..f429e7b58e382 100644
--- a/src/test/run-pass/match-ref-binding-mut-option.rs
+++ b/src/test/run-pass/match-ref-binding-mut-option.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut v = Some(22);
diff --git a/src/test/run-pass/match-ref-binding-mut.rs b/src/test/run-pass/match-ref-binding-mut.rs
index 26c91e1703caf..abc418ddd5169 100644
--- a/src/test/run-pass/match-ref-binding-mut.rs
+++ b/src/test/run-pass/match-ref-binding-mut.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Rec {
     f: isize
diff --git a/src/test/run-pass/match-ref-binding.rs b/src/test/run-pass/match-ref-binding.rs
index 826edb30b36f4..eab7ed529b1f6 100644
--- a/src/test/run-pass/match-ref-binding.rs
+++ b/src/test/run-pass/match-ref-binding.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn destructure(x: Option<isize>) -> isize {
     match x {
diff --git a/src/test/run-pass/match-static-const-rename.rs b/src/test/run-pass/match-static-const-rename.rs
index 21b806f80dee4..08f3182900fc2 100644
--- a/src/test/run-pass/match-static-const-rename.rs
+++ b/src/test/run-pass/match-static-const-rename.rs
@@ -16,7 +16,6 @@
 // around this problem locally by renaming the constant in the `use`
 // form to an uppercase identifier that placates the lint.
 
-// pretty-expanded FIXME #23616
 
 #![deny(non_upper_case_globals)]
 
diff --git a/src/test/run-pass/match-str.rs b/src/test/run-pass/match-str.rs
index 5d8958c6b9e87..e6def65e53a6f 100644
--- a/src/test/run-pass/match-str.rs
+++ b/src/test/run-pass/match-str.rs
@@ -10,7 +10,6 @@
 
 // Issue #53
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     match "test" { "not-test" => panic!(), "test" => (), _ => panic!() }
diff --git a/src/test/run-pass/match-struct-0.rs b/src/test/run-pass/match-struct-0.rs
index 450b310b8f408..e9e45df460df1 100644
--- a/src/test/run-pass/match-struct-0.rs
+++ b/src/test/run-pass/match-struct-0.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Foo{
     f : isize,
diff --git a/src/test/run-pass/match-tag.rs b/src/test/run-pass/match-tag.rs
index 82d29f9050bfc..e4a0d4e95f3c7 100644
--- a/src/test/run-pass/match-tag.rs
+++ b/src/test/run-pass/match-tag.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 enum color {
     rgb(isize, isize, isize),
diff --git a/src/test/run-pass/match-vec-alternatives.rs b/src/test/run-pass/match-vec-alternatives.rs
index f9b49281bab0c..43e0b442251bd 100644
--- a/src/test/run-pass/match-vec-alternatives.rs
+++ b/src/test/run-pass/match-vec-alternatives.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(advanced_slice_patterns)]
 #![feature(slice_patterns)]
diff --git a/src/test/run-pass/match-vec-rvalue.rs b/src/test/run-pass/match-vec-rvalue.rs
index e368aeb976934..a10f9b1d7d61b 100644
--- a/src/test/run-pass/match-vec-rvalue.rs
+++ b/src/test/run-pass/match-vec-rvalue.rs
@@ -11,7 +11,6 @@
 // Tests that matching rvalues with drops does not crash.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     match vec!(1, 2, 3) {
diff --git a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
index 7cc762c934826..25e0b272fd2e5 100644
--- a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
+++ b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
@@ -12,7 +12,6 @@
 // type is `&mut [u8]`, passes in a pointer to the lvalue and not a
 // temporary. Issue #19147.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core, old_io)]
 
diff --git a/src/test/run-pass/method-projection.rs b/src/test/run-pass/method-projection.rs
index 3db7268207086..41d92cc75937b 100644
--- a/src/test/run-pass/method-projection.rs
+++ b/src/test/run-pass/method-projection.rs
@@ -13,7 +13,6 @@
 
 ///////////////////////////////////////////////////////////////////////////
 
-// pretty-expanded FIXME #23616
 
 trait MakeString {
     fn make_string(&self) -> String;
diff --git a/src/test/run-pass/method-self-arg-aux1.rs b/src/test/run-pass/method-self-arg-aux1.rs
index 768e7f94862ac..acda78af5c32d 100644
--- a/src/test/run-pass/method-self-arg-aux1.rs
+++ b/src/test/run-pass/method-self-arg-aux1.rs
@@ -10,7 +10,6 @@
 
 // Test method calls with self as an argument (cross-crate)
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/method-self-arg-aux2.rs b/src/test/run-pass/method-self-arg-aux2.rs
index b40333c67c6ac..0aea4139b0c37 100644
--- a/src/test/run-pass/method-self-arg-aux2.rs
+++ b/src/test/run-pass/method-self-arg-aux2.rs
@@ -10,7 +10,6 @@
 
 // Test method calls with self as an argument (cross-crate)
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/method-self-arg-trait.rs b/src/test/run-pass/method-self-arg-trait.rs
index f0ca0a70acc96..2ba3e78ef1504 100644
--- a/src/test/run-pass/method-self-arg-trait.rs
+++ b/src/test/run-pass/method-self-arg-trait.rs
@@ -10,7 +10,6 @@
 
 // Test method calls with self as an argument
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/method-self-arg.rs b/src/test/run-pass/method-self-arg.rs
index dfc121192228d..543133a3268f8 100644
--- a/src/test/run-pass/method-self-arg.rs
+++ b/src/test/run-pass/method-self-arg.rs
@@ -10,7 +10,6 @@
 
 // Test method calls with self as an argument
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/method-two-trait-defer-resolution-1.rs b/src/test/run-pass/method-two-trait-defer-resolution-1.rs
index d0e0427f37808..ff80ee1986815 100644
--- a/src/test/run-pass/method-two-trait-defer-resolution-1.rs
+++ b/src/test/run-pass/method-two-trait-defer-resolution-1.rs
@@ -11,7 +11,6 @@
 // Test that we pick which version of `foo` to run based on the
 // type that is (ultimately) inferred for `x`.
 
-// pretty-expanded FIXME #23616
 
 trait foo {
     fn foo(&self) -> i32;
diff --git a/src/test/run-pass/method-two-trait-defer-resolution-2.rs b/src/test/run-pass/method-two-trait-defer-resolution-2.rs
index 2ceff22adb9eb..e1b64f250d8e1 100644
--- a/src/test/run-pass/method-two-trait-defer-resolution-2.rs
+++ b/src/test/run-pass/method-two-trait-defer-resolution-2.rs
@@ -19,7 +19,6 @@
 // translate the call as `Foo::foo(&x)` and let the specific impl get
 // chosen later.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/method-where-clause.rs b/src/test/run-pass/method-where-clause.rs
index f2ff0abfad8b8..078dbe0e79e7f 100644
--- a/src/test/run-pass/method-where-clause.rs
+++ b/src/test/run-pass/method-where-clause.rs
@@ -11,7 +11,6 @@
 // Test that we can use method notation to call methods based on a
 // where clause type, and not only type parameters.
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn foo(&self) -> i32;
diff --git a/src/test/run-pass/mod-inside-fn.rs b/src/test/run-pass/mod-inside-fn.rs
index 836f2960d7174..6b922634aade1 100644
--- a/src/test/run-pass/mod-inside-fn.rs
+++ b/src/test/run-pass/mod-inside-fn.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn f() -> isize {
     mod m {
diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs
index 9ccb8f2e6fdd9..e309fa14302ca 100644
--- a/src/test/run-pass/monad.rs
+++ b/src/test/run-pass/monad.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 trait vec_monad<A> {
     fn bind<B, F>(&self, f: F ) -> Vec<B> where F: FnMut(&A) -> Vec<B> ;
diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs
index ab9770b13d451..34a3bdf876538 100644
--- a/src/test/run-pass/move-1-unique.rs
+++ b/src/test/run-pass/move-1-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs
index c65e58a7b6502..e4dc82f9801d1 100644
--- a/src/test/run-pass/move-2-unique.rs
+++ b/src/test/run-pass/move-2-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-2.rs b/src/test/run-pass/move-2.rs
index 054b57b2f432e..0c89c89eb8aa0 100644
--- a/src/test/run-pass/move-2.rs
+++ b/src/test/run-pass/move-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs
index 6036fa26ccf99..360593ffe4882 100644
--- a/src/test/run-pass/move-3-unique.rs
+++ b/src/test/run-pass/move-3-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs
index 79a1b294da9bb..9f80ecf297935 100644
--- a/src/test/run-pass/move-4-unique.rs
+++ b/src/test/run-pass/move-4-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs
index 16ef95023542b..1346860d51d7b 100644
--- a/src/test/run-pass/move-4.rs
+++ b/src/test/run-pass/move-4.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs
index 7aec948c8d472..fa69731963a30 100644
--- a/src/test/run-pass/move-arg-2-unique.rs
+++ b/src/test/run-pass/move-arg-2-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs
index 69b66d81e4355..6e22deed269da 100644
--- a/src/test/run-pass/move-arg-2.rs
+++ b/src/test/run-pass/move-arg-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/move-arg.rs b/src/test/run-pass/move-arg.rs
index 3d9eba8c09f20..0ff9a35874bfc 100644
--- a/src/test/run-pass/move-arg.rs
+++ b/src/test/run-pass/move-arg.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn test(foo: isize) { assert!((foo == 10)); }
 
diff --git a/src/test/run-pass/move-out-of-field.rs b/src/test/run-pass/move-out-of-field.rs
index a0eba4685b887..262add090bde7 100644
--- a/src/test/run-pass/move-out-of-field.rs
+++ b/src/test/run-pass/move-out-of-field.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::string::String;
 
diff --git a/src/test/run-pass/move-scalar.rs b/src/test/run-pass/move-scalar.rs
index a5b0a8b9bf482..798424d107e27 100644
--- a/src/test/run-pass/move-scalar.rs
+++ b/src/test/run-pass/move-scalar.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
 
diff --git a/src/test/run-pass/multi-let.rs b/src/test/run-pass/multi-let.rs
index 658b34e13f99b..1079857c1b387 100644
--- a/src/test/run-pass/multi-let.rs
+++ b/src/test/run-pass/multi-let.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let x = 10;
diff --git a/src/test/run-pass/multidispatch1.rs b/src/test/run-pass/multidispatch1.rs
index fdf9f95b274d4..7137a4109b151 100644
--- a/src/test/run-pass/multidispatch1.rs
+++ b/src/test/run-pass/multidispatch1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::fmt::Debug;
 
diff --git a/src/test/run-pass/multidispatch2.rs b/src/test/run-pass/multidispatch2.rs
index 75c6c5ac7d165..1573c0234a6e4 100644
--- a/src/test/run-pass/multidispatch2.rs
+++ b/src/test/run-pass/multidispatch2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::fmt::Debug;
 use std::default::Default;
diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs
index 644e45575521e..f415a7f2d668c 100644
--- a/src/test/run-pass/mut-function-arguments.rs
+++ b/src/test/run-pass/mut-function-arguments.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/mut-in-ident-patterns.rs b/src/test/run-pass/mut-in-ident-patterns.rs
index 2a8f6f1fc31ea..32ff7efffa0dc 100644
--- a/src/test/run-pass/mut-in-ident-patterns.rs
+++ b/src/test/run-pass/mut-in-ident-patterns.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn foo(&self, mut x: isize) -> isize {
diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
index bed3b87def58b..1766e65b9c734 100644
--- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
+++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn test1() {
     let mut ints = [0; 32];
diff --git a/src/test/run-pass/negative.rs b/src/test/run-pass/negative.rs
index c5b6a6a035bba..df074ddc06ac5 100644
--- a/src/test/run-pass/negative.rs
+++ b/src/test/run-pass/negative.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     match -5 {
diff --git a/src/test/run-pass/nested-class.rs b/src/test/run-pass/nested-class.rs
index 86197d44a689d..1ad68cb9de052 100644
--- a/src/test/run-pass/nested-class.rs
+++ b/src/test/run-pass/nested-class.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     struct b {
diff --git a/src/test/run-pass/nested-function-names-issue-8587.rs b/src/test/run-pass/nested-function-names-issue-8587.rs
index 28f3438f9862b..24b1f5ac75eae 100644
--- a/src/test/run-pass/nested-function-names-issue-8587.rs
+++ b/src/test/run-pass/nested-function-names-issue-8587.rs
@@ -13,7 +13,6 @@
 //
 // Issue #8587
 
-// pretty-expanded FIXME #23616
 
 pub struct X;
 
diff --git a/src/test/run-pass/nested_item_main.rs b/src/test/run-pass/nested_item_main.rs
index f7adfe36695d2..b24d517f7375c 100644
--- a/src/test/run-pass/nested_item_main.rs
+++ b/src/test/run-pass/nested_item_main.rs
@@ -10,7 +10,6 @@
 
 // aux-build:nested_item.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate nested_item;
 
diff --git a/src/test/run-pass/new-unicode-escapes.rs b/src/test/run-pass/new-unicode-escapes.rs
index 8c2d5e09adb47..bfad79e92d2c2 100644
--- a/src/test/run-pass/new-unicode-escapes.rs
+++ b/src/test/run-pass/new-unicode-escapes.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections)]
 
diff --git a/src/test/run-pass/newlambdas.rs b/src/test/run-pass/newlambdas.rs
index c6fa7cc35fd9a..a6f39958632c2 100644
--- a/src/test/run-pass/newlambdas.rs
+++ b/src/test/run-pass/newlambdas.rs
@@ -10,7 +10,6 @@
 
 // Tests for the new |args| expr lambda syntax
 
-// pretty-expanded FIXME #23616
 
 fn f<F>(i: isize, f: F) -> isize where F: FnOnce(isize) -> isize { f(i) }
 
diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs
index 424d518895cfb..91599608ceed6 100644
--- a/src/test/run-pass/newtype-polymorphic.rs
+++ b/src/test/run-pass/newtype-polymorphic.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 #[derive(Clone)]
 struct myvec<X>(Vec<X> );
diff --git a/src/test/run-pass/newtype-struct-drop-run.rs b/src/test/run-pass/newtype-struct-drop-run.rs
index 2d162ba7e336b..4407002aca8d6 100644
--- a/src/test/run-pass/newtype-struct-drop-run.rs
+++ b/src/test/run-pass/newtype-struct-drop-run.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/no-landing-pads.rs b/src/test/run-pass/no-landing-pads.rs
index da57c81a66978..d90e7ef5e473d 100644
--- a/src/test/run-pass/no-landing-pads.rs
+++ b/src/test/run-pass/no-landing-pads.rs
@@ -10,7 +10,6 @@
 
 // compile-flags: -Z no-landing-pads
 
-// pretty-expanded FIXME #23616
 
 use std::thread;
 
diff --git a/src/test/run-pass/non-legacy-modes.rs b/src/test/run-pass/non-legacy-modes.rs
index 5f1c69bb4b654..58534ed96da83 100644
--- a/src/test/run-pass/non-legacy-modes.rs
+++ b/src/test/run-pass/non-legacy-modes.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct X {
     repr: isize
diff --git a/src/test/run-pass/nul-characters.rs b/src/test/run-pass/nul-characters.rs
index 25c111daad597..cbea5e71f255f 100644
--- a/src/test/run-pass/nul-characters.rs
+++ b/src/test/run-pass/nul-characters.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main()
 {
diff --git a/src/test/run-pass/nullable-pointer-ffi-compat.rs b/src/test/run-pass/nullable-pointer-ffi-compat.rs
index 22aa09c718a74..224111900d60c 100644
--- a/src/test/run-pass/nullable-pointer-ffi-compat.rs
+++ b/src/test/run-pass/nullable-pointer-ffi-compat.rs
@@ -20,7 +20,6 @@
 // then we simply express the enum as just a pointer and not wrap it
 // in a struct.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index ad2716e00de56..ced2b24f36cfe 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/nullable-pointer-size.rs b/src/test/run-pass/nullable-pointer-size.rs
index 6e3f438575e2a..b097d350c8d5e 100644
--- a/src/test/run-pass/nullable-pointer-size.rs
+++ b/src/test/run-pass/nullable-pointer-size.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/nullary-or-pattern.rs b/src/test/run-pass/nullary-or-pattern.rs
index f4cfc80827498..feb8726c0e4a8 100644
--- a/src/test/run-pass/nullary-or-pattern.rs
+++ b/src/test/run-pass/nullary-or-pattern.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum blah { a, b, }
 
diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs
index cb41949a722c2..d5f64c1c7b1aa 100644
--- a/src/test/run-pass/numeric-method-autoexport.rs
+++ b/src/test/run-pass/numeric-method-autoexport.rs
@@ -15,7 +15,6 @@
 // necessary. Testing the methods of the impls is done within the source
 // file for each numeric type.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/object-method-numbering.rs b/src/test/run-pass/object-method-numbering.rs
index 8b8c56aee8391..82d34fa9ae48b 100644
--- a/src/test/run-pass/object-method-numbering.rs
+++ b/src/test/run-pass/object-method-numbering.rs
@@ -11,7 +11,6 @@
 // Test for using an object with an associated type binding as the
 // instantiation for a generic type with a bound.
 
-// pretty-expanded FIXME #23616
 
 trait SomeTrait {
     type SomeType;
diff --git a/src/test/run-pass/object-safety-sized-self-by-value-self.rs b/src/test/run-pass/object-safety-sized-self-by-value-self.rs
index b735743927c89..81acd94ebe516 100644
--- a/src/test/run-pass/object-safety-sized-self-by-value-self.rs
+++ b/src/test/run-pass/object-safety-sized-self-by-value-self.rs
@@ -11,7 +11,6 @@
 // Check that a trait is still object-safe (and usable) if it has
 // methods with by-value self so long as they require `Self : Sized`.
 
-// pretty-expanded FIXME #23616
 
 trait Counter {
     fn tick(&mut self) -> u32;
diff --git a/src/test/run-pass/object-safety-sized-self-generic-method.rs b/src/test/run-pass/object-safety-sized-self-generic-method.rs
index 696c5a0970914..2e84117566e47 100644
--- a/src/test/run-pass/object-safety-sized-self-generic-method.rs
+++ b/src/test/run-pass/object-safety-sized-self-generic-method.rs
@@ -11,7 +11,6 @@
 // Check that a trait is still object-safe (and usable) if it has
 // generic methods so long as they require `Self : Sized`.
 
-// pretty-expanded FIXME #23616
 
 trait Counter {
     fn tick(&mut self) -> u32;
diff --git a/src/test/run-pass/object-safety-sized-self-return-Self.rs b/src/test/run-pass/object-safety-sized-self-return-Self.rs
index 17c41f2194b69..eda541262bd94 100644
--- a/src/test/run-pass/object-safety-sized-self-return-Self.rs
+++ b/src/test/run-pass/object-safety-sized-self-return-Self.rs
@@ -11,7 +11,6 @@
 // Check that a trait is still object-safe (and usable) if it has
 // methods that return `Self` so long as they require `Self : Sized`.
 
-// pretty-expanded FIXME #23616
 
 trait Counter {
     fn new() -> Self where Self : Sized;
diff --git a/src/test/run-pass/objects-coerce-freeze-borrored.rs b/src/test/run-pass/objects-coerce-freeze-borrored.rs
index 686924a31400a..f907b5723f41b 100644
--- a/src/test/run-pass/objects-coerce-freeze-borrored.rs
+++ b/src/test/run-pass/objects-coerce-freeze-borrored.rs
@@ -10,7 +10,6 @@
 
 // Test that we can coerce an `@Object` to an `&Object`
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn foo(&self) -> usize;
diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
index 9a1cdd2922f7a..176f67fd3a18a 100644
--- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
+++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
@@ -12,7 +12,6 @@
 // closed over do not contain managed values, and thus the boxes do
 // not have headers.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/objects-owned-object-owned-method.rs b/src/test/run-pass/objects-owned-object-owned-method.rs
index 4357adbf65bfd..71ed995e76c82 100644
--- a/src/test/run-pass/objects-owned-object-owned-method.rs
+++ b/src/test/run-pass/objects-owned-object-owned-method.rs
@@ -12,7 +12,6 @@
 // closed over contain managed values. This implies that the boxes
 // will have headers that must be skipped over.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/once-move-out-on-heap.rs b/src/test/run-pass/once-move-out-on-heap.rs
index 7bf8b693d9bbf..6dd4c0ddce3c5 100644
--- a/src/test/run-pass/once-move-out-on-heap.rs
+++ b/src/test/run-pass/once-move-out-on-heap.rs
@@ -11,7 +11,6 @@
 // Testing guarantees provided by once functions.
 
 
-// pretty-expanded FIXME #23616
 
 use std::sync::Arc;
 
diff --git a/src/test/run-pass/one-tuple.rs b/src/test/run-pass/one-tuple.rs
index 6520e42dbe3f8..68974b47d06a9 100644
--- a/src/test/run-pass/one-tuple.rs
+++ b/src/test/run-pass/one-tuple.rs
@@ -10,7 +10,6 @@
 
 // Why one-tuples? Because macros.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     match ('c',) {
diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs
index ccfdb83ab8aa1..78834ef914d59 100644
--- a/src/test/run-pass/operator-associativity.rs
+++ b/src/test/run-pass/operator-associativity.rs
@@ -12,6 +12,5 @@
 
 
 // Testcase for issue #130, operator associativity.
-// pretty-expanded FIXME #23616
 
 pub fn main() { assert!((3 * 5 / 2 == 7)); }
diff --git a/src/test/run-pass/option-unwrap.rs b/src/test/run-pass/option-unwrap.rs
index 4902038667cd8..44f13a3eb1a52 100644
--- a/src/test/run-pass/option-unwrap.rs
+++ b/src/test/run-pass/option-unwrap.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs
index 3ab78e8d05344..3bb0c71c58115 100644
--- a/src/test/run-pass/or-pattern.rs
+++ b/src/test/run-pass/or-pattern.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum blah { a(isize, isize, usize), b(isize, isize), c, }
 
diff --git a/src/test/run-pass/order-drop-with-match.rs b/src/test/run-pass/order-drop-with-match.rs
index c8a2ba0af47cb..8f82e3aaba155 100644
--- a/src/test/run-pass/order-drop-with-match.rs
+++ b/src/test/run-pass/order-drop-with-match.rs
@@ -14,7 +14,6 @@
 // in ORDER matching up to when it ran.
 // Correct order is: matched, inner, outer
 
-// pretty-expanded FIXME #23616
 
 static mut ORDER: [usize; 3] = [0, 0, 0];
 static mut INDEX: usize = 0;
diff --git a/src/test/run-pass/out-pointer-aliasing.rs b/src/test/run-pass/out-pointer-aliasing.rs
index 0a58411041e64..790affd939f24 100644
--- a/src/test/run-pass/out-pointer-aliasing.rs
+++ b/src/test/run-pass/out-pointer-aliasing.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 pub struct Foo {
diff --git a/src/test/run-pass/overloaded-autoderef-indexing.rs b/src/test/run-pass/overloaded-autoderef-indexing.rs
index fdf42423b662b..67b8bc1d157ca 100644
--- a/src/test/run-pass/overloaded-autoderef-indexing.rs
+++ b/src/test/run-pass/overloaded-autoderef-indexing.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::ops::Deref;
 
diff --git a/src/test/run-pass/overloaded-autoderef-order.rs b/src/test/run-pass/overloaded-autoderef-order.rs
index 6880032e69f66..7433494dec677 100644
--- a/src/test/run-pass/overloaded-autoderef-order.rs
+++ b/src/test/run-pass/overloaded-autoderef-order.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::rc::Rc;
 use std::ops::Deref;
diff --git a/src/test/run-pass/overloaded-autoderef-vtable.rs b/src/test/run-pass/overloaded-autoderef-vtable.rs
index 38bf68b746946..ed11c8c0baecc 100644
--- a/src/test/run-pass/overloaded-autoderef-vtable.rs
+++ b/src/test/run-pass/overloaded-autoderef-vtable.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::ops::Deref;
 
diff --git a/src/test/run-pass/overloaded-autoderef-xcrate.rs b/src/test/run-pass/overloaded-autoderef-xcrate.rs
index b97fb49112484..174e09cb14c7a 100644
--- a/src/test/run-pass/overloaded-autoderef-xcrate.rs
+++ b/src/test/run-pass/overloaded-autoderef-xcrate.rs
@@ -10,7 +10,6 @@
 
 // aux-build:overloaded_autoderef_xc.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate overloaded_autoderef_xc;
 
diff --git a/src/test/run-pass/overloaded-calls-object-one-arg.rs b/src/test/run-pass/overloaded-calls-object-one-arg.rs
index 291d2c6498f99..ec64f627c9462 100644
--- a/src/test/run-pass/overloaded-calls-object-one-arg.rs
+++ b/src/test/run-pass/overloaded-calls-object-one-arg.rs
@@ -11,7 +11,6 @@
 // Tests calls to closure arguments where the closure takes 1 argument.
 // This is a bit tricky due to rust-call ABI.
 
-// pretty-expanded FIXME #23616
 
 fn foo(f: &mut FnMut(isize) -> isize) -> isize {
     f(22)
diff --git a/src/test/run-pass/overloaded-calls-object-two-args.rs b/src/test/run-pass/overloaded-calls-object-two-args.rs
index 42c71572a3a94..c38a62147a011 100644
--- a/src/test/run-pass/overloaded-calls-object-two-args.rs
+++ b/src/test/run-pass/overloaded-calls-object-two-args.rs
@@ -11,7 +11,6 @@
 // Tests calls to closure arguments where the closure takes 2 arguments.
 // This is a bit tricky due to rust-call ABI.
 
-// pretty-expanded FIXME #23616
 
 fn foo(f: &mut FnMut(isize, isize) -> isize) -> isize {
     f(1, 2)
diff --git a/src/test/run-pass/overloaded-calls-object-zero-args.rs b/src/test/run-pass/overloaded-calls-object-zero-args.rs
index 9bc6c9f042835..08ab465ebb04c 100644
--- a/src/test/run-pass/overloaded-calls-object-zero-args.rs
+++ b/src/test/run-pass/overloaded-calls-object-zero-args.rs
@@ -11,7 +11,6 @@
 // Tests calls to closure arguments where the closure takes 0 arguments.
 // This is a bit tricky due to rust-call ABI.
 
-// pretty-expanded FIXME #23616
 
 fn foo(f: &mut FnMut() -> isize) -> isize {
     f()
diff --git a/src/test/run-pass/overloaded-calls-simple.rs b/src/test/run-pass/overloaded-calls-simple.rs
index eeb705a2e3c99..6566f6c1260cd 100644
--- a/src/test/run-pass/overloaded-calls-simple.rs
+++ b/src/test/run-pass/overloaded-calls-simple.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(lang_items, unboxed_closures, core)]
 
diff --git a/src/test/run-pass/overloaded-calls-zero-args.rs b/src/test/run-pass/overloaded-calls-zero-args.rs
index 8df4adf6713c4..621b2f9420938 100644
--- a/src/test/run-pass/overloaded-calls-zero-args.rs
+++ b/src/test/run-pass/overloaded-calls-zero-args.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures, core)]
 
diff --git a/src/test/run-pass/overloaded-deref-count.rs b/src/test/run-pass/overloaded-deref-count.rs
index 5f6eb87ae1be4..a8a3b3014e099 100644
--- a/src/test/run-pass/overloaded-deref-count.rs
+++ b/src/test/run-pass/overloaded-deref-count.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::cell::Cell;
 use std::ops::{Deref, DerefMut};
diff --git a/src/test/run-pass/overloaded-index-assoc-list.rs b/src/test/run-pass/overloaded-index-assoc-list.rs
index d98b1d9deae62..455099f1eba8f 100644
--- a/src/test/run-pass/overloaded-index-assoc-list.rs
+++ b/src/test/run-pass/overloaded-index-assoc-list.rs
@@ -11,7 +11,6 @@
 // Test overloading of the `[]` operator.  In particular test that it
 // takes its argument *by reference*.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/overloaded-index-autoderef.rs b/src/test/run-pass/overloaded-index-autoderef.rs
index 56d71edd56cd0..efa0051493414 100644
--- a/src/test/run-pass/overloaded-index-autoderef.rs
+++ b/src/test/run-pass/overloaded-index-autoderef.rs
@@ -10,7 +10,6 @@
 
 // Test overloaded indexing combined with autoderef.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax, core)]
diff --git a/src/test/run-pass/overloaded-index-in-field.rs b/src/test/run-pass/overloaded-index-in-field.rs
index bc53836aca3ef..ff867e76810a6 100644
--- a/src/test/run-pass/overloaded-index-in-field.rs
+++ b/src/test/run-pass/overloaded-index-in-field.rs
@@ -11,7 +11,6 @@
 // Test using overloaded indexing when the "map" is stored in a
 // field. This caused problems at some point.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/overloaded-index.rs b/src/test/run-pass/overloaded-index.rs
index 4f8cf0e9e38ef..fa3c107697e67 100644
--- a/src/test/run-pass/overloaded-index.rs
+++ b/src/test/run-pass/overloaded-index.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/packed-struct-borrow-element.rs b/src/test/run-pass/packed-struct-borrow-element.rs
index 8819b20136105..4886874062178 100644
--- a/src/test/run-pass/packed-struct-borrow-element.rs
+++ b/src/test/run-pass/packed-struct-borrow-element.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[repr(packed)]
 struct Foo {
diff --git a/src/test/run-pass/packed-struct-generic-layout.rs b/src/test/run-pass/packed-struct-generic-layout.rs
index 5d518749d9aef..e03772ddf9ff7 100644
--- a/src/test/run-pass/packed-struct-generic-layout.rs
+++ b/src/test/run-pass/packed-struct-generic-layout.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/packed-struct-generic-size.rs b/src/test/run-pass/packed-struct-generic-size.rs
index 6c24b71971e38..4e1f62b28ab91 100644
--- a/src/test/run-pass/packed-struct-generic-size.rs
+++ b/src/test/run-pass/packed-struct-generic-size.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/packed-struct-layout.rs b/src/test/run-pass/packed-struct-layout.rs
index 5d2454be2fbd5..2ac07a5d7eafc 100644
--- a/src/test/run-pass/packed-struct-layout.rs
+++ b/src/test/run-pass/packed-struct-layout.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/packed-struct-match.rs b/src/test/run-pass/packed-struct-match.rs
index 3c3d632222e19..3cd254014c181 100644
--- a/src/test/run-pass/packed-struct-match.rs
+++ b/src/test/run-pass/packed-struct-match.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[repr(packed)]
 struct Foo {
diff --git a/src/test/run-pass/packed-struct-size-xc.rs b/src/test/run-pass/packed-struct-size-xc.rs
index b7ea720caf76d..372693433db6f 100644
--- a/src/test/run-pass/packed-struct-size-xc.rs
+++ b/src/test/run-pass/packed-struct-size-xc.rs
@@ -10,7 +10,6 @@
 
 // aux-build:packed.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate packed;
 
diff --git a/src/test/run-pass/packed-struct-size.rs b/src/test/run-pass/packed-struct-size.rs
index 3d748c404228b..754a357333979 100644
--- a/src/test/run-pass/packed-struct-size.rs
+++ b/src/test/run-pass/packed-struct-size.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/packed-tuple-struct-layout.rs b/src/test/run-pass/packed-tuple-struct-layout.rs
index 9d96adc29dd36..376aadc735b60 100644
--- a/src/test/run-pass/packed-tuple-struct-layout.rs
+++ b/src/test/run-pass/packed-tuple-struct-layout.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/packed-tuple-struct-size.rs b/src/test/run-pass/packed-tuple-struct-size.rs
index 7b7cd5929883d..b0c8684cfe3e5 100644
--- a/src/test/run-pass/packed-tuple-struct-size.rs
+++ b/src/test/run-pass/packed-tuple-struct-size.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/panic-in-dtor-drops-fields.rs b/src/test/run-pass/panic-in-dtor-drops-fields.rs
index 4226fba9d3e37..f84a823d3db22 100644
--- a/src/test/run-pass/panic-in-dtor-drops-fields.rs
+++ b/src/test/run-pass/panic-in-dtor-drops-fields.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::thread;
 
diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs
index 1ab578b933257..59ead3e3e989b 100644
--- a/src/test/run-pass/pattern-bound-var-in-for-each.rs
+++ b/src/test/run-pass/pattern-bound-var-in-for-each.rs
@@ -12,7 +12,6 @@
 // pattern-bound var is an upvar (when translating
 // the for-each body)
 
-// pretty-expanded FIXME #23616
 
 fn foo(src: usize) {
 
diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs
index d32ac4b90821f..8c92a05ba2a67 100644
--- a/src/test/run-pass/private-class-field.rs
+++ b/src/test/run-pass/private-class-field.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct cat {
     meows : usize,
diff --git a/src/test/run-pass/process-remove-from-env.rs b/src/test/run-pass/process-remove-from-env.rs
index 6429352f44918..c6adda6067936 100644
--- a/src/test/run-pass/process-remove-from-env.rs
+++ b/src/test/run-pass/process-remove-from-env.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(old_io)]
 
diff --git a/src/test/run-pass/range-type-infer.rs b/src/test/run-pass/range-type-infer.rs
index 2d664c00ed527..b6d4d09d69727 100644
--- a/src/test/run-pass/range-type-infer.rs
+++ b/src/test/run-pass/range-type-infer.rs
@@ -12,7 +12,6 @@
 // good as the old one. Check out issue #21672, #21595 and #21649 for
 // more details.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let xs = (0..8).map(|i| i == 1u64).collect::<Vec<_>>();
diff --git a/src/test/run-pass/range.rs b/src/test/run-pass/range.rs
index 4633f73b9a007..03a8af319e819 100644
--- a/src/test/run-pass/range.rs
+++ b/src/test/run-pass/range.rs
@@ -10,7 +10,6 @@
 
 // Test range syntax.
 
-// pretty-expanded FIXME #23616
 
 fn foo() -> isize { 42 }
 
diff --git a/src/test/run-pass/ranges-precedence.rs b/src/test/run-pass/ranges-precedence.rs
index 870d7a0bc0873..807e23c81cf4f 100644
--- a/src/test/run-pass/ranges-precedence.rs
+++ b/src/test/run-pass/ranges-precedence.rs
@@ -11,7 +11,6 @@
 // Test that the precedence of ranges is correct
 
 
-// pretty-expanded FIXME #23616
 
 struct Foo {
     foo: usize,
diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs
index d3b9e56f7d079..29e45ce8a9ad5 100644
--- a/src/test/run-pass/readalias.rs
+++ b/src/test/run-pass/readalias.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 struct Point {x: isize, y: isize, z: isize}
 
diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs
index 1071df84cd2bb..ffef77a4b8de4 100644
--- a/src/test/run-pass/rec-extend.rs
+++ b/src/test/run-pass/rec-extend.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 struct Point {x: isize, y: isize}
 
diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs
index 1644a1694269a..810888b0d8e78 100644
--- a/src/test/run-pass/rec-tup.rs
+++ b/src/test/run-pass/rec-tup.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 struct Point {x: isize, y: isize}
diff --git a/src/test/run-pass/rec.rs b/src/test/run-pass/rec.rs
index a422aaba84b30..b47bda0931fed 100644
--- a/src/test/run-pass/rec.rs
+++ b/src/test/run-pass/rec.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 struct Rect {x: isize, y: isize, w: isize, h: isize}
diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs
index 6b39cc196f1e6..99bec7ab7d1fb 100644
--- a/src/test/run-pass/record-pat.rs
+++ b/src/test/run-pass/record-pat.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum t1 { a(isize), b(usize), }
 struct T2 {x: t1, y: isize}
diff --git a/src/test/run-pass/reexported-static-methods-cross-crate.rs b/src/test/run-pass/reexported-static-methods-cross-crate.rs
index 3efd913cf543c..4d10503838446 100644
--- a/src/test/run-pass/reexported-static-methods-cross-crate.rs
+++ b/src/test/run-pass/reexported-static-methods-cross-crate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:reexported_static_methods.rs
-// pretty-expanded FIXME #23616
 
 extern crate reexported_static_methods;
 
diff --git a/src/test/run-pass/regions-borrow-evec-fixed.rs b/src/test/run-pass/regions-borrow-evec-fixed.rs
index 7f3db86783060..6d1f2930abf32 100644
--- a/src/test/run-pass/regions-borrow-evec-fixed.rs
+++ b/src/test/run-pass/regions-borrow-evec-fixed.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn foo(x: &[isize]) -> isize {
     x[0]
diff --git a/src/test/run-pass/regions-borrow-evec-uniq.rs b/src/test/run-pass/regions-borrow-evec-uniq.rs
index adf88037d2841..ec1f4eda28cc5 100644
--- a/src/test/run-pass/regions-borrow-evec-uniq.rs
+++ b/src/test/run-pass/regions-borrow-evec-uniq.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn foo(x: &[isize]) -> isize {
     x[0]
diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs
index 01a4e9c20ca5b..2a08940dab6ed 100644
--- a/src/test/run-pass/regions-borrow-uniq.rs
+++ b/src/test/run-pass/regions-borrow-uniq.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/regions-bot.rs b/src/test/run-pass/regions-bot.rs
index 269e30741f47a..4347cbe2dc9c2 100644
--- a/src/test/run-pass/regions-bot.rs
+++ b/src/test/run-pass/regions-bot.rs
@@ -10,7 +10,6 @@
 
 // A very limited test of the "bottom" region
 
-// pretty-expanded FIXME #23616
 
 fn produce_static<T>() -> &'static T { panic!(); }
 
diff --git a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs
index cc417219ee3df..d048633519ae1 100644
--- a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs
+++ b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs
@@ -11,7 +11,6 @@
 // A test where we (successfully) close over a reference into
 // an object.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs
index 9e3fe79197d5d..3c01a7f8923e8 100644
--- a/src/test/run-pass/regions-copy-closure.rs
+++ b/src/test/run-pass/regions-copy-closure.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(unboxed_closures, core)]
diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs
index 123806a4d9d17..a6a179c432c3c 100644
--- a/src/test/run-pass/regions-dependent-addr-of.rs
+++ b/src/test/run-pass/regions-dependent-addr-of.rs
@@ -11,7 +11,6 @@
 // Test lifetimes are linked properly when we create dependent region pointers.
 // Issue #3148.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_patterns)]
diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs
index 738f5dbb7b9ad..33889b27a872b 100644
--- a/src/test/run-pass/regions-early-bound-trait-param.rs
+++ b/src/test/run-pass/regions-early-bound-trait-param.rs
@@ -11,7 +11,6 @@
 // Tests that you can use an early-bound lifetime parameter as
 // on of the generic parameters in a trait.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/regions-early-bound-used-in-bound-method.rs b/src/test/run-pass/regions-early-bound-used-in-bound-method.rs
index 6ad8995123889..c7bc8dc0a515b 100644
--- a/src/test/run-pass/regions-early-bound-used-in-bound-method.rs
+++ b/src/test/run-pass/regions-early-bound-used-in-bound-method.rs
@@ -11,7 +11,6 @@
 // Tests that you can use a fn lifetime parameter as part of
 // the value for a type parameter in a bound.
 
-// pretty-expanded FIXME #23616
 
 trait GetRef<'a> {
     fn get(&self) -> &'a isize;
diff --git a/src/test/run-pass/regions-early-bound-used-in-bound.rs b/src/test/run-pass/regions-early-bound-used-in-bound.rs
index 6ab95d6e497bc..3c8c78aa1169a 100644
--- a/src/test/run-pass/regions-early-bound-used-in-bound.rs
+++ b/src/test/run-pass/regions-early-bound-used-in-bound.rs
@@ -11,7 +11,6 @@
 // Tests that you can use a fn lifetime parameter as part of
 // the value for a type parameter in a bound.
 
-// pretty-expanded FIXME #23616
 
 trait GetRef<'a, T> {
     fn get(&self) -> &'a T;
diff --git a/src/test/run-pass/regions-early-bound-used-in-type-param.rs b/src/test/run-pass/regions-early-bound-used-in-type-param.rs
index dc991e9493fe4..8d145fad004a6 100644
--- a/src/test/run-pass/regions-early-bound-used-in-type-param.rs
+++ b/src/test/run-pass/regions-early-bound-used-in-type-param.rs
@@ -11,7 +11,6 @@
 // Tests that you can use a fn lifetime parameter as part of
 // the value for a type parameter in a bound.
 
-// pretty-expanded FIXME #23616
 
 trait Get<T> {
     fn get(&self) -> T;
diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs
index 3e2fec717f997..597333482fde3 100644
--- a/src/test/run-pass/regions-escape-into-other-fn.rs
+++ b/src/test/run-pass/regions-escape-into-other-fn.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs
index 5d171811732a1..5c80863ce859d 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::swap;
 
diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs
index 9c200a370ad85..f9ba8e82ef715 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-view.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn view<T>(x: &[T]) -> &[T] {x}
 
diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
index 59221afcefffe..a89f6f4a7b56b 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs
index 3289da3cfd87e..01f4163731145 100644
--- a/src/test/run-pass/regions-infer-borrow-scope.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/regions-infer-call-2.rs b/src/test/run-pass/regions-infer-call-2.rs
index 7e6767b0de422..b994bc7b85553 100644
--- a/src/test/run-pass/regions-infer-call-2.rs
+++ b/src/test/run-pass/regions-infer-call-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn takes_two(x: &isize, y: &isize) -> isize { *x + *y }
 
diff --git a/src/test/run-pass/regions-infer-call.rs b/src/test/run-pass/regions-infer-call.rs
index bc752a1d504e3..76b93f2356b06 100644
--- a/src/test/run-pass/regions-infer-call.rs
+++ b/src/test/run-pass/regions-infer-call.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn takes_two(x: &isize, y: &isize) -> isize { *x + *y }
 
diff --git a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs
index 73cfbcddd9aa7..3c6bc13399960 100644
--- a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs
+++ b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct boxed_int<'a> {
     f: &'a isize,
diff --git a/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs b/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs
index 451c745358ae6..d1c1ec43b40f0 100644
--- a/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs
+++ b/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs
@@ -11,7 +11,6 @@
 // This test verifies that temporary lifetime is correctly computed
 // for static objects in enclosing scopes.
 
-// pretty-expanded FIXME #23616
 
 use std::cmp::PartialEq;
 
diff --git a/src/test/run-pass/regions-no-variance-from-fn-generics.rs b/src/test/run-pass/regions-no-variance-from-fn-generics.rs
index 89bdbfaed9e0a..d385804da5790 100644
--- a/src/test/run-pass/regions-no-variance-from-fn-generics.rs
+++ b/src/test/run-pass/regions-no-variance-from-fn-generics.rs
@@ -12,7 +12,6 @@
 // should not upset the variance inference for actual occurrences of
 // that lifetime in type expressions.
 
-// pretty-expanded FIXME #23616
 
 pub trait HasLife<'a> {
     fn dummy(&'a self) { } // just to induce a variance on 'a
diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs
index 5002fcce96b96..dbd52bd6b60ed 100644
--- a/src/test/run-pass/regions-params.rs
+++ b/src/test/run-pass/regions-params.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn region_identity(x: &usize) -> &usize { x }
 
diff --git a/src/test/run-pass/regions-refcell.rs b/src/test/run-pass/regions-refcell.rs
index 63525b36206a4..ca6a62c10c26b 100644
--- a/src/test/run-pass/regions-refcell.rs
+++ b/src/test/run-pass/regions-refcell.rs
@@ -12,7 +12,6 @@
 // attempting to bootstrap librustc with new destructor lifetime
 // semantics.
 
-// pretty-expanded FIXME #23616
 
 use std::collections::HashMap;
 use std::cell::RefCell;
diff --git a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
index a36c1b30ead0b..465f43e36b94f 100644
--- a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
+++ b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
@@ -17,7 +17,6 @@
 // changes were caught. However, those uses in the compiler could
 // easily get changed or refactored away in the future.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/regions-return-interior-of-option.rs b/src/test/run-pass/regions-return-interior-of-option.rs
index e6ab4a81426c2..fe1c68ff4281a 100644
--- a/src/test/run-pass/regions-return-interior-of-option.rs
+++ b/src/test/run-pass/regions-return-interior-of-option.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn get<T>(opt: &Option<T>) -> &T {
     match *opt {
diff --git a/src/test/run-pass/regions-trait-object-1.rs b/src/test/run-pass/regions-trait-object-1.rs
index d235298857939..542dc76061fef 100644
--- a/src/test/run-pass/regions-trait-object-1.rs
+++ b/src/test/run-pass/regions-trait-object-1.rs
@@ -12,7 +12,6 @@
 // attempting to bootstrap libsyntax; it is adapted from
 // `syntax::ext::tt::generic_extension`.
 
-// pretty-expanded FIXME #23616
 
 pub struct E<'a> {
     pub f: &'a u8,
diff --git a/src/test/run-pass/repeat-expr-in-static.rs b/src/test/run-pass/repeat-expr-in-static.rs
index 5a4475ae947b6..a040d680f9da8 100644
--- a/src/test/run-pass/repeat-expr-in-static.rs
+++ b/src/test/run-pass/repeat-expr-in-static.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 static FOO: [isize; 4] = [32; 4];
 static BAR: [isize; 4] = [32, 32, 32, 32];
diff --git a/src/test/run-pass/resolve-issue-2428.rs b/src/test/run-pass/resolve-issue-2428.rs
index bad5b83b5484c..d3bdd54624239 100644
--- a/src/test/run-pass/resolve-issue-2428.rs
+++ b/src/test/run-pass/resolve-issue-2428.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 const foo: isize = 4 >> 1;
 enum bs { thing = foo }
diff --git a/src/test/run-pass/resource-in-struct.rs b/src/test/run-pass/resource-in-struct.rs
index a8426f90cc489..c1e1ff0658b6e 100644
--- a/src/test/run-pass/resource-in-struct.rs
+++ b/src/test/run-pass/resource-in-struct.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/return-from-closure.rs b/src/test/run-pass/return-from-closure.rs
index 4395f6fcb4b7c..76eddd05382fc 100644
--- a/src/test/run-pass/return-from-closure.rs
+++ b/src/test/run-pass/return-from-closure.rs
@@ -10,7 +10,6 @@
 
 // just to make sure that `return` is only returning from the closure,
 // not the surrounding function.
-// pretty-expanded FIXME #23616
 
 static mut calls: usize = 0;
 
diff --git a/src/test/run-pass/segfault-no-out-of-stack.rs b/src/test/run-pass/segfault-no-out-of-stack.rs
index 6eb9600cf8b53..385c5326c978e 100644
--- a/src/test/run-pass/segfault-no-out-of-stack.rs
+++ b/src/test/run-pass/segfault-no-out-of-stack.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(old_io)]
 
diff --git a/src/test/run-pass/self-in-mut-slot-default-method.rs b/src/test/run-pass/self-in-mut-slot-default-method.rs
index f8502137be129..877988e60a946 100644
--- a/src/test/run-pass/self-in-mut-slot-default-method.rs
+++ b/src/test/run-pass/self-in-mut-slot-default-method.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/self-in-mut-slot-immediate-value.rs b/src/test/run-pass/self-in-mut-slot-immediate-value.rs
index fa9ad9f6517a6..24014c289f919 100644
--- a/src/test/run-pass/self-in-mut-slot-immediate-value.rs
+++ b/src/test/run-pass/self-in-mut-slot-immediate-value.rs
@@ -11,7 +11,6 @@
 // Assert that `mut self` on an immediate value doesn't
 // allow mutating the original - issue #10615.
 
-// pretty-expanded FIXME #23616
 
 #[derive(Copy, Clone)]
 struct Value {
diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs
index b3c81cab3c1ce..7314a65b60c0a 100644
--- a/src/test/run-pass/self-re-assign.rs
+++ b/src/test/run-pass/self-re-assign.rs
@@ -11,7 +11,6 @@
 // Ensure assigning an owned or managed variable to itself works. In particular,
 // that we do not glue_drop before we glue_take (#3290).
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/self-shadowing-import.rs b/src/test/run-pass/self-shadowing-import.rs
index 5de1686ef9d8d..cd47a0e86bda4 100644
--- a/src/test/run-pass/self-shadowing-import.rs
+++ b/src/test/run-pass/self-shadowing-import.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod a {
     pub mod b {
diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs
index 16a695f08fe6e..2501ef94bea82 100644
--- a/src/test/run-pass/send_str_hashmap.rs
+++ b/src/test/run-pass/send_str_hashmap.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections, into_cow)]
 
diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs
index d56657ee4d517..146f5253508c6 100644
--- a/src/test/run-pass/send_str_treemap.rs
+++ b/src/test/run-pass/send_str_treemap.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections, into_cow)]
 
diff --git a/src/test/run-pass/sendfn-is-a-block.rs b/src/test/run-pass/sendfn-is-a-block.rs
index 59b92ec6a48da..162b05f0bb3f5 100644
--- a/src/test/run-pass/sendfn-is-a-block.rs
+++ b/src/test/run-pass/sendfn-is-a-block.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 fn test<F>(f: F) -> usize where F: FnOnce(usize) -> usize {
     return f(22);
diff --git a/src/test/run-pass/sepcomp-cci.rs b/src/test/run-pass/sepcomp-cci.rs
index a4d74dbd55ae1..a1c5ad113c76d 100644
--- a/src/test/run-pass/sepcomp-cci.rs
+++ b/src/test/run-pass/sepcomp-cci.rs
@@ -14,7 +14,6 @@
 
 // Test accessing cross-crate inlined items from multiple compilation units.
 
-// pretty-expanded FIXME #23616
 
 extern crate sepcomp_cci_lib;
 use sepcomp_cci_lib::{cci_fn, CCI_STATIC};
diff --git a/src/test/run-pass/sepcomp-extern.rs b/src/test/run-pass/sepcomp-extern.rs
index 3ec27466f4ced..973c61712c3ed 100644
--- a/src/test/run-pass/sepcomp-extern.rs
+++ b/src/test/run-pass/sepcomp-extern.rs
@@ -14,7 +14,6 @@
 
 // Test accessing external items from multiple compilation units.
 
-// pretty-expanded FIXME #23616
 
 #[link(name = "sepcomp_extern_lib")]
 extern {
diff --git a/src/test/run-pass/sepcomp-fns-backwards.rs b/src/test/run-pass/sepcomp-fns-backwards.rs
index cd101bb20642f..1ab8bc7f88c53 100644
--- a/src/test/run-pass/sepcomp-fns-backwards.rs
+++ b/src/test/run-pass/sepcomp-fns-backwards.rs
@@ -16,7 +16,6 @@
 // Generate some code in the first compilation unit before declaring any
 // modules.  This ensures that the first module doesn't go into the same
 // compilation unit as the top-level module.
-// pretty-expanded FIXME #23616
 
 fn pad() -> usize { 0 }
 
diff --git a/src/test/run-pass/sepcomp-fns.rs b/src/test/run-pass/sepcomp-fns.rs
index b76c24bfc18b5..a2356cf02a11f 100644
--- a/src/test/run-pass/sepcomp-fns.rs
+++ b/src/test/run-pass/sepcomp-fns.rs
@@ -18,7 +18,6 @@
 // Generate some code in the first compilation unit before declaring any
 // modules.  This ensures that the first module doesn't go into the same
 // compilation unit as the top-level module.
-// pretty-expanded FIXME #23616
 
 fn one() -> usize { 1 }
 
diff --git a/src/test/run-pass/sepcomp-lib.rs b/src/test/run-pass/sepcomp-lib.rs
index 00e83a570579d..abe842a332d8f 100644
--- a/src/test/run-pass/sepcomp-lib.rs
+++ b/src/test/run-pass/sepcomp-lib.rs
@@ -12,7 +12,6 @@
 
 // Test linking against a library built with -C codegen-units > 1
 
-// pretty-expanded FIXME #23616
 
 extern crate sepcomp_lib;
 use sepcomp_lib::a::one;
diff --git a/src/test/run-pass/sepcomp-statics.rs b/src/test/run-pass/sepcomp-statics.rs
index f10f25a58bf7e..8cda469a88bf5 100644
--- a/src/test/run-pass/sepcomp-statics.rs
+++ b/src/test/run-pass/sepcomp-statics.rs
@@ -13,7 +13,6 @@
 
 // Test references to static items across compilation units.
 
-// pretty-expanded FIXME #23616
 
 fn pad() -> usize { 0 }
 
diff --git a/src/test/run-pass/sepcomp-unwind.rs b/src/test/run-pass/sepcomp-unwind.rs
index 9663679d09a7e..766e2b6b7228f 100644
--- a/src/test/run-pass/sepcomp-unwind.rs
+++ b/src/test/run-pass/sepcomp-unwind.rs
@@ -20,7 +20,6 @@
 // In any case, this test should let us know if enabling parallel codegen ever
 // breaks unwinding.
 
-// pretty-expanded FIXME #23616
 
 use std::thread;
 
diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs
index 743f54abcfa66..f1a21d90ab2dc 100644
--- a/src/test/run-pass/seq-compare.rs
+++ b/src/test/run-pass/seq-compare.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert!(("hello".to_string() < "hellr".to_string()));
diff --git a/src/test/run-pass/shift-various-types.rs b/src/test/run-pass/shift-various-types.rs
index b0ab72c650d74..9238112a0818f 100644
--- a/src/test/run-pass/shift-various-types.rs
+++ b/src/test/run-pass/shift-various-types.rs
@@ -10,7 +10,6 @@
 
 // Test that we can do shifts by any integral type.
 
-// pretty-expanded FIXME #23616
 
 struct Panolpy {
     i8: i8,
diff --git a/src/test/run-pass/shift.rs b/src/test/run-pass/shift.rs
index f1637fe1e0931..2f417e0e2f4e8 100644
--- a/src/test/run-pass/shift.rs
+++ b/src/test/run-pass/shift.rs
@@ -11,7 +11,6 @@
 // Testing shifts for various combinations of integers
 // Issue #1570
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     test_misc();
diff --git a/src/test/run-pass/signed-shift-const-eval.rs b/src/test/run-pass/signed-shift-const-eval.rs
index 7167236438088..9ea2dedcba17d 100644
--- a/src/test/run-pass/signed-shift-const-eval.rs
+++ b/src/test/run-pass/signed-shift-const-eval.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum test { thing = -5 >> 1_usize }
 pub fn main() {
diff --git a/src/test/run-pass/sigpipe-should-be-ignored.rs b/src/test/run-pass/sigpipe-should-be-ignored.rs
index 4a05b487ae24e..7734a2e80c3c4 100644
--- a/src/test/run-pass/sigpipe-should-be-ignored.rs
+++ b/src/test/run-pass/sigpipe-should-be-ignored.rs
@@ -12,7 +12,6 @@
 // doesn't die in a ball of fire, but rather it's gracefully handled.
 
 // ignore-aarch64
-// pretty-expanded FIXME #23616
 
 use std::env;
 use std::io::prelude::*;
diff --git a/src/test/run-pass/simd-binop.rs b/src/test/run-pass/simd-binop.rs
index 9f7b78e4e3354..3ebf2a87361f6 100644
--- a/src/test/run-pass/simd-binop.rs
+++ b/src/test/run-pass/simd-binop.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/simd-generics.rs b/src/test/run-pass/simd-generics.rs
index 867f028a3fb3c..0e3d6b83a4be6 100644
--- a/src/test/run-pass/simd-generics.rs
+++ b/src/test/run-pass/simd-generics.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 #![feature(simd)]
 
diff --git a/src/test/run-pass/simd-size-align.rs b/src/test/run-pass/simd-size-align.rs
index 8324efc641727..025b2a77375e8 100644
--- a/src/test/run-pass/simd-size-align.rs
+++ b/src/test/run-pass/simd-size-align.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(simd)]
 #![allow(non_camel_case_types)]
diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs
index 7f34b94ad04b0..4762470a74735 100644
--- a/src/test/run-pass/slice-2.rs
+++ b/src/test/run-pass/slice-2.rs
@@ -10,7 +10,6 @@
 
 // Test slicing expressions on slices and Vecs.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let x: &[isize] = &[1, 2, 3, 4, 5];
diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs
index a4f737f74619c..854b03f917866 100644
--- a/src/test/run-pass/slice-panic-1.rs
+++ b/src/test/run-pass/slice-panic-1.rs
@@ -10,7 +10,6 @@
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
-// pretty-expanded FIXME #23616
 
 use std::thread;
 
diff --git a/src/test/run-pass/slice-panic-2.rs b/src/test/run-pass/slice-panic-2.rs
index f02a84b9070bf..42a19342884b0 100644
--- a/src/test/run-pass/slice-panic-2.rs
+++ b/src/test/run-pass/slice-panic-2.rs
@@ -10,7 +10,6 @@
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
-// pretty-expanded FIXME #23616
 
 use std::thread;
 
diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs
index edc5f6b184624..60160bd668fa6 100644
--- a/src/test/run-pass/slice.rs
+++ b/src/test/run-pass/slice.rs
@@ -10,7 +10,6 @@
 
 // Test slicing sugar.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/small-enum-range-edge.rs b/src/test/run-pass/small-enum-range-edge.rs
index 9515da6fcbc8d..56abdf6e20a72 100644
--- a/src/test/run-pass/small-enum-range-edge.rs
+++ b/src/test/run-pass/small-enum-range-edge.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 // this is for the wrapping_add call below.
 #![feature(core)]
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index aab292a940afb..ae4fabd34d629 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 /*
   Make sure we can spawn tasks that take different types of
diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs
index f93600195dc25..5ffceb2c6a8bc 100644
--- a/src/test/run-pass/stable-addr-of.rs
+++ b/src/test/run-pass/stable-addr-of.rs
@@ -10,7 +10,6 @@
 
 // Issue #2040
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let foo: isize = 1;
diff --git a/src/test/run-pass/static-function-pointer-xc.rs b/src/test/run-pass/static-function-pointer-xc.rs
index 55f3b0883b9d9..a09928bd2208f 100644
--- a/src/test/run-pass/static-function-pointer-xc.rs
+++ b/src/test/run-pass/static-function-pointer-xc.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:static-function-pointer-aux.rs
-// pretty-expanded FIXME #23616
 
 extern crate static_function_pointer_aux as aux;
 
diff --git a/src/test/run-pass/static-function-pointer.rs b/src/test/run-pass/static-function-pointer.rs
index 67cc033f7cf75..be297524309d2 100644
--- a/src/test/run-pass/static-function-pointer.rs
+++ b/src/test/run-pass/static-function-pointer.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn f(x: isize) -> isize { x }
 fn g(x: isize) -> isize { 2 * x }
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index aff2797c1acce..84bb1b871b97e 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub trait plus {
     fn plus(&self) -> isize;
diff --git a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs
index 4ccb044bbd2ca..c2b3a9a72283b 100644
--- a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs
+++ b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Deserializer {
     fn read_int(&self) -> isize;
diff --git a/src/test/run-pass/static-method-xcrate.rs b/src/test/run-pass/static-method-xcrate.rs
index d0b69b430a692..57609cec9f2b0 100644
--- a/src/test/run-pass/static-method-xcrate.rs
+++ b/src/test/run-pass/static-method-xcrate.rs
@@ -10,7 +10,6 @@
 
 // aux-build:static-methods-crate.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate static_methods_crate;
 
diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs
index cb23feb05a59d..3fd3bbe936fff 100644
--- a/src/test/run-pass/static-methods-in-traits.rs
+++ b/src/test/run-pass/static-methods-in-traits.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod a {
     pub trait Foo {
diff --git a/src/test/run-pass/static-mut-foreign.rs b/src/test/run-pass/static-mut-foreign.rs
index c6b919c9738d4..b916a1ae2be7d 100644
--- a/src/test/run-pass/static-mut-foreign.rs
+++ b/src/test/run-pass/static-mut-foreign.rs
@@ -12,7 +12,6 @@
 // statics cannot. This ensures that there's some form of error if this is
 // attempted.
 
-// pretty-expanded FIXME #23616
 
 #![feature(libc)]
 
diff --git a/src/test/run-pass/static-mut-xc.rs b/src/test/run-pass/static-mut-xc.rs
index 0456d17bdc4b4..c819db9454796 100644
--- a/src/test/run-pass/static-mut-xc.rs
+++ b/src/test/run-pass/static-mut-xc.rs
@@ -14,7 +14,6 @@
 
 // aux-build:static_mut_xc.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate static_mut_xc;
 
diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs
index 0d0d56fcafb0b..94e14290498b8 100644
--- a/src/test/run-pass/str-multiline.rs
+++ b/src/test/run-pass/str-multiline.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let a: String = "this \
diff --git a/src/test/run-pass/string-escapes.rs b/src/test/run-pass/string-escapes.rs
index e0fc1c4ce46a7..1d13e531004c8 100644
--- a/src/test/run-pass/string-escapes.rs
+++ b/src/test/run-pass/string-escapes.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let x = "\\\\\
diff --git a/src/test/run-pass/struct-aliases-xcrate.rs b/src/test/run-pass/struct-aliases-xcrate.rs
index 17cb8acea6fad..2ca9d599d84a0 100644
--- a/src/test/run-pass/struct-aliases-xcrate.rs
+++ b/src/test/run-pass/struct-aliases-xcrate.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:xcrate_struct_aliases.rs
-// pretty-expanded FIXME #23616
 
 extern crate xcrate_struct_aliases;
 
diff --git a/src/test/run-pass/struct-aliases.rs b/src/test/run-pass/struct-aliases.rs
index 79e7960cfb27c..7107243d760a4 100644
--- a/src/test/run-pass/struct-aliases.rs
+++ b/src/test/run-pass/struct-aliases.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct S {
     x: isize,
diff --git a/src/test/run-pass/struct-destructuring-cross-crate.rs b/src/test/run-pass/struct-destructuring-cross-crate.rs
index 5fed712bd663a..63e8d694ddb56 100644
--- a/src/test/run-pass/struct-destructuring-cross-crate.rs
+++ b/src/test/run-pass/struct-destructuring-cross-crate.rs
@@ -10,7 +10,6 @@
 
 // aux-build:struct_destructuring_cross_crate.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate struct_destructuring_cross_crate;
 
diff --git a/src/test/run-pass/struct-like-variant-match.rs b/src/test/run-pass/struct-like-variant-match.rs
index f072d315d72bf..175090eadd982 100644
--- a/src/test/run-pass/struct-like-variant-match.rs
+++ b/src/test/run-pass/struct-like-variant-match.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum Foo {
     Bar {
diff --git a/src/test/run-pass/struct-new-as-field-name.rs b/src/test/run-pass/struct-new-as-field-name.rs
index 73f27448f81a4..7fb3a64e02b88 100644
--- a/src/test/run-pass/struct-new-as-field-name.rs
+++ b/src/test/run-pass/struct-new-as-field-name.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Foo {
     new: isize,
diff --git a/src/test/run-pass/struct-order-of-eval-1.rs b/src/test/run-pass/struct-order-of-eval-1.rs
index 49ec695a1228b..b5e4011bbea58 100644
--- a/src/test/run-pass/struct-order-of-eval-1.rs
+++ b/src/test/run-pass/struct-order-of-eval-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct S { f0: String, f1: isize }
 
diff --git a/src/test/run-pass/struct-order-of-eval-2.rs b/src/test/run-pass/struct-order-of-eval-2.rs
index 45755608ff56a..7ec28f597edbe 100644
--- a/src/test/run-pass/struct-order-of-eval-2.rs
+++ b/src/test/run-pass/struct-order-of-eval-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct S {
     f0: String,
diff --git a/src/test/run-pass/struct-order-of-eval-3.rs b/src/test/run-pass/struct-order-of-eval-3.rs
index 37b6de8e17ef1..60f9c4465a01c 100644
--- a/src/test/run-pass/struct-order-of-eval-3.rs
+++ b/src/test/run-pass/struct-order-of-eval-3.rs
@@ -11,7 +11,6 @@
 // Checks that functional-record-update order-of-eval is as expected
 // even when no Drop-implementations are involved.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::atomic::{Ordering, AtomicUsize, ATOMIC_USIZE_INIT};
 
diff --git a/src/test/run-pass/struct-order-of-eval-4.rs b/src/test/run-pass/struct-order-of-eval-4.rs
index 1b53895f7d1a7..23a7e1ea71b8b 100644
--- a/src/test/run-pass/struct-order-of-eval-4.rs
+++ b/src/test/run-pass/struct-order-of-eval-4.rs
@@ -11,7 +11,6 @@
 // Checks that struct-literal expression order-of-eval is as expected
 // even when no Drop-implementations are involved.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::atomic::{Ordering, AtomicUsize, ATOMIC_USIZE_INIT};
 
diff --git a/src/test/run-pass/struct_variant_xc_match.rs b/src/test/run-pass/struct_variant_xc_match.rs
index f43dd2332a17a..3ceb65bcfdeb1 100644
--- a/src/test/run-pass/struct_variant_xc_match.rs
+++ b/src/test/run-pass/struct_variant_xc_match.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // aux-build:struct_variant_xc_aux.rs
-// pretty-expanded FIXME #23616
 
 extern crate struct_variant_xc_aux;
 
diff --git a/src/test/run-pass/supertrait-default-generics.rs b/src/test/run-pass/supertrait-default-generics.rs
index 351c4259b5ef3..e014ce1966bc5 100644
--- a/src/test/run-pass/supertrait-default-generics.rs
+++ b/src/test/run-pass/supertrait-default-generics.rs
@@ -10,7 +10,6 @@
 
 // There is some other borrowck bug, so we make the stuff not mut.
 
-// pretty-expanded FIXME #23616
 
 use std::ops::Add;
 
diff --git a/src/test/run-pass/swap-1.rs b/src/test/run-pass/swap-1.rs
index e60c672f00f9b..d84ee104514d6 100644
--- a/src/test/run-pass/swap-1.rs
+++ b/src/test/run-pass/swap-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::swap;
 
diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs
index 3891376e463c7..3dbd7f1a60126 100644
--- a/src/test/run-pass/swap-2.rs
+++ b/src/test/run-pass/swap-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::swap;
 
diff --git a/src/test/run-pass/syntax-extension-cfg.rs b/src/test/run-pass/syntax-extension-cfg.rs
index 8766cba5dbb45..c1d8713b20e6b 100644
--- a/src/test/run-pass/syntax-extension-cfg.rs
+++ b/src/test/run-pass/syntax-extension-cfg.rs
@@ -10,7 +10,6 @@
 
 // compile-flags: --cfg foo --cfg qux="foo"
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     // check
diff --git a/src/test/run-pass/tag-align-dyn-u64.rs b/src/test/run-pass/tag-align-dyn-u64.rs
index a9f5875023f18..aaac1869af54f 100644
--- a/src/test/run-pass/tag-align-dyn-u64.rs
+++ b/src/test/run-pass/tag-align-dyn-u64.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs
index 90b583e2e5072..1c3fb209e35a3 100644
--- a/src/test/run-pass/tag-align-dyn-variants.rs
+++ b/src/test/run-pass/tag-align-dyn-variants.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/tag-align-u64.rs b/src/test/run-pass/tag-align-u64.rs
index e922ac3b4668e..43485a5bfcb63 100644
--- a/src/test/run-pass/tag-align-u64.rs
+++ b/src/test/run-pass/tag-align-u64.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs
index a063801032e3d..6dc69656759de 100644
--- a/src/test/run-pass/tag-variant-disr-val.rs
+++ b/src/test/run-pass/tag-variant-disr-val.rs
@@ -7,7 +7,6 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-// pretty-expanded FIXME #23616
 
 use color::{red, green, blue, black, white, imaginary, purple, orange};
 
diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs
index dbd65ee6bd483..e3cfceb0d426f 100644
--- a/src/test/run-pass/tag.rs
+++ b/src/test/run-pass/tag.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 enum colour { red(isize, isize), green, }
 
diff --git a/src/test/run-pass/tail-direct.rs b/src/test/run-pass/tail-direct.rs
index 01fc18af34332..4a7a0acdfa891 100644
--- a/src/test/run-pass/tail-direct.rs
+++ b/src/test/run-pass/tail-direct.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() { assert!((even(42))); assert!((odd(45))); }
 
diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs
index cd3d97b88bade..cd5cb677d460b 100644
--- a/src/test/run-pass/task-comm-5.rs
+++ b/src/test/run-pass/task-comm-5.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::mpsc::channel;
 
diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs
index 80e777d242cfc..b8b5773ade546 100644
--- a/src/test/run-pass/task-comm-6.rs
+++ b/src/test/run-pass/task-comm-6.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_assignment)]
 
diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs
index 77571504fea27..3b9ec42169150 100644
--- a/src/test/run-pass/task-comm-chan-nil.rs
+++ b/src/test/run-pass/task-comm-chan-nil.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::mpsc::channel;
 
diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs
index ec9e7de40dce1..83eb351df530f 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/src/test/run-pass/terminate-in-initializer.rs
@@ -12,7 +12,6 @@
 // Issue #787
 // Don't try to clean up uninitialized locals
 
-// pretty-expanded FIXME #23616
 
 use std::thread;
 
diff --git a/src/test/run-pass/trait-bounds.rs b/src/test/run-pass/trait-bounds.rs
index 642119df15cbf..d501fef122cc7 100644
--- a/src/test/run-pass/trait-bounds.rs
+++ b/src/test/run-pass/trait-bounds.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait connection {
     fn read(&self) -> isize;
diff --git a/src/test/run-pass/trait-default-method-bound-subst.rs b/src/test/run-pass/trait-default-method-bound-subst.rs
index e936989537e0f..b9936bcadd48d 100644
--- a/src/test/run-pass/trait-default-method-bound-subst.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait A<T> {
     fn g<U>(&self, x: T, y: U) -> (T, U) { (x, y) }
diff --git a/src/test/run-pass/trait-default-method-bound-subst2.rs b/src/test/run-pass/trait-default-method-bound-subst2.rs
index 4fedbba81f41a..92b9449461ba1 100644
--- a/src/test/run-pass/trait-default-method-bound-subst2.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst2.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait A<T> {
     fn g(&self, x: T) -> T { x }
diff --git a/src/test/run-pass/trait-default-method-bound-subst3.rs b/src/test/run-pass/trait-default-method-bound-subst3.rs
index 4f749cbd3fdbd..af7e8830332b0 100644
--- a/src/test/run-pass/trait-default-method-bound-subst3.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst3.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait A {
     fn g<T>(&self, x: T, y: T) -> (T, T) { (x, y) }
diff --git a/src/test/run-pass/trait-default-method-bound-subst4.rs b/src/test/run-pass/trait-default-method-bound-subst4.rs
index 6774569cd252a..581a54e57f490 100644
--- a/src/test/run-pass/trait-default-method-bound-subst4.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst4.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait A<T> {
     fn g(&self, x: usize) -> usize { x }
diff --git a/src/test/run-pass/trait-default-method-bound.rs b/src/test/run-pass/trait-default-method-bound.rs
index 4107540a47145..e0ea9651f6139 100644
--- a/src/test/run-pass/trait-default-method-bound.rs
+++ b/src/test/run-pass/trait-default-method-bound.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait A {
     fn g(&self) -> isize { 10 }
diff --git a/src/test/run-pass/trait-default-method-xc-2.rs b/src/test/run-pass/trait-default-method-xc-2.rs
index d4ed727040016..833063d2a2d0e 100644
--- a/src/test/run-pass/trait-default-method-xc-2.rs
+++ b/src/test/run-pass/trait-default-method-xc-2.rs
@@ -12,7 +12,6 @@
 // aux-build:trait_default_method_xc_aux_2.rs
 
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_default_method_xc_aux as aux;
 extern crate trait_default_method_xc_aux_2 as aux2;
diff --git a/src/test/run-pass/trait-default-method-xc.rs b/src/test/run-pass/trait-default-method-xc.rs
index 65e8c53a25ec5..72e3fb256ca83 100644
--- a/src/test/run-pass/trait-default-method-xc.rs
+++ b/src/test/run-pass/trait-default-method-xc.rs
@@ -10,7 +10,6 @@
 
 // aux-build:trait_default_method_xc_aux.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_default_method_xc_aux as aux;
 use aux::{A, TestEquality, Something};
diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs
index 6ef0dacee746a..4998236629153 100644
--- a/src/test/run-pass/trait-generic.rs
+++ b/src/test/run-pass/trait-generic.rs
@@ -10,7 +10,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 trait to_str {
     fn to_string_(&self) -> String;
diff --git a/src/test/run-pass/trait-impl.rs b/src/test/run-pass/trait-impl.rs
index 95fd7bda474ba..10025a76f798f 100644
--- a/src/test/run-pass/trait-impl.rs
+++ b/src/test/run-pass/trait-impl.rs
@@ -11,7 +11,6 @@
 // Test calling methods on an impl for a bare trait.
 
 // aux-build:traitimpl.rs
-// pretty-expanded FIXME #23616
 
 extern crate traitimpl;
 use traitimpl::Bar;
diff --git a/src/test/run-pass/trait-inheritance-auto-xc-2.rs b/src/test/run-pass/trait-inheritance-auto-xc-2.rs
index 128be2993ec1d..270cf652ed7cb 100644
--- a/src/test/run-pass/trait-inheritance-auto-xc-2.rs
+++ b/src/test/run-pass/trait-inheritance-auto-xc-2.rs
@@ -10,7 +10,6 @@
 
 // aux-build:trait_inheritance_auto_xc_2_aux.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_inheritance_auto_xc_2_aux as aux;
 
diff --git a/src/test/run-pass/trait-inheritance-auto-xc.rs b/src/test/run-pass/trait-inheritance-auto-xc.rs
index 827674c81adc1..eaca60c935a60 100644
--- a/src/test/run-pass/trait-inheritance-auto-xc.rs
+++ b/src/test/run-pass/trait-inheritance-auto-xc.rs
@@ -10,7 +10,6 @@
 
 // aux-build:trait_inheritance_auto_xc_aux.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_inheritance_auto_xc_aux as aux;
 
diff --git a/src/test/run-pass/trait-inheritance-auto.rs b/src/test/run-pass/trait-inheritance-auto.rs
index 1b72736cde439..75c48d5171278 100644
--- a/src/test/run-pass/trait-inheritance-auto.rs
+++ b/src/test/run-pass/trait-inheritance-auto.rs
@@ -10,7 +10,6 @@
 
 // Testing that this impl turns A into a Quux, because
 // A is already a Foo Bar Baz
-// pretty-expanded FIXME #23616
 
 impl<T:Foo + Bar + Baz> Quux for T { }
 
diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs
index c8df12392faf4..2fb2b9274c699 100644
--- a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs
+++ b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Foo { fn f(&self) -> isize; }
 trait Bar : Foo { fn g(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs
index fcd6143579c12..87dc04f1c6671 100644
--- a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs
+++ b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Foo { fn f(&self) -> isize; }
 trait Bar : Foo { fn g(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs
index 3996ae850e84e..dd61dc0f9fb83 100644
--- a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs
+++ b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs
@@ -11,7 +11,6 @@
 // Testing that we can cast to a subtrait and call subtrait
 // methods. Not testing supertrait methods
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn f(&self) -> isize;
diff --git a/src/test/run-pass/trait-inheritance-cast.rs b/src/test/run-pass/trait-inheritance-cast.rs
index 7784ed2f26ae9..0de2c586930e6 100644
--- a/src/test/run-pass/trait-inheritance-cast.rs
+++ b/src/test/run-pass/trait-inheritance-cast.rs
@@ -10,7 +10,6 @@
 
 // Testing that supertrait methods can be called on subtrait object types
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn f(&self) -> isize;
diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs
index c665c35b418c0..e1610c1db07fd 100644
--- a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs
+++ b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs
@@ -10,7 +10,6 @@
 
 // aux-build:trait_inheritance_cross_trait_call_xc_aux.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_inheritance_cross_trait_call_xc_aux as aux;
 
diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call.rs b/src/test/run-pass/trait-inheritance-cross-trait-call.rs
index 418986f961e58..27b0f66603f8c 100644
--- a/src/test/run-pass/trait-inheritance-cross-trait-call.rs
+++ b/src/test/run-pass/trait-inheritance-cross-trait-call.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Foo { fn f(&self) -> isize; }
 trait Bar : Foo { fn g(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance-diamond.rs b/src/test/run-pass/trait-inheritance-diamond.rs
index 07b1a79110f63..43151bb0f9921 100644
--- a/src/test/run-pass/trait-inheritance-diamond.rs
+++ b/src/test/run-pass/trait-inheritance-diamond.rs
@@ -10,7 +10,6 @@
 
 // B and C both require A, so D does as well, twice, but that's just fine
 
-// pretty-expanded FIXME #23616
 
 trait A { fn a(&self) -> isize; }
 trait B: A { fn b(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs
index b89246269542e..8125ce20912e5 100644
--- a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs
+++ b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait A { fn a(&self) -> isize; }
 trait B: A { fn b(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance-multiple-params.rs b/src/test/run-pass/trait-inheritance-multiple-params.rs
index 37803edb752b1..c0f7a9d9c254a 100644
--- a/src/test/run-pass/trait-inheritance-multiple-params.rs
+++ b/src/test/run-pass/trait-inheritance-multiple-params.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait A { fn a(&self) -> isize; }
 trait B: A { fn b(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
index f44c6927c87e0..21d6c53a465cf 100644
--- a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
+++ b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
@@ -10,7 +10,6 @@
 
 // aux-build:trait_inheritance_overloading_xc.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_inheritance_overloading_xc;
 use trait_inheritance_overloading_xc::{MyNum, MyInt};
diff --git a/src/test/run-pass/trait-inheritance-self-in-supertype.rs b/src/test/run-pass/trait-inheritance-self-in-supertype.rs
index 87a36ba7b90cc..ac9485594eb3e 100644
--- a/src/test/run-pass/trait-inheritance-self-in-supertype.rs
+++ b/src/test/run-pass/trait-inheritance-self-in-supertype.rs
@@ -10,7 +10,6 @@
 
 // Test for issue #4183: use of Self in supertraits.
 
-// pretty-expanded FIXME #23616
 
 use std::num::Float as StdFloat;
 
diff --git a/src/test/run-pass/trait-inheritance-simple.rs b/src/test/run-pass/trait-inheritance-simple.rs
index ff89b1ee5d30d..917e520339af4 100644
--- a/src/test/run-pass/trait-inheritance-simple.rs
+++ b/src/test/run-pass/trait-inheritance-simple.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Foo { fn f(&self) -> isize; }
 trait Bar : Foo { fn g(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance-static.rs b/src/test/run-pass/trait-inheritance-static.rs
index 9ed5fd0aaa53f..8e56582951154 100644
--- a/src/test/run-pass/trait-inheritance-static.rs
+++ b/src/test/run-pass/trait-inheritance-static.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub trait MyNum {
     fn from_int(isize) -> Self;
diff --git a/src/test/run-pass/trait-inheritance-static2.rs b/src/test/run-pass/trait-inheritance-static2.rs
index 9fe9d7fce7af5..62feecf045b54 100644
--- a/src/test/run-pass/trait-inheritance-static2.rs
+++ b/src/test/run-pass/trait-inheritance-static2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/trait-inheritance-subst.rs b/src/test/run-pass/trait-inheritance-subst.rs
index d35a937a5733d..6074c8a71b0d0 100644
--- a/src/test/run-pass/trait-inheritance-subst.rs
+++ b/src/test/run-pass/trait-inheritance-subst.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub trait Add<RHS,Result> {
     fn add(&self, rhs: &RHS) -> Result;
diff --git a/src/test/run-pass/trait-inheritance-subst2.rs b/src/test/run-pass/trait-inheritance-subst2.rs
index e0be5759503c6..6a3639954350f 100644
--- a/src/test/run-pass/trait-inheritance-subst2.rs
+++ b/src/test/run-pass/trait-inheritance-subst2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Panda<T> {
     fn chomp(&self, bamboo: &T) -> T;
diff --git a/src/test/run-pass/trait-inheritance-visibility.rs b/src/test/run-pass/trait-inheritance-visibility.rs
index 8c8b9232dee8c..f00a4f2ecb6aa 100644
--- a/src/test/run-pass/trait-inheritance-visibility.rs
+++ b/src/test/run-pass/trait-inheritance-visibility.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 mod traits {
     pub trait Foo { fn f(&self) -> isize; }
diff --git a/src/test/run-pass/trait-inheritance2.rs b/src/test/run-pass/trait-inheritance2.rs
index 9e721836d6319..2161c0f894f43 100644
--- a/src/test/run-pass/trait-inheritance2.rs
+++ b/src/test/run-pass/trait-inheritance2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 trait Foo { fn f(&self) -> isize; }
 trait Bar { fn g(&self) -> isize; }
diff --git a/src/test/run-pass/trait-object-generics.rs b/src/test/run-pass/trait-object-generics.rs
index 63246b870cb59..15a8a2e83e340 100644
--- a/src/test/run-pass/trait-object-generics.rs
+++ b/src/test/run-pass/trait-object-generics.rs
@@ -10,7 +10,6 @@
 
 // test for #8664
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/trait-object-with-lifetime-bound.rs b/src/test/run-pass/trait-object-with-lifetime-bound.rs
index 30a05ee1c562e..21b84221d06e0 100644
--- a/src/test/run-pass/trait-object-with-lifetime-bound.rs
+++ b/src/test/run-pass/trait-object-with-lifetime-bound.rs
@@ -11,7 +11,6 @@
 // Uncovered during work on new scoping rules for safe destructors
 // as an important use case to support properly.
 
-// pretty-expanded FIXME #23616
 
 pub struct E<'a> {
     pub f: &'a u8,
diff --git a/src/test/run-pass/trait-safety-ok-cc.rs b/src/test/run-pass/trait-safety-ok-cc.rs
index ada79399561a9..abbc556f34e4c 100644
--- a/src/test/run-pass/trait-safety-ok-cc.rs
+++ b/src/test/run-pass/trait-safety-ok-cc.rs
@@ -12,7 +12,6 @@
 
 // Simple smoke test that unsafe traits can be compiled across crates.
 
-// pretty-expanded FIXME #23616
 
 extern crate trait_safety_lib as lib;
 
diff --git a/src/test/run-pass/trait-safety-ok.rs b/src/test/run-pass/trait-safety-ok.rs
index 3cd23aeaf27a5..0ccc6cd152dfc 100644
--- a/src/test/run-pass/trait-safety-ok.rs
+++ b/src/test/run-pass/trait-safety-ok.rs
@@ -10,7 +10,6 @@
 
 // Simple smoke test that unsafe traits can be compiled etc.
 
-// pretty-expanded FIXME #23616
 
 unsafe trait Foo {
     fn foo(&self) -> isize;
diff --git a/src/test/run-pass/traits-assoc-type-in-supertrait.rs b/src/test/run-pass/traits-assoc-type-in-supertrait.rs
index 751cd50441362..5cecacafc74b1 100644
--- a/src/test/run-pass/traits-assoc-type-in-supertrait.rs
+++ b/src/test/run-pass/traits-assoc-type-in-supertrait.rs
@@ -11,7 +11,6 @@
 // Test case where an associated type is referenced from within the
 // supertrait definition. Issue #20220.
 
-// pretty-expanded FIXME #23616
 
 use std::vec::IntoIter;
 
diff --git a/src/test/run-pass/traits-conditional-dispatch.rs b/src/test/run-pass/traits-conditional-dispatch.rs
index 0a6b9da74f218..8d2faaf418b54 100644
--- a/src/test/run-pass/traits-conditional-dispatch.rs
+++ b/src/test/run-pass/traits-conditional-dispatch.rs
@@ -12,7 +12,6 @@
 // blanket impl for T:Copy coexists with an impl for Box<T>, because
 // Box does not impl Copy.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/traits-conditional-model-fn.rs b/src/test/run-pass/traits-conditional-model-fn.rs
index 65a48844620de..d19f7143ed222 100644
--- a/src/test/run-pass/traits-conditional-model-fn.rs
+++ b/src/test/run-pass/traits-conditional-model-fn.rs
@@ -14,7 +14,6 @@
 
 // aux-build:go_trait.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate go_trait;
 
diff --git a/src/test/run-pass/traits-default-method-macro.rs b/src/test/run-pass/traits-default-method-macro.rs
index 1ec58eac58bbd..193038d9e50f3 100644
--- a/src/test/run-pass/traits-default-method-macro.rs
+++ b/src/test/run-pass/traits-default-method-macro.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn bar(&self) -> String {
diff --git a/src/test/run-pass/traits-multidispatch-infer-convert-target.rs b/src/test/run-pass/traits-multidispatch-infer-convert-target.rs
index 1f1d1a46cf973..6634c1ad0a220 100644
--- a/src/test/run-pass/traits-multidispatch-infer-convert-target.rs
+++ b/src/test/run-pass/traits-multidispatch-infer-convert-target.rs
@@ -10,7 +10,6 @@
 
 // Test that we can infer the Target based on the Self or vice versa.
 
-// pretty-expanded FIXME #23616
 
 use std::mem;
 
diff --git a/src/test/run-pass/traits-repeated-supertrait.rs b/src/test/run-pass/traits-repeated-supertrait.rs
index 509a6e36afdec..b059945ef74e3 100644
--- a/src/test/run-pass/traits-repeated-supertrait.rs
+++ b/src/test/run-pass/traits-repeated-supertrait.rs
@@ -13,7 +13,6 @@
 // various methods in various ways successfully.
 // See also `compile-fail/trait-repeated-supertrait-ambig.rs`.
 
-// pretty-expanded FIXME #23616
 
 trait CompareTo<T> {
     fn same_as(&self, t: T) -> bool;
diff --git a/src/test/run-pass/trans-tag-static-padding.rs b/src/test/run-pass/trans-tag-static-padding.rs
index 3e2297f008f02..ba01d51dc6a5d 100644
--- a/src/test/run-pass/trans-tag-static-padding.rs
+++ b/src/test/run-pass/trans-tag-static-padding.rs
@@ -21,7 +21,6 @@
 // Last 7 bytes of Request struct are not occupied by any fields.
 
 
-// pretty-expanded FIXME #23616
 
 enum TestOption<T> {
     TestNone,
diff --git a/src/test/run-pass/tup.rs b/src/test/run-pass/tup.rs
index 50687756e2abe..86ca37deb02d1 100644
--- a/src/test/run-pass/tup.rs
+++ b/src/test/run-pass/tup.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 type point = (isize, isize);
 
diff --git a/src/test/run-pass/tuple-index-fat-types.rs b/src/test/run-pass/tuple-index-fat-types.rs
index 395531d1573a1..e4ea073bfc28a 100644
--- a/src/test/run-pass/tuple-index-fat-types.rs
+++ b/src/test/run-pass/tuple-index-fat-types.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Foo<'a>(&'a [isize]);
 
diff --git a/src/test/run-pass/tuple-index.rs b/src/test/run-pass/tuple-index.rs
index a70b49296fa19..26d918f236750 100644
--- a/src/test/run-pass/tuple-index.rs
+++ b/src/test/run-pass/tuple-index.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct Point(isize, isize);
 
diff --git a/src/test/run-pass/tydesc-name.rs b/src/test/run-pass/tydesc-name.rs
index 4ba7e786ec8d2..1534c301c996c 100644
--- a/src/test/run-pass/tydesc-name.rs
+++ b/src/test/run-pass/tydesc-name.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/type-id-higher-rank.rs b/src/test/run-pass/type-id-higher-rank.rs
index ec5aa2863a0c5..3030833c7721d 100644
--- a/src/test/run-pass/type-id-higher-rank.rs
+++ b/src/test/run-pass/type-id-higher-rank.rs
@@ -11,7 +11,6 @@
 // Test that type IDs correctly account for higher-rank lifetimes
 // Also acts as a regression test for an ICE (issue #19791)
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures, core)]
 
diff --git a/src/test/run-pass/type-namespace.rs b/src/test/run-pass/type-namespace.rs
index c03ddd0c649f5..36f8b2ca5b42a 100644
--- a/src/test/run-pass/type-namespace.rs
+++ b/src/test/run-pass/type-namespace.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 struct A { a: isize }
 
diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs
index 8c1251feea269..fc6499ce5d462 100644
--- a/src/test/run-pass/type-sizes.rs
+++ b/src/test/run-pass/type-sizes.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::size_of;
 
diff --git a/src/test/run-pass/typeck-macro-interaction-issue-8852.rs b/src/test/run-pass/typeck-macro-interaction-issue-8852.rs
index 2da8b0a508ae4..696e151a80e8b 100644
--- a/src/test/run-pass/typeck-macro-interaction-issue-8852.rs
+++ b/src/test/run-pass/typeck-macro-interaction-issue-8852.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 enum T {
     A(isize),
diff --git a/src/test/run-pass/typeck_type_placeholder_1.rs b/src/test/run-pass/typeck_type_placeholder_1.rs
index 53e78db68b19d..113d52ffb35b9 100644
--- a/src/test/run-pass/typeck_type_placeholder_1.rs
+++ b/src/test/run-pass/typeck_type_placeholder_1.rs
@@ -11,7 +11,6 @@
 // This test checks that the `_` type placeholder works
 // correctly for enabling type inference.
 
-// pretty-expanded FIXME #23616
 
 struct TestStruct {
     x: *const isize
diff --git a/src/test/run-pass/typeid-intrinsic.rs b/src/test/run-pass/typeid-intrinsic.rs
index 7a143ce588915..9741ed0fddec8 100644
--- a/src/test/run-pass/typeid-intrinsic.rs
+++ b/src/test/run-pass/typeid-intrinsic.rs
@@ -11,7 +11,6 @@
 // aux-build:typeid-intrinsic.rs
 // aux-build:typeid-intrinsic2.rs
 
-// pretty-expanded FIXME #23616
 
 #![feature(hash, core)]
 
diff --git a/src/test/run-pass/typestate-multi-decl.rs b/src/test/run-pass/typestate-multi-decl.rs
index c7762a8464d6b..0749b52a1c601 100644
--- a/src/test/run-pass/typestate-multi-decl.rs
+++ b/src/test/run-pass/typestate-multi-decl.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let (x, y) = (10, 20);
diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs
index 4955ac8a4be63..b56b6f32c0291 100644
--- a/src/test/run-pass/u32-decr.rs
+++ b/src/test/run-pass/u32-decr.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut word: u32 = 200000;
diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs
index 7c67d304edb68..d35ef015e6f0b 100644
--- a/src/test/run-pass/u8-incr-decr.rs
+++ b/src/test/run-pass/u8-incr-decr.rs
@@ -14,7 +14,6 @@
 
 // These constants were chosen because they aren't used anywhere
 // in the rest of the generated code so they're easily grep-able.
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut x: u8 = 19; // 0x13
diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs
index e15576c3fabce..9554f9c2dfbca 100644
--- a/src/test/run-pass/u8-incr.rs
+++ b/src/test/run-pass/u8-incr.rs
@@ -11,7 +11,6 @@
 
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut x: u8 = 12;
diff --git a/src/test/run-pass/ufcs-polymorphic-paths.rs b/src/test/run-pass/ufcs-polymorphic-paths.rs
index a6ea0f76dc2f9..db3581976bbc3 100644
--- a/src/test/run-pass/ufcs-polymorphic-paths.rs
+++ b/src/test/run-pass/ufcs-polymorphic-paths.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections, rand, into_cow)]
 
diff --git a/src/test/run-pass/ufcs-trait-object.rs b/src/test/run-pass/ufcs-trait-object.rs
index b242018458dfc..457beeb3f37a3 100644
--- a/src/test/run-pass/ufcs-trait-object.rs
+++ b/src/test/run-pass/ufcs-trait-object.rs
@@ -11,7 +11,6 @@
 // Test that when you use ufcs form to invoke a trait method (on a
 // trait object) everything works fine.
 
-// pretty-expanded FIXME #23616
 
 trait Foo {
     fn test(&self) -> i32;
diff --git a/src/test/run-pass/unboxed-closures-all-traits.rs b/src/test/run-pass/unboxed-closures-all-traits.rs
index 9ca8e5403a130..c28d4f463e572 100644
--- a/src/test/run-pass/unboxed-closures-all-traits.rs
+++ b/src/test/run-pass/unboxed-closures-all-traits.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(lang_items, unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs b/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs
index 37dccca1e2245..54c92900c89bb 100644
--- a/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs
+++ b/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs
@@ -10,7 +10,6 @@
 
 // Test that you can supply `&F` where `F: FnMut()`.
 
-// pretty-expanded FIXME #23616
 
 #![feature(lang_items, unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-blanket-fn.rs b/src/test/run-pass/unboxed-closures-blanket-fn.rs
index 0f93966077bc3..eb474473094a2 100644
--- a/src/test/run-pass/unboxed-closures-blanket-fn.rs
+++ b/src/test/run-pass/unboxed-closures-blanket-fn.rs
@@ -10,7 +10,6 @@
 
 // Test that you can supply `&F` where `F: Fn()`.
 
-// pretty-expanded FIXME #23616
 
 #![feature(lang_items, unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-by-ref.rs b/src/test/run-pass/unboxed-closures-by-ref.rs
index 7855cf6ba0c2a..e3ddfdbac00f8 100644
--- a/src/test/run-pass/unboxed-closures-by-ref.rs
+++ b/src/test/run-pass/unboxed-closures-by-ref.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs b/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs
index 6e92850ac2e59..64236ce563b0e 100644
--- a/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs
+++ b/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs
@@ -10,7 +10,6 @@
 
 // Test that the call operator autoderefs when calling a bounded type parameter.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs b/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs
index 402b4b0b85d4b..67ab84f0276cc 100644
--- a/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs
+++ b/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs
@@ -10,7 +10,6 @@
 
 // Test that the call operator autoderefs when calling a bounded type parameter.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-counter-not-moved.rs b/src/test/run-pass/unboxed-closures-counter-not-moved.rs
index 792d17227766e..cb5f190bcd736 100644
--- a/src/test/run-pass/unboxed-closures-counter-not-moved.rs
+++ b/src/test/run-pass/unboxed-closures-counter-not-moved.rs
@@ -10,7 +10,6 @@
 
 // Test that we mutate a counter on the stack only when we expect to.
 
-// pretty-expanded FIXME #23616
 
 fn call<F>(f: F) where F : FnOnce() {
     f();
diff --git a/src/test/run-pass/unboxed-closures-cross-crate.rs b/src/test/run-pass/unboxed-closures-cross-crate.rs
index 0c255c6bd6cb8..37dc760cedcfe 100644
--- a/src/test/run-pass/unboxed-closures-cross-crate.rs
+++ b/src/test/run-pass/unboxed-closures-cross-crate.rs
@@ -12,7 +12,6 @@
 // Acts as a regression test for #16790, #18378 and #18543
 
 // aux-build:unboxed-closures-cross-crate.rs
-// pretty-expanded FIXME #23616
 
 extern crate unboxed_closures_cross_crate as ubcc;
 
diff --git a/src/test/run-pass/unboxed-closures-drop.rs b/src/test/run-pass/unboxed-closures-drop.rs
index f0c6c0ff453ff..78f4905aef976 100644
--- a/src/test/run-pass/unboxed-closures-drop.rs
+++ b/src/test/run-pass/unboxed-closures-drop.rs
@@ -11,7 +11,6 @@
 // A battery of tests to ensure destructors of unboxed closure environments
 // run at the right times.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-extern-fn-hr.rs b/src/test/run-pass/unboxed-closures-extern-fn-hr.rs
index 4af4b320d0e4e..e71757abd0e7d 100644
--- a/src/test/run-pass/unboxed-closures-extern-fn-hr.rs
+++ b/src/test/run-pass/unboxed-closures-extern-fn-hr.rs
@@ -10,7 +10,6 @@
 
 // Checks that higher-ranked extern fn pointers implement the full range of Fn traits.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures, core)]
 
diff --git a/src/test/run-pass/unboxed-closures-extern-fn.rs b/src/test/run-pass/unboxed-closures-extern-fn.rs
index d711ebbe4b8c2..57acbae4ce6d8 100644
--- a/src/test/run-pass/unboxed-closures-extern-fn.rs
+++ b/src/test/run-pass/unboxed-closures-extern-fn.rs
@@ -10,7 +10,6 @@
 
 // Checks that extern fn pointers implement the full range of Fn traits.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 #![feature(unboxed_closures)]
diff --git a/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs b/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs
index 9b71abf365331..5d6d372ea5c95 100644
--- a/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs
+++ b/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs
@@ -11,7 +11,6 @@
 // Checks that the Fn trait hierarchy rules permit
 // any Fn trait to be used where Fn is implemented.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures, core)]
 
diff --git a/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs b/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs
index 6261058b86742..c19b5b273c7eb 100644
--- a/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs
+++ b/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs
@@ -11,7 +11,6 @@
 // Checks that the Fn trait hierarchy rules permit
 // FnMut or FnOnce to be used where FnMut is implemented.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures, core)]
 
diff --git a/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs b/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs
index 798959f69d687..2da899ed95b5a 100644
--- a/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs
+++ b/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs
@@ -11,7 +11,6 @@
 // Test that we are able to infer a suitable kind for this closure
 // that is just called (`FnMut`).
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let mut counter = 0;
diff --git a/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs b/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs
index 5b1e35a3e5c72..32fc3433e8477 100644
--- a/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs
+++ b/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs
@@ -11,7 +11,6 @@
 // Test that we are able to infer a suitable kind for this `move`
 // closure that is just called (`FnMut`).
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let mut counter = 0;
diff --git a/src/test/run-pass/unboxed-closures-infer-fnmut.rs b/src/test/run-pass/unboxed-closures-infer-fnmut.rs
index cd7f26bba2676..a8469f4019ab1 100644
--- a/src/test/run-pass/unboxed-closures-infer-fnmut.rs
+++ b/src/test/run-pass/unboxed-closures-infer-fnmut.rs
@@ -11,7 +11,6 @@
 // Test that we are able to infer a suitable kind for this closure
 // that is just called (`FnMut`).
 
-// pretty-expanded FIXME #23616
 
 fn main() {
     let mut counter = 0;
diff --git a/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs b/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs
index dc106614b53dd..dcda724c7b8fe 100644
--- a/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs
+++ b/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/unboxed-closures-infer-fnonce.rs b/src/test/run-pass/unboxed-closures-infer-fnonce.rs
index 036b32a44d255..275ba0520c568 100644
--- a/src/test/run-pass/unboxed-closures-infer-fnonce.rs
+++ b/src/test/run-pass/unboxed-closures-infer-fnonce.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/unboxed-closures-infer-kind.rs b/src/test/run-pass/unboxed-closures-infer-kind.rs
index edc01d91f58fc..fa668475f587a 100644
--- a/src/test/run-pass/unboxed-closures-infer-kind.rs
+++ b/src/test/run-pass/unboxed-closures-infer-kind.rs
@@ -11,7 +11,6 @@
 // Test that we can infer the "kind" of an unboxed closure based on
 // the expected type.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs b/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs
index e02784f917a97..e499ab5cca06c 100644
--- a/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs
+++ b/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(core,unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-infer-upvar.rs b/src/test/run-pass/unboxed-closures-infer-upvar.rs
index e29632b007b3f..f2423145b1974 100644
--- a/src/test/run-pass/unboxed-closures-infer-upvar.rs
+++ b/src/test/run-pass/unboxed-closures-infer-upvar.rs
@@ -11,7 +11,6 @@
 // Test that the type variable in the type(`Vec<_>`) of a closed over
 // variable does not interfere with type inference.
 
-// pretty-expanded FIXME #23616
 
 fn f<F: FnMut()>(mut f: F) {
     f();
diff --git a/src/test/run-pass/unboxed-closures-manual-impl.rs b/src/test/run-pass/unboxed-closures-manual-impl.rs
index 38f15d6e4499b..6a76fdb5ad7e4 100644
--- a/src/test/run-pass/unboxed-closures-manual-impl.rs
+++ b/src/test/run-pass/unboxed-closures-manual-impl.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures, core)]
 
diff --git a/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs b/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs
index b69153b73a369..e2b286738e76d 100644
--- a/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs
+++ b/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs
@@ -11,7 +11,6 @@
 // Test that in a by-ref once closure we move some variables even as
 // we capture others by mutable reference.
 
-// pretty-expanded FIXME #23616
 
 fn call<F>(f: F) where F : FnOnce() {
     f();
diff --git a/src/test/run-pass/unboxed-closures-simple.rs b/src/test/run-pass/unboxed-closures-simple.rs
index 1443d305bce94..ec3419816693e 100644
--- a/src/test/run-pass/unboxed-closures-simple.rs
+++ b/src/test/run-pass/unboxed-closures-simple.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-single-word-env.rs b/src/test/run-pass/unboxed-closures-single-word-env.rs
index 65a26d14e120b..166054e88b7b3 100644
--- a/src/test/run-pass/unboxed-closures-single-word-env.rs
+++ b/src/test/run-pass/unboxed-closures-single-word-env.rs
@@ -11,7 +11,6 @@
 // Ensures that single-word environments work right in unboxed closures.
 // These take a different path in codegen.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unboxed-closures-sugar-object.rs b/src/test/run-pass/unboxed-closures-sugar-object.rs
index 77beeb13fb029..49b9b7f061e72 100644
--- a/src/test/run-pass/unboxed-closures-sugar-object.rs
+++ b/src/test/run-pass/unboxed-closures-sugar-object.rs
@@ -10,7 +10,6 @@
 
 // Test unboxed closure sugar used in object types.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_code)]
 #![feature(unboxed_closures)]
diff --git a/src/test/run-pass/unboxed-closures-unique-type-id.rs b/src/test/run-pass/unboxed-closures-unique-type-id.rs
index 403b2ca9aaf39..de7eeb57de10d 100644
--- a/src/test/run-pass/unboxed-closures-unique-type-id.rs
+++ b/src/test/run-pass/unboxed-closures-unique-type-id.rs
@@ -19,7 +19,6 @@
 //
 // compile-flags: -g
 
-// pretty-expanded FIXME #23616
 
 #![feature(unboxed_closures)]
 
diff --git a/src/test/run-pass/unfold-cross-crate.rs b/src/test/run-pass/unfold-cross-crate.rs
index fceccb499c7b0..5c699bf3044e6 100644
--- a/src/test/run-pass/unfold-cross-crate.rs
+++ b/src/test/run-pass/unfold-cross-crate.rs
@@ -10,7 +10,6 @@
 
 // no-pretty-expanded FIXME #15189
 
-// pretty-expanded FIXME #23616
 
 #![feature(core)]
 
diff --git a/src/test/run-pass/uniq-self-in-mut-slot.rs b/src/test/run-pass/uniq-self-in-mut-slot.rs
index a6408128c3a28..baca157a488b7 100644
--- a/src/test/run-pass/uniq-self-in-mut-slot.rs
+++ b/src/test/run-pass/uniq-self-in-mut-slot.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs
index 32a0713ca9397..3323b3c046b11 100644
--- a/src/test/run-pass/unique-assign-copy.rs
+++ b/src/test/run-pass/unique-assign-copy.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs
index 715fa548a7d76..37aa1f0a64bc6 100644
--- a/src/test/run-pass/unique-assign-drop.rs
+++ b/src/test/run-pass/unique-assign-drop.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_assignment)]
 #![allow(unknown_features)]
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index ca145479a381f..249b734a691e0 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs
index e4e7b69671b82..8e97fdd4a6af9 100644
--- a/src/test/run-pass/unique-assign.rs
+++ b/src/test/run-pass/unique-assign.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs
index 8ee1b28ea2e7e..a711dbb685f19 100644
--- a/src/test/run-pass/unique-autoderef-field.rs
+++ b/src/test/run-pass/unique-autoderef-field.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs
index 9dc98cf2e3c47..c68ff1f0612f5 100644
--- a/src/test/run-pass/unique-autoderef-index.rs
+++ b/src/test/run-pass/unique-autoderef-index.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs
index be7e46c8699d7..3b0ad63aeffe9 100644
--- a/src/test/run-pass/unique-cmp.rs
+++ b/src/test/run-pass/unique-cmp.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs
index 0840f1308cc1f..9d749803ffb16 100644
--- a/src/test/run-pass/unique-decl-init-copy.rs
+++ b/src/test/run-pass/unique-decl-init-copy.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs
index 1d5a44f45abba..a00de08998f4e 100644
--- a/src/test/run-pass/unique-decl-init.rs
+++ b/src/test/run-pass/unique-decl-init.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs
index 203a30e76bc1a..f4ff44ffff52c 100644
--- a/src/test/run-pass/unique-decl-move.rs
+++ b/src/test/run-pass/unique-decl-move.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-decl.rs b/src/test/run-pass/unique-decl.rs
index 7404e8887ebce..bbf9b2f47a742 100644
--- a/src/test/run-pass/unique-decl.rs
+++ b/src/test/run-pass/unique-decl.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let _: Box<isize>;
diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs
index 44681742a7041..70b2617797dae 100644
--- a/src/test/run-pass/unique-deref.rs
+++ b/src/test/run-pass/unique-deref.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs
index 87bc6f6639d65..b368cbee2f632 100644
--- a/src/test/run-pass/unique-destructure.rs
+++ b/src/test/run-pass/unique-destructure.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_patterns)]
diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs
index e608ab9b6367a..d101cbd31290c 100644
--- a/src/test/run-pass/unique-fn-arg-move.rs
+++ b/src/test/run-pass/unique-fn-arg-move.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs
index f0d2abfe27cbc..ebe89b275d4f7 100644
--- a/src/test/run-pass/unique-fn-arg-mut.rs
+++ b/src/test/run-pass/unique-fn-arg-mut.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs
index 3d7ef31d020e7..97006d2a01a2d 100644
--- a/src/test/run-pass/unique-fn-arg.rs
+++ b/src/test/run-pass/unique-fn-arg.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs
index bb1948bf3c81b..d3be0cf01f1dd 100644
--- a/src/test/run-pass/unique-fn-ret.rs
+++ b/src/test/run-pass/unique-fn-ret.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index 129c0784cca5e..ab0e3ee809dbd 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs
index dc94fa6ca4fce..41945821587ca 100644
--- a/src/test/run-pass/unique-in-vec.rs
+++ b/src/test/run-pass/unique-in-vec.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index 96d54193ac86d..b808ac2b00823 100644
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs
index e81095d548e07..530ba4789102e 100644
--- a/src/test/run-pass/unique-move-drop.rs
+++ b/src/test/run-pass/unique-move-drop.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unused_variable)]
 #![allow(unknown_features)]
diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs
index 634a1569acffd..4b937625201c0 100644
--- a/src/test/run-pass/unique-move-temp.rs
+++ b/src/test/run-pass/unique-move-temp.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs
index 29bf113926572..bed1d6e171a8b 100644
--- a/src/test/run-pass/unique-move.rs
+++ b/src/test/run-pass/unique-move.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs
index 106481e3189ee..8beec6a419833 100644
--- a/src/test/run-pass/unique-mutable.rs
+++ b/src/test/run-pass/unique-mutable.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs
index d16355af99fd5..c314b70e53662 100644
--- a/src/test/run-pass/unique-pat-2.rs
+++ b/src/test/run-pass/unique-pat-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_patterns)]
diff --git a/src/test/run-pass/unique-pat.rs b/src/test/run-pass/unique-pat.rs
index ae76179b5ec22..1312ea924b599 100644
--- a/src/test/run-pass/unique-pat.rs
+++ b/src/test/run-pass/unique-pat.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_patterns)]
diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs
index 7a09e241ca639..72975c27eeaf5 100644
--- a/src/test/run-pass/unique-rec.rs
+++ b/src/test/run-pass/unique-rec.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index 99a3b64105318..d80d0e82f4fe9 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs
index c9649ef60d303..bc0f790b2b02d 100644
--- a/src/test/run-pass/unique-send.rs
+++ b/src/test/run-pass/unique-send.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs
index 454011a9ec31e..cfa076f1a0744 100644
--- a/src/test/run-pass/unique-swap.rs
+++ b/src/test/run-pass/unique-swap.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs
index c2db63ed251a5..e31d4c811fc63 100644
--- a/src/test/run-pass/unit-like-struct-drop-run.rs
+++ b/src/test/run-pass/unit-like-struct-drop-run.rs
@@ -10,7 +10,6 @@
 
 // Make sure the destructor is run for unit-like structs.
 
-// pretty-expanded FIXME #23616
 
 #![feature(alloc)]
 
diff --git a/src/test/run-pass/unreachable-code-1.rs b/src/test/run-pass/unreachable-code-1.rs
index 612beabb03586..c1c069236c88d 100644
--- a/src/test/run-pass/unreachable-code-1.rs
+++ b/src/test/run-pass/unreachable-code-1.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unreachable_code)]
 #![allow(unused_variable)]
diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs
index 4f58df66256be..e19fda5f872d2 100644
--- a/src/test/run-pass/unreachable-code.rs
+++ b/src/test/run-pass/unreachable-code.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(path_statement)]
 #![allow(unreachable_code)]
diff --git a/src/test/run-pass/unsafe-coercion.rs b/src/test/run-pass/unsafe-coercion.rs
index d0c633e8278ea..8661ebb414ce5 100644
--- a/src/test/run-pass/unsafe-coercion.rs
+++ b/src/test/run-pass/unsafe-coercion.rs
@@ -10,7 +10,6 @@
 
 // Check that safe fns are not a subtype of unsafe fns.
 
-// pretty-expanded FIXME #23616
 
 fn foo(x: i32) -> i32 {
     x * 22
diff --git a/src/test/run-pass/unsafe-pointer-assignability.rs b/src/test/run-pass/unsafe-pointer-assignability.rs
index 75c7cabfcb6d3..c8ee0f83b9b0c 100644
--- a/src/test/run-pass/unsafe-pointer-assignability.rs
+++ b/src/test/run-pass/unsafe-pointer-assignability.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn f(x: *const isize) {
     unsafe {
diff --git a/src/test/run-pass/unsized3.rs b/src/test/run-pass/unsized3.rs
index 8db294bdcc1c0..2977f579fc592 100644
--- a/src/test/run-pass/unsized3.rs
+++ b/src/test/run-pass/unsized3.rs
@@ -10,7 +10,6 @@
 
 // Test structs with always-unsized fields.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax, core)]
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index 1d6ce626c28c5..07bfc8062f9d4 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs b/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs
index e21ea025d8ff4..af06fe381368b 100644
--- a/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs
+++ b/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs
@@ -13,7 +13,6 @@
 // us from approximating the lifetimes of `field1` and `field2` to a
 // common intersection.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_code)]
 #![feature(core)]
diff --git a/src/test/run-pass/variance-vec-covariant.rs b/src/test/run-pass/variance-vec-covariant.rs
index 2f554c3c4f3f5..89927b7b55b97 100644
--- a/src/test/run-pass/variance-vec-covariant.rs
+++ b/src/test/run-pass/variance-vec-covariant.rs
@@ -10,7 +10,6 @@
 
 // Test that vec is now covariant in its argument type.
 
-// pretty-expanded FIXME #23616
 
 #![allow(dead_code)]
 #![feature(core)]
diff --git a/src/test/run-pass/vec-dst.rs b/src/test/run-pass/vec-dst.rs
index e88acb3838ba8..223907c01bea3 100644
--- a/src/test/run-pass/vec-dst.rs
+++ b/src/test/run-pass/vec-dst.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![allow(unknown_features)]
 #![feature(box_syntax)]
diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs
index 4dadf53c77222..fbaba9b8a6191 100644
--- a/src/test/run-pass/vec-fixed-length.rs
+++ b/src/test/run-pass/vec-fixed-length.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::mem::size_of;
 
diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs
index d5e6a9c424515..e51d898e1d46e 100644
--- a/src/test/run-pass/vec-growth.rs
+++ b/src/test/run-pass/vec-growth.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut v = vec!(1);
diff --git a/src/test/run-pass/vec-macro-repeat.rs b/src/test/run-pass/vec-macro-repeat.rs
index 2a83ccaba82e2..d178041b85e1e 100644
--- a/src/test/run-pass/vec-macro-repeat.rs
+++ b/src/test/run-pass/vec-macro-repeat.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert_eq!(vec![1; 3], vec![1, 1, 1]);
diff --git a/src/test/run-pass/vec-macro-rvalue-scope.rs b/src/test/run-pass/vec-macro-rvalue-scope.rs
index 5869558eacaff..305755347d04b 100644
--- a/src/test/run-pass/vec-macro-rvalue-scope.rs
+++ b/src/test/run-pass/vec-macro-rvalue-scope.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 fn one() -> i32 { 1 }
 
diff --git a/src/test/run-pass/vec-macro-with-trailing-comma.rs b/src/test/run-pass/vec-macro-with-trailing-comma.rs
index 3018a746b4a9d..35af249ef5fad 100644
--- a/src/test/run-pass/vec-macro-with-trailing-comma.rs
+++ b/src/test/run-pass/vec-macro-with-trailing-comma.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert_eq!(vec!(1), vec!(1,));
diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs
index 2b80ad81037f2..5728424e32bb1 100644
--- a/src/test/run-pass/vec-matching-autoslice.rs
+++ b/src/test/run-pass/vec-matching-autoslice.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]
 
diff --git a/src/test/run-pass/vec-matching-fixed.rs b/src/test/run-pass/vec-matching-fixed.rs
index 1278eaf96a48c..1ed6ddc411076 100644
--- a/src/test/run-pass/vec-matching-fixed.rs
+++ b/src/test/run-pass/vec-matching-fixed.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(advanced_slice_patterns)]
 #![feature(slice_patterns)]
diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs
index c375fc85bc1d3..ee70ea58750d9 100644
--- a/src/test/run-pass/vec-matching-fold.rs
+++ b/src/test/run-pass/vec-matching-fold.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(advanced_slice_patterns)]
 #![feature(slice_patterns)]
diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs
index b81bdda613f7c..eedf27f857700 100644
--- a/src/test/run-pass/vec-matching.rs
+++ b/src/test/run-pass/vec-matching.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(advanced_slice_patterns)]
 #![feature(slice_patterns)]
diff --git a/src/test/run-pass/vec-slice-drop.rs b/src/test/run-pass/vec-slice-drop.rs
index 1d749d4963c5e..f400869682fd2 100644
--- a/src/test/run-pass/vec-slice-drop.rs
+++ b/src/test/run-pass/vec-slice-drop.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_destructor)]
 
diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs
index 6baeb99df9e8c..a7e6cae93b34b 100644
--- a/src/test/run-pass/vec-slice.rs
+++ b/src/test/run-pass/vec-slice.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let  v = vec![1,2,3,4,5];
diff --git a/src/test/run-pass/vec-tail-matching.rs b/src/test/run-pass/vec-tail-matching.rs
index 091e3f03e7ac7..75f970543a45a 100644
--- a/src/test/run-pass/vec-tail-matching.rs
+++ b/src/test/run-pass/vec-tail-matching.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]
 
diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs
index a9bb68395c425..f000ada770a40 100644
--- a/src/test/run-pass/vec-to_str.rs
+++ b/src/test/run-pass/vec-to_str.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     assert_eq!(format!("{:?}", vec!(0, 1)), "[0, 1]".to_string());
diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs
index ce20d452c403c..c61b3d56dbfb9 100644
--- a/src/test/run-pass/vec.rs
+++ b/src/test/run-pass/vec.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let v: Vec<isize> = vec!(10, 20);
diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs
index eca7e62d67cbf..acb29d284b956 100644
--- a/src/test/run-pass/vector-sort-panic-safe.rs
+++ b/src/test/run-pass/vector-sort-panic-safe.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(rand, core)]
 
diff --git a/src/test/run-pass/wait-forked-but-failed-child.rs b/src/test/run-pass/wait-forked-but-failed-child.rs
index 079c97013abee..998360f08ba0d 100644
--- a/src/test/run-pass/wait-forked-but-failed-child.rs
+++ b/src/test/run-pass/wait-forked-but-failed-child.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(libc, old_io)]
 
diff --git a/src/test/run-pass/where-for-self.rs b/src/test/run-pass/where-for-self.rs
index eb95b13d3fa5b..1d477b87446d4 100644
--- a/src/test/run-pass/where-for-self.rs
+++ b/src/test/run-pass/where-for-self.rs
@@ -11,7 +11,6 @@
 // Test that we can quantify lifetimes outside a constraint (i.e., including
 // the self type) in a where clause.
 
-// pretty-expanded FIXME #23616
 
 static mut COUNT: u32 = 1;
 
diff --git a/src/test/run-pass/while-label.rs b/src/test/run-pass/while-label.rs
index 076ba8f428f06..8cbb845836f3e 100644
--- a/src/test/run-pass/while-label.rs
+++ b/src/test/run-pass/while-label.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-// pretty-expanded FIXME #23616
 
 pub fn main() {
     let mut i = 100;
diff --git a/src/test/run-pass/while-let.rs b/src/test/run-pass/while-let.rs
index b1e80c86ec72d..5a2ecdd45dbe5 100644
--- a/src/test/run-pass/while-let.rs
+++ b/src/test/run-pass/while-let.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(collections)]
 
diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs
index 10718e981ff59..7339fe47dc297 100644
--- a/src/test/run-pass/writealias.rs
+++ b/src/test/run-pass/writealias.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 use std::sync::Mutex;
 
diff --git a/src/test/run-pass/x86stdcall2.rs b/src/test/run-pass/x86stdcall2.rs
index 7b15531dacc33..62da9c9d14be2 100644
--- a/src/test/run-pass/x86stdcall2.rs
+++ b/src/test/run-pass/x86stdcall2.rs
@@ -10,6 +10,8 @@
 
 // pretty-expanded FIXME #23616
 
+#![feature(std_misc)]
+
 pub type HANDLE = u32;
 pub type DWORD = u32;
 pub type SIZE_T = u32;
diff --git a/src/test/run-pass/xcrate-address-insignificant.rs b/src/test/run-pass/xcrate-address-insignificant.rs
index ac8b15d7bf589..8794ecd061b47 100644
--- a/src/test/run-pass/xcrate-address-insignificant.rs
+++ b/src/test/run-pass/xcrate-address-insignificant.rs
@@ -10,7 +10,6 @@
 
 // aux-build:xcrate_address_insignificant.rs
 
-// pretty-expanded FIXME #23616
 
 extern crate xcrate_address_insignificant as foo;
 
diff --git a/src/test/run-pass/zero-size-type-destructors.rs b/src/test/run-pass/zero-size-type-destructors.rs
index dea9edf0582bd..a80faeaea7ea7 100644
--- a/src/test/run-pass/zero-size-type-destructors.rs
+++ b/src/test/run-pass/zero-size-type-destructors.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(unsafe_no_drop_flag)]
 
diff --git a/src/test/run-pass/zero_sized_subslice_match.rs b/src/test/run-pass/zero_sized_subslice_match.rs
index b98f907774b97..697508ae48889 100644
--- a/src/test/run-pass/zero_sized_subslice_match.rs
+++ b/src/test/run-pass/zero_sized_subslice_match.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
 
 #![feature(slice_patterns)]