From d89c7024edc5f64294ba7386b08215c93886fac7 Mon Sep 17 00:00:00 2001
From: Sergio Benitez <sb@sergio.bz>
Date: Sat, 27 Jun 2020 22:59:40 -0700
Subject: [PATCH] Replace 'Manifest' with 'Cargo'.

This is largely an internal change. Prior to this commit, the 'Manifest'
type, now replaced with the 'Cargo' type, robbed responsibility from the
core 'Rocket' type. This new construction restores the previous
responsibility and makes it clear that 'Cargo' is _only_ for freezing,
and representing the stability of, Rocket's internal state.
---
 contrib/codegen/src/database.rs            |   4 +-
 contrib/lib/src/databases.rs               |   2 +-
 contrib/lib/src/helmet/helmet.rs           |   8 +-
 contrib/lib/src/templates/mod.rs           |   8 +-
 contrib/lib/tests/templates.rs             |  14 +-
 core/codegen/src/attribute/async_entry.rs  |   1 +
 core/lib/benches/simple-routing.rs         |   2 +-
 core/lib/src/catcher.rs                    |   9 +
 core/lib/src/ext.rs                        |  52 +-
 core/lib/src/fairing/ad_hoc.rs             |  10 +-
 core/lib/src/fairing/fairings.rs           |   6 +-
 core/lib/src/fairing/info_kind.rs          |   1 +
 core/lib/src/fairing/mod.rs                |  14 +-
 core/lib/src/lib.rs                        |   2 +-
 core/lib/src/local/client.rs               |  41 +-
 core/lib/src/local/request.rs              |   6 +-
 core/lib/src/request/request.rs            |  14 +-
 core/lib/src/request/state.rs              |  12 +-
 core/lib/src/request/tests.rs              |   2 +-
 core/lib/src/rocket.rs                     | 649 +++++++++++----------
 core/lib/src/router/collider.rs            |   4 +-
 core/lib/src/router/mod.rs                 |   4 +-
 core/lib/tests/attach-inspect.rs           |  43 ++
 examples/cookies/src/tests.rs              |   4 +-
 examples/handlebars_templates/src/tests.rs |   6 +-
 examples/request_local_state/src/tests.rs  |   6 +-
 examples/state/src/tests.rs                |   8 +-
 examples/tera_templates/src/tests.rs       |   6 +-
 28 files changed, 534 insertions(+), 404 deletions(-)
 create mode 100644 core/lib/tests/attach-inspect.rs

diff --git a/contrib/codegen/src/database.rs b/contrib/codegen/src/database.rs
index efd23441..2fea4263 100644
--- a/contrib/codegen/src/database.rs
+++ b/contrib/codegen/src/database.rs
@@ -118,8 +118,8 @@ pub fn database_attr(attr: TokenStream, input: TokenStream) -> Result<TokenStrea
             /// Retrieves a connection of type `Self` from the `rocket`
             /// instance. Returns `Some` as long as `Self::fairing()` has been
             /// attached and there is at least one connection in the pool.
