Remove use of the 'crate_visibility_modifier' feature.

Most items with 'crate' visibility become 'pub(crate)'.
Items are made 'pub' instead when they would remain private.

Author: jhpratt

contrib/lib/src/helmet/policy.rs

@@ -63,7 +63,7 @@ pub trait Policy: Default + Send + Sync + 'static {
     fn header(&self) -> Header<'static>;
 }
 
-crate trait SubPolicy: Send + Sync {
+pub(crate) trait SubPolicy: Send + Sync {
     fn name(&self) -> &'static UncasedStr;
     fn header(&self) -> Header<'static>;
 }

contrib/lib/src/lib.rs

@@ -1,5 +1,3 @@
-#![feature(crate_visibility_modifier)]
-
 #![doc(html_root_url = "https://api.rocket.rs/v0.5")]
 #![doc(html_favicon_url = "https://rocket.rs/v0.5/images/favicon.ico")]
 #![doc(html_logo_url = "https://rocket.rs/v0.5/images/logo-boxed.png")]

contrib/lib/src/templates/context.rs

@@ -5,13 +5,13 @@ use crate::templates::{Engines, TemplateInfo};
 
 use rocket::http::ContentType;
 
-crate struct Context {
+pub(crate) struct Context {
     /// The root of the template directory.
-    crate root: PathBuf,
+    pub root: PathBuf,
     /// Mapping from template name to its information.
-    crate templates: HashMap<String, TemplateInfo>,
+    pub templates: HashMap<String, TemplateInfo>,
     /// Loaded template engines
-    crate engines: Engines,
+    pub engines: Engines,
 }
 
 impl Context {

contrib/lib/src/templates/engine.rs

@@ -7,7 +7,7 @@ use crate::templates::TemplateInfo;
 #[cfg(feature = "tera_templates")] use crate::templates::tera::Tera;
 #[cfg(feature = "handlebars_templates")] use crate::templates::handlebars::Handlebars;
 
-crate trait Engine: Send + Sync + 'static {
+pub(crate) trait Engine: Send + Sync + 'static {
     const EXT: &'static str;
 
     fn init(templates: &[(&str, &TemplateInfo)]) -> Option<Self> where Self: Sized;
@@ -60,12 +60,12 @@ pub struct Engines {
 }
 
 impl Engines {
-    crate const ENABLED_EXTENSIONS: &'static [&'static str] = &[
+    pub(crate) const ENABLED_EXTENSIONS: &'static [&'static str] = &[
         #[cfg(feature = "tera_templates")] Tera::EXT,
         #[cfg(feature = "handlebars_templates")] Handlebars::EXT,
     ];
 
-    crate fn init(templates: &HashMap<String, TemplateInfo>) -> Option<Engines> {
+    pub(crate) fn init(templates: &HashMap<String, TemplateInfo>) -> Option<Engines> {
         fn inner<E: Engine>(templates: &HashMap<String, TemplateInfo>) -> Option<E> {
             let named_templates = templates.iter()
                 .filter(|&(_, i)| i.extension == E::EXT)
@@ -89,7 +89,7 @@ impl Engines {
         })
     }
 
-    crate fn render<C: Serialize>(
+    pub(crate) fn render<C: Serialize>(
         &self,
         name: &str,
         info: &TemplateInfo,

contrib/lib/src/templates/fairing.rs

@@ -4,7 +4,7 @@ use rocket::Rocket;
 use rocket::config::ConfigError;
 use rocket::fairing::{Fairing, Info, Kind};
 
-crate use self::context::ContextManager;
+pub(crate) use self::context::ContextManager;
 
 #[cfg(not(debug_assertions))]
 mod context {
@@ -13,18 +13,18 @@ mod context {
 
     /// Wraps a Context. With `cfg(debug_assertions)` active, this structure
     /// additionally provides a method to reload the context at runtime.
-    crate struct ContextManager(Context);
+    pub(crate) struct ContextManager(Context);
 
     impl ContextManager {
-        crate fn new(ctxt: Context) -> ContextManager {
+        pub fn new(ctxt: Context) -> ContextManager {
             ContextManager(ctxt)
         }
 
-        crate fn context<'a>(&'a self) -> impl Deref<Target=Context> + 'a {
+        pub fn context<'a>(&'a self) -> impl Deref<Target=Context> + 'a {
             &self.0
         }
 
-        crate fn is_reloading(&self) -> bool {
+        pub fn is_reloading(&self) -> bool {
             false
         }
     }
@@ -42,15 +42,15 @@ mod context {
 
     /// Wraps a Context. With `cfg(debug_assertions)` active, this structure
     /// additionally provides a method to reload the context at runtime.
-    crate struct ContextManager {
+    pub(crate) struct ContextManager {
         /// The current template context, inside an RwLock so it can be updated.
         context: RwLock<Context>,
         /// A filesystem watcher and the receive queue for its events.
         watcher: Option<Mutex<(RecommendedWatcher, Receiver<RawEvent>)>>,
     }
 
     impl ContextManager {
-        crate fn new(ctxt: Context) -> ContextManager {
+        pub fn new(ctxt: Context) -> ContextManager {
             let (tx, rx) = channel();
             let watcher = raw_watcher(tx).and_then(|mut watcher| {
                 watcher.watch(ctxt.root.canonicalize()?, RecursiveMode::Recursive)?;
@@ -73,11 +73,11 @@ mod context {
             }
         }
 
-        crate fn context(&self) -> impl Deref<Target=Context> + '_ {
+        pub fn context(&self) -> impl Deref<Target=Context> + '_ {
             self.context.read().unwrap()
         }
 
-        crate fn is_reloading(&self) -> bool {
+        pub fn is_reloading(&self) -> bool {
             self.watcher.is_some()
         }
 
@@ -89,7 +89,7 @@ mod context {
         /// have been changes since the last reload, all templates are
         /// reinitialized from disk and the user's customization callback is run
         /// again.
-        crate fn reload_if_needed<F: Fn(&mut Engines)>(&self, custom_callback: F) {
+        pub fn reload_if_needed<F: Fn(&mut Engines)>(&self, custom_callback: F) {
             self.watcher.as_ref().map(|w| {
                 let rx_lock = w.lock().expect("receive queue lock");
                 let mut changed = false;
@@ -121,7 +121,7 @@ pub struct TemplateFairing {
     /// The user-provided customization callback, allowing the use of
     /// functionality specific to individual template engines. In debug mode,
     /// this callback might be run multiple times as templates are reloaded.
-    crate custom_callback: Box<dyn Fn(&mut Engines) + Send + Sync + 'static>,
+    pub custom_callback: Box<dyn Fn(&mut Engines) + Send + Sync + 'static>,
 }
 
 impl Fairing for TemplateFairing {

contrib/lib/src/templates/mod.rs

@@ -129,8 +129,8 @@ mod metadata;
 
 pub use self::engine::Engines;
 pub use self::metadata::Metadata;
-crate use self::context::Context;
-crate use self::fairing::ContextManager;
+pub(crate) use self::context::Context;
+pub(crate) use self::fairing::ContextManager;
 
 use self::engine::Engine;
 use self::fairing::TemplateFairing;
@@ -209,7 +209,7 @@ pub struct Template {
 }
 
 #[derive(Debug)]
-crate struct TemplateInfo {
+pub(crate) struct TemplateInfo {
     /// The complete path, including `template_dir`, to this template.
     path: PathBuf,
     /// The extension for the engine of this template.

core/codegen/src/attribute/segments.rs

@@ -7,15 +7,15 @@ use crate::http::uri::{UriPart, Path};
 use crate::http::route::RouteSegment;
 use crate::proc_macro_ext::{Diagnostics, StringLit, PResult, DResult};
 
-crate use crate::http::route::{Error, Kind, Source};
+pub use crate::http::route::{Error, Kind, Source};
 
 #[derive(Debug, Clone)]
-crate struct Segment {
-    crate span: Span,
-    crate kind: Kind,
-    crate source: Source,
-    crate name: String,
-    crate index: Option<usize>,
+pub struct Segment {
+    pub span: Span,
+    pub kind: Kind,
+    pub source: Source,
+    pub name: String,
+    pub index: Option<usize>,
 }
 
 impl Segment {
@@ -115,7 +115,7 @@ fn into_diagnostic(
     }
 }
 
-crate fn parse_data_segment(segment: &str, span: Span) -> PResult<Segment> {
+pub fn parse_data_segment(segment: &str, span: Span) -> PResult<Segment> {
     <RouteSegment<'_, Path>>::parse_one(segment)
         .map(|segment| {
             let mut seg = Segment::from(segment, span);
@@ -126,7 +126,7 @@ crate fn parse_data_segment(segment: &str, span: Span) -> PResult<Segment> {
         .map_err(|e| into_diagnostic(segment, segment, span, &e))
 }
 
-crate fn parse_segments<P: UriPart>(
+pub fn parse_segments<P: UriPart>(
     string: &str,
     span: Span
 ) -> DResult<Vec<Segment>> {

core/codegen/src/bang/mod.rs

@@ -9,7 +9,7 @@ use crate::{ROUTE_STRUCT_PREFIX, CATCH_STRUCT_PREFIX};
 mod uri;
 mod uri_parsing;
 
-crate fn prefix_last_segment(path: &mut Path, prefix: &str) {
+pub fn prefix_last_segment(path: &mut Path, prefix: &str) {
     let mut last_seg = path.segments.last_mut().expect("syn::Path has segments");
     last_seg.ident = last_seg.ident.prepend(prefix);
 }

core/codegen/src/bang/uri.rs

@@ -23,7 +23,7 @@ macro_rules! p {
     ($n:expr, "parameter") => (p!(@go $n, "1 parameter", format!("{} parameters", $n)));
 }
 
-crate fn _uri_macro(input: TokenStream) -> Result<TokenStream> {
+pub fn _uri_macro(input: TokenStream) -> Result<TokenStream> {
     let input2: TokenStream2 = input.clone().into();
     let mut params = syn::parse::<UriParams>(input).map_err(syn_to_diag)?;
     prefix_last_segment(&mut params.route_path, URI_MACRO_PREFIX);
@@ -212,7 +212,7 @@ fn build_origin(internal: &InternalUriParams) -> Origin<'static> {
     Origin::new(path, query).to_normalized().into_owned()
 }
 
-crate fn _uri_internal_macro(input: TokenStream) -> Result<TokenStream> {
+pub fn _uri_internal_macro(input: TokenStream) -> Result<TokenStream> {
     // Parse the internal invocation and the user's URI param expressions.
     let internal = syn::parse::<InternalUriParams>(input).map_err(syn_to_diag)?;
     let (path_params, query_params) = extract_exprs(&internal)?;

core/codegen/src/derive/from_form.rs

@@ -2,13 +2,13 @@ use proc_macro::{Span, TokenStream};
 use devise::{*, ext::{TypeExt, Split3}};
 
 #[derive(FromMeta)]
-crate struct Form {
-    crate field: FormField,
+pub struct Form {
+    pub field: FormField,
 }
 
-crate struct FormField {
-    crate span: Span,
-    crate name: String
+pub struct FormField {
+    pub span: Span,
+    pub name: String
 }
 
 fn is_valid_field_name(s: &str) -> bool {