-            pub fn get_one(manifest: &::rocket::Manifest) -> Option<Self> {
-                manifest.state::<#pool_type>()
+            pub fn get_one(cargo: &::rocket::Cargo) -> Option<Self> {
+                cargo.state::<#pool_type>()
                     .and_then(|pool| pool.0.get().ok())
                     .map(#guard_type)
             }
diff --git a/contrib/lib/src/databases.rs b/contrib/lib/src/databases.rs
index 2251a8ec..37a8a254 100644
--- a/contrib/lib/src/databases.rs
+++ b/contrib/lib/src/databases.rs
@@ -239,7 +239,7 @@
 //!      Returns a fairing that initializes the associated database connection
 //!      pool.
 //!
-//!   * `fn get_one(&Manifest) -> Option<Self>`
+//!   * `fn get_one(&Cargo) -> Option<Self>`
 //!
 //!     Retrieves a connection from the configured pool. Returns `Some` as long
 //!     as `Self::fairing()` has been attached and there is at least one
diff --git a/contrib/lib/src/helmet/helmet.rs b/contrib/lib/src/helmet/helmet.rs
index e6a863eb..8ca38316 100644
--- a/contrib/lib/src/helmet/helmet.rs
+++ b/contrib/lib/src/helmet/helmet.rs
@@ -3,7 +3,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 
 use rocket::http::uncased::UncasedStr;
 use rocket::fairing::{Fairing, Info, Kind};
-use rocket::{Manifest, Request, Response};
+use rocket::{Cargo, Request, Response};
 
 use crate::helmet::*;
 
@@ -201,9 +201,9 @@ impl Fairing for SpaceHelmet {
         self.apply(res);
     }
 
-    fn on_launch(&self, manifest: &Manifest) {
-        if manifest.config().tls_enabled()
-            && !manifest.config().environment.is_dev()
+    fn on_launch(&self, cargo: &Cargo) {
+        if cargo.config().tls_enabled()
+            && !cargo.config().environment.is_dev()
             && !self.is_enabled::<Hsts>()
         {
             warn_!("Space Helmet: deploying with TLS without enabling HSTS.");
diff --git a/contrib/lib/src/templates/mod.rs b/contrib/lib/src/templates/mod.rs
index 4cd2c8c8..ada0b48c 100644
--- a/contrib/lib/src/templates/mod.rs
+++ b/contrib/lib/src/templates/mod.rs
@@ -141,7 +141,7 @@ use serde_json::{Value, to_value};
 use std::borrow::Cow;
 use std::path::PathBuf;
 
-use rocket::Manifest;
+use rocket::Cargo;
 use rocket::request::Request;
 use rocket::fairing::Fairing;
 use rocket::response::{self, Content, Responder};
@@ -340,15 +340,15 @@ impl Template {
     ///
     ///     # context.insert("test", "test");
     ///     # #[allow(unused_variables)]
-    ///     let template = Template::show(client.manifest(), "index", context);
+    ///     let template = Template::show(client.cargo(), "index", context);
     /// # });
     /// }
     /// ```
     #[inline]
-    pub fn show<S, C>(manifest: &Manifest, name: S, context: C) -> Option<String>
+    pub fn show<S, C>(cargo: &Cargo, name: S, context: C) -> Option<String>
         where S: Into<Cow<'static, str>>, C: Serialize
     {
-        let ctxt = manifest.state::<ContextManager>().map(ContextManager::context).or_else(|| {
+        let ctxt = cargo.state::<ContextManager>().map(ContextManager::context).or_else(|| {
             warn!("Uninitialized template context: missing fairing.");
             info!("To use templates, you must attach `Template::fairing()`.");
             info!("See the `Template` documentation for more information.");
diff --git a/contrib/lib/tests/templates.rs b/contrib/lib/tests/templates.rs
index 6d7e0361..ed51bfed 100644
--- a/contrib/lib/tests/templates.rs
+++ b/contrib/lib/tests/templates.rs
@@ -52,17 +52,17 @@ mod templates_tests {
         #[rocket::async_test]
         async fn test_tera_templates() {
             let mut rocket = rocket();
-            let manifest = rocket.inspect().await;
+            let cargo = rocket.inspect().await;
             let mut map = HashMap::new();
             map.insert("title", "_test_");
             map.insert("content", "<script />");
 
             // Test with a txt file, which shouldn't escape.
-            let template = Template::show(manifest, "tera/txt_test", &map);
+            let template = Template::show(cargo, "tera/txt_test", &map);
             assert_eq!(template, Some(UNESCAPED_EXPECTED.into()));
 
             // Now with an HTML file, which should.
-            let template = Template::show(manifest, "tera/html_test", &map);
+            let template = Template::show(cargo, "tera/html_test", &map);
             assert_eq!(template, Some(ESCAPED_EXPECTED.into()));
         }
 
@@ -97,13 +97,13 @@ mod templates_tests {
         #[rocket::async_test]
         async fn test_handlebars_templates() {
             let mut rocket = rocket();
-            let manifest = rocket.inspect().await;
+            let cargo = rocket.inspect().await;
             let mut map = HashMap::new();
             map.insert("title", "_test_");
             map.insert("content", "<script /> hi");
 
             // Test with a txt file, which shouldn't escape.
-            let template = Template::show(manifest, "hbs/test", &map);
+            let template = Template::show(cargo, "hbs/test", &map);
             assert_eq!(template, Some(EXPECTED.into()));
         }
 
@@ -153,7 +153,7 @@ mod templates_tests {
             }
 
             // verify that the initial content is correct
-            let initial_rendered = Template::show(client.manifest(), RELOAD_TEMPLATE, ());
+            let initial_rendered = Template::show(client.cargo(), RELOAD_TEMPLATE, ());
             assert_eq!(initial_rendered, Some(INITIAL_TEXT.into()));
 
             // write a change to the file
@@ -164,7 +164,7 @@ mod templates_tests {
                 client.get("/").dispatch().await;
 
                 // if the new content is correct, we are done
-                let new_rendered = Template::show(client.manifest(), RELOAD_TEMPLATE, ());
+                let new_rendered = Template::show(client.cargo(), RELOAD_TEMPLATE, ());
                 if new_rendered == Some(NEW_TEXT.into()) {
                     write_file(&reload_path, INITIAL_TEXT);
                     return;
diff --git a/core/codegen/src/attribute/async_entry.rs b/core/codegen/src/attribute/async_entry.rs
index e121129e..edb1f367 100644
--- a/core/codegen/src/attribute/async_entry.rs
+++ b/core/codegen/src/attribute/async_entry.rs
@@ -73,6 +73,7 @@ impl EntryAttr for Launch {
             ___rocket
         });
 
+        // FIXME: Don't duplicate the `#block` here!
         let (vis, mut sig) = (&f.vis, f.sig.clone());
         sig.ident = syn::Ident::new("main", sig.ident.span());
         sig.output = syn::ReturnType::Default;
diff --git a/core/lib/benches/simple-routing.rs b/core/lib/benches/simple-routing.rs
index b63474ed..576f2d50 100644
--- a/core/lib/benches/simple-routing.rs
+++ b/core/lib/benches/simple-routing.rs
@@ -114,7 +114,7 @@ mod benches {
 
         // Hold all of the requests we're going to make during the benchmark.
         let mut requests = vec![];
-        for route in client.manifest().routes() {
+        for route in client.cargo().routes() {
             let request = client.req(route.method, route.uri.path());
             requests.push(request);
         }
diff --git a/core/lib/src/catcher.rs b/core/lib/src/catcher.rs
index 74941cea..f750d474 100644
--- a/core/lib/src/catcher.rs
+++ b/core/lib/src/catcher.rs
@@ -123,6 +123,15 @@ impl fmt::Display for Catcher {
     }
 }
 
+impl fmt::Debug for Catcher {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Catcher")
+            .field("code", &self.code)
+            .field("default", &self.is_default)
+            .finish()
+    }
+}
+
 macro_rules! error_page_template {
     ($code:expr, $name:expr, $description:expr) => (
         concat!(r#"
diff --git a/core/lib/src/ext.rs b/core/lib/src/ext.rs
index 81236216..0595d625 100644
--- a/core/lib/src/ext.rs
+++ b/core/lib/src/ext.rs
@@ -2,7 +2,7 @@ use std::io::{self, Cursor};
 use std::pin::Pin;
 use std::task::{Poll, Context};
 
-use futures::{ready, future::BoxFuture, stream::Stream};
+use futures::{ready, Future, future::BoxFuture, stream::Stream};
 use tokio::io::{AsyncRead, AsyncReadExt as _};
 
 use crate::http::hyper;
@@ -111,3 +111,53 @@ impl AsyncRead for AsyncReadBody {
         }
     }
 }
+
+// The code below was adapted from the `replace_with` crate and reproduced here
+// under the rights granted by the MIT license. The code is copyright the
+// `replace_with` developers. See LICENSE-MIT for the full text.
+
+struct OnUnwind<F: FnOnce()>(std::mem::ManuallyDrop<F>);
+
+impl<F: FnOnce()> Drop for OnUnwind<F> {
+    #[inline(always)]
+    fn drop(&mut self) {
+        (unsafe { std::ptr::read(&*self.0) })();
+    }
+}
+
+#[inline(always)]
+pub async fn async_on_unwind<F, Fut, T, P: FnOnce()>(f: F, p: P) -> T
+    where F: FnOnce() -> Fut, Fut: Future<Output = T>,
+{
+    let x = OnUnwind(std::mem::ManuallyDrop::new(p));
+    let t = f().await;
+    let _ = unsafe { std::ptr::read(&*x.0) };
+    std::mem::forget(x);
+    t
+}
+
+#[inline]
+pub async fn async_replace_with_or_else<T, Fut, F, D>(dest: &mut T, d: D, f: F)
+    where Fut: Future<Output = T>,
+          F: FnOnce(T) -> Fut,
+          D: FnOnce() -> T,
+{
+    unsafe {
+        let old = std::ptr::read(dest);
+        let new = async_on_unwind(
+            || async move { f(old).await },
+            || std::ptr::write(dest, d()),
+        ).await;
+
+        std::ptr::write(dest, new);
+    }
+}
+
+
+#[inline]
+pub async fn async_replace_with<T, Fut, F>(dest: &mut T, f: F)
+    where Fut: Future<Output = T>,
+          F: FnOnce(T) -> Fut,
+{
+    async_replace_with_or_else(dest, || std::process::abort(), f).await
+}
diff --git a/core/lib/src/fairing/ad_hoc.rs b/core/lib/src/fairing/ad_hoc.rs
index 4d085673..9902c3c6 100644
--- a/core/lib/src/fairing/ad_hoc.rs
+++ b/core/lib/src/fairing/ad_hoc.rs
@@ -2,7 +2,7 @@ use std::sync::Mutex;
 
 use futures::future::{Future, BoxFuture};
 
-use crate::{Manifest, Rocket, Request, Response, Data};
+use crate::{Cargo, Rocket, Request, Response, Data};
 use crate::fairing::{Fairing, Kind, Info};
 
 /// A ad-hoc fairing that can be created from a function or closure.
@@ -67,7 +67,7 @@ enum AdHocKind {
         -> BoxFuture<'static, Result<Rocket, Rocket>> + Send + 'static>>>),
 
     /// An ad-hoc **launch** fairing. Called just before Rocket launches.
-    Launch(Mutex<Option<Box<dyn FnOnce(&Manifest) + Send + 'static>>>),
+    Launch(Mutex<Option<Box<dyn FnOnce(&Cargo) + Send + 'static>>>),
 
     /// An ad-hoc **request** fairing. Called when a request is received.
     Request(Box<dyn for<'a> Fn(&'a mut Request<'_>, &'a Data)
@@ -116,7 +116,7 @@ impl AdHoc {
     /// });
     /// ```
     pub fn on_launch<F: Send + 'static>(name: &'static str, f: F) -> AdHoc
-        where F: FnOnce(&Manifest)
+        where F: FnOnce(&Cargo)
     {
         AdHoc { name, kind: AdHocKind::Launch(Mutex::new(Some(Box::new(f)))) }
     }
@@ -204,11 +204,11 @@ impl Fairing for AdHoc {
         }
     }
 
-    fn on_launch(&self, manifest: &Manifest) {
+    fn on_launch(&self, state: &Cargo) {
         if let AdHocKind::Launch(ref mutex) = self.kind {
             let mut opt = mutex.lock().expect("AdHoc::Launch lock");
             let f = opt.take().expect("internal error: `on_launch` one-call invariant broken");
-            f(manifest)
+            f(state)
         }
     }
 
diff --git a/core/lib/src/fairing/fairings.rs b/core/lib/src/fairing/fairings.rs
index 48f8cd73..b09ac965 100644
--- a/core/lib/src/fairing/fairings.rs
+++ b/core/lib/src/fairing/fairings.rs
@@ -1,4 +1,4 @@
-use crate::{Manifest, Rocket, Request, Response, Data};
+use crate::{Cargo, Rocket, Request, Response, Data};
 use crate::fairing::{Fairing, Kind};
 use crate::logger::PaintExt;
 
@@ -52,9 +52,9 @@ impl Fairings {
     }
 
     #[inline(always)]
-    pub fn handle_launch(&self, manifest: &Manifest) {
+    pub fn handle_launch(&self, cargo: &Cargo) {
         for &i in &self.launch {
-            self.all_fairings[i].on_launch(manifest);
+            self.all_fairings[i].on_launch(cargo);
         }
     }
 
diff --git a/core/lib/src/fairing/info_kind.rs b/core/lib/src/fairing/info_kind.rs
index 0e0a0943..00dffb4b 100644
--- a/core/lib/src/fairing/info_kind.rs
+++ b/core/lib/src/fairing/info_kind.rs
@@ -22,6 +22,7 @@ use std::ops::BitOr;
 /// }
 /// # ;
 /// ```
+#[derive(Debug)]
 pub struct Info {
     /// The name of the fairing.
     pub name: &'static str,
diff --git a/core/lib/src/fairing/mod.rs b/core/lib/src/fairing/mod.rs
index 728a597e..f2062a60 100644
--- a/core/lib/src/fairing/mod.rs
+++ b/core/lib/src/fairing/mod.rs
@@ -47,7 +47,7 @@
 //! of other `Fairings` are not jeopardized. For instance, unless it is made
 //! abundantly clear, a fairing should not rewrite every request.
 
-use crate::{Manifest, Rocket, Request, Response, Data};
+use crate::{Cargo, Rocket, Request, Response, Data};
 
 mod fairings;
 mod ad_hoc;
@@ -196,7 +196,7 @@ pub use self::info_kind::{Info, Kind};
 /// decorated with an attribute of `#[rocket::async_trait]`:
 ///
 /// ```rust
-/// use rocket::{Manifest, Rocket, Request, Data, Response};
+/// use rocket::{Cargo, Rocket, Request, Data, Response};
 /// use rocket::fairing::{Fairing, Info, Kind};
 ///
 /// # struct MyType;
@@ -212,7 +212,7 @@ pub use self::info_kind::{Info, Kind};
 ///         # unimplemented!()
 ///     }
 ///
-///     fn on_launch(&self, manifest: &Manifest) {
+///     fn on_launch(&self, cargo: &Cargo) {
 ///         /* ... */
 ///         # unimplemented!()
 ///     }
@@ -421,14 +421,14 @@ pub trait Fairing: Send + Sync + 'static {
     ///
     /// This method is called just prior to launching the application if
     /// `Kind::Launch` is in the `kind` field of the `Info` structure for this
-    /// fairing. The `Manifest` parameter corresponds to the application that
+    /// fairing. The `Cargo` parameter corresponds to the application that
     /// will be launched.
     ///
     /// ## Default Implementation
     ///
     /// The default implementation of this method does nothing.
     #[allow(unused_variables)]
-    fn on_launch(&self, manifest: &Manifest) {}
+    fn on_launch(&self, cargo: &Cargo) {}
 
     /// The request callback.
     ///
@@ -470,8 +470,8 @@ impl<T: Fairing> Fairing for std::sync::Arc<T> {
     }
 
     #[inline]
-    fn on_launch(&self, manifest: &Manifest) {
-        (self as &T).on_launch(manifest)
+    fn on_launch(&self, cargo: &Cargo) {
+        (self as &T).on_launch(cargo)
     }
 
     #[inline]
diff --git a/core/lib/src/lib.rs b/core/lib/src/lib.rs
index 5aac7fab..79a19fcb 100644
--- a/core/lib/src/lib.rs
+++ b/core/lib/src/lib.rs
@@ -139,7 +139,7 @@ mod ext;
 pub use crate::router::Route;
 pub use crate::request::{Request, State};
 pub use crate::catcher::Catcher;
-pub use crate::rocket::{Manifest, Rocket};
+pub use crate::rocket::{Cargo, Rocket};
 
 /// Alias to [`Rocket::ignite()`] Creates a new instance of `Rocket`.
 pub fn ignite() -> Rocket {
diff --git a/core/lib/src/local/client.rs b/core/lib/src/local/client.rs
index a5900149..b4570492 100644
--- a/core/lib/src/local/client.rs
+++ b/core/lib/src/local/client.rs
@@ -1,7 +1,7 @@
 use std::sync::RwLock;
 use std::borrow::Cow;
 
-use crate::rocket::{Rocket, Manifest};
+use crate::rocket::{Rocket, Cargo};
 use crate::local::LocalRequest;
 use crate::http::{Method, private::CookieJar};
 use crate::error::LaunchError;
@@ -70,7 +70,7 @@ use crate::error::LaunchError;
 /// [`put()`]: #method.put
 /// [`post()`]: #method.post
 pub struct Client {
-    manifest: Manifest,
+    cargo: Cargo,
     pub(crate) cookies: Option<RwLock<CookieJar>>,
 }
 
@@ -78,16 +78,14 @@ impl Client {
     /// Constructs a new `Client`. If `tracked` is `true`, an empty `CookieJar`
     /// is created for cookie tracking. Otherwise, the internal `CookieJar` is
     /// set to `None`.
-    async fn _new(rocket: Rocket, tracked: bool) -> Result<Client, LaunchError> {
-        let mut manifest = rocket.actualize_and_take_manifest().await;
-        manifest.prelaunch_check()?;
-
+    async fn _new(mut rocket: Rocket, tracked: bool) -> Result<Client, LaunchError> {
+        rocket.prelaunch_check().await?;
         let cookies = match tracked {
             true => Some(RwLock::new(CookieJar::new())),
             false => None
         };
 
-        Ok(Client { manifest, cookies })
+        Ok(Client { cargo: rocket.into_cargo().await, cookies })
     }
 
     /// Construct a new `Client` from an instance of `Rocket` with cookie
@@ -153,7 +151,7 @@ impl Client {
         Client::_new(rocket, false).await
     }
 
-    /// Returns a reference to the `Manifest` of the `Rocket` this client is
+    /// Returns a reference to the `Rocket` of the `Rocket` this client is
     /// creating requests for.
     ///
     /// # Example
@@ -165,13 +163,32 @@ impl Client {
     /// let my_rocket = rocket::ignite();
     /// let client = Client::new(my_rocket).await.expect("valid rocket");
     ///
-    /// // get access to the manifest within `client`
-    /// let manifest = client.manifest();
+    /// let rocket = client.rocket();
     /// # });
     /// ```
     #[inline(always)]
-    pub fn manifest(&self) -> &Manifest {
-        &self.manifest
+    pub fn rocket(&self) -> &Rocket {
+        &*self.cargo
+    }
+
+    /// Returns a reference to the `Rocket` of the `Rocket` this client is
+    /// creating requests for.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use rocket::local::Client;
+    ///
+    /// # rocket::async_test(async {
+    /// let my_rocket = rocket::ignite();
+    /// let client = Client::new(my_rocket).await.expect("valid rocket");
+    ///
+    /// let cargo = client.cargo();
+    /// # });
+    /// ```
+    #[inline(always)]
+    pub fn cargo(&self) -> &Cargo {
+        &self.cargo
     }
 
     /// Create a local `GET` request to the URI `uri`.
diff --git a/core/lib/src/local/request.rs b/core/lib/src/local/request.rs
index 9ab669e7..1b02350e 100644
--- a/core/lib/src/local/request.rs
+++ b/core/lib/src/local/request.rs
@@ -105,7 +105,7 @@ impl<'c> LocalRequest<'c> {
         uri: Cow<'c, str>
     ) -> LocalRequest<'c> {
         // We set a dummy string for now and check the user's URI on dispatch.
-        let request = Request::new(client.manifest(), method, Origin::dummy());
+        let request = Request::new(client.rocket(), method, Origin::dummy());
 
         // Set up any cookies we know about.
         if let Some(ref jar) = client.cookies {
@@ -428,12 +428,12 @@ impl<'c> LocalRequest<'c> {
             request.set_uri(uri.into_owned());
         } else {
             error!("Malformed request URI: {}", uri);
-            let res = client.manifest().handle_error(Status::BadRequest, request).await;
+            let res = client.rocket().handle_error(Status::BadRequest, request).await;
             return LocalResponse { _request: owned_request, response: res };
         }
 
         // Actually dispatch the request.
-        let response = client.manifest().dispatch(request, Data::local(data)).await;
+        let response = client.rocket().dispatch(request, Data::local(data)).await;
 
         // If the client is tracking cookies, updates the internal cookie jar
         // with the changes reflected by `response`.
diff --git a/core/lib/src/request/request.rs b/core/lib/src/request/request.rs
index 6f24c363..75867089 100644
--- a/core/lib/src/request/request.rs
+++ b/core/lib/src/request/request.rs
@@ -11,7 +11,7 @@ use futures::future::BoxFuture;
 use crate::request::{FromParam, FromSegments, FromRequest, Outcome};
 use crate::request::{FromFormValue, FormItems, FormItem};
 
-use crate::rocket::{Rocket, Manifest};
+use crate::rocket::Rocket;
 use crate::router::Route;
 use crate::config::{Config, Limits};
 use crate::http::{hyper, uri::{Origin, Segments}};
@@ -60,7 +60,7 @@ impl<'r> Request<'r> {
     /// Create a new `Request` with the given `method` and `uri`.
     #[inline(always)]
     pub(crate) fn new<'s: 'r>(
-        manifest: &'r Manifest,
+        rocket: &'r Rocket,
         method: Method,
         uri: Origin<'s>
     ) -> Request<'r> {
@@ -72,8 +72,8 @@ impl<'r> Request<'r> {
             state: RequestState {
                 path_segments: SmallVec::new(),
                 query_items: None,
-                config: &manifest.config,
-                managed: &manifest.state,
+                config: &rocket.config,
+                managed: &rocket.managed_state,
                 route: RwLock::new(None),
                 cookies: Mutex::new(Some(CookieJar::new())),
                 accept: Storage::new(),
@@ -749,7 +749,7 @@ impl<'r> Request<'r> {
     pub fn example<F: Fn(&mut Request<'_>)>(method: Method, uri: &str, f: F) {
         let rocket = Rocket::custom(Config::development());
         let uri = Origin::parse(uri).expect("invalid URI in example");
-        let mut request = Request::new(rocket._manifest(), method, uri);
+        let mut request = Request::new(&rocket, method, uri);
         f(&mut request);
     }
 
@@ -832,7 +832,7 @@ impl<'r> Request<'r> {
 
     /// Convert from Hyper types into a Rocket Request.
     pub(crate) fn from_hyp(
-        manifest: &'r Manifest,
+        rocket: &'r Rocket,
         h_method: hyper::Method,
         h_headers: hyper::HeaderMap<hyper::HeaderValue>,
         h_uri: &'r hyper::Uri,
@@ -854,7 +854,7 @@ impl<'r> Request<'r> {
         let uri = Origin::parse(uri).map_err(|e| e.to_string())?;
 
         // Construct the request object.
-        let mut request = Request::new(manifest, method, uri);
+        let mut request = Request::new(rocket, method, uri);
         request.set_remote(h_addr);
 
         // Set the request cookies, if they exist.
diff --git a/core/lib/src/request/state.rs b/core/lib/src/request/state.rs
index 7a6f71e0..dd83556e 100644
--- a/core/lib/src/request/state.rs
+++ b/core/lib/src/request/state.rs
@@ -1,6 +1,6 @@
 use std::ops::Deref;
 
-use crate::rocket::Manifest;
+use crate::rocket::Cargo;
 use crate::request::{self, FromRequest, Request};
 use crate::outcome::Outcome;
 use crate::http::Status;
@@ -150,18 +150,18 @@ impl<'r, T: Send + Sync + 'static> State<'r, T> {
     ///
     /// # rocket::async_test(async {
     /// let mut rocket = rocket::ignite().manage(Managed(7));
-    /// let manifest = rocket.inspect().await;
+    /// let cargo = rocket.inspect().await;
     ///
-    /// let state: Option<State<Managed>> = State::from(manifest);
+    /// let state: Option<State<Managed>> = State::from(cargo);
     /// assert_eq!(state.map(|s| s.inner()), Some(&Managed(7)));
     ///
-    /// let state: Option<State<Unmanaged>> = State::from(manifest);
+    /// let state: Option<State<Unmanaged>> = State::from(cargo);
     /// assert_eq!(state, None);
     /// # });
     /// ```
     #[inline(always)]
-    pub fn from(manifest: &'r Manifest) -> Option<Self> {
-        manifest.state().map(State)
+    pub fn from(rocket: &'r Cargo) -> Option<Self> {
+        rocket.state().map(State)
     }
 }
 
diff --git a/core/lib/src/request/tests.rs b/core/lib/src/request/tests.rs
index 90783738..9e50feaa 100644
--- a/core/lib/src/request/tests.rs
+++ b/core/lib/src/request/tests.rs
@@ -22,7 +22,7 @@ macro_rules! assert_headers {
         // Dispatch the request and check that the headers are what we expect.
         let config = Config::development();
         let r = Rocket::custom(config);
-        let req = Request::from_hyp(r._manifest(), h_method, h_headers, &h_uri, h_addr).unwrap();
+        let req = Request::from_hyp(&r, h_method, h_headers, &h_uri, h_addr).unwrap();
         let actual_headers = req.headers();
         for (key, values) in expected.iter() {
             let actual: Vec<_> = actual_headers.get(key).collect();
diff --git a/core/lib/src/rocket.rs b/core/lib/src/rocket.rs
index c1dfa7bf..453b9124 100644
--- a/core/lib/src/rocket.rs
+++ b/core/lib/src/rocket.rs
@@ -23,7 +23,7 @@ use crate::outcome::Outcome;
 use crate::error::{LaunchError, LaunchErrorKind};
 use crate::fairing::{Fairing, Fairings};
 use crate::logger::PaintExt;
-use crate::ext::AsyncReadExt;
+use crate::ext::{AsyncReadExt, async_replace_with};
 use crate::shutdown::{ShutdownHandle, ShutdownHandleManaged};
 
 use crate::http::{Method, Status, Header};
@@ -34,39 +34,135 @@ use crate::http::uri::Origin;
 /// The main `Rocket` type: used to mount routes and catchers and launch the
 /// application.
 pub struct Rocket {
-    pub(crate) manifest: Option<Manifest>,
-    pending: Vec<BuildOperation>,
-}
-
-enum BuildOperation {
-    Mount(Origin<'static>, Vec<Route>),
-    Register(Vec<Catcher>),
-    Manage(Box<dyn FnOnce(Manifest) -> Manifest + Send + Sync + 'static>),
-    Attach(Box<dyn Fairing>),
-}
-
-/// The state of an unlaunched [`Rocket`].
-///
-/// A `Manifest` includes configuration, managed state, and mounted routes and
-/// can be accessed through [`Rocket::inspect()`] before launching.
-pub struct Manifest {
+    manifest: Vec<PreLaunchOp>,
     pub(crate) config: Config,
     router: Router,
     default_catchers: HashMap<u16, Catcher>,
     catchers: HashMap<u16, Catcher>,
-    pub(crate) state: Container,
+    pub(crate) managed_state: Container,
     fairings: Fairings,
     shutdown_handle: ShutdownHandle,
     shutdown_receiver: Option<mpsc::Receiver<()>>,
 }
 
-// This function tries to hide all of the Hyper-ness from Rocket. It
-// essentially converts Hyper types into Rocket types, then calls the
-// `dispatch` function, which knows nothing about Hyper. Because responding
-// depends on the `HyperResponse` type, this function does the actual
-// response processing.
+/// An operation that occurs prior to launching a Rocket instance.
+enum PreLaunchOp {
+    Mount(Origin<'static>, Vec<Route>),
+    Register(Vec<Catcher>),
+    Manage(&'static str, Box<dyn FnOnce(&mut Container) + Send + Sync + 'static>),
+    Attach(Box<dyn Fairing>),
+}
+
+/// A frozen view into the contents of an instance of `Rocket`.
+///
+/// Obtained via [`Rocket::inspect()`].
+#[repr(transparent)]
+pub struct Cargo(Rocket);
+
+impl Rocket {
+    #[inline]
+    fn _mount(&mut self, base: Origin<'static>, routes: Vec<Route>) {
+        info!("{}{} {}{}",
+              Paint::emoji("🛰  "),
+              Paint::magenta("Mounting"),
+              Paint::blue(&base),
+              Paint::magenta(":"));
+
+        for mut route in routes {
+            let path = route.uri.clone();
+            if let Err(e) = route.set_uri(base.clone(), path) {
+                error_!("{}", e);
+                panic!("Invalid route URI.");
+            }
+
+            info_!("{}", route);
+            self.router.add(route);
+        }
+    }
+
+    #[inline]
+    fn _register(&mut self, catchers: Vec<Catcher>) {
+        info!("{}{}", Paint::emoji("👾 "), Paint::magenta("Catchers:"));
+
+        for c in catchers {
+            if self.catchers.get(&c.code).map_or(false, |e| !e.is_default) {
+                info_!("{} {}", c, Paint::yellow("(warning: duplicate catcher!)"));
+            } else {
+                info_!("{}", c);
+            }
+
+            self.catchers.insert(c.code, c);
+        }
+    }
+
+    #[inline]
+    async fn _attach(mut self, fairing: Box<dyn Fairing>) -> Self {
+        // Attach (and run attach-) fairings, which requires us to move `self`.
+        let mut fairings = mem::replace(&mut self.fairings, Fairings::new());
+        self = fairings.attach(fairing, self).await;
+
+        // Note that `self.fairings` may now be non-empty! Move them to the end.
+        fairings.append(self.fairings);
+        self.fairings = fairings;
+        self
+    }
+
+    // Instead of requiring the user to individually `await` each call to
+    // `attach()`, some operations are queued in `self.pending`. Functions that
+    // want to provide read access to any data from the Cargo, such as
+    // `inspect()`, need to apply those pending operations first.
+    //
+    // This function returns a future that executes those pending operations,
+    // requiring only a single `await` at the call site. After completion,
+    // `self.pending` will be empty and `self.manifest` will reflect all pending
+    // changes.
+    //
+    // Note that this returns a boxed future, because `_attach()` calls this
+    // function again creating a cycle.
+    fn actualize_manifest(&mut self) -> BoxFuture<'_, ()> {
+        Box::pin(async move {
+            // Note: attach fairings may add more ops to the `manifest`! We
+            // process them as a stack to maintain proper ordering.
+            let mut manifest = mem::replace(&mut self.manifest, vec![]);
+            while !manifest.is_empty() {
+                trace_!("[MANIEST PROGRESS]: {:?}", manifest);
+                match manifest.remove(0) {
+                    PreLaunchOp::Manage(_, callback) => callback(&mut self.managed_state),
+                    PreLaunchOp::Mount(base, routes) => self._mount(base, routes),
+                    PreLaunchOp::Register(catchers) => self._register(catchers),
+                    PreLaunchOp::Attach(fairing) => {
+                        async_replace_with(self, |rocket| rocket._attach(fairing)).await;
+                        self.manifest.append(&mut manifest);
+                        manifest = mem::replace(&mut self.manifest, vec![]);
+                    }
+                }
+            }
+        })
+    }
+
+    pub(crate) async fn into_cargo(mut self) -> Cargo {
+        self.actualize_manifest().await;
+        Cargo(self)
+    }
+
+    fn cargo(&self) -> &Cargo {
+        if !self.manifest.is_empty() {
+            panic!("internal error: immutable launch state with manifest");
+        }
+
+        // This is simply a `newtype`-like transformation. The
+        // `repr(transparent)` on `Cargo` ensures that this is safe and
+        // correct. Note that this exact pattern appears often in `std`.
+        unsafe { &*(self as *const Rocket as *const Cargo) }
+    }
+}
+
+// This function tries to hide all of the Hyper-ness from Rocket. It essentially
+// converts Hyper types into Rocket types, then calls the `dispatch` function,
+// which knows nothing about Hyper. Because responding depends on the
+// `HyperResponse` type, this function does the actual response processing.
 fn hyper_service_fn(
-    rocket: Arc<Manifest>,
+    rocket: Arc<Rocket>,
     h_addr: std::net::SocketAddr,
     hyp_req: hyper::Request<hyper::Body>,
 ) -> impl Future<Output = Result<hyper::Response<hyper::Body>, io::Error>> {
@@ -109,7 +205,7 @@ fn hyper_service_fn(
     }
 }
 
-impl Manifest {
+impl Rocket {
     #[inline]
     async fn issue_response(
         &self,
@@ -180,9 +276,7 @@ impl Manifest {
 
         Ok(())
     }
-}
 
-impl Manifest {
     /// Preprocess the request for Rocket things. Currently, this means:
     ///
     ///   * Rewriting the method in the request if _method form field exists.
@@ -209,45 +303,6 @@ impl Manifest {
         }
     }
 
-    #[inline]
-    pub(crate) fn dispatch<'s, 'r: 's>(
-        &'s self,
-        request: &'r mut Request<'s>,
-        data: Data
-    ) -> impl Future<Output = Response<'r>> + 's {
-        async move {
-            info!("{}:", request);
-
-            // Do a bit of preprocessing before routing.
-            self.preprocess_request(request, &data);
-
-            // Run the request fairings.
-            self.fairings.handle_request(request, &data).await;
-
-            // Remember if the request is a `HEAD` request for later body stripping.
-            let was_head_request = request.method() == Method::Head;
-
-            // Route the request and run the user's handlers.
-            let mut response = self.route_and_process(request, data).await;
-
-            // Add a default 'Server' header if it isn't already there.
-            // TODO: If removing Hyper, write out `Date` header too.
-            if !response.headers().contains("Server") {
-                response.set_header(Header::new("Server", "Rocket"));
-            }
-
-            // Run the response fairings.
-            self.fairings.handle_response(request, &mut response).await;
-
-            // Strip the body if this is a `HEAD` request.
-            if was_head_request {
-                response.strip_body();
-            }
-
-            response
-        }
-    }
-
     /// Route the request and process the outcome to eventually get a response.
     fn route_and_process<'s, 'r: 's>(
         &'s self,
@@ -328,6 +383,45 @@ impl Manifest {
         }
     }
 
+    #[inline]
+    pub(crate) fn dispatch<'s, 'r: 's>(
+        &'s self,
+        request: &'r mut Request<'s>,
+        data: Data
+    ) -> impl Future<Output = Response<'r>> + 's {
+        async move {
+            info!("{}:", request);
+
+            // Do a bit of preprocessing before routing.
+            self.preprocess_request(request, &data);
+
+            // Run the request fairings.
+            self.fairings.handle_request(request, &data).await;
+
+            // Remember if the request is `HEAD` for later body stripping.
+            let was_head_request = request.method() == Method::Head;
+
+            // Route the request and run the user's handlers.
+            let mut response = self.route_and_process(request, data).await;
+
+            // Add a default 'Server' header if it isn't already there.
+            // TODO: If removing Hyper, write out `Date` header too.
+            if !response.headers().contains("Server") {
+                response.set_header(Header::new("Server", "Rocket"));
+            }
+
+            // Run the response fairings.
+            self.fairings.handle_response(request, &mut response).await;
+
+            // Strip the body if this is a `HEAD` request.
+            if was_head_request {
+                response.strip_body();
+            }
+
+            response
+        }
+    }
+
     // Finds the error catcher for the status `status` and executes it for the
     // given request `req`. If a user has registered a catcher for `status`, the
     // catcher is called. If the catcher fails to return a good response, the
@@ -364,104 +458,23 @@ impl Manifest {
             }
         }
     }
-}
-
-impl Manifest {
-    #[inline]
-    fn _mount(mut self, base: Origin<'static>, routes: Vec<Route>) -> Self {
-        info!("{}{} {}{}",
-              Paint::emoji("🛰  "),
-              Paint::magenta("Mounting"),
-              Paint::blue(&base),
-              Paint::magenta(":"));
-
-        for mut route in routes {
-            let path = route.uri.clone();
-            if let Err(e) = route.set_uri(base.clone(), path) {
-                error_!("{}", e);
-                panic!("Invalid route URI.");
-            }
-
-            info_!("{}", route);
-            self.router.add(route);
-        }
-
-        self
-    }
-
-    #[inline]
-    fn _register(mut self, catchers: Vec<Catcher>) -> Self {
-        info!("{}{}", Paint::emoji("👾 "), Paint::magenta("Catchers:"));
-
-        for c in catchers {
-            if self.catchers.get(&c.code).map_or(false, |e| !e.is_default) {
-                info_!("{} {}", c, Paint::yellow("(warning: duplicate catcher!)"));
-            } else {
-                info_!("{}", c);
-            }
-
-            self.catchers.insert(c.code, c);
-        }
-        self
-    }
-
-    #[inline]
-    fn _manage(self, callback: Box<dyn FnOnce(Manifest) -> Manifest>) -> Self {
-        callback(self)
-    }
-
-    #[inline]
-    async fn _attach(mut self, fairing: Box<dyn Fairing>) -> Self {
-        // Attach (and run attach) fairings, which requires us to move `self`.
-        let mut fairings = mem::replace(&mut self.fairings, Fairings::new());
-
-        let mut rocket = Rocket { manifest: Some(self), pending: vec![] };
-        rocket = fairings.attach(fairing, rocket).await;
-        self = rocket.actualize_and_take_manifest().await;
-
-        // Make sure we keep all fairings around: the old and newly added ones!
-        fairings.append(self.fairings);
-        self.fairings = fairings;
-        self
-    }
-
-    pub(crate) fn prelaunch_check(&mut self) -> Result<(), LaunchError> {
-        if let Err(e) = self.router.collisions() {
-            return Err(LaunchError::new(LaunchErrorKind::Collision(e)));
-        }
-
-        if let Some(failures) = self.fairings.failures() {
-            return Err(LaunchError::new(LaunchErrorKind::FailedFairings(failures.to_vec())))
-        }
-
-        Ok(())
-    }
 
     // TODO.async: Solidify the Listener APIs and make this function public
     async fn listen_on<L>(mut self, listener: L) -> Result<(), crate::error::Error>
-    where
-        L: Listener + Send + Unpin + 'static,
-        <L as Listener>::Connection: Send + Unpin + 'static,
+        where L: Listener + Send + Unpin + 'static,
+              <L as Listener>::Connection: Send + Unpin + 'static,
     {
-        self.fairings.pretty_print_counts();
-
         // Determine the address and port we actually binded to.
         self.config.port = listener.local_addr().map(|a| a.port()).unwrap_or(0);
-
         let proto = self.config.tls.as_ref().map_or("http://", |_| "https://");
-
         let full_addr = format!("{}:{}", self.config.address, self.config.port);
 
-        // Set the keep-alive.
-        // TODO.async: implement keep-alive in Listener
-        // let timeout = self.config.keep_alive.map(|s| Duration::from_secs(s as u64));
-        // listener.set_keepalive(timeout);
-
         // Freeze managed state for synchronization-free accesses later.
-        self.state.freeze();
+        self.managed_state.freeze();
 
         // Run the launch fairings.
-        self.fairings.handle_launch(&self);
+        self.fairings.pretty_print_counts();
+        self.fairings.handle_launch(self.cargo());
 
         launch_info!("{}{} {}{}",
                      Paint::emoji("🚀 "),
@@ -472,6 +485,11 @@ impl Manifest {
         // Restore the log level back to what it originally was.
         logger::pop_max_level();
 
+        // Set the keep-alive.
+        // TODO.async: implement keep-alive in Listener
+        // let timeout = self.config.keep_alive.map(|s| Duration::from_secs(s as u64));
+        // listener.set_keepalive(timeout);
+
         // We need to get this before moving `self` into an `Arc`.
         let mut shutdown_receiver = self.shutdown_receiver
             .take().expect("shutdown receiver has already been used");
@@ -614,22 +632,20 @@ impl Rocket {
                           Paint::default(LoggedValue(value)).bold());
         }
 
+        let managed_state = Container::new();
         let (shutdown_sender, shutdown_receiver) = mpsc::channel(1);
+        let shutdown_handle = ShutdownHandle(shutdown_sender);
+        managed_state.set(ShutdownHandleManaged(shutdown_handle.clone()));
 
-        let manifest = Manifest {
-            config,
+        Rocket {
+            config, managed_state, shutdown_handle,
+            manifest: vec![],
             router: Router::new(),
             default_catchers: catcher::defaults::get(),
             catchers: catcher::defaults::get(),
-            state: Container::new(),
             fairings: Fairings::new(),
-            shutdown_handle: ShutdownHandle(shutdown_sender),
             shutdown_receiver: Some(shutdown_receiver),
-        };
-
-        manifest.state.set(ShutdownHandleManaged(manifest.shutdown_handle.clone()));
-
-        Rocket { manifest: Some(manifest), pending: vec![] }
+        }
     }
 
     /// Mounts all of the routes in the supplied vector at the given `base`
@@ -697,7 +713,7 @@ impl Rocket {
             panic!("Invalid mount point.");
         }
 
-        self.pending.push(BuildOperation::Mount(base_uri, routes.into()));
+        self.manifest.push(PreLaunchOp::Mount(base_uri, routes.into()));
         self
     }
 
@@ -727,7 +743,7 @@ impl Rocket {
     /// ```
     #[inline]
     pub fn register(mut self, catchers: Vec<Catcher>) -> Self {
-        self.pending.push(BuildOperation::Register(catchers));
+        self.manifest.push(PreLaunchOp::Register(catchers));
         self
     }
 
@@ -768,13 +784,12 @@ impl Rocket {
     /// ```
     #[inline]
     pub fn manage<T: Send + Sync + 'static>(mut self, state: T) -> Self {
-        self.pending.push(BuildOperation::Manage(Box::new(|rocket| {
-            if !rocket.state.set::<T>(state) {
-                error!("State for this type is already being managed!");
+        let type_name = std::any::type_name::<T>();
+        self.manifest.push(PreLaunchOp::Manage(type_name, Box::new(move |managed| {
+            if !managed.set::<T>(state) {
+                error!("State for type '{}' is already being managed!", type_name);
                 panic!("Aborting due to duplicately managed state.");
             }
-
-            rocket
         })));
 
         self
@@ -802,44 +817,115 @@ impl Rocket {
     /// ```
     #[inline]
     pub fn attach<F: Fairing>(mut self, fairing: F) -> Self {
-        self.pending.push(BuildOperation::Attach(Box::new(fairing)));
+        self.manifest.push(PreLaunchOp::Attach(Box::new(fairing)));
         self
     }
 
-    // Instead of requiring the user to individually `await` each call to
-    // `attach()`, some operations are queued in `self.pending`. Functions that
-    // want to provide read access to any data from the Manifest, such as
-    // `inspect()`, need to apply those pending operations first.
-    //
-    // This function returns a future that executes those pending operations,
-    // requiring only a single `await` at the call site. After completion,
-    // `self.pending` will be empty and `self.manifest` will reflect all pending
-    // changes.
-    //
-    // Note that this returns a boxed future, because `_attach()` calls this
-    // function again creating a cycle.
-    pub(crate) fn actualize_manifest(&mut self) -> BoxFuture<'_, ()> {
-        Box::pin(async move {
-            while !self.pending.is_empty() {
-                // We need to preserve insertion order here,
-                // so we can't use `self.pending.pop()`
-                let op = self.pending.remove(0);
-                let manifest = self.manifest.take()
-                    .expect("internal error: manifest was taken and not replaced. \
-                            Was `inspect()` called but not polled to completion?");
-                self.manifest = Some(match op {
-                    BuildOperation::Mount(base, routes) => manifest._mount(base, routes),
-                    BuildOperation::Register(catchers) => manifest._register(catchers),
-                    BuildOperation::Manage(callback) => manifest._manage(callback),
-                    BuildOperation::Attach(fairing) => manifest._attach(fairing).await,
-                });
-            }
-        })
+    /// Access the current state of this `Rocket` instance.
+    ///
+    /// The `Cargo` type provides methods such as [`Cargo::routes()`]
+    /// and [`Cargo::state()`]. This method is called to get a `Cargo`
+    /// instance.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # rocket::async_test(async {
+    /// let mut rocket = rocket::ignite();
+    /// let config = rocket.inspect().await.config();
+    /// # let _ = config;
+    /// # });
+    /// ```
+    pub async fn inspect(&mut self) -> &Cargo {
+        self.actualize_manifest().await;
+        self.cargo()
     }
 
-    pub(crate) async fn actualize_and_take_manifest(mut self) -> Manifest {
+    /// Returns `Some` of the managed state value for the type `T` if it is
+    /// being managed by `self`. Otherwise, returns `None`.
+    ///
+    /// This function is equivalent to `.inspect().await.state()` and is
+    /// provided as a convenience.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// #[derive(PartialEq, Debug)]
+    /// struct MyState(&'static str);
+    ///
+    /// # rocket::async_test(async {
+    /// let mut rocket = rocket::ignite().manage(MyState("hello!"));
+    /// assert_eq!(rocket.state::<MyState>().await, Some(&MyState("hello!")));
+    /// # });
+    /// ```
+    pub async fn state<T: Send + Sync + 'static>(&mut self) -> Option<&T> {
+        self.inspect().await.state()
+    }
+
+    /// Returns the active configuration.
+    ///
+    /// This function is equivalent to `.inspect().await.config()` and is
+    /// provided as a convenience.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use rocket::Rocket;
+    /// use rocket::fairing::AdHoc;
+    ///
+    /// # rocket::async_test(async {
+    /// let mut rocket = rocket::ignite();
+    /// println!("Rocket config: {:?}", rocket.config().await);
+    /// # });
+    /// ```
+    pub async fn config(&mut self) -> &Config {
+        self.inspect().await.config()
+    }
+
+    /// Returns a [`ShutdownHandle`], which can be used to gracefully terminate
+    /// the instance of Rocket. In routes, you should use the [`ShutdownHandle`]
+    /// request guard.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # #![feature(proc_macro_hygiene)]
+    /// # use std::{thread, time::Duration};
+    /// #
+    /// # rocket::async_test(async {
+    /// let mut rocket = rocket::ignite();
+    /// let handle = rocket.inspect().await.shutdown_handle();
+    ///
+    /// # if false {
+    /// thread::spawn(move || {
+    ///     thread::sleep(Duration::from_secs(10));
+    ///     handle.shutdown();
+    /// });
+    ///
+    /// // Shuts down after 10 seconds
+    /// let shutdown_result = rocket.launch().await;
+    /// assert!(shutdown_result.is_ok());
+    /// # }
+    /// # });
+    /// ```
+    #[inline(always)]
+    pub fn shutdown_handle(&self) -> ShutdownHandle {
+        self.shutdown_handle.clone()
+    }
+
+    /// Perform "pre-launch" checks: verify that there are no routing colisions
+    /// and that there were no fairing failures.
+    pub(crate) async fn prelaunch_check(&mut self) -> Result<(), LaunchError> {
         self.actualize_manifest().await;
-        self.manifest.take().expect("internal error: actualize_manifest() should have replaced self.manifest")
+        if let Err(e) = self.router.collisions() {
+            return Err(LaunchError::new(LaunchErrorKind::Collision(e)));
+        }
+
+        if let Some(failures) = self.fairings.failures() {
+            return Err(LaunchError::new(LaunchErrorKind::FailedFairings(failures.to_vec())))
+        }
+
+        Ok(())
     }
 
     /// Returns a `Future` that drives the server, listening for and dispatching
@@ -866,28 +952,24 @@ impl Rocket {
     /// # }
     /// }
     /// ```
-    pub async fn launch(self) -> Result<(), crate::error::Error> {
+    pub async fn launch(mut self) -> Result<(), crate::error::Error> {
         use std::net::ToSocketAddrs;
-
         use crate::error::Error::Launch;
 
-        let mut manifest = self.actualize_and_take_manifest().await;
-        manifest.prelaunch_check().map_err(crate::error::Error::Launch)?;
+        self.prelaunch_check().await.map_err(crate::error::Error::Launch)?;
 
-        let config = manifest.config();
-        let full_addr = format!("{}:{}", config.address, config.port);
-        let addrs = match full_addr.to_socket_addrs() {
-            Ok(a) => a.collect::<Vec<_>>(),
-            Err(e) => return Err(Launch(From::from(e))),
+        let full_addr = format!("{}:{}", self.config.address, self.config.port);
+        let addr = match full_addr.to_socket_addrs() {
+            Ok(mut addrs) => addrs.next().expect(">= 1 socket addr"),
+            Err(e) => return Err(Launch(e.into())),
         };
-        let addr = addrs[0];
 
         #[cfg(feature = "ctrl_c_shutdown")]
         let (
             shutdown_handle,
             (cancel_ctrl_c_listener_sender, cancel_ctrl_c_listener_receiver)
         ) = (
-            manifest.get_shutdown_handle(),
+            self.shutdown_handle.clone(),
             oneshot::channel(),
         );
 
@@ -898,14 +980,13 @@ impl Rocket {
                         Ok(ok) => ok,
                         Err(err) => return Err(Launch(LaunchError::new(LaunchErrorKind::Bind(err)))),
                     };
-                    manifest.listen_on(listener)
+                    self.listen_on(listener)
                 }};
             }
 
             #[cfg(feature = "tls")]
             {
-                let config = manifest.config();
-                if let Some(tls) = config.tls.clone() {
+                if let Some(tls) = self.config.tls.clone() {
                     listen_on!(crate::http::tls::bind_tls(addr, tls.certs, tls.key).await).boxed()
                 } else {
                     listen_on!(crate::http::private::bind_tcp(addr).await).boxed()
@@ -948,108 +1029,38 @@ impl Rocket {
 
         server.await
     }
+}
 
-    pub(crate) fn _manifest(&self) -> &Manifest {
-        self.manifest.as_ref().expect("internal error: manifest was taken and not replaced. \
-                                      Was `inspect()` called but not polled to completion?")
-    }
-
-    /// Access the current state of this `Rocket` instance.
-    ///
-    /// The `Manifest` type provides methods such as [`Manifest::routes()`]
-    /// and [`Manifest::state()`]. This method is called to get a `Manifest`
-    /// instance.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # rocket::async_test(async {
-    /// let mut rocket = rocket::ignite();
-    /// let config = rocket.inspect().await.config();
-    /// # let _ = config;
-    /// # });
-    /// ```
-    pub async fn inspect(&mut self) -> &Manifest {
-        self.actualize_manifest().await;
-        self._manifest()
-    }
-
-    /// Returns `Some` of the managed state value for the type `T` if it is
-    /// being managed by `self`. Otherwise, returns `None`.
-    ///
-    /// This function is equivalent to `.inspect().await.state()` and is
-    /// provided as a convenience.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// #[derive(PartialEq, Debug)]
-    /// struct MyState(&'static str);
-    ///
-    /// # rocket::async_test(async {
-    /// let mut rocket = rocket::ignite().manage(MyState("hello!"));
-    /// assert_eq!(rocket.state::<MyState>().await, Some(&MyState("hello!")));
-    /// # });
-    /// ```
-    pub async fn state<T: Send + Sync + 'static>(&mut self) -> Option<&T> {
-        self.inspect().await.state()
-    }
-
-    /// Returns the active configuration.
-    ///
-    /// This function is equivalent to `.inspect().await.config()` and is
-    /// provided as a convenience.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # #![feature(proc_macro_hygiene)]
-    /// # #[macro_use] extern crate rocket;
-    /// use rocket::Rocket;
-    /// use rocket::fairing::AdHoc;
-    ///
-    /// # rocket::async_test(async {
-    /// let mut rocket = rocket::ignite();
-    /// println!("Rocket config: {:?}", rocket.config().await);
-    /// # });
-    /// ```
-    pub async fn config(&mut self) -> &Config {
-        self.inspect().await.config()
+impl std::fmt::Debug for PreLaunchOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) ->  std::fmt::Result {
+        use PreLaunchOp::*;
+        match self {
+            Mount(origin, routes) => f.debug_tuple("PreLaunchOp::Mount")
+                .field(&origin)
+                .field(&routes)
+                .finish(),
+            Register(catchers) => f.debug_tuple("PreLaunchOp::Register")
+                .field(&catchers)
+                .finish(),
+            Manage(name, _) => f.debug_tuple("PreLaunchOp::Manage")
+                .field(&name)
+                .finish(),
+            Attach(fairing) => f.debug_tuple("PreLaunchOp::Attach")
+                .field(&fairing.info())
+                .finish()
+        }
     }
 }
 
-impl Manifest {
-    /// Returns a [`ShutdownHandle`], which can be used to gracefully terminate
-    /// the instance of Rocket. In routes, you should use the [`ShutdownHandle`]
-    /// request guard.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # #![feature(proc_macro_hygiene)]
-    /// # use std::{thread, time::Duration};
-    /// #
-    /// # rocket::async_test(async {
-    /// let mut rocket = rocket::ignite();
-    /// let handle = rocket.inspect().await.get_shutdown_handle();
-    ///
-    /// # if false {
-    /// thread::spawn(move || {
-    ///     thread::sleep(Duration::from_secs(10));
-    ///     handle.shutdown();
-    /// });
-    ///
-    /// // Shuts down after 10 seconds
-    /// let shutdown_result = rocket.launch().await;
-    /// assert!(shutdown_result.is_ok());
-    /// # }
-    /// # });
-    /// ```
-    #[inline(always)]
-    pub fn get_shutdown_handle(&self) -> ShutdownHandle {
-        self.shutdown_handle.clone()
-    }
+impl std::ops::Deref for Cargo {
+    type Target = Rocket;
 
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Cargo {
     /// Returns an iterator over all of the routes mounted on this instance of
     /// Rocket.
     ///
@@ -1086,7 +1097,7 @@ impl Manifest {
     /// ```
     #[inline(always)]
     pub fn routes(&self) -> impl Iterator<Item = &Route> + '_ {
-        self.router.routes()
+        self.0.router.routes()
     }
 
     /// Returns `Some` of the managed state value for the type `T` if it is
@@ -1100,15 +1111,13 @@ impl Manifest {
     ///
     /// # rocket::async_test(async {
     /// let mut rocket = rocket::ignite().manage(MyState("hello!"));
-    /// assert_eq!(rocket.inspect().await.state::<MyState>(), Some(&MyState("hello!")));
-    ///
-    /// let client = rocket::local::Client::new(rocket).await.expect("valid rocket");
-    /// assert_eq!(client.manifest().state::<MyState>(), Some(&MyState("hello!")));
+    /// let cargo = rocket.inspect().await;
+    /// assert_eq!(cargo.state::<MyState>(), Some(&MyState("hello!")));
     /// # });
     /// ```
     #[inline(always)]
     pub fn state<T: Send + Sync + 'static>(&self) -> Option<&T> {
-        self.state.try_get()
+        self.0.managed_state.try_get()
     }
 
     /// Returns the active configuration.
@@ -1124,13 +1133,13 @@ impl Manifest {
     /// #[rocket::launch]
     /// fn rocket() -> rocket::Rocket {
     ///     rocket::ignite()
-    ///         .attach(AdHoc::on_launch("Config Printer", |manifest| {
-    ///             println!("Rocket launch config: {:?}", manifest.config());
+    ///         .attach(AdHoc::on_launch("Config Printer", |cargo| {
+    ///             println!("Rocket launch config: {:?}", cargo.config());
     ///         }))
     /// }
     /// ```
     #[inline(always)]
     pub fn config(&self) -> &Config {
-        &self.config
+        &self.0.config
     }
 }
diff --git a/core/lib/src/router/collider.rs b/core/lib/src/router/collider.rs
index 2a23727a..f3b1aa68 100644
--- a/core/lib/src/router/collider.rs
+++ b/core/lib/src/router/collider.rs
@@ -402,7 +402,7 @@ mod tests {
         where S1: Into<Option<&'static str>>, S2: Into<Option<&'static str>>
     {
         let rocket = Rocket::custom(Config::development());
-        let mut req = Request::new(rocket._manifest(), m, Origin::dummy());
+        let mut req = Request::new(&rocket, m, Origin::dummy());
         if let Some(mt_str) = mt1.into() {
             if m.supports_payload() {
                 req.replace_header(mt_str.parse::<ContentType>().unwrap());
@@ -469,7 +469,7 @@ mod tests {
 
     fn req_route_path_match(a: &'static str, b: &'static str) -> bool {
         let rocket = Rocket::custom(Config::development());
-        let req = Request::new(&rocket._manifest(), Get, Origin::parse(a).expect("valid URI"));
+        let req = Request::new(&rocket, Get, Origin::parse(a).expect("valid URI"));
         let route = Route::ranked(0, Get, b.to_string(), dummy_handler);
         route.matches(&req)
     }
diff --git a/core/lib/src/router/mod.rs b/core/lib/src/router/mod.rs
index a4d52d41..8e71e22c 100644
--- a/core/lib/src/router/mod.rs
+++ b/core/lib/src/router/mod.rs
@@ -233,7 +233,7 @@ mod test {
 
     fn route<'a>(router: &'a Router, method: Method, uri: &str) -> Option<&'a Route> {
         let rocket = Rocket::custom(Config::development());
-        let request = Request::new(rocket._manifest(), method, Origin::parse(uri).unwrap());
+        let request = Request::new(&rocket, method, Origin::parse(uri).unwrap());
         let matches = router.route(&request);
         if matches.len() > 0 {
             Some(matches[0])
@@ -244,7 +244,7 @@ mod test {
 
     fn matches<'a>(router: &'a Router, method: Method, uri: &str) -> Vec<&'a Route> {
         let rocket = Rocket::custom(Config::development());
-        let request = Request::new(rocket._manifest(), method, Origin::parse(uri).unwrap());
+        let request = Request::new(&rocket, method, Origin::parse(uri).unwrap());
         router.route(&request)
     }
 
diff --git a/core/lib/tests/attach-inspect.rs b/core/lib/tests/attach-inspect.rs
new file mode 100644
index 00000000..e6676112
--- /dev/null
+++ b/core/lib/tests/attach-inspect.rs
@@ -0,0 +1,43 @@
+use rocket::fairing::AdHoc;
+
+#[rocket::async_test]
+async fn test_inspectable_attach_state() {
+    let mut rocket = rocket::ignite()
+        .attach(AdHoc::on_attach("Add State", |rocket| async {
+            Ok(rocket.manage("Hi!"))
+        }));
+
+    let state = rocket.inspect().await;
+    assert_eq!(state.state::<&'static str>(), Some(&"Hi!"));
+}
+
+#[rocket::async_test]
+async fn test_inspectable_attach_state_in_future_attach() {
+    let mut rocket = rocket::ignite()
+        .attach(AdHoc::on_attach("Add State", |rocket| async {
+            Ok(rocket.manage("Hi!"))
+        }))
+        .attach(AdHoc::on_attach("Inspect State", |mut rocket| async {
+            let state = rocket.inspect().await;
+            assert_eq!(state.state::<&'static str>(), Some(&"Hi!"));
+            Ok(rocket)
+        }));
+
+    let _ = rocket.inspect().await;
+}
+
+#[rocket::async_test]
+async fn test_attach_state_is_well_ordered() {
+    let mut rocket = rocket::ignite()
+        .attach(AdHoc::on_attach("Inspect State Pre", |mut rocket| async {
+            let state = rocket.inspect().await;
+            assert_eq!(state.state::<&'static str>(), None);
+            Ok(rocket)
+        }))
+        .attach(AdHoc::on_attach("Add State", |rocket| async {
+            Ok(rocket.manage("Hi!"))
+        }));
+
+    let state = rocket.inspect().await;
+    assert_eq!(state.state::<&'static str>(), Some(&"Hi!"));
+}
diff --git a/examples/cookies/src/tests.rs b/examples/cookies/src/tests.rs
index c7cb9237..055ed1ff 100644
--- a/examples/cookies/src/tests.rs
+++ b/examples/cookies/src/tests.rs
@@ -39,11 +39,11 @@ async fn test_index() {
 
     // Render the template with an empty context.
     let mut context: HashMap<&str, &str> = HashMap::new();
-    let template = Template::show(client.manifest(), "index", &context).unwrap();
+    let template = Template::show(client.cargo(), "index", &context).unwrap();
     test_body(None, template).await;
 
     // Render the template with a context that contains the message.
     context.insert("message", "Hello from Rocket!");
-    let template = Template::show(client.manifest(), "index", &context).unwrap();
+    let template = Template::show(client.cargo(), "index", &context).unwrap();
     test_body(Some(Cookie::new("message", "Hello from Rocket!")), template).await;
 }
diff --git a/examples/handlebars_templates/src/tests.rs b/examples/handlebars_templates/src/tests.rs
index 301ee1f1..e264d650 100644
--- a/examples/handlebars_templates/src/tests.rs
+++ b/examples/handlebars_templates/src/tests.rs
@@ -31,7 +31,7 @@ async fn test_root() {
         dispatch!(*method, "/", |client, response| {
             let mut map = std::collections::HashMap::new();
             map.insert("path", "/");
-            let expected = Template::show(client.manifest(), "error/404", &map).unwrap();
+            let expected = Template::show(client.cargo(), "error/404", &map).unwrap();
 
             assert_eq!(response.status(), Status::NotFound);
             assert_eq!(response.body_string().await, Some(expected));
@@ -50,7 +50,7 @@ async fn test_name() {
             parent: "layout",
         };
 
-        let expected = Template::show(client.manifest(), "index", &context).unwrap();
+        let expected = Template::show(client.cargo(), "index", &context).unwrap();
         assert_eq!(response.status(), Status::Ok);
         assert_eq!(response.body_string().await, Some(expected));
     });
@@ -63,7 +63,7 @@ async fn test_404() {
         let mut map = std::collections::HashMap::new();
         map.insert("path", "/hello/");
 
-        let expected = Template::show(client.manifest(), "error/404", &map).unwrap();
+        let expected = Template::show(client.cargo(), "error/404", &map).unwrap();
         assert_eq!(response.status(), Status::NotFound);
         assert_eq!(response.body_string().await, Some(expected));
     });
diff --git a/examples/request_local_state/src/tests.rs b/examples/request_local_state/src/tests.rs
index 919ce45f..a7e8c10d 100644
--- a/examples/request_local_state/src/tests.rs
+++ b/examples/request_local_state/src/tests.rs
@@ -1,4 +1,4 @@
-use std::sync::atomic::{Ordering};
+use std::sync::atomic::Ordering;
 
 use super::{rocket, Atomics};
 use rocket::local::Client;
@@ -8,13 +8,13 @@ async fn test() {
     let client = Client::new(rocket()).await.unwrap();
     client.get("/sync").dispatch().await;
 
-    let atomics = client.manifest().state::<Atomics>().unwrap();
+    let atomics = client.cargo().state::<Atomics>().unwrap();
     assert_eq!(atomics.uncached.load(Ordering::Relaxed), 2);
     assert_eq!(atomics.cached.load(Ordering::Relaxed), 1);
 
     client.get("/async").dispatch().await;
 
-    let atomics = client.manifest().state::<Atomics>().unwrap();
+    let atomics = client.cargo().state::<Atomics>().unwrap();
     assert_eq!(atomics.uncached.load(Ordering::Relaxed), 4);
     assert_eq!(atomics.cached.load(Ordering::Relaxed), 2);
 }
diff --git a/examples/state/src/tests.rs b/examples/state/src/tests.rs
index da177359..47f0c3a5 100644
--- a/examples/state/src/tests.rs
+++ b/examples/state/src/tests.rs
@@ -31,11 +31,11 @@ async fn test_raw_state_count() {
     use super::{count, index};
 
     let mut rocket = super::rocket();
-    let manifest = rocket.inspect().await;
+    let cargo = rocket.inspect().await;
 
-    assert_eq!(count(State::from(manifest).unwrap()), "0");
-    assert!(index(State::from(manifest).unwrap()).0.contains("Visits: 1"));
-    assert_eq!(count(State::from(manifest).unwrap()), "1");
+    assert_eq!(count(State::from(cargo).unwrap()), "0");
+    assert!(index(State::from(cargo).unwrap()).0.contains("Visits: 1"));
+    assert_eq!(count(State::from(cargo).unwrap()), "1");
 }
 
 // Cargo runs each test in parallel on different threads. We use all of these
diff --git a/examples/tera_templates/src/tests.rs b/examples/tera_templates/src/tests.rs
index c1daf9b7..4655ed96 100644
--- a/examples/tera_templates/src/tests.rs
+++ b/examples/tera_templates/src/tests.rs
@@ -30,7 +30,7 @@ async fn test_root() {
         dispatch!(*method, "/", |client, response| {
             let mut map = std::collections::HashMap::new();
             map.insert("path", "/");
-            let expected = Template::show(client.manifest(), "error/404", &map).unwrap();
+            let expected = Template::show(client.cargo(), "error/404", &map).unwrap();
 
             assert_eq!(response.status(), Status::NotFound);
             assert_eq!(response.body_string().await, Some(expected));
@@ -47,7 +47,7 @@ async fn test_name() {
             items: vec!["One", "Two", "Three"]
         };
 
-        let expected = Template::show(client.manifest(), "index", &context).unwrap();
+        let expected = Template::show(client.cargo(), "index", &context).unwrap();
         assert_eq!(response.status(), Status::Ok);
         assert_eq!(response.body_string().await, Some(expected));
     });
@@ -60,7 +60,7 @@ async fn test_404() {
         let mut map = std::collections::HashMap::new();
         map.insert("path", "/hello/");
 
-        let expected = Template::show(client.manifest(), "error/404", &map).unwrap();
+        let expected = Template::show(client.cargo(), "error/404", &map).unwrap();
         assert_eq!(response.status(), Status::NotFound);
         assert_eq!(response.body_string().await, Some(expected));
     });