From fc7a772c2381230c1aaa78ee8f5444df38ec0967 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 12 Aug 2019 17:22:22 -0700
Subject: [PATCH 01/36] Make prost a `no_std` compatible library, and
 prost-build able to generate `no_std` code

The alternative is to get collections types from `core` and `alloc`.
In the `no_std` mode in `prost_build`, we force it to always use BTreeMap
since HashMap was not stabilized in `alloc::collections` library.

The functionality is identical and the only incompatibilities in the interface
are that we cannot use `std::error::Error` or `std::io::Error` in `no_std` mode
because these types have not been moved to `alloc` and there is no alternative.

This also uprevs `bytes` dependency to 0.5, and fixes up breakage after IntoBuf api
is removed in `bytes` crate.

Note that for now, we put a patch to `bytes` to pin to a specific commit in master,
since bytes `0.5` is not released yet.
---
 .travis.yml                       |   2 +-
 Cargo.toml                        |  12 +-
 conformance/Cargo.toml            |   2 +-
 prost-build/Cargo.toml            |   2 +-
 prost-build/src/code_generator.rs |  20 +-
 prost-build/src/lib.rs            |  33 ++-
 prost-derive/src/field/group.rs   |   2 +-
 prost-derive/src/field/map.rs     |  16 +-
 prost-derive/src/field/message.rs |   2 +-
 prost-derive/src/lib.rs           |  28 +--
 prost-types/Cargo.toml            |   8 +-
 prost-types/src/compiler.rs       |  22 +-
 prost-types/src/lib.rs            |  15 +-
 prost-types/src/protobuf.rs       | 322 +++++++++++++++---------------
 protobuf/Cargo.toml               |   2 +-
 protobuf/src/lib.rs               |   2 +
 src/encoding.rs                   |  26 ++-
 src/error.rs                      |  14 +-
 src/lib.rs                        |  16 +-
 src/message.rs                    |  29 +--
 src/types.rs                      |   3 +
 tests-2015/Cargo.toml             |   2 +-
 tests-alloc/Cargo.toml            |  34 ++++
 tests/Cargo.toml                  |   2 +-
 tests/src/build.rs                |  13 +-
 tests/src/lib.rs                  |   2 +-
 26 files changed, 383 insertions(+), 248 deletions(-)
 create mode 100644 tests-alloc/Cargo.toml

diff --git a/.travis.yml b/.travis.yml
index a393f0b9c..d9ada51ec 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -15,7 +15,7 @@ os:
   - osx
 
 rust:
-  - 1.32.0
+  - 1.36.0
   - nightly
 
 script:
diff --git a/Cargo.toml b/Cargo.toml
index 5521708b7..780fa414b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ members = [
   "protobuf",
   "tests",
   "tests-2015",
+  "tests-alloc",
 ]
 exclude = [
   # The fuzz crate can't be compiled or tested without the 'cargo fuzz' command,
@@ -33,11 +34,15 @@ exclude = [
 ]
 
 [features]
-default = ["prost-derive"]
+default = ["prost-derive", "std"]
 no-recursion-limit = []
+std = []
+   # When std is disabled, we attempt to provide no_std support in prost
+   # Config::use_alloc_collections() should be set when using prost_build in your build.rs
+   # so that generated files will not have std:: either, and will use alloc crate instead
 
 [dependencies]
-bytes = "0.4.7"
+bytes = { version = "0.5", default-features = false }
 prost-derive = { version = "0.5.0", path = "prost-derive", optional = true }
 
 [dev-dependencies]
@@ -54,3 +59,6 @@ name = "varint"
 [[bench]]
 name = "benchmark"
 harness = false
+
+[patch.crates-io]
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024" }
diff --git a/conformance/Cargo.toml b/conformance/Cargo.toml
index 94dbeb95d..c7963b479 100644
--- a/conformance/Cargo.toml
+++ b/conformance/Cargo.toml
@@ -6,7 +6,7 @@ publish = false
 edition = "2018"
 
 [dependencies]
-bytes = "0.4.7"
+bytes = "0.5"
 env_logger = { version = "0.6", default-features = false }
 log = "0.3"
 prost = { path = ".." }
diff --git a/prost-build/Cargo.toml b/prost-build/Cargo.toml
index 008110768..6c43137dc 100644
--- a/prost-build/Cargo.toml
+++ b/prost-build/Cargo.toml
@@ -11,7 +11,7 @@ description = "A Protocol Buffers implementation for the Rust Language."
 edition = "2018"
 
 [dependencies]
-bytes = "0.4.7"
+bytes = { version = "0.5", default-features = false }
 heck = "0.3"
 itertools = "0.8"
 log = "0.4"
diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index 593bba807..7afbbc3d7 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -17,6 +17,7 @@ use crate::ast::{Comments, Method, Service};
 use crate::extern_paths::ExternPaths;
 use crate::ident::{match_ident, to_snake, to_upper_camel};
 use crate::message_graph::MessageGraph;
+use crate::CollectionsLib;
 use crate::Config;
 
 #[derive(PartialEq)]
@@ -366,12 +367,14 @@ impl<'a> CodeGenerator<'a> {
         self.buf.push_str(&to_snake(field.name()));
         self.buf.push_str(": ");
         if repeated {
-            self.buf.push_str("::std::vec::Vec<");
+            self.buf.push_str(self.config.collections_lib.to_str());
+            self.buf.push_str("::vec::Vec<");
         } else if optional {
-            self.buf.push_str("::std::option::Option<");
+            self.buf.push_str("::core::option::Option<");
         }
         if boxed {
-            self.buf.push_str("::std::boxed::Box<");
+            self.buf.push_str(self.config.collections_lib.to_str());
+            self.buf.push_str("::boxed::Box<");
         }
         self.buf.push_str(&ty);
         if boxed {
@@ -403,7 +406,7 @@ impl<'a> CodeGenerator<'a> {
         self.append_doc();
         self.push_indent();
 
-        let btree_map = self
+        let btree_map = (self.config.collections_lib != CollectionsLib::Std) || self
             .config
             .btree_map
             .iter()
@@ -426,8 +429,9 @@ impl<'a> CodeGenerator<'a> {
         self.append_field_attributes(msg_name, field.name());
         self.push_indent();
         self.buf.push_str(&format!(
-            "pub {}: ::std::collections::{}<{}, {}>,\n",
+            "pub {}: {}::collections::{}<{}, {}>,\n",
             to_snake(field.name()),
+            self.config.collections_lib.to_str(),
             rust_ty,
             key_ty,
             value_ty
@@ -459,7 +463,7 @@ impl<'a> CodeGenerator<'a> {
         self.append_field_attributes(fq_message_name, oneof.name());
         self.push_indent();
         self.buf.push_str(&format!(
-            "pub {}: ::std::option::Option<{}>,\n",
+            "pub {}: ::core::option::Option<{}>,\n",
             to_snake(oneof.name()),
             name
         ));
@@ -713,8 +717,8 @@ impl<'a> CodeGenerator<'a> {
             Type::Int32 | Type::Sfixed32 | Type::Sint32 | Type::Enum => String::from("i32"),
             Type::Int64 | Type::Sfixed64 | Type::Sint64 => String::from("i64"),
             Type::Bool => String::from("bool"),
-            Type::String => String::from("std::string::String"),
-            Type::Bytes => String::from("std::vec::Vec<u8>"),
+            Type::String => format!("{}::string::String", self.config.collections_lib.to_str()),
+            Type::Bytes => format!("{}::vec::Vec<u8>", self.config.collections_lib.to_str()),
             Type::Group | Type::Message => self.resolve_ident(field.type_name()),
         }
     }
diff --git a/prost-build/src/lib.rs b/prost-build/src/lib.rs
index fb5e68d17..69754ea41 100644
--- a/prost-build/src/lib.rs
+++ b/prost-build/src/lib.rs
@@ -165,11 +165,32 @@ pub trait ServiceGenerator {
     fn finalize(&mut self, _buf: &mut String) {}
 }
 
+/// Configuration enum for whether to use `std` prefixes or `alloc` prefixes in generated code
+///
+/// This option also forces Btree everywhere, overriding the BtreeMap options,
+/// since HashMap is not in alloc::collections, only std (it requires randomness)
+/// 
+#[derive(PartialEq)]
+pub enum CollectionsLib {
+    Std,
+    Alloc,
+}
+
+impl CollectionsLib {
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            CollectionsLib::Std => { "::std" },
+            CollectionsLib::Alloc => { "::alloc" },
+        }
+    }
+}
+
 /// Configuration options for Protobuf code generation.
 ///
 /// This configuration builder can be used to set non-default code generation options.
 pub struct Config {
     service_generator: Option<Box<dyn ServiceGenerator>>,
+    collections_lib: CollectionsLib,
     btree_map: Vec<String>,
     type_attributes: Vec<(String, String)>,
     field_attributes: Vec<(String, String)>,
@@ -460,6 +481,15 @@ impl Config {
         self
     }
 
+    /// Configure the code generator to use the `::alloc` namespace rather than `::std`, and Btree everywhere
+    /// rather than `std`.
+    ///
+    /// This allows generated code to be used in a `#![no_std]` crate
+    pub fn use_alloc_collections_lib(&mut self) -> &mut Self {
+        self.collections_lib = CollectionsLib::Alloc;
+        self
+    }
+
     /// Configures the output directory where generated Rust files will be written.
     ///
     /// If unset, defaults to the `OUT_DIR` environment variable. `OUT_DIR` is set by Cargo when
@@ -538,7 +568,7 @@ impl Config {
 
         let mut buf = Vec::new();
         fs::File::open(descriptor_set)?.read_to_end(&mut buf)?;
-        let descriptor_set = FileDescriptorSet::decode(&buf)?;
+        let descriptor_set = FileDescriptorSet::decode(&buf[..])?;
 
         let modules = self.generate(descriptor_set.file)?;
         for (module, content) in modules {
@@ -581,6 +611,7 @@ impl default::Default for Config {
     fn default() -> Config {
         Config {
             service_generator: None,
+            collections_lib: CollectionsLib::Std,
             btree_map: Vec::new(),
             type_attributes: Vec::new(),
             field_attributes: Vec::new(),
diff --git a/prost-derive/src/field/group.rs b/prost-derive/src/field/group.rs
index 0197e753e..b0e9a33d3 100644
--- a/prost-derive/src/field/group.rs
+++ b/prost-derive/src/field/group.rs
@@ -120,7 +120,7 @@ impl Field {
 
     pub fn clear(&self, ident: TokenStream) -> TokenStream {
         match self.label {
-            Label::Optional => quote!(#ident = ::std::option::Option::None),
+            Label::Optional => quote!(#ident = ::core::option::Option::None),
             Label::Required => quote!(#ident.clear()),
             Label::Repeated => quote!(#ident.clear()),
         }
diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index 07f3cf9d0..ed8d3e9b3 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -223,10 +223,10 @@ impl Field {
             };
 
             Some(quote! {
-                pub fn #get(&self, key: #key_ref_ty) -> ::std::option::Option<#ty> {
+                pub fn #get(&self, key: #key_ref_ty) -> ::core::option::Option<#ty> {
                     self.#ident.get(#take_ref key).cloned().and_then(#ty::from_i32)
                 }
-                pub fn #insert(&mut self, key: #key_ty, value: #ty) -> ::std::option::Option<#ty> {
+                pub fn #insert(&mut self, key: #key_ty, value: #ty) -> ::core::option::Option<#ty> {
                     self.#ident.insert(key, value as i32).and_then(#ty::from_i32)
                 }
             })
@@ -249,7 +249,7 @@ impl Field {
         let key = self.key_ty.rust_type();
         let value_wrapper = self.value_ty.debug();
         let fmt = quote! {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                 #key_wrapper
                 #value_wrapper
                 let mut builder = f.debug_map();
@@ -263,17 +263,17 @@ impl Field {
             ValueTy::Scalar(ref ty) => {
                 let value = ty.rust_type();
                 quote! {
-                    struct #wrapper_name<'a>(&'a ::std::collections::#type_name<#key, #value>);
-                    impl<'a> ::std::fmt::Debug for #wrapper_name<'a> {
+                    struct #wrapper_name<'a>(&'a ::alloc::collections::#type_name<#key, #value>);
+                    impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
                         #fmt
                     }
                 }
             }
             ValueTy::Message => quote! {
-                struct #wrapper_name<'a, V: 'a>(&'a ::std::collections::#type_name<#key, V>);
-                impl<'a, V> ::std::fmt::Debug for #wrapper_name<'a, V>
+                struct #wrapper_name<'a, V: 'a>(&'a ::alloc::collections::#type_name<#key, V>);
+                impl<'a, V> ::core::fmt::Debug for #wrapper_name<'a, V>
                 where
-                    V: ::std::fmt::Debug + 'a,
+                    V: ::core::fmt::Debug + 'a,
                 {
                     #fmt
                 }
diff --git a/prost-derive/src/field/message.rs b/prost-derive/src/field/message.rs
index 6d6ecd46f..1d3b1f041 100644
--- a/prost-derive/src/field/message.rs
+++ b/prost-derive/src/field/message.rs
@@ -123,7 +123,7 @@ impl Field {
 
     pub fn clear(&self, ident: TokenStream) -> TokenStream {
         match self.label {
-            Label::Optional => quote!(#ident = ::std::option::Option::None),
+            Label::Optional => quote!(#ident = ::core::option::Option::None),
             Label::Required => quote!(#ident.clear()),
             Label::Repeated => quote!(#ident.clear()),
         }
diff --git a/prost-derive/src/lib.rs b/prost-derive/src/lib.rs
index 6f1b4c027..609cf07c7 100644
--- a/prost-derive/src/lib.rs
+++ b/prost-derive/src/lib.rs
@@ -191,7 +191,7 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
                                   wire_type: _prost::encoding::WireType,
                                   buf: &mut B,
                                   ctx: _prost::encoding::DecodeContext,
-                ) -> ::std::result::Result<(), _prost::DecodeError>
+                ) -> ::core::result::Result<(), _prost::DecodeError>
                 where B: _bytes::Buf {
                     #struct_name
                     match tag {
@@ -218,8 +218,8 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
                 }
             }
 
-            impl ::std::fmt::Debug for #ident {
-                fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+            impl ::core::fmt::Debug for #ident {
+                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                     let mut builder = #debug_builder;
                     #(#debugs;)*
                     builder.finish()
@@ -286,7 +286,7 @@ fn try_enumeration(input: TokenStream) -> Result<TokenStream, Error> {
         .iter()
         .map(|&(_, ref value)| quote!(#value => true));
     let from = variants.iter().map(
-        |&(ref variant, ref value)| quote!(#value => ::std::option::Option::Some(#ident::#variant)),
+        |&(ref variant, ref value)| quote!(#value => ::core::option::Option::Some(#ident::#variant)),
     );
 
     let is_valid_doc = format!("Returns `true` if `value` is a variant of `{}`.", ident);
@@ -309,21 +309,21 @@ fn try_enumeration(input: TokenStream) -> Result<TokenStream, Error> {
                 }
 
                 #[doc=#from_i32_doc]
-                pub fn from_i32(value: i32) -> ::std::option::Option<#ident> {
+                pub fn from_i32(value: i32) -> ::core::option::Option<#ident> {
                     match value {
                         #(#from,)*
-                        _ => ::std::option::Option::None,
+                        _ => ::core::option::Option::None,
                     }
                 }
             }
 
-            impl ::std::default::Default for #ident {
+            impl ::core::default::Default for #ident {
                 fn default() -> #ident {
                     #ident::#default
                 }
             }
 
-            impl ::std::convert::From<#ident> for i32 {
+            impl ::core::convert::From<#ident> for i32 {
                 fn from(value: #ident) -> i32 {
                     value as i32
                 }
@@ -411,8 +411,8 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
         let merge = field.merge(quote!(value));
         quote! {
             #tag => {
-                let mut value = ::std::default::Default::default();
-                #merge.map(|_| *field = ::std::option::Option::Some(#ident::#variant_ident(value)))
+                let mut value = ::core::default::Default::default();
+                #merge.map(|_| *field = ::core::option::Option::Some(#ident::#variant_ident(value)))
             }
         }
     });
@@ -445,12 +445,12 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
                     }
                 }
 
-                pub fn merge<B>(field: &mut ::std::option::Option<#ident>,
+                pub fn merge<B>(field: &mut ::core::option::Option<#ident>,
                                 tag: u32,
                                 wire_type: _prost::encoding::WireType,
                                 buf: &mut B,
                                 ctx: _prost::encoding::DecodeContext,
-                ) -> ::std::result::Result<(), _prost::DecodeError>
+                ) -> ::core::result::Result<(), _prost::DecodeError>
                 where B: _bytes::Buf {
                     match tag {
                         #(#merge,)*
@@ -466,8 +466,8 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
                 }
             }
 
-            impl ::std::fmt::Debug for #ident {
-                fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+            impl ::core::fmt::Debug for #ident {
+                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                     match *self {
                         #(#debug,)*
                     }
diff --git a/prost-types/Cargo.toml b/prost-types/Cargo.toml
index 24415d32b..9c0eefae8 100644
--- a/prost-types/Cargo.toml
+++ b/prost-types/Cargo.toml
@@ -14,6 +14,10 @@ edition = "2018"
 doctest = false
 test = false
 
+[features]
+default = ["std"]
+std = []
+
 [dependencies]
-bytes = "0.4.7"
-prost = { version = "0.5.0", path = ".." }
+bytes = { version = "0.5", default-features = false }
+prost = { version = "0.5.0", path = "..", default-features = false }
diff --git a/prost-types/src/compiler.rs b/prost-types/src/compiler.rs
index 421bd78ba..c7477eab8 100644
--- a/prost-types/src/compiler.rs
+++ b/prost-types/src/compiler.rs
@@ -2,15 +2,15 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Version {
     #[prost(int32, optional, tag="1")]
-    pub major: ::std::option::Option<i32>,
+    pub major: ::core::option::Option<i32>,
     #[prost(int32, optional, tag="2")]
-    pub minor: ::std::option::Option<i32>,
+    pub minor: ::core::option::Option<i32>,
     #[prost(int32, optional, tag="3")]
-    pub patch: ::std::option::Option<i32>,
+    pub patch: ::core::option::Option<i32>,
     /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     /// be empty for mainline stable releases.
     #[prost(string, optional, tag="4")]
-    pub suffix: ::std::option::Option<std::string::String>,
+    pub suffix: ::core::option::Option<alloc::string::String>,
 }
 /// An encoded CodeGeneratorRequest is written to the plugin's stdin.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -19,10 +19,10 @@ pub struct CodeGeneratorRequest {
     /// code generator should generate code only for these files.  Each file's
     /// descriptor will be included in proto_file, below.
     #[prost(string, repeated, tag="1")]
-    pub file_to_generate: ::std::vec::Vec<std::string::String>,
+    pub file_to_generate: ::std::vec::Vec<alloc::string::String>,
     /// The generator parameter passed on the command-line.
     #[prost(string, optional, tag="2")]
-    pub parameter: ::std::option::Option<std::string::String>,
+    pub parameter: ::core::option::Option<alloc::string::String>,
     /// FileDescriptorProtos for all files in files_to_generate and everything
     /// they import.  The files will appear in topological order, so each file
     /// appears before any file that imports it.
@@ -41,7 +41,7 @@ pub struct CodeGeneratorRequest {
     pub proto_file: ::std::vec::Vec<super::FileDescriptorProto>,
     /// The version number of protocol compiler.
     #[prost(message, optional, tag="3")]
-    pub compiler_version: ::std::option::Option<Version>,
+    pub compiler_version: ::core::option::Option<Version>,
 }
 /// The plugin writes an encoded CodeGeneratorResponse to stdout.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -55,7 +55,7 @@ pub struct CodeGeneratorResponse {
     /// unparseable -- should be reported by writing a message to stderr and
     /// exiting with a non-zero status code.
     #[prost(string, optional, tag="1")]
-    pub error: ::std::option::Option<std::string::String>,
+    pub error: ::core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="15")]
     pub file: ::std::vec::Vec<code_generator_response::File>,
 }
@@ -75,7 +75,7 @@ pub mod code_generator_response {
         /// this writing protoc does not optimize for this -- it will read the entire
         /// CodeGeneratorResponse before writing files to disk.
         #[prost(string, optional, tag="1")]
-        pub name: ::std::option::Option<std::string::String>,
+        pub name: ::core::option::Option<alloc::string::String>,
         /// If non-empty, indicates that the named file should already exist, and the
         /// content here is to be inserted into that file at a defined insertion
         /// point.  This feature allows a code generator to extend the output
@@ -114,9 +114,9 @@ pub mod code_generator_response {
         ///
         /// If |insertion_point| is present, |name| must also be present.
         #[prost(string, optional, tag="2")]
-        pub insertion_point: ::std::option::Option<std::string::String>,
+        pub insertion_point: ::core::option::Option<alloc::string::String>,
         /// The file contents.
         #[prost(string, optional, tag="15")]
-        pub content: ::std::option::Option<std::string::String>,
+        pub content: ::core::option::Option<alloc::string::String>,
     }
 }
diff --git a/prost-types/src/lib.rs b/prost-types/src/lib.rs
index 6796d4af2..62ff534ef 100644
--- a/prost-types/src/lib.rs
+++ b/prost-types/src/lib.rs
@@ -9,8 +9,15 @@
 //!
 //! [1]: https://developers.google.com/protocol-buffers/docs/reference/google.protobuf
 
-use std::i32;
-use std::i64;
+#![no_std]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
+use core::i32;
+use core::i64;
+
+#[cfg(feature = "std")]
 use std::time;
 
 include!("protobuf.rs");
@@ -51,6 +58,7 @@ impl Duration {
 }
 
 /// Converts a `std::time::Duration` to a `Duration`.
+#[cfg(feature = "std")]
 impl From<time::Duration> for Duration {
     fn from(duration: time::Duration) -> Duration {
         let seconds = duration.as_secs();
@@ -74,6 +82,7 @@ impl From<time::Duration> for Duration {
 /// Converts a `Duration` to a result containing a positive (`Ok`) or negative (`Err`)
 /// `std::time::Duration`.
 // TODO: convert this to TryFrom when it's stable.
+#[cfg(feature = "std")]
 impl From<Duration> for Result<time::Duration, time::Duration> {
     fn from(mut duration: Duration) -> Result<time::Duration, time::Duration> {
         duration.normalize();
@@ -116,6 +125,7 @@ impl Timestamp {
 }
 
 /// Converts a `std::time::SystemTime` to a `Timestamp`.
+#[cfg(feature = "std")]
 impl From<time::SystemTime> for Timestamp {
     fn from(time: time::SystemTime) -> Timestamp {
         let duration = Duration::from(time.duration_since(time::UNIX_EPOCH).unwrap());
@@ -129,6 +139,7 @@ impl From<time::SystemTime> for Timestamp {
 /// Converts a `Timestamp` to a `SystemTime`, or if the timestamp falls before the Unix epoch, a
 /// duration containing the difference.
 // TODO: convert this to TryFrom when it's stable.
+#[cfg(feature = "std")]
 impl From<Timestamp> for Result<time::SystemTime, time::Duration> {
     fn from(mut timestamp: Timestamp) -> Result<time::SystemTime, time::Duration> {
         timestamp.normalize();
diff --git a/prost-types/src/protobuf.rs b/prost-types/src/protobuf.rs
index 07a70e61c..8324b0d72 100644
--- a/prost-types/src/protobuf.rs
+++ b/prost-types/src/protobuf.rs
@@ -3,84 +3,84 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorSet {
     #[prost(message, repeated, tag="1")]
-    pub file: ::std::vec::Vec<FileDescriptorProto>,
+    pub file: ::alloc::vec::Vec<FileDescriptorProto>,
 }
 /// Describes a complete .proto file.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorProto {
     /// file name, relative to root of source tree
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     /// e.g. "foo", "foo.bar", etc.
     #[prost(string, optional, tag="2")]
-    pub package: ::std::option::Option<std::string::String>,
+    pub package: ::core::option::Option<alloc::string::String>,
     /// Names of files imported by this file.
     #[prost(string, repeated, tag="3")]
-    pub dependency: ::std::vec::Vec<std::string::String>,
+    pub dependency: ::alloc::vec::Vec<alloc::string::String>,
     /// Indexes of the public imported files in the dependency list above.
     #[prost(int32, repeated, packed="false", tag="10")]
-    pub public_dependency: ::std::vec::Vec<i32>,
+    pub public_dependency: ::alloc::vec::Vec<i32>,
     /// Indexes of the weak imported files in the dependency list.
     /// For Google-internal migration only. Do not use.
     #[prost(int32, repeated, packed="false", tag="11")]
-    pub weak_dependency: ::std::vec::Vec<i32>,
+    pub weak_dependency: ::alloc::vec::Vec<i32>,
     /// All top-level definitions in this file.
     #[prost(message, repeated, tag="4")]
-    pub message_type: ::std::vec::Vec<DescriptorProto>,
+    pub message_type: ::alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub service: ::std::vec::Vec<ServiceDescriptorProto>,
+    pub service: ::alloc::vec::Vec<ServiceDescriptorProto>,
     #[prost(message, repeated, tag="7")]
-    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
+    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, optional, tag="8")]
-    pub options: ::std::option::Option<FileOptions>,
+    pub options: ::core::option::Option<FileOptions>,
     /// This field contains optional information about the original source code.
     /// You may safely remove this entire field without harming runtime
     /// functionality of the descriptors -- the information is needed only by
     /// development tools.
     #[prost(message, optional, tag="9")]
-    pub source_code_info: ::std::option::Option<SourceCodeInfo>,
+    pub source_code_info: ::core::option::Option<SourceCodeInfo>,
     /// The syntax of the proto file.
     /// The supported values are "proto2" and "proto3".
     #[prost(string, optional, tag="12")]
-    pub syntax: ::std::option::Option<std::string::String>,
+    pub syntax: ::core::option::Option<alloc::string::String>,
 }
 /// Describes a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub field: ::std::vec::Vec<FieldDescriptorProto>,
+    pub field: ::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
+    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="3")]
-    pub nested_type: ::std::vec::Vec<DescriptorProto>,
+    pub nested_type: ::alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="4")]
-    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub extension_range: ::std::vec::Vec<descriptor_proto::ExtensionRange>,
+    pub extension_range: ::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
     #[prost(message, repeated, tag="8")]
-    pub oneof_decl: ::std::vec::Vec<OneofDescriptorProto>,
+    pub oneof_decl: ::alloc::vec::Vec<OneofDescriptorProto>,
     #[prost(message, optional, tag="7")]
-    pub options: ::std::option::Option<MessageOptions>,
+    pub options: ::core::option::Option<MessageOptions>,
     #[prost(message, repeated, tag="9")]
-    pub reserved_range: ::std::vec::Vec<descriptor_proto::ReservedRange>,
+    pub reserved_range: ::alloc::vec::Vec<descriptor_proto::ReservedRange>,
     /// Reserved field names, which may not be used by fields in the same message.
     /// A given name may only be reserved once.
     #[prost(string, repeated, tag="10")]
-    pub reserved_name: ::std::vec::Vec<std::string::String>,
+    pub reserved_name: ::alloc::vec::Vec<alloc::string::String>,
 }
 pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct ExtensionRange {
         #[prost(int32, optional, tag="1")]
-        pub start: ::std::option::Option<i32>,
+        pub start: ::core::option::Option<i32>,
         #[prost(int32, optional, tag="2")]
-        pub end: ::std::option::Option<i32>,
+        pub end: ::core::option::Option<i32>,
         #[prost(message, optional, tag="3")]
-        pub options: ::std::option::Option<super::ExtensionRangeOptions>,
+        pub options: ::core::option::Option<super::ExtensionRangeOptions>,
     }
     /// Range of reserved tag numbers. Reserved tag numbers may not be used by
     /// fields or extension ranges in the same message. Reserved ranges may
@@ -89,61 +89,61 @@ pub mod descriptor_proto {
     pub struct ReservedRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::std::option::Option<i32>,
+        pub start: ::core::option::Option<i32>,
         /// Exclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::std::option::Option<i32>,
+        pub end: ::core::option::Option<i32>,
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ExtensionRangeOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 /// Describes a field within a message.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     #[prost(int32, optional, tag="3")]
-    pub number: ::std::option::Option<i32>,
+    pub number: ::core::option::Option<i32>,
     #[prost(enumeration="field_descriptor_proto::Label", optional, tag="4")]
-    pub label: ::std::option::Option<i32>,
+    pub label: ::core::option::Option<i32>,
     /// If type_name is set, this need not be set.  If both this and type_name
     /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
     #[prost(enumeration="field_descriptor_proto::Type", optional, tag="5")]
-    pub r#type: ::std::option::Option<i32>,
+    pub r#type: ::core::option::Option<i32>,
     /// For message and enum types, this is the name of the type.  If the name
     /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
     /// rules are used to find the type (i.e. first the nested types within this
     /// message are searched, then within the parent, on up to the root
     /// namespace).
     #[prost(string, optional, tag="6")]
-    pub type_name: ::std::option::Option<std::string::String>,
+    pub type_name: ::core::option::Option<alloc::string::String>,
     /// For extensions, this is the name of the type being extended.  It is
     /// resolved in the same manner as type_name.
     #[prost(string, optional, tag="2")]
-    pub extendee: ::std::option::Option<std::string::String>,
+    pub extendee: ::core::option::Option<alloc::string::String>,
     /// For numeric types, contains the original text representation of the value.
     /// For booleans, "true" or "false".
     /// For strings, contains the default text contents (not escaped in any way).
     /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
     /// TODO(kenton):  Base-64 encode?
     #[prost(string, optional, tag="7")]
-    pub default_value: ::std::option::Option<std::string::String>,
+    pub default_value: ::core::option::Option<alloc::string::String>,
     /// If set, gives the index of a oneof in the containing type's oneof_decl
     /// list.  This field is a member of that oneof.
     #[prost(int32, optional, tag="9")]
-    pub oneof_index: ::std::option::Option<i32>,
+    pub oneof_index: ::core::option::Option<i32>,
     /// JSON name of this field. The value is set by protocol compiler. If the
     /// user has set a "json_name" option on this field, that option's value
     /// will be used. Otherwise, it's deduced from the field's name by converting
     /// it to camelCase.
     #[prost(string, optional, tag="10")]
-    pub json_name: ::std::option::Option<std::string::String>,
+    pub json_name: ::core::option::Option<alloc::string::String>,
     #[prost(message, optional, tag="8")]
-    pub options: ::std::option::Option<FieldOptions>,
+    pub options: ::core::option::Option<FieldOptions>,
 }
 pub mod field_descriptor_proto {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -195,28 +195,28 @@ pub mod field_descriptor_proto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     #[prost(message, optional, tag="2")]
-    pub options: ::std::option::Option<OneofOptions>,
+    pub options: ::core::option::Option<OneofOptions>,
 }
 /// Describes an enum type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub value: ::std::vec::Vec<EnumValueDescriptorProto>,
+    pub value: ::alloc::vec::Vec<EnumValueDescriptorProto>,
     #[prost(message, optional, tag="3")]
-    pub options: ::std::option::Option<EnumOptions>,
+    pub options: ::core::option::Option<EnumOptions>,
     /// Range of reserved numeric values. Reserved numeric values may not be used
     /// by enum values in the same enum declaration. Reserved ranges may not
     /// overlap.
     #[prost(message, repeated, tag="4")]
-    pub reserved_range: ::std::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
+    pub reserved_range: ::alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
     /// Reserved enum value names, which may not be reused. A given name may only
     /// be reserved once.
     #[prost(string, repeated, tag="5")]
-    pub reserved_name: ::std::vec::Vec<std::string::String>,
+    pub reserved_name: ::alloc::vec::Vec<alloc::string::String>,
 }
 pub mod enum_descriptor_proto {
     /// Range of reserved numeric values. Reserved values may not be used by
@@ -229,51 +229,51 @@ pub mod enum_descriptor_proto {
     pub struct EnumReservedRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::std::option::Option<i32>,
+        pub start: ::core::option::Option<i32>,
         /// Inclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::std::option::Option<i32>,
+        pub end: ::core::option::Option<i32>,
     }
 }
 /// Describes a value within an enum.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     #[prost(int32, optional, tag="2")]
-    pub number: ::std::option::Option<i32>,
+    pub number: ::core::option::Option<i32>,
     #[prost(message, optional, tag="3")]
-    pub options: ::std::option::Option<EnumValueOptions>,
+    pub options: ::core::option::Option<EnumValueOptions>,
 }
 /// Describes a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub method: ::std::vec::Vec<MethodDescriptorProto>,
+    pub method: ::alloc::vec::Vec<MethodDescriptorProto>,
     #[prost(message, optional, tag="3")]
-    pub options: ::std::option::Option<ServiceOptions>,
+    pub options: ::core::option::Option<ServiceOptions>,
 }
 /// Describes a method of a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: ::core::option::Option<alloc::string::String>,
     /// Input and output type names.  These are resolved in the same way as
     /// FieldDescriptorProto.type_name, but must refer to a message type.
     #[prost(string, optional, tag="2")]
-    pub input_type: ::std::option::Option<std::string::String>,
+    pub input_type: ::core::option::Option<alloc::string::String>,
     #[prost(string, optional, tag="3")]
-    pub output_type: ::std::option::Option<std::string::String>,
+    pub output_type: ::core::option::Option<alloc::string::String>,
     #[prost(message, optional, tag="4")]
-    pub options: ::std::option::Option<MethodOptions>,
+    pub options: ::core::option::Option<MethodOptions>,
     /// Identifies if client streams multiple client messages
     #[prost(bool, optional, tag="5", default="false")]
-    pub client_streaming: ::std::option::Option<bool>,
+    pub client_streaming: ::core::option::Option<bool>,
     /// Identifies if server streams multiple server messages
     #[prost(bool, optional, tag="6", default="false")]
-    pub server_streaming: ::std::option::Option<bool>,
+    pub server_streaming: ::core::option::Option<bool>,
 }
 // ===================================================================
 // Options
@@ -314,14 +314,14 @@ pub struct FileOptions {
     /// inappropriate because proto packages do not normally start with backwards
     /// domain names.
     #[prost(string, optional, tag="1")]
-    pub java_package: ::std::option::Option<std::string::String>,
+    pub java_package: ::core::option::Option<alloc::string::String>,
     /// If set, all the classes from the .proto file are wrapped in a single
     /// outer class with the given name.  This applies to both Proto1
     /// (equivalent to the old "--one_java_file" option) and Proto2 (where
     /// a .proto always translates to a single class, but you may want to
     /// explicitly choose the class name).
     #[prost(string, optional, tag="8")]
-    pub java_outer_classname: ::std::option::Option<std::string::String>,
+    pub java_outer_classname: ::core::option::Option<alloc::string::String>,
     /// If set true, then the Java code generator will generate a separate .java
     /// file for each top-level message, enum, and service defined in the .proto
     /// file.  Thus, these types will *not* be nested inside the outer class
@@ -329,10 +329,10 @@ pub struct FileOptions {
     /// generated to contain the file's getDescriptor() method as well as any
     /// top-level extensions defined in the file.
     #[prost(bool, optional, tag="10", default="false")]
-    pub java_multiple_files: ::std::option::Option<bool>,
+    pub java_multiple_files: ::core::option::Option<bool>,
     /// This option does nothing.
     #[prost(bool, optional, tag="20")]
-    pub java_generate_equals_and_hash: ::std::option::Option<bool>,
+    pub java_generate_equals_and_hash: ::core::option::Option<bool>,
     /// If set true, then the Java2 code generator will generate code that
     /// throws an exception whenever an attempt is made to assign a non-UTF-8
     /// byte sequence to a string field.
@@ -340,16 +340,16 @@ pub struct FileOptions {
     /// However, an extension field still accepts non-UTF-8 byte sequences.
     /// This option has no effect on when used with the lite runtime.
     #[prost(bool, optional, tag="27", default="false")]
-    pub java_string_check_utf8: ::std::option::Option<bool>,
+    pub java_string_check_utf8: ::core::option::Option<bool>,
     #[prost(enumeration="file_options::OptimizeMode", optional, tag="9", default="Speed")]
-    pub optimize_for: ::std::option::Option<i32>,
+    pub optimize_for: ::core::option::Option<i32>,
     /// Sets the Go package where structs generated from this .proto will be
     /// placed. If omitted, the Go package will be derived from the following:
     ///   - The basename of the package import path, if provided.
     ///   - Otherwise, the package statement in the .proto file, if present.
     ///   - Otherwise, the basename of the .proto file, without extension.
     #[prost(string, optional, tag="11")]
-    pub go_package: ::std::option::Option<std::string::String>,
+    pub go_package: ::core::option::Option<alloc::string::String>,
     /// Should generic services be generated in each language?  "Generic" services
     /// are not specific to any particular RPC system.  They are generated by the
     /// main code generators in each language (without additional plugins).
@@ -361,59 +361,59 @@ pub struct FileOptions {
     /// these default to false.  Old code which depends on generic services should
     /// explicitly set them to true.
     #[prost(bool, optional, tag="16", default="false")]
-    pub cc_generic_services: ::std::option::Option<bool>,
+    pub cc_generic_services: ::core::option::Option<bool>,
     #[prost(bool, optional, tag="17", default="false")]
-    pub java_generic_services: ::std::option::Option<bool>,
+    pub java_generic_services: ::core::option::Option<bool>,
     #[prost(bool, optional, tag="18", default="false")]
-    pub py_generic_services: ::std::option::Option<bool>,
+    pub py_generic_services: ::core::option::Option<bool>,
     #[prost(bool, optional, tag="42", default="false")]
-    pub php_generic_services: ::std::option::Option<bool>,
+    pub php_generic_services: ::core::option::Option<bool>,
     /// Is this file deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for everything in the file, or it will be completely ignored; in the very
     /// least, this is a formalization for deprecating files.
     #[prost(bool, optional, tag="23", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: ::core::option::Option<bool>,
     /// Enables the use of arenas for the proto messages in this file. This applies
     /// only to generated classes for C++.
     #[prost(bool, optional, tag="31", default="false")]
-    pub cc_enable_arenas: ::std::option::Option<bool>,
+    pub cc_enable_arenas: ::core::option::Option<bool>,
     /// Sets the objective c class prefix which is prepended to all objective c
     /// generated classes from this .proto. There is no default.
     #[prost(string, optional, tag="36")]
-    pub objc_class_prefix: ::std::option::Option<std::string::String>,
+    pub objc_class_prefix: ::core::option::Option<alloc::string::String>,
     /// Namespace for generated classes; defaults to the package.
     #[prost(string, optional, tag="37")]
-    pub csharp_namespace: ::std::option::Option<std::string::String>,
+    pub csharp_namespace: ::core::option::Option<alloc::string::String>,
     /// By default Swift generators will take the proto package and CamelCase it
     /// replacing '.' with underscore and use that to prefix the types/symbols
     /// defined. When this options is provided, they will use this value instead
     /// to prefix the types/symbols defined.
     #[prost(string, optional, tag="39")]
-    pub swift_prefix: ::std::option::Option<std::string::String>,
+    pub swift_prefix: ::core::option::Option<alloc::string::String>,
     /// Sets the php class prefix which is prepended to all php generated classes
     /// from this .proto. Default is empty.
     #[prost(string, optional, tag="40")]
-    pub php_class_prefix: ::std::option::Option<std::string::String>,
+    pub php_class_prefix: ::core::option::Option<alloc::string::String>,
     /// Use this option to change the namespace of php generated classes. Default
     /// is empty. When this option is empty, the package name will be used for
     /// determining the namespace.
     #[prost(string, optional, tag="41")]
-    pub php_namespace: ::std::option::Option<std::string::String>,
+    pub php_namespace: ::core::option::Option<alloc::string::String>,
     /// Use this option to change the namespace of php generated metadata classes.
     /// Default is empty. When this option is empty, the proto file name will be used
     /// for determining the namespace.
     #[prost(string, optional, tag="44")]
-    pub php_metadata_namespace: ::std::option::Option<std::string::String>,
+    pub php_metadata_namespace: ::core::option::Option<alloc::string::String>,
     /// Use this option to change the package of ruby generated classes. Default
     /// is empty. When this option is not set, the package name will be used for
     /// determining the ruby package.
     #[prost(string, optional, tag="45")]
-    pub ruby_package: ::std::option::Option<std::string::String>,
+    pub ruby_package: ::core::option::Option<alloc::string::String>,
     /// The parser stores options it doesn't recognize here.
     /// See the documentation for the "Options" section above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod file_options {
     /// Generated classes can be optimized for speed or code size.
@@ -451,18 +451,18 @@ pub struct MessageOptions {
     /// Because this is an option, the above two restrictions are not enforced by
     /// the protocol compiler.
     #[prost(bool, optional, tag="1", default="false")]
-    pub message_set_wire_format: ::std::option::Option<bool>,
+    pub message_set_wire_format: ::core::option::Option<bool>,
     /// Disables the generation of the standard "descriptor()" accessor, which can
     /// conflict with a field of the same name.  This is meant to make migration
     /// from proto1 easier; new code should avoid fields named "descriptor".
     #[prost(bool, optional, tag="2", default="false")]
-    pub no_standard_descriptor_accessor: ::std::option::Option<bool>,
+    pub no_standard_descriptor_accessor: ::core::option::Option<bool>,
     /// Is this message deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the message, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating messages.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: ::core::option::Option<bool>,
     /// Whether the message is an automatically generated map entry type for the
     /// maps field.
     ///
@@ -485,10 +485,10 @@ pub struct MessageOptions {
     /// instead. The option should only be implicitly set by the proto compiler
     /// parser.
     #[prost(bool, optional, tag="7")]
-    pub map_entry: ::std::option::Option<bool>,
+    pub map_entry: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldOptions {
@@ -497,14 +497,14 @@ pub struct FieldOptions {
     /// options below.  This option is not yet implemented in the open source
     /// release -- sorry, we'll try to include it in a future version!
     #[prost(enumeration="field_options::CType", optional, tag="1", default="String")]
-    pub ctype: ::std::option::Option<i32>,
+    pub ctype: ::core::option::Option<i32>,
     /// The packed option can be enabled for repeated primitive fields to enable
     /// a more efficient representation on the wire. Rather than repeatedly
     /// writing the tag and type for each element, the entire array is encoded as
     /// a single length-delimited blob. In proto3, only explicit setting it to
     /// false will avoid using packed encoding.
     #[prost(bool, optional, tag="2")]
-    pub packed: ::std::option::Option<bool>,
+    pub packed: ::core::option::Option<bool>,
     /// The jstype option determines the JavaScript type used for values of the
     /// field.  The option is permitted only for 64 bit integral and fixed types
     /// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
@@ -517,7 +517,7 @@ pub struct FieldOptions {
     /// This option is an enum to permit additional types to be added, e.g.
     /// goog.math.Integer.
     #[prost(enumeration="field_options::JsType", optional, tag="6", default="JsNormal")]
-    pub jstype: ::std::option::Option<i32>,
+    pub jstype: ::core::option::Option<i32>,
     /// Should this field be parsed lazily?  Lazy applies only to message-type
     /// fields.  It means that when the outer message is initially parsed, the
     /// inner message's contents will not be parsed but instead stored in encoded
@@ -547,19 +547,19 @@ pub struct FieldOptions {
     /// check its required fields, regardless of whether or not the message has
     /// been parsed.
     #[prost(bool, optional, tag="5", default="false")]
-    pub lazy: ::std::option::Option<bool>,
+    pub lazy: ::core::option::Option<bool>,
     /// Is this field deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for accessors, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating fields.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: ::core::option::Option<bool>,
     /// For Google-internal migration only. Do not use.
     #[prost(bool, optional, tag="10", default="false")]
-    pub weak: ::std::option::Option<bool>,
+    pub weak: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod field_options {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -585,23 +585,23 @@ pub mod field_options {
 pub struct OneofOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumOptions {
     /// Set this option to true to allow mapping different tag names to the same
     /// value.
     #[prost(bool, optional, tag="2")]
-    pub allow_alias: ::std::option::Option<bool>,
+    pub allow_alias: ::core::option::Option<bool>,
     /// Is this enum deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the enum, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating enums.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueOptions {
@@ -610,10 +610,10 @@ pub struct EnumValueOptions {
     /// for the enum value, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating enum values.
     #[prost(bool, optional, tag="1", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceOptions {
@@ -627,10 +627,10 @@ pub struct ServiceOptions {
     /// for the service, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating services.
     #[prost(bool, optional, tag="33", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodOptions {
@@ -644,12 +644,12 @@ pub struct MethodOptions {
     /// for the method, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating methods.
     #[prost(bool, optional, tag="33", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: ::core::option::Option<bool>,
     #[prost(enumeration="method_options::IdempotencyLevel", optional, tag="34", default="IdempotencyUnknown")]
-    pub idempotency_level: ::std::option::Option<i32>,
+    pub idempotency_level: ::core::option::Option<i32>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod method_options {
     /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
@@ -674,21 +674,21 @@ pub mod method_options {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UninterpretedOption {
     #[prost(message, repeated, tag="2")]
-    pub name: ::std::vec::Vec<uninterpreted_option::NamePart>,
+    pub name: ::alloc::vec::Vec<uninterpreted_option::NamePart>,
     /// The value of the uninterpreted option, in whatever type the tokenizer
     /// identified it as during parsing. Exactly one of these should be set.
     #[prost(string, optional, tag="3")]
-    pub identifier_value: ::std::option::Option<std::string::String>,
+    pub identifier_value: ::core::option::Option<alloc::string::String>,
     #[prost(uint64, optional, tag="4")]
-    pub positive_int_value: ::std::option::Option<u64>,
+    pub positive_int_value: ::core::option::Option<u64>,
     #[prost(int64, optional, tag="5")]
-    pub negative_int_value: ::std::option::Option<i64>,
+    pub negative_int_value: ::core::option::Option<i64>,
     #[prost(double, optional, tag="6")]
-    pub double_value: ::std::option::Option<f64>,
+    pub double_value: ::core::option::Option<f64>,
     #[prost(bytes, optional, tag="7")]
-    pub string_value: ::std::option::Option<std::vec::Vec<u8>>,
+    pub string_value: ::core::option::Option<alloc::vec::Vec<u8>>,
     #[prost(string, optional, tag="8")]
-    pub aggregate_value: ::std::option::Option<std::string::String>,
+    pub aggregate_value: ::core::option::Option<alloc::string::String>,
 }
 pub mod uninterpreted_option {
     /// The name of the uninterpreted option.  Each string represents a segment in
@@ -699,7 +699,7 @@ pub mod uninterpreted_option {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NamePart {
         #[prost(string, required, tag="1")]
-        pub name_part: std::string::String,
+        pub name_part: alloc::string::String,
         #[prost(bool, required, tag="2")]
         pub is_extension: bool,
     }
@@ -755,7 +755,7 @@ pub struct SourceCodeInfo {
     ///   ignore those that it doesn't understand, as more types of locations could
     ///   be recorded in the future.
     #[prost(message, repeated, tag="1")]
-    pub location: ::std::vec::Vec<source_code_info::Location>,
+    pub location: ::alloc::vec::Vec<source_code_info::Location>,
 }
 pub mod source_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -784,14 +784,14 @@ pub mod source_code_info {
         /// this path refers to the whole field declaration (from the beginning
         /// of the label to the terminating semicolon).
         #[prost(int32, repeated, tag="1")]
-        pub path: ::std::vec::Vec<i32>,
+        pub path: ::alloc::vec::Vec<i32>,
         /// Always has exactly three or four elements: start line, start column,
         /// end line (optional, otherwise assumed same as start line), end column.
         /// These are packed into a single field for efficiency.  Note that line
         /// and column numbers are zero-based -- typically you will want to add
         /// 1 to each before displaying to a user.
         #[prost(int32, repeated, tag="2")]
-        pub span: ::std::vec::Vec<i32>,
+        pub span: ::alloc::vec::Vec<i32>,
         /// If this SourceCodeInfo represents a complete declaration, these are any
         /// comments appearing before and after the declaration which appear to be
         /// attached to the declaration.
@@ -840,11 +840,11 @@ pub mod source_code_info {
         ///
         ///   // ignored detached comments.
         #[prost(string, optional, tag="3")]
-        pub leading_comments: ::std::option::Option<std::string::String>,
+        pub leading_comments: ::core::option::Option<alloc::string::String>,
         #[prost(string, optional, tag="4")]
-        pub trailing_comments: ::std::option::Option<std::string::String>,
+        pub trailing_comments: ::core::option::Option<alloc::string::String>,
         #[prost(string, repeated, tag="6")]
-        pub leading_detached_comments: ::std::vec::Vec<std::string::String>,
+        pub leading_detached_comments: ::alloc::vec::Vec<alloc::string::String>,
     }
 }
 /// Describes the relationship between generated code and its original source
@@ -855,7 +855,7 @@ pub struct GeneratedCodeInfo {
     /// An Annotation connects some span of text in generated code to an element
     /// of its generating .proto file.
     #[prost(message, repeated, tag="1")]
-    pub annotation: ::std::vec::Vec<generated_code_info::Annotation>,
+    pub annotation: ::alloc::vec::Vec<generated_code_info::Annotation>,
 }
 pub mod generated_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -863,19 +863,19 @@ pub mod generated_code_info {
         /// Identifies the element in the original source .proto file. This field
         /// is formatted the same as SourceCodeInfo.Location.path.
         #[prost(int32, repeated, tag="1")]
-        pub path: ::std::vec::Vec<i32>,
+        pub path: ::alloc::vec::Vec<i32>,
         /// Identifies the filesystem path to the original source .proto.
         #[prost(string, optional, tag="2")]
-        pub source_file: ::std::option::Option<std::string::String>,
+        pub source_file: ::core::option::Option<alloc::string::String>,
         /// Identifies the starting offset in bytes in the generated code
         /// that relates to the identified object.
         #[prost(int32, optional, tag="3")]
-        pub begin: ::std::option::Option<i32>,
+        pub begin: ::core::option::Option<i32>,
         /// Identifies the ending offset in bytes in the generated code that
         /// relates to the identified offset. The end offset should be one past
         /// the last relevant byte (so the length of the text = end - begin).
         #[prost(int32, optional, tag="4")]
-        pub end: ::std::option::Option<i32>,
+        pub end: ::core::option::Option<i32>,
     }
 }
 /// `Any` contains an arbitrary serialized protocol buffer message along with a
@@ -989,10 +989,10 @@ pub struct Any {
     /// used with implementation specific semantics.
     ///
     #[prost(string, tag="1")]
-    pub type_url: std::string::String,
+    pub type_url: alloc::string::String,
     /// Must be a valid serialized protocol buffer of the above specified type.
     #[prost(bytes, tag="2")]
-    pub value: std::vec::Vec<u8>,
+    pub value: alloc::vec::Vec<u8>,
 }
 /// `SourceContext` represents information about the source of a
 /// protobuf element, like the file in which it is defined.
@@ -1001,26 +1001,26 @@ pub struct SourceContext {
     /// The path-qualified name of the .proto file that contained the associated
     /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
     #[prost(string, tag="1")]
-    pub file_name: std::string::String,
+    pub file_name: alloc::string::String,
 }
 /// A protocol buffer message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Type {
     /// The fully qualified message name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// The list of fields.
     #[prost(message, repeated, tag="2")]
-    pub fields: ::std::vec::Vec<Field>,
+    pub fields: ::alloc::vec::Vec<Field>,
     /// The list of types appearing in `oneof` definitions in this type.
     #[prost(string, repeated, tag="3")]
-    pub oneofs: ::std::vec::Vec<std::string::String>,
+    pub oneofs: ::alloc::vec::Vec<alloc::string::String>,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="4")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: ::alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="5")]
-    pub source_context: ::std::option::Option<SourceContext>,
+    pub source_context: ::core::option::Option<SourceContext>,
     /// The source syntax.
     #[prost(enumeration="Syntax", tag="6")]
     pub syntax: i32,
@@ -1039,11 +1039,11 @@ pub struct Field {
     pub number: i32,
     /// The field name.
     #[prost(string, tag="4")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// The field type URL, without the scheme, for message or enumeration
     /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
     #[prost(string, tag="6")]
-    pub type_url: std::string::String,
+    pub type_url: alloc::string::String,
     /// The index of the field type in `Type.oneofs`, for message or enumeration
     /// types. The first type has index 1; zero means the type is not in the list.
     #[prost(int32, tag="7")]
@@ -1053,13 +1053,13 @@ pub struct Field {
     pub packed: bool,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="9")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: ::alloc::vec::Vec<Option>,
     /// The field JSON name.
     #[prost(string, tag="10")]
-    pub json_name: std::string::String,
+    pub json_name: alloc::string::String,
     /// The string value of the default value of this field. Proto2 syntax only.
     #[prost(string, tag="11")]
-    pub default_value: std::string::String,
+    pub default_value: alloc::string::String,
 }
 pub mod field {
     /// Basic field types.
@@ -1124,16 +1124,16 @@ pub mod field {
 pub struct Enum {
     /// Enum type name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// Enum value definitions.
     #[prost(message, repeated, tag="2")]
-    pub enumvalue: ::std::vec::Vec<EnumValue>,
+    pub enumvalue: ::alloc::vec::Vec<EnumValue>,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: ::alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="4")]
-    pub source_context: ::std::option::Option<SourceContext>,
+    pub source_context: ::core::option::Option<SourceContext>,
     /// The source syntax.
     #[prost(enumeration="Syntax", tag="5")]
     pub syntax: i32,
@@ -1143,13 +1143,13 @@ pub struct Enum {
 pub struct EnumValue {
     /// Enum value name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// Enum value number.
     #[prost(int32, tag="2")]
     pub number: i32,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: ::alloc::vec::Vec<Option>,
 }
 /// A protocol buffer option, which can be attached to a message, field,
 /// enumeration, etc.
@@ -1160,13 +1160,13 @@ pub struct Option {
     /// For custom options, it should be the fully-qualified name. For example,
     /// `"google.api.http"`.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// The option's value packed in an Any message. If the value is a primitive,
     /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
     /// should be used. If the value is an enum, it should be stored as an int32
     /// value using the google.protobuf.Int32Value type.
     #[prost(message, optional, tag="2")]
-    pub value: ::std::option::Option<Any>,
+    pub value: ::core::option::Option<Any>,
 }
 /// The syntax in which a protocol buffer element is defined.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -1191,13 +1191,13 @@ pub struct Api {
     /// The fully qualified name of this interface, including package name
     /// followed by the interface's simple name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// The methods of this interface, in unspecified order.
     #[prost(message, repeated, tag="2")]
-    pub methods: ::std::vec::Vec<Method>,
+    pub methods: ::alloc::vec::Vec<Method>,
     /// Any metadata attached to the interface.
     #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: ::alloc::vec::Vec<Option>,
     /// A version string for this interface. If specified, must have the form
     /// `major-version.minor-version`, as in `1.10`. If the minor version is
     /// omitted, it defaults to zero. If the entire version field is empty, the
@@ -1220,14 +1220,14 @@ pub struct Api {
     ///
     ///
     #[prost(string, tag="4")]
-    pub version: std::string::String,
+    pub version: alloc::string::String,
     /// Source context for the protocol buffer service represented by this
     /// message.
     #[prost(message, optional, tag="5")]
-    pub source_context: ::std::option::Option<SourceContext>,
+    pub source_context: ::core::option::Option<SourceContext>,
     /// Included interfaces. See [Mixin][].
     #[prost(message, repeated, tag="6")]
-    pub mixins: ::std::vec::Vec<Mixin>,
+    pub mixins: ::alloc::vec::Vec<Mixin>,
     /// The source syntax of the service.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1237,22 +1237,22 @@ pub struct Api {
 pub struct Method {
     /// The simple name of this method.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// A URL of the input message type.
     #[prost(string, tag="2")]
-    pub request_type_url: std::string::String,
+    pub request_type_url: alloc::string::String,
     /// If true, the request is streamed.
     #[prost(bool, tag="3")]
     pub request_streaming: bool,
     /// The URL of the output message type.
     #[prost(string, tag="4")]
-    pub response_type_url: std::string::String,
+    pub response_type_url: alloc::string::String,
     /// If true, the response is streamed.
     #[prost(bool, tag="5")]
     pub response_streaming: bool,
     /// Any metadata attached to the method.
     #[prost(message, repeated, tag="6")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: ::alloc::vec::Vec<Option>,
     /// The source syntax of this method.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1339,11 +1339,11 @@ pub struct Method {
 pub struct Mixin {
     /// The fully qualified name of the interface which is included.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: alloc::string::String,
     /// If non-empty specifies a path under which inherited HTTP paths
     /// are rooted.
     #[prost(string, tag="2")]
-    pub root: std::string::String,
+    pub root: alloc::string::String,
 }
 /// A Duration represents a signed, fixed-length span of time represented
 /// as a count of seconds and fractions of seconds at nanosecond
@@ -1624,7 +1624,7 @@ pub struct Duration {
 pub struct FieldMask {
     /// The set of field mask paths.
     #[prost(string, repeated, tag="1")]
-    pub paths: ::std::vec::Vec<std::string::String>,
+    pub paths: ::alloc::vec::Vec<alloc::string::String>,
 }
 /// `Struct` represents a structured data value, consisting of fields
 /// which map to dynamically typed values. In some languages, `Struct`
@@ -1638,7 +1638,7 @@ pub struct FieldMask {
 pub struct Struct {
     /// Unordered map of dynamically typed values.
     #[prost(btree_map="string, message", tag="1")]
-    pub fields: ::std::collections::BTreeMap<std::string::String, Value>,
+    pub fields: ::alloc::collections::BTreeMap<alloc::string::String, Value>,
 }
 /// `Value` represents a dynamically typed value which can be either
 /// null, a number, a string, a boolean, a recursive struct value, or a
@@ -1650,7 +1650,7 @@ pub struct Struct {
 pub struct Value {
     /// The kind of value.
     #[prost(oneof="value::Kind", tags="1, 2, 3, 4, 5, 6")]
-    pub kind: ::std::option::Option<value::Kind>,
+    pub kind: ::core::option::Option<value::Kind>,
 }
 pub mod value {
     /// The kind of value.
@@ -1664,7 +1664,7 @@ pub mod value {
         NumberValue(f64),
         /// Represents a string value.
         #[prost(string, tag="3")]
-        StringValue(std::string::String),
+        StringValue(alloc::string::String),
         /// Represents a boolean value.
         #[prost(bool, tag="4")]
         BoolValue(bool),
@@ -1683,7 +1683,7 @@ pub mod value {
 pub struct ListValue {
     /// Repeated field of dynamically typed values.
     #[prost(message, repeated, tag="1")]
-    pub values: ::std::vec::Vec<Value>,
+    pub values: ::alloc::vec::Vec<Value>,
 }
 /// `NullValue` is a singleton enumeration to represent the null value for the
 /// `Value` type union.
diff --git a/protobuf/Cargo.toml b/protobuf/Cargo.toml
index 6086e86f2..33e9ff358 100644
--- a/protobuf/Cargo.toml
+++ b/protobuf/Cargo.toml
@@ -6,7 +6,7 @@ publish = false
 edition = "2018"
 
 [dependencies]
-bytes = "0.4.7"
+bytes = { version = "0.5", default-features = false }
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
 
diff --git a/protobuf/src/lib.rs b/protobuf/src/lib.rs
index 88aa422c5..ebd6a6507 100644
--- a/protobuf/src/lib.rs
+++ b/protobuf/src/lib.rs
@@ -1,3 +1,5 @@
+extern crate alloc;
+
 pub mod benchmarks {
     include!(concat!(env!("OUT_DIR"), "/benchmarks.rs"));
 
diff --git a/src/encoding.rs b/src/encoding.rs
index faa52019e..60df19067 100644
--- a/src/encoding.rs
+++ b/src/encoding.rs
@@ -2,10 +2,14 @@
 //!
 //! Meant to be used only from `Message` implementations.
 
-use std::cmp::min;
-use std::mem;
-use std::u32;
-use std::usize;
+use core::cmp::min;
+use core::mem;
+use core::u32;
+use core::usize;
+
+use alloc::format;
+use alloc::string::String;
+use alloc::vec::Vec;
 
 use ::bytes::{Buf, BufMut};
 
@@ -1040,10 +1044,8 @@ pub mod group {
 /// generic over `HashMap` and `BTreeMap`.
 macro_rules! map {
     ($map_ty:ident) => {
-        use std::collections::$map_ty;
-        use std::hash::Hash;
-
         use crate::encoding::*;
+        use core::hash::Hash;
 
         /// Generic protobuf map encode function.
         pub fn encode<K, V, B, KE, KL, VE, VL>(
@@ -1225,11 +1227,17 @@ macro_rules! map {
     };
 }
 
+#[cfg(feature = "std")]
 pub mod hash_map {
+    use std::collections::HashMap;
     map!(HashMap);
 }
 
 pub mod btree_map {
+    #[cfg(feature = "std")]
+    use std::collections::BTreeMap;
+    #[cfg(not(feature = "std"))]
+    use alloc::collections::BTreeMap;
     map!(BTreeMap);
 }
 
@@ -1240,7 +1248,7 @@ mod test {
     use std::io::Cursor;
     use std::u64;
 
-    use ::bytes::{Bytes, BytesMut, IntoBuf};
+    use ::bytes::{Bytes, BytesMut};
     use quickcheck::TestResult;
 
     use crate::encoding::*;
@@ -1266,7 +1274,7 @@ mod test {
         let mut buf = BytesMut::with_capacity(expected_len);
         encode(tag, value.borrow(), &mut buf);
 
-        let mut buf = buf.freeze().into_buf();
+        let mut buf = buf.freeze().to_bytes();
 
         if buf.remaining() != expected_len {
             return TestResult::error(format!(
diff --git a/src/error.rs b/src/error.rs
index 889326bea..f91e9bfbe 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,8 +1,14 @@
 //! Protobuf encoding and decoding errors.
 
-use std::borrow::Cow;
+use alloc::borrow::Cow;
+use alloc::vec::Vec;
+
+#[cfg(feature = "std")]
 use std::error;
-use std::fmt;
+
+use core::fmt;
+
+#[cfg(feature = "std")]
 use std::io;
 
 /// A Protobuf message decoding error.
@@ -54,12 +60,14 @@ impl fmt::Display for DecodeError {
     }
 }
 
+#[cfg(feature = "std")]
 impl error::Error for DecodeError {
     fn description(&self) -> &str {
         &self.description
     }
 }
 
+#[cfg(feature = "std")]
 impl From<DecodeError> for io::Error {
     fn from(error: DecodeError) -> io::Error {
         io::Error::new(io::ErrorKind::InvalidData, error)
@@ -108,12 +116,14 @@ impl fmt::Display for EncodeError {
     }
 }
 
+#[cfg(feature = "std")]
 impl error::Error for EncodeError {
     fn description(&self) -> &str {
         "failed to encode Protobuf message: insufficient buffer capacity"
     }
 }
 
+#[cfg(feature = "std")]
 impl From<EncodeError> for io::Error {
     fn from(error: EncodeError) -> io::Error {
         io::Error::new(io::ErrorKind::InvalidInput, error)
diff --git a/src/lib.rs b/src/lib.rs
index cfc3d2e7b..fce880fd8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,12 @@
 #![doc(html_root_url = "https://docs.rs/prost/0.5.0")]
 
+#![no_std]
+
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
 mod error;
 mod message;
 mod types;
@@ -10,7 +17,7 @@ pub mod encoding;
 pub use crate::error::{DecodeError, EncodeError};
 pub use crate::message::Message;
 
-use bytes::{BufMut, IntoBuf};
+use bytes::{Buf, BufMut};
 
 use crate::encoding::{decode_varint, encode_varint, encoded_len_varint};
 
@@ -58,12 +65,11 @@ pub fn length_delimiter_len(length: usize) -> usize {
 ///    input is required to decode the full delimiter.
 ///  * If the supplied buffer contains more than 10 bytes, then the buffer contains an invalid
 ///    delimiter, and typically the buffer should be considered corrupt.
-pub fn decode_length_delimiter<B>(buf: B) -> Result<usize, DecodeError>
+pub fn decode_length_delimiter<B>(buf: &mut B) -> Result<usize, DecodeError>
 where
-    B: IntoBuf,
+    B: Buf,
 {
-    let mut buf = buf.into_buf();
-    let length = decode_varint(&mut buf)?;
+    let length = decode_varint(buf)?;
     if length > usize::max_value() as u64 {
         return Err(DecodeError::new(
             "length delimiter exceeds maximum usize value",
diff --git a/src/message.rs b/src/message.rs
index a4acfd2b4..df7595f4d 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,7 +1,9 @@
-use std::fmt::Debug;
-use std::usize;
+use core::fmt::Debug;
+use core::usize;
 
-use ::bytes::{Buf, BufMut, IntoBuf};
+use alloc::boxed::Box;
+
+use ::bytes::{Buf, BufMut};
 
 use crate::encoding::*;
 use crate::DecodeError;
@@ -80,17 +82,19 @@ pub trait Message: Debug + Send + Sync {
     /// The entire buffer will be consumed.
     fn decode<B>(buf: B) -> Result<Self, DecodeError>
     where
-        B: IntoBuf,
+        B: Buf,
         Self: Default,
     {
         let mut message = Self::default();
-        Self::merge(&mut message, &mut buf.into_buf()).map(|_| message)
+        Self::merge(&mut message, buf).map(|_| message)
     }
 
     /// Decodes a length-delimited instance of the message from the buffer.
+    ///
+    /// The entire buffer will be consumed.
     fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>
     where
-        B: IntoBuf,
+        B: Buf,
         Self: Default,
     {
         let mut message = Self::default();
@@ -101,12 +105,11 @@ pub trait Message: Debug + Send + Sync {
     /// Decodes an instance of the message from a buffer, and merges it into `self`.
     ///
     /// The entire buffer will be consumed.
-    fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>
+    fn merge<B>(&mut self, mut buf: B) -> Result<(), DecodeError>
     where
-        B: IntoBuf,
+        B: Buf,
         Self: Sized,
     {
-        let mut buf = buf.into_buf();
         let ctx = DecodeContext::default();
         while buf.has_remaining() {
             let (tag, wire_type) = decode_key(&mut buf)?;
@@ -117,15 +120,17 @@ pub trait Message: Debug + Send + Sync {
 
     /// Decodes a length-delimited instance of the message from buffer, and
     /// merges it into `self`.
-    fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError>
+    ///
+    /// The entire buffer will be consumed.
+    fn merge_length_delimited<B>(&mut self, mut buf: B) -> Result<(), DecodeError>
     where
-        B: IntoBuf,
+        B: Buf,
         Self: Sized,
     {
         message::merge(
             WireType::LengthDelimited,
             self,
-            &mut buf.into_buf(),
+            &mut buf,
             DecodeContext::default(),
         )
     }
diff --git a/src/types.rs b/src/types.rs
index 6156e297f..d08cb1c14 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -11,6 +11,9 @@ use crate::encoding::*;
 use crate::DecodeError;
 use crate::Message;
 
+use alloc::string::String;
+use alloc::vec::Vec;
+
 /// `google.protobuf.BoolValue`
 impl Message for bool {
     fn encode_raw<B>(&self, buf: &mut B)
diff --git a/tests-2015/Cargo.toml b/tests-2015/Cargo.toml
index c07585f67..e0f6eea6d 100644
--- a/tests-2015/Cargo.toml
+++ b/tests-2015/Cargo.toml
@@ -16,7 +16,7 @@ default = ["edition-2015"]
 edition-2015 = []
 
 [dependencies]
-bytes = "0.4.7"
+bytes = "0.5"
 cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
diff --git a/tests-alloc/Cargo.toml b/tests-alloc/Cargo.toml
new file mode 100644
index 000000000..453ea5380
--- /dev/null
+++ b/tests-alloc/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "tests-alloc"
+version = "0.0.0"
+authors = ["Dan Burkert <dan@danburkert.com>"]
+publish = false
+edition = "2018"
+
+build = "../tests/src/build.rs"
+
+[lib]
+doctest = false
+path = "../tests/src/lib.rs"
+
+[features]
+default = ["nostd-collections"]
+nostd-collections = []
+
+[dependencies]
+bytes = { version = "0.5", default-features = false }
+cfg-if = "0.1"
+prost = { path = ".." }
+prost-types = { path = "../prost-types" }
+protobuf = { path = "../protobuf" }
+
+[dev-dependencies]
+diff = "0.1"
+prost-build = { path = "../prost-build" }
+tempfile = "3"
+
+[build-dependencies]
+cfg-if = "0.1"
+env_logger = { version = "0.6", default-features = false }
+prost-build = { path = "../prost-build" }
+protobuf = { path = "../protobuf" }
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index 11d99b15f..b8580c292 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -11,7 +11,7 @@ build = "src/build.rs"
 doctest = false
 
 [dependencies]
-bytes = "0.4.7"
+bytes = "0.5"
 cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
diff --git a/tests/src/build.rs b/tests/src/build.rs
index 70c4b0480..a0f2a6869 100644
--- a/tests/src/build.rs
+++ b/tests/src/build.rs
@@ -20,12 +20,21 @@ fn main() {
     let src = PathBuf::from("../tests/src");
     let includes = &[src.clone()];
 
+    let mut config = prost_build::Config::new();
+
     // Generate BTreeMap fields for all messages. This forces encoded output to be consistent, so
     // that encode/decode roundtrips can use encoded output for comparison. Otherwise trying to
     // compare based on the Rust PartialEq implementations is difficult, due to presence of NaN
     // values.
-    let mut config = prost_build::Config::new();
-    config.btree_map(&["."]);
+    //
+    // Note nostd collections implies Btree everywhere anyways
+    cfg_if! {
+        if #[cfg(feature = "nostd-collections")] {
+            config.use_alloc_collections_lib();
+        } else {
+            config.btree_map(&["."]);
+        }
+    }
     // Tests for custom attributes
     config.type_attribute("Foo.Bar_Baz.Foo_barBaz", "#[derive(Eq, PartialOrd, Ord)]");
     config.type_attribute(
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index ca2b83332..5ccc7b8e5 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -76,7 +76,7 @@ pub mod groups {
 
 use std::error::Error;
 
-use bytes::{Buf, IntoBuf};
+use bytes::{Buf};
 
 use prost::Message;
 

From cc51c9d4a71e0ecb048e08f220941eefc22d7d18 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Wed, 11 Sep 2019 19:35:31 -0700
Subject: [PATCH 02/36] WIP fixes to prost-derive, and porting of tests to
 alloc configuration

---
 .travis.yml                         |   1 +
 Cargo.toml                          |   3 +-
 prost-derive/Cargo.toml             |  13 +-
 prost-derive/src/field/map.rs       |   6 +-
 prost-derive/src/field/mod.rs       |  18 +-
 prost-derive/src/field/oneof.rs     |   2 +-
 prost-derive/src/field/scalar.rs    |  66 ++---
 prost-derive/src/lib.rs             |   1 +
 protobuf/build.rs                   |   2 +-
 tests-2015/Cargo.toml               |   1 +
 tests-alloc/Cargo.toml              |  19 +-
 tests-alloc/src/bin.rs              | 403 ++++++++++++++++++++++++++++
 tests-alloc/src/build.rs            | 110 ++++++++
 tests-infra/Cargo.toml              |  14 +
 tests-infra/src/lib.rs              | 162 +++++++++++
 tests/Cargo.toml                    |   1 +
 tests/src/build.rs                  |  11 +-
 tests/src/lib.rs                    | 133 +--------
 tests/src/message_encoding_alloc.rs | 369 +++++++++++++++++++++++++
 19 files changed, 1146 insertions(+), 189 deletions(-)
 create mode 100644 tests-alloc/src/bin.rs
 create mode 100644 tests-alloc/src/build.rs
 create mode 100644 tests-infra/Cargo.toml
 create mode 100644 tests-infra/src/lib.rs
 create mode 100644 tests/src/message_encoding_alloc.rs

diff --git a/.travis.yml b/.travis.yml
index d9ada51ec..b1e813438 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -21,6 +21,7 @@ rust:
 script:
   - cargo build --verbose --all --exclude benchmarks
   - cargo test --verbose --all --exclude benchmarks
+  - cargo run -p tests-alloc --verbose
   - if [[ $TRAVIS_RUST_VERSION = nightly* ]]; then
       cargo bench --verbose --no-run;
     fi
diff --git a/Cargo.toml b/Cargo.toml
index 780fa414b..6a09a9b75 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ exclude = [
 [features]
 default = ["prost-derive", "std"]
 no-recursion-limit = []
-std = []
+std = ["prost-derive/std"]
    # When std is disabled, we attempt to provide no_std support in prost
    # Config::use_alloc_collections() should be set when using prost_build in your build.rs
    # so that generated files will not have std:: either, and will use alloc crate instead
@@ -60,5 +60,6 @@ name = "varint"
 name = "benchmark"
 harness = false
 
+# TODO: Remove this after bytes releases 0.5, and before we make a release
 [patch.crates-io]
 bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024" }
diff --git a/prost-derive/Cargo.toml b/prost-derive/Cargo.toml
index 7b9125970..8cb7089fd 100644
--- a/prost-derive/Cargo.toml
+++ b/prost-derive/Cargo.toml
@@ -13,8 +13,19 @@ edition = "2018"
 [lib]
 proc_macro = true
 
+[features]
+std = [ "failure/std" ]
+# std feature means that prost-derive attempts to use std collections
+#
+# When this feature is disabled, we attempt to use alloc.
+# This should be similar to putting `config.use_alloc_collections` in a
+# prost-build config
+#
+# Generated code assumes that user's crate has `extern crate alloc` somewhere
+default = ["std"]
+
 [dependencies]
-failure = { version = "0.1", default-features = false, features = ["std"] }
+failure = { version = "0.1", default-features = false }
 itertools = "0.8"
 proc-macro2 = "0.4.4"
 quote = "0.6.3"
diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index ed8d3e9b3..6096d4feb 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -240,6 +240,8 @@ impl Field {
     /// The Debug tries to convert any enumerations met into the variants if possible, instead of
     /// outputting the raw numbers.
     pub fn debug(&self, wrapper_name: TokenStream) -> TokenStream {
+        let libname = super::collections_lib_name();
+
         let type_name = match self.map_ty {
             MapTy::HashMap => Ident::new("HashMap", Span::call_site()),
             MapTy::BTreeMap => Ident::new("BTreeMap", Span::call_site()),
@@ -263,14 +265,14 @@ impl Field {
             ValueTy::Scalar(ref ty) => {
                 let value = ty.rust_type();
                 quote! {
-                    struct #wrapper_name<'a>(&'a ::alloc::collections::#type_name<#key, #value>);
+                    struct #wrapper_name<'a>(&'a ::#libname::collections::#type_name<#key, #value>);
                     impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
                         #fmt
                     }
                 }
             }
             ValueTy::Message => quote! {
-                struct #wrapper_name<'a, V: 'a>(&'a ::alloc::collections::#type_name<#key, V>);
+                struct #wrapper_name<'a, V: 'a>(&'a ::#libname::collections::#type_name<#key, V>);
                 impl<'a, V> ::core::fmt::Debug for #wrapper_name<'a, V>
                 where
                     V: ::core::fmt::Debug + 'a,
diff --git a/prost-derive/src/field/mod.rs b/prost-derive/src/field/mod.rs
index 0d362d241..f96c91382 100644
--- a/prost-derive/src/field/mod.rs
+++ b/prost-derive/src/field/mod.rs
@@ -4,11 +4,11 @@ mod message;
 mod oneof;
 mod scalar;
 
-use std::fmt;
-use std::slice;
+use core::fmt;
+use core::slice;
 
 use failure::{bail, Error};
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{Attribute, Ident, Lit, LitBool, Meta, MetaList, MetaNameValue, NestedMeta};
 
@@ -135,7 +135,7 @@ impl Field {
     pub fn default(&self) -> TokenStream {
         match *self {
             Field::Scalar(ref scalar) => scalar.default(),
-            _ => quote!(::std::default::Default::default()),
+            _ => quote!(::core::default::Default::default()),
         }
     }
 
@@ -364,3 +364,13 @@ fn tags_attr(attr: &Meta) -> Result<Option<Vec<u32>>, Error> {
         _ => bail!("invalid tag attribute: {:?}", attr),
     }
 }
+
+// Helper which builds an identifier corresponding `std` or `alloc` depending
+// on feature selection
+fn collections_lib_name() -> Ident {
+        if cfg!(std) {
+            Ident::new("std", Span::call_site())
+        } else {
+            Ident::new("alloc", Span::call_site())
+        }
+}
diff --git a/prost-derive/src/field/oneof.rs b/prost-derive/src/field/oneof.rs
index 893a1f4ee..45a72ce64 100644
--- a/prost-derive/src/field/oneof.rs
+++ b/prost-derive/src/field/oneof.rs
@@ -90,6 +90,6 @@ impl Field {
     }
 
     pub fn clear(&self, ident: TokenStream) -> TokenStream {
-        quote!(#ident = ::std::option::Option::None)
+        quote!(#ident = ::core::option::Option::None)
     }
 }
diff --git a/prost-derive/src/field/scalar.rs b/prost-derive/src/field/scalar.rs
index e59bf2df6..5015576a3 100644
--- a/prost-derive/src/field/scalar.rs
+++ b/prost-derive/src/field/scalar.rs
@@ -1,4 +1,4 @@
-use std::fmt;
+use core::fmt;
 
 use failure::{bail, format_err, Error};
 use proc_macro2::{Span, TokenStream};
@@ -131,7 +131,7 @@ impl Field {
                 }
             }
             Kind::Optional(..) => quote! {
-                if let ::std::option::Option::Some(ref value) = #ident {
+                if let ::core::option::Option::Some(ref value) = #ident {
                     #encode_fn(#tag, value, buf);
                 }
             },
@@ -204,17 +204,18 @@ impl Field {
                     _ => quote!(#ident = #default),
                 }
             }
-            Kind::Optional(_) => quote!(#ident = ::std::option::Option::None),
+            Kind::Optional(_) => quote!(#ident = ::core::option::Option::None),
             Kind::Repeated | Kind::Packed => quote!(#ident.clear()),
         }
     }
 
     /// Returns an expression which evaluates to the default value of the field.
     pub fn default(&self) -> TokenStream {
+        let libname = super::collections_lib_name();
         match self.kind {
             Kind::Plain(ref value) | Kind::Required(ref value) => value.owned(),
-            Kind::Optional(_) => quote!(::std::option::Option::None),
-            Kind::Repeated | Kind::Packed => quote!(::std::vec::Vec::new()),
+            Kind::Optional(_) => quote!(::core::option::Option::None),
+            Kind::Repeated | Kind::Packed => quote!(::#libname::vec::Vec::new()),
         }
     }
 
@@ -223,11 +224,11 @@ impl Field {
         if let Ty::Enumeration(ref ty) = self.ty {
             quote! {
                 struct #wrap_name<'a>(&'a i32);
-                impl<'a> ::std::fmt::Debug for #wrap_name<'a> {
-                    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                impl<'a> ::core::fmt::Debug for #wrap_name<'a> {
+                    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                         match #ty::from_i32(*self.0) {
-                            None => ::std::fmt::Debug::fmt(&self.0, f),
-                            Some(en) => ::std::fmt::Debug::fmt(&en, f),
+                            None => ::core::fmt::Debug::fmt(&self.0, f),
+                            Some(en) => ::core::fmt::Debug::fmt(&en, f),
                         }
                     }
                 }
@@ -242,23 +243,24 @@ impl Field {
     /// Returns a fragment for formatting the field `ident` in `Debug`.
     pub fn debug(&self, wrapper_name: TokenStream) -> TokenStream {
         let wrapper = self.debug_inner(quote!(Inner));
+        let libname = super::collections_lib_name();
         let inner_ty = self.ty.rust_type();
         match self.kind {
             Kind::Plain(_) | Kind::Required(_) => self.debug_inner(wrapper_name),
             Kind::Optional(_) => quote! {
-                struct #wrapper_name<'a>(&'a ::std::option::Option<#inner_ty>);
-                impl<'a> ::std::fmt::Debug for #wrapper_name<'a> {
-                    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                struct #wrapper_name<'a>(&'a ::core::option::Option<#inner_ty>);
+                impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
+                    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                         #wrapper
-                        ::std::fmt::Debug::fmt(&self.0.as_ref().map(Inner), f)
+                        ::core::fmt::Debug::fmt(&self.0.as_ref().map(Inner), f)
                     }
                 }
             },
             Kind::Repeated | Kind::Packed => {
                 quote! {
-                    struct #wrapper_name<'a>(&'a ::std::vec::Vec<#inner_ty>);
-                    impl<'a> ::std::fmt::Debug for #wrapper_name<'a> {
-                        fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                    struct #wrapper_name<'a>(&'a ::#libname::vec::Vec<#inner_ty>);
+                    impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
+                        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                             let mut vec_builder = f.debug_list();
                             for v in self.0 {
                                 #wrapper
@@ -300,13 +302,13 @@ impl Field {
                         }
 
                         pub fn #set(&mut self, value: #ty) {
-                            self.#ident = ::std::option::Option::Some(value as i32);
+                            self.#ident = ::core::option::Option::Some(value as i32);
                         }
                     }
                 }
                 Kind::Repeated | Kind::Packed => {
                     quote! {
-                        pub fn #ident(&self) -> ::std::iter::FilterMap<::std::iter::Cloned<::std::slice::Iter<i32>>,
+                        pub fn #ident(&self) -> ::core::iter::FilterMap<::core::iter::Cloned<::core::slice::Iter<i32>>,
                                                                        fn(i32) -> Option<#ty>> {
                             self.#ident.iter().cloned().filter_map(#ty::from_i32)
                         }
@@ -320,16 +322,16 @@ impl Field {
             let ty = self.ty.rust_ref_type();
 
             let match_some = if self.ty.is_numeric() {
-                quote!(::std::option::Option::Some(val) => val,)
+                quote!(::core::option::Option::Some(val) => val,)
             } else {
-                quote!(::std::option::Option::Some(ref val) => &val[..],)
+                quote!(::core::option::Option::Some(ref val) => &val[..],)
             };
 
             Some(quote! {
                 pub fn #ident(&self) -> #ty {
                     match self.#ident {
                         #match_some
-                        ::std::option::Option::None => #default,
+                        ::core::option::Option::None => #default,
                     }
                 }
             })
@@ -465,9 +467,10 @@ impl Ty {
 
     // TODO: rename to 'owned_type'.
     pub fn rust_type(&self) -> TokenStream {
+        let libname = super::collections_lib_name();
         match *self {
-            Ty::String => quote!(::std::string::String),
-            Ty::Bytes => quote!(::std::vec::Vec<u8>),
+            Ty::String => quote!(::#libname::string::String),
+            Ty::Bytes => quote!(::#libname::vec::Vec<u8>),
             _ => self.rust_ref_type(),
         }
     }
@@ -628,16 +631,16 @@ impl DefaultValue {
                     match value {
                         "inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f32::INFINITY",
+                                "::core::f32::INFINITY",
                             )?));
                         }
                         "-inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f32::NEG_INFINITY",
+                                "::core::f32::NEG_INFINITY",
                             )?));
                         }
                         "nan" => {
-                            return Ok(DefaultValue::Path(parse_str::<Path>("::std::f32::NAN")?));
+                            return Ok(DefaultValue::Path(parse_str::<Path>("::core::f32::NAN")?));
                         }
                         _ => (),
                     }
@@ -646,16 +649,16 @@ impl DefaultValue {
                     match value {
                         "inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f64::INFINITY",
+                                "::core::f64::INFINITY",
                             )?));
                         }
                         "-inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f64::NEG_INFINITY",
+                                "::core::f64::NEG_INFINITY",
                             )?));
                         }
                         "nan" => {
-                            return Ok(DefaultValue::Path(parse_str::<Path>("::std::f64::NAN")?));
+                            return Ok(DefaultValue::Path(parse_str::<Path>("::core::f64::NAN")?));
                         }
                         _ => (),
                     }
@@ -745,12 +748,13 @@ impl DefaultValue {
     }
 
     pub fn owned(&self) -> TokenStream {
+        let libname = super::collections_lib_name();
         match *self {
             DefaultValue::String(ref value) if value.is_empty() => {
-                quote!(::std::string::String::new())
+                quote!(::#libname::string::String::new())
             }
             DefaultValue::String(ref value) => quote!(#value.to_owned()),
-            DefaultValue::Bytes(ref value) if value.is_empty() => quote!(::std::vec::Vec::new()),
+            DefaultValue::Bytes(ref value) if value.is_empty() => quote!(::#libname::vec::Vec::new()),
             DefaultValue::Bytes(ref value) => {
                 let lit = LitByteStr::new(value, Span::call_site());
                 quote!(#lit.to_owned())
diff --git a/prost-derive/src/lib.rs b/prost-derive/src/lib.rs
index 609cf07c7..646534a46 100644
--- a/prost-derive/src/lib.rs
+++ b/prost-derive/src/lib.rs
@@ -3,6 +3,7 @@
 #![recursion_limit = "4096"]
 
 extern crate proc_macro;
+extern crate alloc;
 
 use failure::bail;
 use quote::quote;
diff --git a/protobuf/build.rs b/protobuf/build.rs
index 158c1a9e7..8365f1f86 100644
--- a/protobuf/build.rs
+++ b/protobuf/build.rs
@@ -174,7 +174,7 @@ fn install_conformance_test_runner(src_dir: &Path, prefix_dir: &Path) {
 
         let rc = Command::new("make")
             .arg("-j")
-            .arg(&num_jobs)
+            .arg("1") // Note: 1 instead of NUM_JOBS to work around bugs in makefile
             .arg("install")
             .current_dir(src_dir.join("conformance"))
             .status()
diff --git a/tests-2015/Cargo.toml b/tests-2015/Cargo.toml
index e0f6eea6d..7491f7343 100644
--- a/tests-2015/Cargo.toml
+++ b/tests-2015/Cargo.toml
@@ -21,6 +21,7 @@ cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
 protobuf = { path = "../protobuf" }
+tests-infra = { path = "../tests-infra" }
 
 [dev-dependencies]
 diff = "0.1"
diff --git a/tests-alloc/Cargo.toml b/tests-alloc/Cargo.toml
index 453ea5380..87ed5ff82 100644
--- a/tests-alloc/Cargo.toml
+++ b/tests-alloc/Cargo.toml
@@ -5,21 +5,20 @@ authors = ["Dan Burkert <dan@danburkert.com>"]
 publish = false
 edition = "2018"
 
-build = "../tests/src/build.rs"
+build = "src/build.rs"
 
-[lib]
-doctest = false
-path = "../tests/src/lib.rs"
-
-[features]
-default = ["nostd-collections"]
-nostd-collections = []
+# The standard libtest relies on std, so if we want to test no_std builds,
+# we should make a binary and not use #[test]
+[[bin]]
+name = "tests-alloc"
+path = "src/bin.rs"
 
 [dependencies]
 bytes = { version = "0.5", default-features = false }
 cfg-if = "0.1"
-prost = { path = ".." }
-prost-types = { path = "../prost-types" }
+prost = { path = "..", default-features = false }
+prost-derive = { path = "../prost-derive", default-features = false }
+prost-types = { path = "../prost-types", default-features = false }
 protobuf = { path = "../protobuf" }
 
 [dev-dependencies]
diff --git a/tests-alloc/src/bin.rs b/tests-alloc/src/bin.rs
new file mode 100644
index 000000000..5067f9b6c
--- /dev/null
+++ b/tests-alloc/src/bin.rs
@@ -0,0 +1,403 @@
+#![no_std]
+
+extern crate alloc;
+
+extern crate tests_infra;
+
+pub mod foo {
+    pub mod bar_baz {
+        include!(concat!(env!("OUT_DIR"), "/foo.bar_baz.rs"));
+    }
+}
+
+pub mod nesting {
+    include!(concat!(env!("OUT_DIR"), "/nesting.rs"));
+}
+
+pub mod recursive_oneof {
+    include!(concat!(env!("OUT_DIR"), "/recursive_oneof.rs"));
+}
+
+/// This tests the custom attributes support by abusing docs.
+///
+/// Docs really are full-blown attributes. So we use them to ensure we can place them on everything
+/// we need. If they aren't put onto something or allowed not to be there (by the generator),
+/// compilation fails.
+#[deny(missing_docs)]
+pub mod custom_attributes {
+    include!(concat!(env!("OUT_DIR"), "/foo.custom.attrs.rs"));
+}
+
+/// Also for testing custom attributes, but on oneofs.
+///
+/// Unfortunately, an OneOf field generates a companion module in the .rs file. There's no
+/// reasonable way to place a doc comment on that, so we do the test with `derive(Ord)` and have it
+/// in a separate file.
+pub mod oneof_attributes {
+    include!(concat!(env!("OUT_DIR"), "/foo.custom.one_of_attrs.rs"));
+}
+
+/// Issue https://github.com/danburkert/prost/issues/118
+///
+/// When a message contains an enum field with a default value, we
+/// must ensure that the appropriate name conventions are used.
+pub mod default_enum_value {
+    include!(concat!(env!("OUT_DIR"), "/default_enum_value.rs"));
+}
+
+pub mod groups {
+    include!(concat!(env!("OUT_DIR"), "/groups.rs"));
+}
+
+use tests_infra::*;
+
+use alloc::collections::{BTreeMap, BTreeSet};
+
+use protobuf::test_messages::proto3::TestAllTypesProto3;
+
+// Tests
+
+    fn test_all_types_proto3() {
+        // Some selected encoded messages, mostly collected from failed fuzz runs.
+        let msgs: &[&[u8]] = &[
+            &[0x28, 0x28, 0x28, 0xFF, 0xFF, 0xFF, 0xFF, 0x68],
+            &[0x92, 0x01, 0x00, 0x92, 0xF4, 0x01, 0x02, 0x00, 0x00],
+            &[0x5d, 0xff, 0xff, 0xff, 0xff, 0x28, 0xff, 0xff, 0x21],
+            &[0x98, 0x04, 0x02, 0x08, 0x0B, 0x98, 0x04, 0x02, 0x08, 0x02],
+            // optional_int32: -1
+            &[0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x08],
+            // repeated_bool: [true, true]
+            &[0xDA, 0x02, 0x02, 0x2A, 0x03],
+            // oneof_double: nan
+            &[0xb1, 0x07, 0xf6, 0x3d, 0xf5, 0xff, 0x27, 0x3d, 0xf5, 0xff],
+            // optional_float: -0.0
+            &[0xdd, 0x00, 0x00, 0x00, 0x00, 0x80],
+            // optional_value: nan
+            &[
+                0xE2, 0x13, 0x1B, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+                0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                0xFF, 0xFF, 0x08, 0xFF, 0x0E,
+            ],
+        ];
+
+        for msg in msgs {
+            roundtrip::<TestAllTypesProto3>(msg).unwrap();
+        }
+    }
+
+    fn test_ident_conversions() {
+        let msg = foo::bar_baz::FooBarBaz {
+            foo_bar_baz: 42,
+            fuzz_busters: vec![foo::bar_baz::foo_bar_baz::FuzzBuster {
+                t: BTreeMap::<i32, foo::bar_baz::FooBarBaz>::new(),
+                nested_self: None,
+            }],
+            p_i_e: 0,
+            r#as: 4,
+            r#break: 5,
+            r#const: 6,
+            r#continue: 7,
+            r#else: 8,
+            r#enum: 9,
+            r#false: 10,
+            r#fn: 11,
+            r#for: 12,
+            r#if: 13,
+            r#impl: 14,
+            r#in: 15,
+            r#let: 16,
+            r#loop: 17,
+            r#match: 18,
+            r#mod: 19,
+            r#move: 20,
+            r#mut: 21,
+            r#pub: 22,
+            r#ref: 23,
+            r#return: 24,
+            r#static: 25,
+            r#struct: 26,
+            r#trait: 27,
+            r#true: 28,
+            r#type: 29,
+            r#unsafe: 30,
+            r#use: 31,
+            r#where: 32,
+            r#while: 33,
+            r#dyn: 34,
+            r#abstract: 35,
+            r#become: 36,
+            r#box: 37,
+            r#do: 38,
+            r#final: 39,
+            r#macro: 40,
+            r#override: 41,
+            r#priv: 42,
+            r#typeof: 43,
+            r#unsized: 44,
+            r#virtual: 45,
+            r#yield: 46,
+            r#async: 47,
+            r#await: 48,
+            r#try: 49,
+            self_: 50,
+            super_: 51,
+            extern_: 52,
+            crate_: 53,
+        };
+
+        let _ = foo::bar_baz::foo_bar_baz::Self_ {};
+
+        // Test enum ident conversion.
+        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::Foo;
+        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::Bar;
+        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::FooBar;
+        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::FuzzBuster;
+        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::NormalRustEnumCase;
+
+        let mut buf = Vec::new();
+        msg.encode(&mut buf).expect("encode");
+        roundtrip::<foo::bar_baz::FooBarBaz>(&buf).unwrap();
+    }
+
+    fn test_custom_type_attributes() {
+        // We abuse the ident conversion protobuf for the custom attribute additions. We placed
+        // `Ord` on the FooBarBaz (which is not implemented by ordinary messages).
+        let mut set1 = BTreeSet::new();
+        let msg1 = foo::bar_baz::FooBarBaz::default();
+        set1.insert(msg1);
+        // Similar, but for oneof fields
+        let mut set2 = BTreeSet::new();
+        let msg2 = oneof_attributes::Msg::default();
+        set2.insert(msg2.field);
+    }
+
+    fn test_nesting() {
+        use crate::nesting::{A, B};
+        let _ = A {
+            a: Some(Box::new(A::default())),
+            repeated_a: Vec::<A>::new(),
+            map_a: BTreeMap::<i32, A>::new(),
+            b: Some(Box::new(B::default())),
+            repeated_b: Vec::<B>::new(),
+            map_b: BTreeMap::<i32, B>::new(),
+        };
+    }
+
+    fn test_deep_nesting() {
+        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
+            use crate::nesting::A;
+
+            let mut a = Box::new(A::default());
+            for _ in 0..depth {
+                let mut next = Box::new(A::default());
+                next.a = Some(a);
+                a = next;
+            }
+
+            let mut buf = Vec::new();
+            a.encode(&mut buf).unwrap();
+            A::decode(buf).map(|_| ())
+        }
+
+        assert!(build_and_roundtrip(100).is_ok());
+        assert!(build_and_roundtrip(101).is_err());
+    }
+
+    fn test_deep_nesting_oneof() {
+        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
+            use crate::recursive_oneof::{a, A, C};
+
+            let mut a = Box::new(A {
+                kind: Some(a::Kind::C(C {})),
+            });
+            for _ in 0..depth {
+                a = Box::new(A {
+                    kind: Some(a::Kind::A(a)),
+                });
+            }
+
+            let mut buf = Vec::new();
+            a.encode(&mut buf).unwrap();
+            A::decode(buf).map(|_| ())
+        }
+
+        assert!(build_and_roundtrip(99).is_ok());
+        assert!(build_and_roundtrip(100).is_err());
+    }
+
+    fn test_deep_nesting_group() {
+        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
+            use crate::groups::{nested_group2::OptionalGroup, NestedGroup2};
+
+            let mut a = NestedGroup2::default();
+            for _ in 0..depth {
+                a = NestedGroup2 {
+                    optionalgroup: Some(Box::new(OptionalGroup {
+                        nested_group: Some(a),
+                    })),
+                };
+            }
+
+            let mut buf = Vec::new();
+            a.encode(&mut buf).unwrap();
+            NestedGroup2::decode(buf).map(|_| ())
+        }
+
+        assert!(build_and_roundtrip(50).is_ok());
+        assert!(build_and_roundtrip(51).is_err());
+    }
+
+    fn test_deep_nesting_repeated() {
+        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
+            use crate::nesting::C;
+
+            let mut c = C::default();
+            for _ in 0..depth {
+                let mut next = C::default();
+                next.r.push(c);
+                c = next;
+            }
+
+            let mut buf = Vec::new();
+            c.encode(&mut buf).unwrap();
+            C::decode(buf).map(|_| ())
+        }
+
+        assert!(build_and_roundtrip(100).is_ok());
+        assert!(build_and_roundtrip(101).is_err());
+    }
+
+    fn test_deep_nesting_map() {
+        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
+            use crate::nesting::D;
+
+            let mut d = D::default();
+            for _ in 0..depth {
+                let mut next = D::default();
+                next.m.insert("foo".to_owned(), d);
+                d = next;
+            }
+
+            let mut buf = Vec::new();
+            d.encode(&mut buf).unwrap();
+            D::decode(buf).map(|_| ())
+        }
+
+        assert!(build_and_roundtrip(50).is_ok());
+        assert!(build_and_roundtrip(51).is_err());
+    }
+
+    fn test_recursive_oneof() {
+        use crate::recursive_oneof::{a, A, B, C};
+        let _ = A {
+            kind: Some(a::Kind::B(Box::new(B {
+                a: Some(Box::new(A {
+                    kind: Some(a::Kind::C(C {})),
+                })),
+            }))),
+        };
+    }
+
+    fn test_default_enum() {
+        let msg = default_enum_value::Test::default();
+        assert_eq!(msg.privacy_level_1(), default_enum_value::PrivacyLevel::One);
+        assert_eq!(
+            msg.privacy_level_3(),
+            default_enum_value::PrivacyLevel::PrivacyLevelThree
+        );
+        assert_eq!(
+            msg.privacy_level_4(),
+            default_enum_value::PrivacyLevel::PrivacyLevelprivacyLevelFour
+        );
+    }
+
+    fn test_group() {
+        // optional group
+        let msg1_bytes = &[0x0B, 0x10, 0x20, 0x0C];
+
+        let msg1 = groups::Test1 {
+            groupa: Some(groups::test1::GroupA { i2: Some(32) }),
+        };
+
+        let mut bytes = Vec::new();
+        msg1.encode(&mut bytes).unwrap();
+        assert_eq!(&bytes, msg1_bytes);
+
+        // skip group while decoding
+        let data: &[u8] = &[
+            0x0B, // start group (tag=1)
+            0x30, 0x01, // unused int32 (tag=6)
+            0x2B, 0x30, 0xFF, 0x01, 0x2C, // unused group (tag=5)
+            0x10, 0x20, // int32 (tag=2)
+            0x0C, // end group (tag=1)
+        ];
+        assert_eq!(groups::Test1::decode(data), Ok(msg1));
+
+        // repeated group
+        let msg2_bytes: &[u8] = &[
+            0x20, 0x40, 0x2B, 0x30, 0xFF, 0x01, 0x2C, 0x2B, 0x30, 0x01, 0x2C, 0x38, 0x64,
+        ];
+
+        let msg2 = groups::Test2 {
+            i14: Some(64),
+            groupb: vec![
+                groups::test2::GroupB { i16: Some(255) },
+                groups::test2::GroupB { i16: Some(1) },
+            ],
+            i17: Some(100),
+        };
+
+        let mut bytes = Vec::new();
+        msg2.encode(&mut bytes).unwrap();
+        assert_eq!(&*bytes, msg2_bytes);
+
+        assert_eq!(groups::Test2::decode(msg2_bytes), Ok(msg2));
+    }
+
+    fn test_group_oneof() {
+        let msg = groups::OneofGroup {
+            i1: Some(42),
+            field: Some(groups::oneof_group::Field::S2("foo".to_string())),
+        };
+        check_message(&msg);
+
+        let msg = groups::OneofGroup {
+            i1: Some(42),
+            field: Some(groups::oneof_group::Field::G(groups::oneof_group::G {
+                i2: None,
+                s1: "foo".to_string(),
+                t1: None,
+            })),
+        };
+        check_message(&msg);
+
+        let msg = groups::OneofGroup {
+            i1: Some(42),
+            field: Some(groups::oneof_group::Field::G(groups::oneof_group::G {
+                i2: Some(99),
+                s1: "foo".to_string(),
+                t1: Some(groups::Test1 {
+                    groupa: Some(groups::test1::GroupA { i2: None }),
+                }),
+            })),
+        };
+        check_message(&msg);
+
+        check_message(&groups::OneofGroup::default());
+    }
+
+fn main() {
+    test_all_types_proto3();
+    test_ident_conversions();
+    test_custom_type_attributes();
+    test_nesting();
+    test_deep_nesting();
+    test_deep_nesting_oneof();
+    test_deep_nesting_group();
+    test_deep_nesting_repeated();
+    test_deep_nesting_map();
+    test_recursive_oneof();
+    test_default_enum();
+    test_group();
+    test_group_oneof();   
+}
diff --git a/tests-alloc/src/build.rs b/tests-alloc/src/build.rs
new file mode 100644
index 000000000..c8e39abb9
--- /dev/null
+++ b/tests-alloc/src/build.rs
@@ -0,0 +1,110 @@
+#[macro_use]
+extern crate cfg_if;
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let _ = env_logger::init();
+
+    // The source directory.
+    let src = PathBuf::from("../tests/src");
+    let includes = &[src.clone()];
+
+    let mut config = prost_build::Config::new();
+
+    // Generate BTreeMap fields for all messages. This forces encoded output to be consistent, so
+    // that encode/decode roundtrips can use encoded output for comparison. Otherwise trying to
+    // compare based on the Rust PartialEq implementations is difficult, due to presence of NaN
+    // values.
+    //
+    // Note nostd collections implies Btree everywhere anyways
+    config.use_alloc_collections_lib();
+
+    // Tests for custom attributes
+    config.type_attribute("Foo.Bar_Baz.Foo_barBaz", "#[derive(Eq, PartialOrd, Ord)]");
+    config.type_attribute(
+        "Foo.Bar_Baz.Foo_barBaz.fuzz_buster",
+        "#[derive(Eq, PartialOrd, Ord)]",
+    );
+    config.type_attribute("Foo.Custom.Attrs.Msg", "#[allow(missing_docs)]");
+    config.type_attribute("Foo.Custom.Attrs.Msg.field", "/// Oneof docs");
+    config.type_attribute("Foo.Custom.Attrs.AnEnum", "#[allow(missing_docs)]");
+    config.type_attribute("Foo.Custom.Attrs.AnotherEnum", "/// Oneof docs");
+    config.type_attribute(
+        "Foo.Custom.OneOfAttrs.Msg.field",
+        "#[derive(Eq, PartialOrd, Ord)]",
+    );
+    config.field_attribute("Foo.Custom.Attrs.AnotherEnum.C", "/// The C docs");
+    config.field_attribute("Foo.Custom.Attrs.AnotherEnum.D", "/// The D docs");
+    config.field_attribute("Foo.Custom.Attrs.Msg.field.a", "/// Oneof A docs");
+    config.field_attribute("Foo.Custom.Attrs.Msg.field.b", "/// Oneof B docs");
+
+    config
+        .compile_protos(&[src.join("ident_conversion.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("nesting.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("recursive_oneof.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("custom_attributes.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("oneof_attributes.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("no_unused_results.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("default_enum_value.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("groups.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(&[src.join("well_known_types.proto")], includes)
+        .unwrap();
+
+    config
+        .compile_protos(
+            &[src.join("packages/widget_factory.proto")],
+            &[src.join("packages")],
+        )
+        .unwrap();
+
+    let out_dir =
+        &PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR environment variable not set"))
+            .join("extern_paths");
+    fs::create_dir_all(out_dir).expect("failed to create prefix directory");
+    config.out_dir(out_dir);
+
+    // Compile some of the module examples as an extern path. The extern path syntax is edition
+    // specific, since the way crate-internal fully qualified paths has changed.
+    cfg_if! {
+        if #[cfg(feature = "edition-2015")] {
+            const EXTERN_PATH: &str = "::packages::gizmo";
+        } else {
+            const EXTERN_PATH: &str = "crate::packages::gizmo";
+        }
+    };
+    config.extern_path(".packages.gizmo", EXTERN_PATH);
+
+    config
+        .compile_protos(
+            &[src.join("packages").join("widget_factory.proto")],
+            &[src.join("packages")],
+        )
+        .unwrap();
+}
diff --git a/tests-infra/Cargo.toml b/tests-infra/Cargo.toml
new file mode 100644
index 000000000..81c097b5b
--- /dev/null
+++ b/tests-infra/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "tests-infra"
+version = "0.0.0"
+authors = ["Dan Burkert <dan@danburkert.com>"]
+publish = false
+edition = "2018"
+
+[lib]
+doctest = false
+
+[dependencies]
+bytes = "0.5"
+cfg-if = "0.1"
+prost = { path = "..", default-features = false }
diff --git a/tests-infra/src/lib.rs b/tests-infra/src/lib.rs
new file mode 100644
index 000000000..d652628fe
--- /dev/null
+++ b/tests-infra/src/lib.rs
@@ -0,0 +1,162 @@
+#![no_std]
+
+extern crate alloc;
+
+use alloc::string::String;
+use alloc::vec::Vec;
+use alloc::format;
+
+use core::default::Default;
+use core::cmp::PartialEq;
+use core::fmt::Display;
+
+#[macro_use]
+extern crate cfg_if;
+
+use prost;
+use prost::Message;
+
+cfg_if! {
+    if #[cfg(feature = "edition-2015")] {
+        extern crate bytes;
+        extern crate prost;
+        extern crate prost_types;
+        extern crate protobuf;
+        #[cfg(test)]
+        extern crate prost_build;
+        #[cfg(test)]
+        extern crate tempfile;
+        #[cfg(test)]
+        extern crate tests_infra;
+    }
+}
+
+pub enum RoundtripResult {
+    /// The roundtrip succeeded.
+    Ok(Vec<u8>),
+    /// The data could not be decoded. This could indicate a bug in prost,
+    /// or it could indicate that the input was bogus.
+    DecodeError(prost::DecodeError),
+    /// Re-encoding or validating the data failed.  This indicates a bug in `prost`.
+    Error(String),
+}
+
+impl RoundtripResult {
+    /// Unwrap the roundtrip result.
+    pub fn unwrap(self) -> Vec<u8> {
+        match self {
+            RoundtripResult::Ok(buf) => buf,
+            RoundtripResult::DecodeError(error) => {
+                panic!("failed to decode the roundtrip data: {}", error)
+            }
+            RoundtripResult::Error(error) => panic!("failed roundtrip: {}", error),
+        }
+    }
+
+    /// Unwrap the roundtrip result. Panics if the result was a validation or re-encoding error.
+    pub fn unwrap_error(self) -> Result<Vec<u8>, prost::DecodeError> {
+        match self {
+            RoundtripResult::Ok(buf) => Ok(buf),
+            RoundtripResult::DecodeError(error) => Err(error),
+            RoundtripResult::Error(error) => panic!("failed roundtrip: {}", error),
+        }
+    }
+}
+
+/// Tests round-tripping a message type. The message should be compiled with `BTreeMap` fields,
+/// otherwise the comparison may fail due to inconsistent `HashMap` entry encoding ordering.
+pub fn roundtrip<M>(data: &[u8]) -> RoundtripResult
+where
+    M: Message + Default,
+{
+    // Try to decode a message from the data. If decoding fails, continue.
+    let all_types = match M::decode(data) {
+        Ok(all_types) => all_types,
+        Err(error) => return RoundtripResult::DecodeError(error),
+    };
+
+    let encoded_len = all_types.encoded_len();
+
+    // TODO: Reenable this once sign-extension in negative int32s is figured out.
+    // assert!(encoded_len <= data.len(), "encoded_len: {}, len: {}, all_types: {:?}",
+    //         encoded_len, data.len(), all_types);
+
+    let mut buf1 = Vec::new();
+    if let Err(error) = all_types.encode(&mut buf1) {
+        return RoundtripResult::Error(to_string(&error));
+    }
+    if encoded_len != buf1.len() {
+        return RoundtripResult::Error(
+            format!(
+                "expected encoded len ({}) did not match actual encoded len ({})",
+                encoded_len,
+                buf1.len()
+            )
+            .into(),
+        );
+    }
+
+    let roundtrip = match M::decode(&buf1[..]) {
+        Ok(roundtrip) => roundtrip,
+        Err(error) => return RoundtripResult::Error(to_string(&error)),
+    };
+
+    let mut buf2 = Vec::new();
+    if let Err(error) = roundtrip.encode(&mut buf2) {
+        return RoundtripResult::Error(to_string(&error));
+    }
+
+    /*
+    // Useful for debugging:
+    eprintln!(" data: {:?}", data.iter().map(|x| format!("0x{:x}", x)).collect::<Vec<_>>());
+    eprintln!(" buf1: {:?}", buf1.iter().map(|x| format!("0x{:x}", x)).collect::<Vec<_>>());
+    eprintln!("a: {:?}\nb: {:?}", all_types, roundtrip);
+    */
+
+    if buf1 != buf2 {
+        return RoundtripResult::Error("roundtripped encoded buffers do not match".into());
+    }
+
+    RoundtripResult::Ok(buf1)
+}
+
+/// Generic rountrip serialization check for messages.
+pub fn check_message<M>(msg: &M)
+where
+    M: Message + Default + PartialEq,
+{
+    let expected_len = msg.encoded_len();
+
+    let mut buf = Vec::with_capacity(18);
+    msg.encode(&mut buf).unwrap();
+    assert_eq!(expected_len, buf.len());
+
+    use bytes::Buf;
+    let buf = (&buf[..]).to_bytes();
+    let roundtrip = M::decode(buf).unwrap();
+
+    // FIXME(chris)
+    // if buf.has_remaining() {
+    //    panic!("expected buffer to be empty: {}", buf.remaining());
+    // }
+
+    assert_eq!(msg, &roundtrip);
+}
+
+/// Serialize from A should equal Serialize from B
+pub fn check_serialize_equivalent<M, N>(msg_a: &M, msg_b: &N)
+where
+    M: Message + Default + PartialEq,
+    N: Message + Default + PartialEq,
+{
+    let mut buf_a = Vec::new();
+    msg_a.encode(&mut buf_a).unwrap();
+    let mut buf_b = Vec::new();
+    msg_b.encode(&mut buf_b).unwrap();
+    assert_eq!(buf_a, buf_b);
+}
+
+// helper
+fn to_string<T: Display>(obj: &T) -> String {
+    format!("{}", obj)
+}
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index b8580c292..743cf2b4b 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -16,6 +16,7 @@ cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
 protobuf = { path = "../protobuf" }
+tests-infra = { path = "../tests-infra" }
 
 [dev-dependencies]
 diff = "0.1"
diff --git a/tests/src/build.rs b/tests/src/build.rs
index a0f2a6869..3451034fe 100644
--- a/tests/src/build.rs
+++ b/tests/src/build.rs
@@ -26,15 +26,8 @@ fn main() {
     // that encode/decode roundtrips can use encoded output for comparison. Otherwise trying to
     // compare based on the Rust PartialEq implementations is difficult, due to presence of NaN
     // values.
-    //
-    // Note nostd collections implies Btree everywhere anyways
-    cfg_if! {
-        if #[cfg(feature = "nostd-collections")] {
-            config.use_alloc_collections_lib();
-        } else {
-            config.btree_map(&["."]);
-        }
-    }
+    config.btree_map(&["."]);
+
     // Tests for custom attributes
     config.type_attribute("Foo.Bar_Baz.Foo_barBaz", "#[derive(Eq, PartialOrd, Ord)]");
     config.type_attribute(
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index 5ccc7b8e5..e67c02756 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -1,6 +1,8 @@
 #[macro_use]
 extern crate cfg_if;
 
+extern crate alloc;
+
 cfg_if! {
     if #[cfg(feature = "edition-2015")] {
         extern crate bytes;
@@ -11,6 +13,8 @@ cfg_if! {
         extern crate prost_build;
         #[cfg(test)]
         extern crate tempfile;
+        #[cfg(test)]
+        extern crate tests_infra;
     }
 }
 
@@ -74,135 +78,6 @@ pub mod groups {
     include!(concat!(env!("OUT_DIR"), "/groups.rs"));
 }
 
-use std::error::Error;
-
-use bytes::{Buf};
-
-use prost::Message;
-
-pub enum RoundtripResult {
-    /// The roundtrip succeeded.
-    Ok(Vec<u8>),
-    /// The data could not be decoded. This could indicate a bug in prost,
-    /// or it could indicate that the input was bogus.
-    DecodeError(prost::DecodeError),
-    /// Re-encoding or validating the data failed.  This indicates a bug in `prost`.
-    Error(Box<dyn Error + Send + Sync>),
-}
-
-impl RoundtripResult {
-    /// Unwrap the roundtrip result.
-    pub fn unwrap(self) -> Vec<u8> {
-        match self {
-            RoundtripResult::Ok(buf) => buf,
-            RoundtripResult::DecodeError(error) => {
-                panic!("failed to decode the roundtrip data: {}", error)
-            }
-            RoundtripResult::Error(error) => panic!("failed roundtrip: {}", error),
-        }
-    }
-
-    /// Unwrap the roundtrip result. Panics if the result was a validation or re-encoding error.
-    pub fn unwrap_error(self) -> Result<Vec<u8>, prost::DecodeError> {
-        match self {
-            RoundtripResult::Ok(buf) => Ok(buf),
-            RoundtripResult::DecodeError(error) => Err(error),
-            RoundtripResult::Error(error) => panic!("failed roundtrip: {}", error),
-        }
-    }
-}
-
-/// Tests round-tripping a message type. The message should be compiled with `BTreeMap` fields,
-/// otherwise the comparison may fail due to inconsistent `HashMap` entry encoding ordering.
-pub fn roundtrip<M>(data: &[u8]) -> RoundtripResult
-where
-    M: Message + Default,
-{
-    // Try to decode a message from the data. If decoding fails, continue.
-    let all_types = match M::decode(data) {
-        Ok(all_types) => all_types,
-        Err(error) => return RoundtripResult::DecodeError(error),
-    };
-
-    let encoded_len = all_types.encoded_len();
-
-    // TODO: Reenable this once sign-extension in negative int32s is figured out.
-    // assert!(encoded_len <= data.len(), "encoded_len: {}, len: {}, all_types: {:?}",
-    //         encoded_len, data.len(), all_types);
-
-    let mut buf1 = Vec::new();
-    if let Err(error) = all_types.encode(&mut buf1) {
-        return RoundtripResult::Error(error.into());
-    }
-    if encoded_len != buf1.len() {
-        return RoundtripResult::Error(
-            format!(
-                "expected encoded len ({}) did not match actual encoded len ({})",
-                encoded_len,
-                buf1.len()
-            )
-            .into(),
-        );
-    }
-
-    let roundtrip = match M::decode(&buf1) {
-        Ok(roundtrip) => roundtrip,
-        Err(error) => return RoundtripResult::Error(error.into()),
-    };
-
-    let mut buf2 = Vec::new();
-    if let Err(error) = roundtrip.encode(&mut buf2) {
-        return RoundtripResult::Error(error.into());
-    }
-
-    /*
-    // Useful for debugging:
-    eprintln!(" data: {:?}", data.iter().map(|x| format!("0x{:x}", x)).collect::<Vec<_>>());
-    eprintln!(" buf1: {:?}", buf1.iter().map(|x| format!("0x{:x}", x)).collect::<Vec<_>>());
-    eprintln!("a: {:?}\nb: {:?}", all_types, roundtrip);
-    */
-
-    if buf1 != buf2 {
-        return RoundtripResult::Error("roundtripped encoded buffers do not match".into());
-    }
-
-    RoundtripResult::Ok(buf1)
-}
-
-/// Generic rountrip serialization check for messages.
-pub fn check_message<M>(msg: &M)
-where
-    M: Message + Default + PartialEq,
-{
-    let expected_len = msg.encoded_len();
-
-    let mut buf = Vec::with_capacity(18);
-    msg.encode(&mut buf).unwrap();
-    assert_eq!(expected_len, buf.len());
-
-    let mut buf = buf.into_buf();
-    let roundtrip = M::decode(&mut buf).unwrap();
-
-    if buf.has_remaining() {
-        panic!(format!("expected buffer to be empty: {}", buf.remaining()));
-    }
-
-    assert_eq!(msg, &roundtrip);
-}
-
-/// Serialize from A should equal Serialize from B
-pub fn check_serialize_equivalent<M, N>(msg_a: &M, msg_b: &N)
-where
-    M: Message + Default + PartialEq,
-    N: Message + Default + PartialEq,
-{
-    let mut buf_a = Vec::new();
-    msg_a.encode(&mut buf_a).unwrap();
-    let mut buf_b = Vec::new();
-    msg_b.encode(&mut buf_b).unwrap();
-    assert_eq!(buf_a, buf_b);
-}
-
 #[cfg(test)]
 mod tests {
 
diff --git a/tests/src/message_encoding_alloc.rs b/tests/src/message_encoding_alloc.rs
new file mode 100644
index 000000000..2d0c34b5f
--- /dev/null
+++ b/tests/src/message_encoding_alloc.rs
@@ -0,0 +1,369 @@
+// This is the same as message_encoding.rs but all HashMap have been replaced
+// with BTreeMap and items grabbed from alloc namespace
+
+use prost::{Enumeration, Message, Oneof};
+
+use crate::check_message;
+use crate::check_serialize_equivalent;
+
+#[derive(Clone, PartialEq, Message)]
+pub struct RepeatedFloats {
+    #[prost(float, tag = "11")]
+    pub single_float: f32,
+    #[prost(float, repeated, packed = "true", tag = "41")]
+    pub repeated_float: Vec<f32>,
+}
+
+#[test]
+fn check_repeated_floats() {
+    check_message(&RepeatedFloats {
+        single_float: 0.0,
+        repeated_float: vec![
+            0.1,
+            340282300000000000000000000000000000000.0,
+            0.000000000000000000000000000000000000011754944,
+        ],
+    });
+}
+
+#[test]
+fn check_scalar_types() {
+    check_message(&ScalarTypes::default());
+}
+
+/// A protobuf message which contains all scalar types.
+#[derive(Clone, PartialEq, Message)]
+pub struct ScalarTypes {
+    #[prost(int32, tag = "001")]
+    pub int32: i32,
+    #[prost(int64, tag = "002")]
+    pub int64: i64,
+    #[prost(uint32, tag = "003")]
+    pub uint32: u32,
+    #[prost(uint64, tag = "004")]
+    pub uint64: u64,
+    #[prost(sint32, tag = "005")]
+    pub sint32: i32,
+    #[prost(sint64, tag = "006")]
+    pub sint64: i64,
+    #[prost(fixed32, tag = "007")]
+    pub fixed32: u32,
+    #[prost(fixed64, tag = "008")]
+    pub fixed64: u64,
+    #[prost(sfixed32, tag = "009")]
+    pub sfixed32: i32,
+    #[prost(sfixed64, tag = "010")]
+    pub sfixed64: i64,
+    #[prost(float, tag = "011")]
+    pub float: f32,
+    #[prost(double, tag = "012")]
+    pub double: f64,
+    #[prost(bool, tag = "013")]
+    pub _bool: bool,
+    #[prost(string, tag = "014")]
+    pub string: String,
+    #[prost(bytes, tag = "015")]
+    pub bytes: Vec<u8>,
+
+    #[prost(int32, required, tag = "101")]
+    pub required_int32: i32,
+    #[prost(int64, required, tag = "102")]
+    pub required_int64: i64,
+    #[prost(uint32, required, tag = "103")]
+    pub required_uint32: u32,
+    #[prost(uint64, required, tag = "104")]
+    pub required_uint64: u64,
+    #[prost(sint32, required, tag = "105")]
+    pub required_sint32: i32,
+    #[prost(sint64, required, tag = "106")]
+    pub required_sint64: i64,
+    #[prost(fixed32, required, tag = "107")]
+    pub required_fixed32: u32,
+    #[prost(fixed64, required, tag = "108")]
+    pub required_fixed64: u64,
+    #[prost(sfixed32, required, tag = "109")]
+    pub required_sfixed32: i32,
+    #[prost(sfixed64, required, tag = "110")]
+    pub required_sfixed64: i64,
+    #[prost(float, required, tag = "111")]
+    pub required_float: f32,
+    #[prost(double, required, tag = "112")]
+    pub required_double: f64,
+    #[prost(bool, required, tag = "113")]
+    pub required_bool: bool,
+    #[prost(string, required, tag = "114")]
+    pub required_string: String,
+    #[prost(bytes, required, tag = "115")]
+    pub required_bytes: Vec<u8>,
+
+    #[prost(int32, optional, tag = "201")]
+    pub optional_int32: Option<i32>,
+    #[prost(int64, optional, tag = "202")]
+    pub optional_int64: Option<i64>,
+    #[prost(uint32, optional, tag = "203")]
+    pub optional_uint32: Option<u32>,
+    #[prost(uint64, optional, tag = "204")]
+    pub optional_uint64: Option<u64>,
+    #[prost(sint32, optional, tag = "205")]
+    pub optional_sint32: Option<i32>,
+    #[prost(sint64, optional, tag = "206")]
+    pub optional_sint64: Option<i64>,
+
+    #[prost(fixed32, optional, tag = "207")]
+    pub optional_fixed32: Option<u32>,
+    #[prost(fixed64, optional, tag = "208")]
+    pub optional_fixed64: Option<u64>,
+    #[prost(sfixed32, optional, tag = "209")]
+    pub optional_sfixed32: Option<i32>,
+    #[prost(sfixed64, optional, tag = "210")]
+    pub optional_sfixed64: Option<i64>,
+    #[prost(float, optional, tag = "211")]
+    pub optional_float: Option<f32>,
+    #[prost(double, optional, tag = "212")]
+    pub optional_double: Option<f64>,
+    #[prost(bool, optional, tag = "213")]
+    pub optional_bool: Option<bool>,
+    #[prost(string, optional, tag = "214")]
+    pub optional_string: Option<String>,
+    #[prost(bytes, optional, tag = "215")]
+    pub optional_bytes: Option<Vec<u8>>,
+
+    #[prost(int32, repeated, packed = "false", tag = "301")]
+    pub repeated_int32: Vec<i32>,
+    #[prost(int64, repeated, packed = "false", tag = "302")]
+    pub repeated_int64: Vec<i64>,
+    #[prost(uint32, repeated, packed = "false", tag = "303")]
+    pub repeated_uint32: Vec<u32>,
+    #[prost(uint64, repeated, packed = "false", tag = "304")]
+    pub repeated_uint64: Vec<u64>,
+    #[prost(sint32, repeated, packed = "false", tag = "305")]
+    pub repeated_sint32: Vec<i32>,
+    #[prost(sint64, repeated, packed = "false", tag = "306")]
+    pub repeated_sint64: Vec<i64>,
+    #[prost(fixed32, repeated, packed = "false", tag = "307")]
+    pub repeated_fixed32: Vec<u32>,
+    #[prost(fixed64, repeated, packed = "false", tag = "308")]
+    pub repeated_fixed64: Vec<u64>,
+    #[prost(sfixed32, repeated, packed = "false", tag = "309")]
+    pub repeated_sfixed32: Vec<i32>,
+    #[prost(sfixed64, repeated, packed = "false", tag = "310")]
+    pub repeated_sfixed64: Vec<i64>,
+    #[prost(float, repeated, packed = "false", tag = "311")]
+    pub repeated_float: Vec<f32>,
+    #[prost(double, repeated, packed = "false", tag = "312")]
+    pub repeated_double: Vec<f64>,
+    #[prost(bool, repeated, packed = "false", tag = "313")]
+    pub repeated_bool: Vec<bool>,
+    #[prost(string, repeated, packed = "false", tag = "315")]
+    pub repeated_string: Vec<String>,
+    #[prost(bytes, repeated, packed = "false", tag = "316")]
+    pub repeated_bytes: Vec<Vec<u8>>,
+
+    #[prost(int32, repeated, tag = "401")]
+    pub packed_int32: Vec<i32>,
+    #[prost(int64, repeated, tag = "402")]
+    pub packed_int64: Vec<i64>,
+    #[prost(uint32, repeated, tag = "403")]
+    pub packed_uint32: Vec<u32>,
+    #[prost(uint64, repeated, tag = "404")]
+    pub packed_uint64: Vec<u64>,
+    #[prost(sint32, repeated, tag = "405")]
+    pub packed_sint32: Vec<i32>,
+    #[prost(sint64, repeated, tag = "406")]
+    pub packed_sint64: Vec<i64>,
+    #[prost(fixed32, repeated, tag = "407")]
+    pub packed_fixed32: Vec<u32>,
+
+    #[prost(fixed64, repeated, tag = "408")]
+    pub packed_fixed64: Vec<u64>,
+    #[prost(sfixed32, repeated, tag = "409")]
+    pub packed_sfixed32: Vec<i32>,
+    #[prost(sfixed64, repeated, tag = "410")]
+    pub packed_sfixed64: Vec<i64>,
+    #[prost(float, repeated, tag = "411")]
+    pub packed_float: Vec<f32>,
+    #[prost(double, repeated, tag = "412")]
+    pub packed_double: Vec<f64>,
+    #[prost(bool, repeated, tag = "413")]
+    pub packed_bool: Vec<bool>,
+    #[prost(string, repeated, tag = "415")]
+    pub packed_string: Vec<String>,
+    #[prost(bytes, repeated, tag = "416")]
+    pub packed_bytes: Vec<Vec<u8>>,
+}
+
+#[test]
+fn check_tags_inferred() {
+    check_message(&TagsInferred::default());
+    check_serialize_equivalent(&TagsInferred::default(), &TagsQualified::default());
+
+    let tags_inferred = TagsInferred {
+        one: true,
+        two: Some(42),
+        three: vec![0.0, 1.0, 1.0],
+        skip_to_nine: "nine".to_owned(),
+        ten: 0,
+        eleven: Default::default(),
+        back_to_five: vec![1, 0, 1],
+        six: Basic::default(),
+    };
+    check_message(&tags_inferred);
+
+    let tags_qualified = TagsQualified {
+        one: true,
+        two: Some(42),
+        three: vec![0.0, 1.0, 1.0],
+        five: vec![1, 0, 1],
+        six: Basic::default(),
+        nine: "nine".to_owned(),
+        ten: 0,
+        eleven: Default::default(),
+    };
+    check_serialize_equivalent(&tags_inferred, &tags_qualified);
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct TagsInferred {
+    #[prost(bool)]
+    pub one: bool,
+    #[prost(int32, optional)]
+    pub two: Option<i32>,
+    #[prost(float, repeated)]
+    pub three: Vec<f32>,
+
+    #[prost(tag = "9", string, required)]
+    pub skip_to_nine: String,
+    #[prost(enumeration = "BasicEnumeration", default = "ONE")]
+    pub ten: i32,
+    #[prost(btree_map = "string, string")]
+    pub eleven: ::alloc::collections::BTreeMap<String, String>,
+
+    #[prost(tag = "5", bytes)]
+    pub back_to_five: Vec<u8>,
+    #[prost(message, required)]
+    pub six: Basic,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct TagsQualified {
+    #[prost(tag = "1", bool)]
+    pub one: bool,
+    #[prost(tag = "2", int32, optional)]
+    pub two: Option<i32>,
+    #[prost(tag = "3", float, repeated)]
+    pub three: Vec<f32>,
+
+    #[prost(tag = "5", bytes)]
+    pub five: Vec<u8>,
+    #[prost(tag = "6", message, required)]
+    pub six: Basic,
+
+    #[prost(tag = "9", string, required)]
+    pub nine: String,
+    #[prost(tag = "10", enumeration = "BasicEnumeration", default = "ONE")]
+    pub ten: i32,
+    #[prost(tag = "11", btree_map = "string, string")]
+    pub eleven: ::alloc::collections::BTreeMap<String, String>,
+}
+
+/// A prost message with default value.
+#[derive(Clone, PartialEq, Message)]
+pub struct DefaultValues {
+    #[prost(int32, tag = "1", default = "42")]
+    pub int32: i32,
+
+    #[prost(int32, optional, tag = "2", default = "88")]
+    pub optional_int32: Option<i32>,
+
+    #[prost(string, tag = "3", default = "fourty two")]
+    pub string: String,
+
+    #[prost(enumeration = "BasicEnumeration", tag = "4", default = "ONE")]
+    pub enumeration: i32,
+
+    #[prost(enumeration = "BasicEnumeration", optional, tag = "5", default = "TWO")]
+    pub optional_enumeration: Option<i32>,
+
+    #[prost(enumeration = "BasicEnumeration", repeated, tag = "6")]
+    pub repeated_enumeration: Vec<i32>,
+}
+
+#[test]
+fn check_default_values() {
+    let default = DefaultValues::default();
+    assert_eq!(default.int32, 42);
+    assert_eq!(default.optional_int32, None);
+    assert_eq!(&default.string, "fourty two");
+    assert_eq!(default.enumeration, BasicEnumeration::ONE as i32);
+    assert_eq!(default.optional_enumeration, None);
+    assert_eq!(&default.repeated_enumeration, &[]);
+    assert_eq!(0, default.encoded_len());
+}
+
+/// A protobuf enum.
+#[derive(Clone, Copy, Debug, PartialEq, Enumeration)]
+pub enum BasicEnumeration {
+    ZERO = 0,
+    ONE = 1,
+    TWO = 2,
+    THREE = 3,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct Basic {
+    #[prost(int32, tag = "1")]
+    pub int32: i32,
+
+    #[prost(bool, repeated, packed = "false", tag = "2")]
+    pub bools: Vec<bool>,
+
+    #[prost(string, tag = "3")]
+    pub string: String,
+
+    #[prost(string, optional, tag = "4")]
+    pub optional_string: Option<String>,
+
+    #[prost(enumeration = "BasicEnumeration", tag = "5")]
+    pub enumeration: i32,
+
+    #[prost(btree_map = "int32, enumeration(BasicEnumeration)", tag = "6")]
+    pub enumeration_map: ::alloc::collections::BTreeMap<i32, i32>,
+
+    #[prost(btree_map = "string, string", tag = "7")]
+    pub string_map: ::alloc::collections::BTreeMap<String, String>,
+
+    #[prost(btree_map = "int32, enumeration(BasicEnumeration)", tag = "10")]
+    pub enumeration_btree_map: ::alloc::collections::BTreeMap<i32, i32>,
+
+    #[prost(btree_map = "string, string", tag = "11")]
+    pub string_btree_map: ::alloc::collections::BTreeMap<String, String>,
+
+    #[prost(oneof = "BasicOneof", tags = "8, 9")]
+    pub oneof: Option<BasicOneof>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct Compound {
+    #[prost(message, optional, tag = "1")]
+    pub optional_message: Option<Basic>,
+
+    #[prost(message, required, tag = "2")]
+    pub required_message: Basic,
+
+    #[prost(message, repeated, tag = "3")]
+    pub repeated_message: Vec<Basic>,
+
+    #[prost(btree_map = "sint32, message", tag = "4")]
+    pub message_map: ::alloc::collections::BTreeMap<i32, Basic>,
+
+    #[prost(btree_map = "sint32, message", tag = "5")]
+    pub message_btree_map: ::alloc::collections::BTreeMap<i32, Basic>,
+}
+
+#[derive(Clone, PartialEq, Oneof)]
+pub enum BasicOneof {
+    #[prost(int32, tag = "8")]
+    Int(i32),
+    #[prost(string, tag = "9")]
+    String(String),
+}

From 28b932648246ee3caecef25188588c3ecd40b67f Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 12 Sep 2019 10:26:15 -0700
Subject: [PATCH 03/36] fixups to prost-build, tests-alloc

---
 prost-build/src/code_generator.rs |  2 +-
 tests-alloc/Cargo.toml            |  1 +
 tests-alloc/src/bin.rs            | 49 +++++++++++++++++++------------
 tests/src/lib.rs                  |  1 +
 4 files changed, 34 insertions(+), 19 deletions(-)

diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index 7afbbc3d7..2d038b8e5 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -525,7 +525,7 @@ impl<'a> CodeGenerator<'a> {
 
             if boxed {
                 self.buf
-                    .push_str(&format!("{}(Box<{}>),\n", to_upper_camel(field.name()), ty));
+                    .push_str(&format!("{}({}::boxed::Box<{}>),\n",to_upper_camel(field.name()), self.config.collections_lib.to_str(), ty));
             } else {
                 self.buf
                     .push_str(&format!("{}({}),\n", to_upper_camel(field.name()), ty));
diff --git a/tests-alloc/Cargo.toml b/tests-alloc/Cargo.toml
index 87ed5ff82..8358380dd 100644
--- a/tests-alloc/Cargo.toml
+++ b/tests-alloc/Cargo.toml
@@ -20,6 +20,7 @@ prost = { path = "..", default-features = false }
 prost-derive = { path = "../prost-derive", default-features = false }
 prost-types = { path = "../prost-types", default-features = false }
 protobuf = { path = "../protobuf" }
+tests-infra = { path = "../tests-infra" }
 
 [dev-dependencies]
 diff = "0.1"
diff --git a/tests-alloc/src/bin.rs b/tests-alloc/src/bin.rs
index 5067f9b6c..64c957e33 100644
--- a/tests-alloc/src/bin.rs
+++ b/tests-alloc/src/bin.rs
@@ -2,6 +2,14 @@
 
 extern crate alloc;
 
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::string::ToString;
+use alloc::vec;
+use alloc::vec::Vec;
+
+use prost::Message;
+
 extern crate tests_infra;
 
 pub mod foo {
@@ -57,7 +65,10 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
 
 // Tests
 
-    fn test_all_types_proto3() {
+mod tests {
+    use super::*;
+
+    pub fn test_all_types_proto3() {
         // Some selected encoded messages, mostly collected from failed fuzz runs.
         let msgs: &[&[u8]] = &[
             &[0x28, 0x28, 0x28, 0xFF, 0xFF, 0xFF, 0xFF, 0x68],
@@ -85,7 +96,7 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
         }
     }
 
-    fn test_ident_conversions() {
+    pub fn test_ident_conversions() {
         let msg = foo::bar_baz::FooBarBaz {
             foo_bar_baz: 42,
             fuzz_busters: vec![foo::bar_baz::foo_bar_baz::FuzzBuster {
@@ -159,7 +170,7 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
         roundtrip::<foo::bar_baz::FooBarBaz>(&buf).unwrap();
     }
 
-    fn test_custom_type_attributes() {
+    pub fn test_custom_type_attributes() {
         // We abuse the ident conversion protobuf for the custom attribute additions. We placed
         // `Ord` on the FooBarBaz (which is not implemented by ordinary messages).
         let mut set1 = BTreeSet::new();
@@ -171,7 +182,7 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
         set2.insert(msg2.field);
     }
 
-    fn test_nesting() {
+    pub fn test_nesting() {
         use crate::nesting::{A, B};
         let _ = A {
             a: Some(Box::new(A::default())),
@@ -183,7 +194,7 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
         };
     }
 
-    fn test_deep_nesting() {
+    pub fn test_deep_nesting() {
         fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
             use crate::nesting::A;
 
@@ -196,14 +207,14 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
 
             let mut buf = Vec::new();
             a.encode(&mut buf).unwrap();
-            A::decode(buf).map(|_| ())
+            A::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(100).is_ok());
         assert!(build_and_roundtrip(101).is_err());
     }
 
-    fn test_deep_nesting_oneof() {
+    pub fn test_deep_nesting_oneof() {
         fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
             use crate::recursive_oneof::{a, A, C};
 
@@ -218,14 +229,14 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
 
             let mut buf = Vec::new();
             a.encode(&mut buf).unwrap();
-            A::decode(buf).map(|_| ())
+            A::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(99).is_ok());
         assert!(build_and_roundtrip(100).is_err());
     }
 
-    fn test_deep_nesting_group() {
+    pub fn test_deep_nesting_group() {
         fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
             use crate::groups::{nested_group2::OptionalGroup, NestedGroup2};
 
@@ -240,14 +251,14 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
 
             let mut buf = Vec::new();
             a.encode(&mut buf).unwrap();
-            NestedGroup2::decode(buf).map(|_| ())
+            NestedGroup2::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(50).is_ok());
         assert!(build_and_roundtrip(51).is_err());
     }
 
-    fn test_deep_nesting_repeated() {
+    pub fn test_deep_nesting_repeated() {
         fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
             use crate::nesting::C;
 
@@ -260,14 +271,14 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
 
             let mut buf = Vec::new();
             c.encode(&mut buf).unwrap();
-            C::decode(buf).map(|_| ())
+            C::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(100).is_ok());
         assert!(build_and_roundtrip(101).is_err());
     }
 
-    fn test_deep_nesting_map() {
+    pub fn test_deep_nesting_map() {
         fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
             use crate::nesting::D;
 
@@ -280,14 +291,14 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
 
             let mut buf = Vec::new();
             d.encode(&mut buf).unwrap();
-            D::decode(buf).map(|_| ())
+            D::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(50).is_ok());
         assert!(build_and_roundtrip(51).is_err());
     }
 
-    fn test_recursive_oneof() {
+    pub fn test_recursive_oneof() {
         use crate::recursive_oneof::{a, A, B, C};
         let _ = A {
             kind: Some(a::Kind::B(Box::new(B {
@@ -298,7 +309,7 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
         };
     }
 
-    fn test_default_enum() {
+    pub fn test_default_enum() {
         let msg = default_enum_value::Test::default();
         assert_eq!(msg.privacy_level_1(), default_enum_value::PrivacyLevel::One);
         assert_eq!(
@@ -311,7 +322,7 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
         );
     }
 
-    fn test_group() {
+    pub fn test_group() {
         // optional group
         let msg1_bytes = &[0x0B, 0x10, 0x20, 0x0C];
 
@@ -354,7 +365,7 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
         assert_eq!(groups::Test2::decode(msg2_bytes), Ok(msg2));
     }
 
-    fn test_group_oneof() {
+    pub fn test_group_oneof() {
         let msg = groups::OneofGroup {
             i1: Some(42),
             field: Some(groups::oneof_group::Field::S2("foo".to_string())),
@@ -385,8 +396,10 @@ use protobuf::test_messages::proto3::TestAllTypesProto3;
 
         check_message(&groups::OneofGroup::default());
     }
+}
 
 fn main() {
+    use tests::*;
     test_all_types_proto3();
     test_ident_conversions();
     test_custom_type_attributes();
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index e67c02756..b52ff1eab 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -6,6 +6,7 @@ extern crate alloc;
 cfg_if! {
     if #[cfg(feature = "edition-2015")] {
         extern crate bytes;
+        extern crate core;
         extern crate prost;
         extern crate prost_types;
         extern crate protobuf;

From 01a500d0f157951d0635451d5028429b5b955b90 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 12 Sep 2019 10:51:19 -0700
Subject: [PATCH 04/36] more WIP

---
 Cargo.toml                    | 2 +-
 tests/src/lib.rs              | 1 +
 tests/src/message_encoding.rs | 4 ++--
 tests/src/well_known_types.rs | 2 +-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 6a09a9b75..44c7ed7a3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,7 +43,7 @@ std = ["prost-derive/std"]
 
 [dependencies]
 bytes = { version = "0.5", default-features = false }
-prost-derive = { version = "0.5.0", path = "prost-derive", optional = true }
+prost-derive = { version = "0.5.0", path = "prost-derive", default-features = false, optional = true }
 
 [dev-dependencies]
 criterion = "0.2"
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index b52ff1eab..1ae9dd89a 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -86,6 +86,7 @@ mod tests {
 
     use super::*;
     use protobuf::test_messages::proto3::TestAllTypesProto3;
+    use tests_infra::*;
 
     #[test]
     fn test_all_types_proto3() {
diff --git a/tests/src/message_encoding.rs b/tests/src/message_encoding.rs
index 2ee8c94b4..e03691373 100644
--- a/tests/src/message_encoding.rs
+++ b/tests/src/message_encoding.rs
@@ -1,7 +1,7 @@
 use prost::{Enumeration, Message, Oneof};
 
-use crate::check_message;
-use crate::check_serialize_equivalent;
+use tests_infra::check_message;
+use tests_infra::check_serialize_equivalent;
 
 #[derive(Clone, PartialEq, Message)]
 pub struct RepeatedFloats {
diff --git a/tests/src/well_known_types.rs b/tests/src/well_known_types.rs
index d7ced9553..923210dc2 100644
--- a/tests/src/well_known_types.rs
+++ b/tests/src/well_known_types.rs
@@ -10,5 +10,5 @@ fn test_well_known_types() {
         }),
     };
 
-    crate::check_message(&msg);
+    tests_infra::check_message(&msg);
 }

From 21b58666e128e519832c6fd345ae54deda3c2226 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 12 Sep 2019 12:27:26 -0700
Subject: [PATCH 05/36] more WIP -- tests-alloc working, prost-derive
 configuration issue identified

---
 Cargo.toml                    |   2 +-
 prost-derive/Cargo.toml       |   8 +-
 prost-derive/src/field/mod.rs |  19 +++-
 prost-types/src/compiler.rs   |  14 +--
 prost-types/src/protobuf.rs   | 204 +++++++++++++++++-----------------
 protobuf/Cargo.toml           |   4 +-
 tests-infra/Cargo.toml        |   2 +-
 tests/src/lib.rs              |  12 +-
 8 files changed, 140 insertions(+), 125 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 44c7ed7a3..d7fc8d3ef 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ exclude = [
 [features]
 default = ["prost-derive", "std"]
 no-recursion-limit = []
-std = ["prost-derive/std"]
+std = ["prost-derive/use_std"]
    # When std is disabled, we attempt to provide no_std support in prost
    # Config::use_alloc_collections() should be set when using prost_build in your build.rs
    # so that generated files will not have std:: either, and will use alloc crate instead
diff --git a/prost-derive/Cargo.toml b/prost-derive/Cargo.toml
index 8cb7089fd..c89da0b4e 100644
--- a/prost-derive/Cargo.toml
+++ b/prost-derive/Cargo.toml
@@ -14,7 +14,7 @@ edition = "2018"
 proc_macro = true
 
 [features]
-std = [ "failure/std" ]
+use_std = [ "failure/std" ]
 # std feature means that prost-derive attempts to use std collections
 #
 # When this feature is disabled, we attempt to use alloc.
@@ -22,7 +22,11 @@ std = [ "failure/std" ]
 # prost-build config
 #
 # Generated code assumes that user's crate has `extern crate alloc` somewhere
-default = ["std"]
+#
+# Note that prost/std => prost-derive/std, so we don't default prost-derive/std
+# This makes it so that prost with default-features = false => prost-derive
+# without std.
+default = []
 
 [dependencies]
 failure = { version = "0.1", default-features = false }
diff --git a/prost-derive/src/field/mod.rs b/prost-derive/src/field/mod.rs
index f96c91382..0deb8a036 100644
--- a/prost-derive/src/field/mod.rs
+++ b/prost-derive/src/field/mod.rs
@@ -367,10 +367,19 @@ fn tags_attr(attr: &Meta) -> Result<Option<Vec<u32>>, Error> {
 
 // Helper which builds an identifier corresponding `std` or `alloc` depending
 // on feature selection
+// FIXME(chris): This doesn't seem to work, maybe related to this issue:
+// https://github.com/rust-lang/rust/issues/54863
+// It seems to pick use_std always
+//
+//#[cfg(feature = "use_std")]
+//fn collections_lib_name() -> Ident {
+//    Ident::new("std", Span::call_site())
+//}
+//
+//#[cfg(not(feature = "use_std"))]
+//fn collections_lib_name() -> Ident {
+//    Ident::new("alloc", Span::call_site())
+//}
 fn collections_lib_name() -> Ident {
-        if cfg!(std) {
-            Ident::new("std", Span::call_site())
-        } else {
-            Ident::new("alloc", Span::call_site())
-        }
+    Ident::new("alloc", Span::call_site())
 }
diff --git a/prost-types/src/compiler.rs b/prost-types/src/compiler.rs
index c7477eab8..c2027dd3c 100644
--- a/prost-types/src/compiler.rs
+++ b/prost-types/src/compiler.rs
@@ -10,7 +10,7 @@ pub struct Version {
     /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     /// be empty for mainline stable releases.
     #[prost(string, optional, tag="4")]
-    pub suffix: ::core::option::Option<alloc::string::String>,
+    pub suffix: ::core::option::Option<::std::string::String>,
 }
 /// An encoded CodeGeneratorRequest is written to the plugin's stdin.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -19,10 +19,10 @@ pub struct CodeGeneratorRequest {
     /// code generator should generate code only for these files.  Each file's
     /// descriptor will be included in proto_file, below.
     #[prost(string, repeated, tag="1")]
-    pub file_to_generate: ::std::vec::Vec<alloc::string::String>,
+    pub file_to_generate: ::std::vec::Vec<::std::string::String>,
     /// The generator parameter passed on the command-line.
     #[prost(string, optional, tag="2")]
-    pub parameter: ::core::option::Option<alloc::string::String>,
+    pub parameter: ::core::option::Option<::std::string::String>,
     /// FileDescriptorProtos for all files in files_to_generate and everything
     /// they import.  The files will appear in topological order, so each file
     /// appears before any file that imports it.
@@ -55,7 +55,7 @@ pub struct CodeGeneratorResponse {
     /// unparseable -- should be reported by writing a message to stderr and
     /// exiting with a non-zero status code.
     #[prost(string, optional, tag="1")]
-    pub error: ::core::option::Option<alloc::string::String>,
+    pub error: ::core::option::Option<::std::string::String>,
     #[prost(message, repeated, tag="15")]
     pub file: ::std::vec::Vec<code_generator_response::File>,
 }
@@ -75,7 +75,7 @@ pub mod code_generator_response {
         /// this writing protoc does not optimize for this -- it will read the entire
         /// CodeGeneratorResponse before writing files to disk.
         #[prost(string, optional, tag="1")]
-        pub name: ::core::option::Option<alloc::string::String>,
+        pub name: ::core::option::Option<::std::string::String>,
         /// If non-empty, indicates that the named file should already exist, and the
         /// content here is to be inserted into that file at a defined insertion
         /// point.  This feature allows a code generator to extend the output
@@ -114,9 +114,9 @@ pub mod code_generator_response {
         ///
         /// If |insertion_point| is present, |name| must also be present.
         #[prost(string, optional, tag="2")]
-        pub insertion_point: ::core::option::Option<alloc::string::String>,
+        pub insertion_point: ::core::option::Option<::std::string::String>,
         /// The file contents.
         #[prost(string, optional, tag="15")]
-        pub content: ::core::option::Option<alloc::string::String>,
+        pub content: ::core::option::Option<::std::string::String>,
     }
 }
diff --git a/prost-types/src/protobuf.rs b/prost-types/src/protobuf.rs
index 8324b0d72..03b64f354 100644
--- a/prost-types/src/protobuf.rs
+++ b/prost-types/src/protobuf.rs
@@ -3,36 +3,36 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorSet {
     #[prost(message, repeated, tag="1")]
-    pub file: ::alloc::vec::Vec<FileDescriptorProto>,
+    pub file: ::std::vec::Vec<FileDescriptorProto>,
 }
 /// Describes a complete .proto file.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorProto {
     /// file name, relative to root of source tree
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     /// e.g. "foo", "foo.bar", etc.
     #[prost(string, optional, tag="2")]
-    pub package: ::core::option::Option<alloc::string::String>,
+    pub package: ::core::option::Option<::std::string::String>,
     /// Names of files imported by this file.
     #[prost(string, repeated, tag="3")]
-    pub dependency: ::alloc::vec::Vec<alloc::string::String>,
+    pub dependency: ::std::vec::Vec<::std::string::String>,
     /// Indexes of the public imported files in the dependency list above.
     #[prost(int32, repeated, packed="false", tag="10")]
-    pub public_dependency: ::alloc::vec::Vec<i32>,
+    pub public_dependency: ::std::vec::Vec<i32>,
     /// Indexes of the weak imported files in the dependency list.
     /// For Google-internal migration only. Do not use.
     #[prost(int32, repeated, packed="false", tag="11")]
-    pub weak_dependency: ::alloc::vec::Vec<i32>,
+    pub weak_dependency: ::std::vec::Vec<i32>,
     /// All top-level definitions in this file.
     #[prost(message, repeated, tag="4")]
-    pub message_type: ::alloc::vec::Vec<DescriptorProto>,
+    pub message_type: ::std::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub service: ::alloc::vec::Vec<ServiceDescriptorProto>,
+    pub service: ::std::vec::Vec<ServiceDescriptorProto>,
     #[prost(message, repeated, tag="7")]
-    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
+    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
     #[prost(message, optional, tag="8")]
     pub options: ::core::option::Option<FileOptions>,
     /// This field contains optional information about the original source code.
@@ -44,33 +44,33 @@ pub struct FileDescriptorProto {
     /// The syntax of the proto file.
     /// The supported values are "proto2" and "proto3".
     #[prost(string, optional, tag="12")]
-    pub syntax: ::core::option::Option<alloc::string::String>,
+    pub syntax: ::core::option::Option<::std::string::String>,
 }
 /// Describes a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub field: ::alloc::vec::Vec<FieldDescriptorProto>,
+    pub field: ::std::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
+    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="3")]
-    pub nested_type: ::alloc::vec::Vec<DescriptorProto>,
+    pub nested_type: ::std::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="4")]
-    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub extension_range: ::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
+    pub extension_range: ::std::vec::Vec<descriptor_proto::ExtensionRange>,
     #[prost(message, repeated, tag="8")]
-    pub oneof_decl: ::alloc::vec::Vec<OneofDescriptorProto>,
+    pub oneof_decl: ::std::vec::Vec<OneofDescriptorProto>,
     #[prost(message, optional, tag="7")]
     pub options: ::core::option::Option<MessageOptions>,
     #[prost(message, repeated, tag="9")]
-    pub reserved_range: ::alloc::vec::Vec<descriptor_proto::ReservedRange>,
+    pub reserved_range: ::std::vec::Vec<descriptor_proto::ReservedRange>,
     /// Reserved field names, which may not be used by fields in the same message.
     /// A given name may only be reserved once.
     #[prost(string, repeated, tag="10")]
-    pub reserved_name: ::alloc::vec::Vec<alloc::string::String>,
+    pub reserved_name: ::std::vec::Vec<::std::string::String>,
 }
 pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -99,13 +99,13 @@ pub mod descriptor_proto {
 pub struct ExtensionRangeOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 /// Describes a field within a message.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     #[prost(int32, optional, tag="3")]
     pub number: ::core::option::Option<i32>,
     #[prost(enumeration="field_descriptor_proto::Label", optional, tag="4")]
@@ -120,18 +120,18 @@ pub struct FieldDescriptorProto {
     /// message are searched, then within the parent, on up to the root
     /// namespace).
     #[prost(string, optional, tag="6")]
-    pub type_name: ::core::option::Option<alloc::string::String>,
+    pub type_name: ::core::option::Option<::std::string::String>,
     /// For extensions, this is the name of the type being extended.  It is
     /// resolved in the same manner as type_name.
     #[prost(string, optional, tag="2")]
-    pub extendee: ::core::option::Option<alloc::string::String>,
+    pub extendee: ::core::option::Option<::std::string::String>,
     /// For numeric types, contains the original text representation of the value.
     /// For booleans, "true" or "false".
     /// For strings, contains the default text contents (not escaped in any way).
     /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
     /// TODO(kenton):  Base-64 encode?
     #[prost(string, optional, tag="7")]
-    pub default_value: ::core::option::Option<alloc::string::String>,
+    pub default_value: ::core::option::Option<::std::string::String>,
     /// If set, gives the index of a oneof in the containing type's oneof_decl
     /// list.  This field is a member of that oneof.
     #[prost(int32, optional, tag="9")]
@@ -141,7 +141,7 @@ pub struct FieldDescriptorProto {
     /// will be used. Otherwise, it's deduced from the field's name by converting
     /// it to camelCase.
     #[prost(string, optional, tag="10")]
-    pub json_name: ::core::option::Option<alloc::string::String>,
+    pub json_name: ::core::option::Option<::std::string::String>,
     #[prost(message, optional, tag="8")]
     pub options: ::core::option::Option<FieldOptions>,
 }
@@ -195,7 +195,7 @@ pub mod field_descriptor_proto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     #[prost(message, optional, tag="2")]
     pub options: ::core::option::Option<OneofOptions>,
 }
@@ -203,20 +203,20 @@ pub struct OneofDescriptorProto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub value: ::alloc::vec::Vec<EnumValueDescriptorProto>,
+    pub value: ::std::vec::Vec<EnumValueDescriptorProto>,
     #[prost(message, optional, tag="3")]
     pub options: ::core::option::Option<EnumOptions>,
     /// Range of reserved numeric values. Reserved numeric values may not be used
     /// by enum values in the same enum declaration. Reserved ranges may not
     /// overlap.
     #[prost(message, repeated, tag="4")]
-    pub reserved_range: ::alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
+    pub reserved_range: ::std::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
     /// Reserved enum value names, which may not be reused. A given name may only
     /// be reserved once.
     #[prost(string, repeated, tag="5")]
-    pub reserved_name: ::alloc::vec::Vec<alloc::string::String>,
+    pub reserved_name: ::std::vec::Vec<::std::string::String>,
 }
 pub mod enum_descriptor_proto {
     /// Range of reserved numeric values. Reserved values may not be used by
@@ -239,7 +239,7 @@ pub mod enum_descriptor_proto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     #[prost(int32, optional, tag="2")]
     pub number: ::core::option::Option<i32>,
     #[prost(message, optional, tag="3")]
@@ -249,9 +249,9 @@ pub struct EnumValueDescriptorProto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub method: ::alloc::vec::Vec<MethodDescriptorProto>,
+    pub method: ::std::vec::Vec<MethodDescriptorProto>,
     #[prost(message, optional, tag="3")]
     pub options: ::core::option::Option<ServiceOptions>,
 }
@@ -259,13 +259,13 @@ pub struct ServiceDescriptorProto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<alloc::string::String>,
+    pub name: ::core::option::Option<::std::string::String>,
     /// Input and output type names.  These are resolved in the same way as
     /// FieldDescriptorProto.type_name, but must refer to a message type.
     #[prost(string, optional, tag="2")]
-    pub input_type: ::core::option::Option<alloc::string::String>,
+    pub input_type: ::core::option::Option<::std::string::String>,
     #[prost(string, optional, tag="3")]
-    pub output_type: ::core::option::Option<alloc::string::String>,
+    pub output_type: ::core::option::Option<::std::string::String>,
     #[prost(message, optional, tag="4")]
     pub options: ::core::option::Option<MethodOptions>,
     /// Identifies if client streams multiple client messages
@@ -314,14 +314,14 @@ pub struct FileOptions {
     /// inappropriate because proto packages do not normally start with backwards
     /// domain names.
     #[prost(string, optional, tag="1")]
-    pub java_package: ::core::option::Option<alloc::string::String>,
+    pub java_package: ::core::option::Option<::std::string::String>,
     /// If set, all the classes from the .proto file are wrapped in a single
     /// outer class with the given name.  This applies to both Proto1
     /// (equivalent to the old "--one_java_file" option) and Proto2 (where
     /// a .proto always translates to a single class, but you may want to
     /// explicitly choose the class name).
     #[prost(string, optional, tag="8")]
-    pub java_outer_classname: ::core::option::Option<alloc::string::String>,
+    pub java_outer_classname: ::core::option::Option<::std::string::String>,
     /// If set true, then the Java code generator will generate a separate .java
     /// file for each top-level message, enum, and service defined in the .proto
     /// file.  Thus, these types will *not* be nested inside the outer class
@@ -349,7 +349,7 @@ pub struct FileOptions {
     ///   - Otherwise, the package statement in the .proto file, if present.
     ///   - Otherwise, the basename of the .proto file, without extension.
     #[prost(string, optional, tag="11")]
-    pub go_package: ::core::option::Option<alloc::string::String>,
+    pub go_package: ::core::option::Option<::std::string::String>,
     /// Should generic services be generated in each language?  "Generic" services
     /// are not specific to any particular RPC system.  They are generated by the
     /// main code generators in each language (without additional plugins).
@@ -381,39 +381,39 @@ pub struct FileOptions {
     /// Sets the objective c class prefix which is prepended to all objective c
     /// generated classes from this .proto. There is no default.
     #[prost(string, optional, tag="36")]
-    pub objc_class_prefix: ::core::option::Option<alloc::string::String>,
+    pub objc_class_prefix: ::core::option::Option<::std::string::String>,
     /// Namespace for generated classes; defaults to the package.
     #[prost(string, optional, tag="37")]
-    pub csharp_namespace: ::core::option::Option<alloc::string::String>,
+    pub csharp_namespace: ::core::option::Option<::std::string::String>,
     /// By default Swift generators will take the proto package and CamelCase it
     /// replacing '.' with underscore and use that to prefix the types/symbols
     /// defined. When this options is provided, they will use this value instead
     /// to prefix the types/symbols defined.
     #[prost(string, optional, tag="39")]
-    pub swift_prefix: ::core::option::Option<alloc::string::String>,
+    pub swift_prefix: ::core::option::Option<::std::string::String>,
     /// Sets the php class prefix which is prepended to all php generated classes
     /// from this .proto. Default is empty.
     #[prost(string, optional, tag="40")]
-    pub php_class_prefix: ::core::option::Option<alloc::string::String>,
+    pub php_class_prefix: ::core::option::Option<::std::string::String>,
     /// Use this option to change the namespace of php generated classes. Default
     /// is empty. When this option is empty, the package name will be used for
     /// determining the namespace.
     #[prost(string, optional, tag="41")]
-    pub php_namespace: ::core::option::Option<alloc::string::String>,
+    pub php_namespace: ::core::option::Option<::std::string::String>,
     /// Use this option to change the namespace of php generated metadata classes.
     /// Default is empty. When this option is empty, the proto file name will be used
     /// for determining the namespace.
     #[prost(string, optional, tag="44")]
-    pub php_metadata_namespace: ::core::option::Option<alloc::string::String>,
+    pub php_metadata_namespace: ::core::option::Option<::std::string::String>,
     /// Use this option to change the package of ruby generated classes. Default
     /// is empty. When this option is not set, the package name will be used for
     /// determining the ruby package.
     #[prost(string, optional, tag="45")]
-    pub ruby_package: ::core::option::Option<alloc::string::String>,
+    pub ruby_package: ::core::option::Option<::std::string::String>,
     /// The parser stores options it doesn't recognize here.
     /// See the documentation for the "Options" section above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 pub mod file_options {
     /// Generated classes can be optimized for speed or code size.
@@ -488,7 +488,7 @@ pub struct MessageOptions {
     pub map_entry: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldOptions {
@@ -559,7 +559,7 @@ pub struct FieldOptions {
     pub weak: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 pub mod field_options {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -585,7 +585,7 @@ pub mod field_options {
 pub struct OneofOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumOptions {
@@ -601,7 +601,7 @@ pub struct EnumOptions {
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueOptions {
@@ -613,7 +613,7 @@ pub struct EnumValueOptions {
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceOptions {
@@ -630,7 +630,7 @@ pub struct ServiceOptions {
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodOptions {
@@ -649,7 +649,7 @@ pub struct MethodOptions {
     pub idempotency_level: ::core::option::Option<i32>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
 }
 pub mod method_options {
     /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
@@ -674,11 +674,11 @@ pub mod method_options {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UninterpretedOption {
     #[prost(message, repeated, tag="2")]
-    pub name: ::alloc::vec::Vec<uninterpreted_option::NamePart>,
+    pub name: ::std::vec::Vec<uninterpreted_option::NamePart>,
     /// The value of the uninterpreted option, in whatever type the tokenizer
     /// identified it as during parsing. Exactly one of these should be set.
     #[prost(string, optional, tag="3")]
-    pub identifier_value: ::core::option::Option<alloc::string::String>,
+    pub identifier_value: ::core::option::Option<::std::string::String>,
     #[prost(uint64, optional, tag="4")]
     pub positive_int_value: ::core::option::Option<u64>,
     #[prost(int64, optional, tag="5")]
@@ -686,9 +686,9 @@ pub struct UninterpretedOption {
     #[prost(double, optional, tag="6")]
     pub double_value: ::core::option::Option<f64>,
     #[prost(bytes, optional, tag="7")]
-    pub string_value: ::core::option::Option<alloc::vec::Vec<u8>>,
+    pub string_value: ::core::option::Option<::std::vec::Vec<u8>>,
     #[prost(string, optional, tag="8")]
-    pub aggregate_value: ::core::option::Option<alloc::string::String>,
+    pub aggregate_value: ::core::option::Option<::std::string::String>,
 }
 pub mod uninterpreted_option {
     /// The name of the uninterpreted option.  Each string represents a segment in
@@ -699,7 +699,7 @@ pub mod uninterpreted_option {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NamePart {
         #[prost(string, required, tag="1")]
-        pub name_part: alloc::string::String,
+        pub name_part: ::std::string::String,
         #[prost(bool, required, tag="2")]
         pub is_extension: bool,
     }
@@ -755,7 +755,7 @@ pub struct SourceCodeInfo {
     ///   ignore those that it doesn't understand, as more types of locations could
     ///   be recorded in the future.
     #[prost(message, repeated, tag="1")]
-    pub location: ::alloc::vec::Vec<source_code_info::Location>,
+    pub location: ::std::vec::Vec<source_code_info::Location>,
 }
 pub mod source_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -784,14 +784,14 @@ pub mod source_code_info {
         /// this path refers to the whole field declaration (from the beginning
         /// of the label to the terminating semicolon).
         #[prost(int32, repeated, tag="1")]
-        pub path: ::alloc::vec::Vec<i32>,
+        pub path: ::std::vec::Vec<i32>,
         /// Always has exactly three or four elements: start line, start column,
         /// end line (optional, otherwise assumed same as start line), end column.
         /// These are packed into a single field for efficiency.  Note that line
         /// and column numbers are zero-based -- typically you will want to add
         /// 1 to each before displaying to a user.
         #[prost(int32, repeated, tag="2")]
-        pub span: ::alloc::vec::Vec<i32>,
+        pub span: ::std::vec::Vec<i32>,
         /// If this SourceCodeInfo represents a complete declaration, these are any
         /// comments appearing before and after the declaration which appear to be
         /// attached to the declaration.
@@ -840,11 +840,11 @@ pub mod source_code_info {
         ///
         ///   // ignored detached comments.
         #[prost(string, optional, tag="3")]
-        pub leading_comments: ::core::option::Option<alloc::string::String>,
+        pub leading_comments: ::core::option::Option<::std::string::String>,
         #[prost(string, optional, tag="4")]
-        pub trailing_comments: ::core::option::Option<alloc::string::String>,
+        pub trailing_comments: ::core::option::Option<::std::string::String>,
         #[prost(string, repeated, tag="6")]
-        pub leading_detached_comments: ::alloc::vec::Vec<alloc::string::String>,
+        pub leading_detached_comments: ::std::vec::Vec<::std::string::String>,
     }
 }
 /// Describes the relationship between generated code and its original source
@@ -855,7 +855,7 @@ pub struct GeneratedCodeInfo {
     /// An Annotation connects some span of text in generated code to an element
     /// of its generating .proto file.
     #[prost(message, repeated, tag="1")]
-    pub annotation: ::alloc::vec::Vec<generated_code_info::Annotation>,
+    pub annotation: ::std::vec::Vec<generated_code_info::Annotation>,
 }
 pub mod generated_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -863,10 +863,10 @@ pub mod generated_code_info {
         /// Identifies the element in the original source .proto file. This field
         /// is formatted the same as SourceCodeInfo.Location.path.
         #[prost(int32, repeated, tag="1")]
-        pub path: ::alloc::vec::Vec<i32>,
+        pub path: ::std::vec::Vec<i32>,
         /// Identifies the filesystem path to the original source .proto.
         #[prost(string, optional, tag="2")]
-        pub source_file: ::core::option::Option<alloc::string::String>,
+        pub source_file: ::core::option::Option<::std::string::String>,
         /// Identifies the starting offset in bytes in the generated code
         /// that relates to the identified object.
         #[prost(int32, optional, tag="3")]
@@ -989,10 +989,10 @@ pub struct Any {
     /// used with implementation specific semantics.
     ///
     #[prost(string, tag="1")]
-    pub type_url: alloc::string::String,
+    pub type_url: ::std::string::String,
     /// Must be a valid serialized protocol buffer of the above specified type.
     #[prost(bytes, tag="2")]
-    pub value: alloc::vec::Vec<u8>,
+    pub value: ::std::vec::Vec<u8>,
 }
 /// `SourceContext` represents information about the source of a
 /// protobuf element, like the file in which it is defined.
@@ -1001,23 +1001,23 @@ pub struct SourceContext {
     /// The path-qualified name of the .proto file that contained the associated
     /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
     #[prost(string, tag="1")]
-    pub file_name: alloc::string::String,
+    pub file_name: ::std::string::String,
 }
 /// A protocol buffer message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Type {
     /// The fully qualified message name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// The list of fields.
     #[prost(message, repeated, tag="2")]
-    pub fields: ::alloc::vec::Vec<Field>,
+    pub fields: ::std::vec::Vec<Field>,
     /// The list of types appearing in `oneof` definitions in this type.
     #[prost(string, repeated, tag="3")]
-    pub oneofs: ::alloc::vec::Vec<alloc::string::String>,
+    pub oneofs: ::std::vec::Vec<::std::string::String>,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="4")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: ::std::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="5")]
     pub source_context: ::core::option::Option<SourceContext>,
@@ -1039,11 +1039,11 @@ pub struct Field {
     pub number: i32,
     /// The field name.
     #[prost(string, tag="4")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// The field type URL, without the scheme, for message or enumeration
     /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
     #[prost(string, tag="6")]
-    pub type_url: alloc::string::String,
+    pub type_url: ::std::string::String,
     /// The index of the field type in `Type.oneofs`, for message or enumeration
     /// types. The first type has index 1; zero means the type is not in the list.
     #[prost(int32, tag="7")]
@@ -1053,13 +1053,13 @@ pub struct Field {
     pub packed: bool,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="9")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: ::std::vec::Vec<Option>,
     /// The field JSON name.
     #[prost(string, tag="10")]
-    pub json_name: alloc::string::String,
+    pub json_name: ::std::string::String,
     /// The string value of the default value of this field. Proto2 syntax only.
     #[prost(string, tag="11")]
-    pub default_value: alloc::string::String,
+    pub default_value: ::std::string::String,
 }
 pub mod field {
     /// Basic field types.
@@ -1124,13 +1124,13 @@ pub mod field {
 pub struct Enum {
     /// Enum type name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// Enum value definitions.
     #[prost(message, repeated, tag="2")]
-    pub enumvalue: ::alloc::vec::Vec<EnumValue>,
+    pub enumvalue: ::std::vec::Vec<EnumValue>,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: ::std::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="4")]
     pub source_context: ::core::option::Option<SourceContext>,
@@ -1143,13 +1143,13 @@ pub struct Enum {
 pub struct EnumValue {
     /// Enum value name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// Enum value number.
     #[prost(int32, tag="2")]
     pub number: i32,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: ::std::vec::Vec<Option>,
 }
 /// A protocol buffer option, which can be attached to a message, field,
 /// enumeration, etc.
@@ -1160,7 +1160,7 @@ pub struct Option {
     /// For custom options, it should be the fully-qualified name. For example,
     /// `"google.api.http"`.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// The option's value packed in an Any message. If the value is a primitive,
     /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
     /// should be used. If the value is an enum, it should be stored as an int32
@@ -1191,13 +1191,13 @@ pub struct Api {
     /// The fully qualified name of this interface, including package name
     /// followed by the interface's simple name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// The methods of this interface, in unspecified order.
     #[prost(message, repeated, tag="2")]
-    pub methods: ::alloc::vec::Vec<Method>,
+    pub methods: ::std::vec::Vec<Method>,
     /// Any metadata attached to the interface.
     #[prost(message, repeated, tag="3")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: ::std::vec::Vec<Option>,
     /// A version string for this interface. If specified, must have the form
     /// `major-version.minor-version`, as in `1.10`. If the minor version is
     /// omitted, it defaults to zero. If the entire version field is empty, the
@@ -1220,14 +1220,14 @@ pub struct Api {
     ///
     ///
     #[prost(string, tag="4")]
-    pub version: alloc::string::String,
+    pub version: ::std::string::String,
     /// Source context for the protocol buffer service represented by this
     /// message.
     #[prost(message, optional, tag="5")]
     pub source_context: ::core::option::Option<SourceContext>,
     /// Included interfaces. See [Mixin][].
     #[prost(message, repeated, tag="6")]
-    pub mixins: ::alloc::vec::Vec<Mixin>,
+    pub mixins: ::std::vec::Vec<Mixin>,
     /// The source syntax of the service.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1237,22 +1237,22 @@ pub struct Api {
 pub struct Method {
     /// The simple name of this method.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// A URL of the input message type.
     #[prost(string, tag="2")]
-    pub request_type_url: alloc::string::String,
+    pub request_type_url: ::std::string::String,
     /// If true, the request is streamed.
     #[prost(bool, tag="3")]
     pub request_streaming: bool,
     /// The URL of the output message type.
     #[prost(string, tag="4")]
-    pub response_type_url: alloc::string::String,
+    pub response_type_url: ::std::string::String,
     /// If true, the response is streamed.
     #[prost(bool, tag="5")]
     pub response_streaming: bool,
     /// Any metadata attached to the method.
     #[prost(message, repeated, tag="6")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: ::std::vec::Vec<Option>,
     /// The source syntax of this method.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1339,11 +1339,11 @@ pub struct Method {
 pub struct Mixin {
     /// The fully qualified name of the interface which is included.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: ::std::string::String,
     /// If non-empty specifies a path under which inherited HTTP paths
     /// are rooted.
     #[prost(string, tag="2")]
-    pub root: alloc::string::String,
+    pub root: ::std::string::String,
 }
 /// A Duration represents a signed, fixed-length span of time represented
 /// as a count of seconds and fractions of seconds at nanosecond
@@ -1624,7 +1624,7 @@ pub struct Duration {
 pub struct FieldMask {
     /// The set of field mask paths.
     #[prost(string, repeated, tag="1")]
-    pub paths: ::alloc::vec::Vec<alloc::string::String>,
+    pub paths: ::std::vec::Vec<::std::string::String>,
 }
 /// `Struct` represents a structured data value, consisting of fields
 /// which map to dynamically typed values. In some languages, `Struct`
@@ -1638,7 +1638,7 @@ pub struct FieldMask {
 pub struct Struct {
     /// Unordered map of dynamically typed values.
     #[prost(btree_map="string, message", tag="1")]
-    pub fields: ::alloc::collections::BTreeMap<alloc::string::String, Value>,
+    pub fields: ::std::collections::BTreeMap<::std::string::String, Value>,
 }
 /// `Value` represents a dynamically typed value which can be either
 /// null, a number, a string, a boolean, a recursive struct value, or a
@@ -1664,7 +1664,7 @@ pub mod value {
         NumberValue(f64),
         /// Represents a string value.
         #[prost(string, tag="3")]
-        StringValue(alloc::string::String),
+        StringValue(::std::string::String),
         /// Represents a boolean value.
         #[prost(bool, tag="4")]
         BoolValue(bool),
@@ -1683,7 +1683,7 @@ pub mod value {
 pub struct ListValue {
     /// Repeated field of dynamically typed values.
     #[prost(message, repeated, tag="1")]
-    pub values: ::alloc::vec::Vec<Value>,
+    pub values: ::std::vec::Vec<Value>,
 }
 /// `NullValue` is a singleton enumeration to represent the null value for the
 /// `Value` type union.
diff --git a/protobuf/Cargo.toml b/protobuf/Cargo.toml
index 33e9ff358..d516a7259 100644
--- a/protobuf/Cargo.toml
+++ b/protobuf/Cargo.toml
@@ -7,8 +7,8 @@ edition = "2018"
 
 [dependencies]
 bytes = { version = "0.5", default-features = false }
-prost = { path = ".." }
-prost-types = { path = "../prost-types" }
+prost = { path = "..", default-features = false }
+prost-types = { path = "../prost-types", default-features = false }
 
 [build-dependencies]
 cfg-if = "0.1"
diff --git a/tests-infra/Cargo.toml b/tests-infra/Cargo.toml
index 81c097b5b..57c1e9d90 100644
--- a/tests-infra/Cargo.toml
+++ b/tests-infra/Cargo.toml
@@ -9,6 +9,6 @@ edition = "2018"
 doctest = false
 
 [dependencies]
-bytes = "0.5"
+bytes = { version = "0.5", default-features = false }
 cfg-if = "0.1"
 prost = { path = "..", default-features = false }
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index 1ae9dd89a..ee101d75f 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -85,6 +85,8 @@ mod tests {
     use std::collections::{BTreeMap, BTreeSet};
 
     use super::*;
+
+    use prost::Message;
     use protobuf::test_messages::proto3::TestAllTypesProto3;
     use tests_infra::*;
 
@@ -232,7 +234,7 @@ mod tests {
 
             let mut buf = Vec::new();
             a.encode(&mut buf).unwrap();
-            A::decode(buf).map(|_| ())
+            A::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(100).is_ok());
@@ -255,7 +257,7 @@ mod tests {
 
             let mut buf = Vec::new();
             a.encode(&mut buf).unwrap();
-            A::decode(buf).map(|_| ())
+            A::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(99).is_ok());
@@ -278,7 +280,7 @@ mod tests {
 
             let mut buf = Vec::new();
             a.encode(&mut buf).unwrap();
-            NestedGroup2::decode(buf).map(|_| ())
+            NestedGroup2::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(50).is_ok());
@@ -299,7 +301,7 @@ mod tests {
 
             let mut buf = Vec::new();
             c.encode(&mut buf).unwrap();
-            C::decode(buf).map(|_| ())
+            C::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(100).is_ok());
@@ -320,7 +322,7 @@ mod tests {
 
             let mut buf = Vec::new();
             d.encode(&mut buf).unwrap();
-            D::decode(buf).map(|_| ())
+            D::decode(&buf[..]).map(|_| ())
         }
 
         assert!(build_and_roundtrip(50).is_ok());

From 8e6d7943cd4a17e35ba5f4b1c3a2c84125861919 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 12 Sep 2019 13:55:50 -0700
Subject: [PATCH 06/36] use git dependencies instead of patch

---
 Cargo.toml             | 8 +++-----
 prost-build/Cargo.toml | 4 +++-
 prost-types/Cargo.toml | 4 +++-
 protobuf/Cargo.toml    | 4 +++-
 4 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index d7fc8d3ef..865a4257d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,7 +42,9 @@ std = ["prost-derive/use_std"]
    # so that generated files will not have std:: either, and will use alloc crate instead
 
 [dependencies]
-bytes = { version = "0.5", default-features = false }
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 prost-derive = { version = "0.5.0", path = "prost-derive", default-features = false, optional = true }
 
 [dev-dependencies]
@@ -59,7 +61,3 @@ name = "varint"
 [[bench]]
 name = "benchmark"
 harness = false
-
-# TODO: Remove this after bytes releases 0.5, and before we make a release
-[patch.crates-io]
-bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024" }
diff --git a/prost-build/Cargo.toml b/prost-build/Cargo.toml
index 6c43137dc..9b890257a 100644
--- a/prost-build/Cargo.toml
+++ b/prost-build/Cargo.toml
@@ -11,7 +11,9 @@ description = "A Protocol Buffers implementation for the Rust Language."
 edition = "2018"
 
 [dependencies]
-bytes = { version = "0.5", default-features = false }
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 heck = "0.3"
 itertools = "0.8"
 log = "0.4"
diff --git a/prost-types/Cargo.toml b/prost-types/Cargo.toml
index 9c0eefae8..38c2d35f3 100644
--- a/prost-types/Cargo.toml
+++ b/prost-types/Cargo.toml
@@ -19,5 +19,7 @@ default = ["std"]
 std = []
 
 [dependencies]
-bytes = { version = "0.5", default-features = false }
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 prost = { version = "0.5.0", path = "..", default-features = false }
diff --git a/protobuf/Cargo.toml b/protobuf/Cargo.toml
index d516a7259..a5663b31b 100644
--- a/protobuf/Cargo.toml
+++ b/protobuf/Cargo.toml
@@ -6,7 +6,9 @@ publish = false
 edition = "2018"
 
 [dependencies]
-bytes = { version = "0.5", default-features = false }
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 prost = { path = "..", default-features = false }
 prost-types = { path = "../prost-types", default-features = false }
 

From e5d878c8e4e43dd7e6698b150d5d69da2d8a9ae4 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 12 Sep 2019 15:41:46 -0700
Subject: [PATCH 07/36] Use git dependencies for bytes, and use alt-failure
 crate in prost-derive as a workaround for feature-unification issues

---
 Cargo.toml              | 2 +-
 conformance/Cargo.toml  | 4 +++-
 prost-derive/Cargo.toml | 4 ++--
 tests-2015/Cargo.toml   | 4 +++-
 tests-alloc/Cargo.toml  | 4 +++-
 tests-infra/Cargo.toml  | 4 +++-
 tests/Cargo.toml        | 4 +++-
 7 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 865a4257d..68fd80d39 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,7 +50,7 @@ prost-derive = { version = "0.5.0", path = "prost-derive", default-features = fa
 [dev-dependencies]
 criterion = "0.2"
 env_logger = { version = "0.6", default-features = false }
-failure = "0.1"
+failure = { version = "0.1", default-features = false }
 log = "0.4"
 protobuf = { version = "0", path = "protobuf" }
 quickcheck = "0.8"
diff --git a/conformance/Cargo.toml b/conformance/Cargo.toml
index c7963b479..05788f2c3 100644
--- a/conformance/Cargo.toml
+++ b/conformance/Cargo.toml
@@ -6,7 +6,9 @@ publish = false
 edition = "2018"
 
 [dependencies]
-bytes = "0.5"
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 env_logger = { version = "0.6", default-features = false }
 log = "0.3"
 prost = { path = ".." }
diff --git a/prost-derive/Cargo.toml b/prost-derive/Cargo.toml
index c89da0b4e..dafba7c34 100644
--- a/prost-derive/Cargo.toml
+++ b/prost-derive/Cargo.toml
@@ -14,7 +14,7 @@ edition = "2018"
 proc_macro = true
 
 [features]
-use_std = [ "failure/std" ]
+use_std = []
 # std feature means that prost-derive attempts to use std collections
 #
 # When this feature is disabled, we attempt to use alloc.
@@ -29,7 +29,7 @@ use_std = [ "failure/std" ]
 default = []
 
 [dependencies]
-failure = { version = "0.1", default-features = false }
+failure = { package = "alt-failure" , version = "0.1.5" }
 itertools = "0.8"
 proc-macro2 = "0.4.4"
 quote = "0.6.3"
diff --git a/tests-2015/Cargo.toml b/tests-2015/Cargo.toml
index 7491f7343..42e6e7a8f 100644
--- a/tests-2015/Cargo.toml
+++ b/tests-2015/Cargo.toml
@@ -16,7 +16,9 @@ default = ["edition-2015"]
 edition-2015 = []
 
 [dependencies]
-bytes = "0.5"
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
diff --git a/tests-alloc/Cargo.toml b/tests-alloc/Cargo.toml
index 8358380dd..544d60a37 100644
--- a/tests-alloc/Cargo.toml
+++ b/tests-alloc/Cargo.toml
@@ -14,7 +14,9 @@ name = "tests-alloc"
 path = "src/bin.rs"
 
 [dependencies]
-bytes = { version = "0.5", default-features = false }
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 cfg-if = "0.1"
 prost = { path = "..", default-features = false }
 prost-derive = { path = "../prost-derive", default-features = false }
diff --git a/tests-infra/Cargo.toml b/tests-infra/Cargo.toml
index 57c1e9d90..3669e9382 100644
--- a/tests-infra/Cargo.toml
+++ b/tests-infra/Cargo.toml
@@ -9,6 +9,8 @@ edition = "2018"
 doctest = false
 
 [dependencies]
-bytes = { version = "0.5", default-features = false }
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 cfg-if = "0.1"
 prost = { path = "..", default-features = false }
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index 743cf2b4b..a0ac7e1c1 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -11,7 +11,9 @@ build = "src/build.rs"
 doctest = false
 
 [dependencies]
-bytes = "0.5"
+#TODO bytes = { version = "0.5", default-features = false }
+# Not using patch because it makes it harder for downstream projects
+bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
 cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }

From 0804e3d2e6e457339d926345e856bac945591c2e Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 12 Sep 2019 15:55:08 -0700
Subject: [PATCH 08/36] fix build failure in no_std mode

---
 prost-build/Cargo.toml | 2 +-
 src/error.rs           | 8 ++++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/prost-build/Cargo.toml b/prost-build/Cargo.toml
index 9b890257a..3612a81e9 100644
--- a/prost-build/Cargo.toml
+++ b/prost-build/Cargo.toml
@@ -19,7 +19,7 @@ itertools = "0.8"
 log = "0.4"
 multimap = { version = "0.4", default-features = false }
 petgraph = { version = "0.4", default-features = false }
-prost = { version = "0.5.0", path = ".." }
+prost = { version = "0.5.0", path = "..", default-features = false }
 prost-types = { version = "0.5.0", path = "../prost-types" }
 tempfile = "3"
 
diff --git a/src/error.rs b/src/error.rs
index f91e9bfbe..e7eeb0bfd 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -103,11 +103,15 @@ impl EncodeError {
     pub fn remaining(&self) -> usize {
         self.remaining
     }
+
+    fn desc_str(&self) -> &str {
+        "failed to encode Protobuf message: insufficient buffer capacity"
+    }
 }
 
 impl fmt::Display for EncodeError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(error::Error::description(self))?;
+        f.write_str(self.desc_str())?;
         write!(
             f,
             " (required: {}, remaining: {})",
@@ -119,7 +123,7 @@ impl fmt::Display for EncodeError {
 #[cfg(feature = "std")]
 impl error::Error for EncodeError {
     fn description(&self) -> &str {
-        "failed to encode Protobuf message: insufficient buffer capacity"
+        self.desc_str()
     }
 }
 

From 7b9beaba8f702586fa6f32db5fd2aa89e73b195f Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 12 Sep 2019 18:19:41 -0700
Subject: [PATCH 09/36] avoid need for user to declare dependency on bytes

---
 prost-derive/src/lib.rs | 2 +-
 src/lib.rs              | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/prost-derive/src/lib.rs b/prost-derive/src/lib.rs
index 646534a46..abe747437 100644
--- a/prost-derive/src/lib.rs
+++ b/prost-derive/src/lib.rs
@@ -436,8 +436,8 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
     let expanded = quote! {
         #[allow(non_snake_case, unused_attributes)]
         const #dummy_const: () = {
-            extern crate bytes as _bytes;
             extern crate prost as _prost;
+            use _prost::_bytes;
 
             impl #ident {
                 pub fn encode<B>(&self, buf: &mut B) where B: _bytes::BufMut {
diff --git a/src/lib.rs b/src/lib.rs
index fce880fd8..53a92c594 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,6 +17,10 @@ pub mod encoding;
 pub use crate::error::{DecodeError, EncodeError};
 pub use crate::message::Message;
 
+// This allows people to use prost and prost-derive without declaring dependency
+// on bytes in their Cargo.toml
+pub use bytes as _bytes;
+
 use bytes::{Buf, BufMut};
 
 use crate::encoding::{decode_varint, encode_varint, encoded_len_varint};

From af60702cf7072ddd3817f984c4a6d28746bd22c3 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Tue, 10 Dec 2019 15:10:00 -0800
Subject: [PATCH 10/36] uprev bytes to 0.5

---
 Cargo.toml      | 4 +---
 src/encoding.rs | 7 ++++---
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 68fd80d39..a82607b74 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,9 +42,7 @@ std = ["prost-derive/use_std"]
    # so that generated files will not have std:: either, and will use alloc crate instead
 
 [dependencies]
-#TODO bytes = { version = "0.5", default-features = false }
-# Not using patch because it makes it harder for downstream projects
-bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
+bytes = { version = "0.5", default-features = false }
 prost-derive = { version = "0.5.0", path = "prost-derive", default-features = false, optional = true }
 
 [dev-dependencies]
diff --git a/src/encoding.rs b/src/encoding.rs
index 60df19067..3e7676962 100644
--- a/src/encoding.rs
+++ b/src/encoding.rs
@@ -35,13 +35,13 @@ where
     'outer: loop {
         i = 0;
 
-        for byte in unsafe { buf.bytes_mut() } {
+        for byte in buf.bytes_mut() {
             i += 1;
             if value < 0x80 {
-                *byte = value as u8;
+                *byte = mem::MaybeUninit::new(value as u8);
                 break 'outer;
             } else {
-                *byte = ((value & 0x7F) | 0x80) as u8;
+                *byte =  mem::MaybeUninit::new(((value & 0x7F) | 0x80) as u8);
                 value >>= 7;
             }
         }
@@ -862,6 +862,7 @@ pub mod bytes {
         }
         let len = len as usize;
         value.reserve(len);
+        use ::bytes::buf::ext::BufExt;
         value.put(buf.take(len));
         Ok(())
     }

From a14e69412865363fa840bf9a7273cd65b966e96f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Flemstr=C3=B6m?= <david.flemstrom@gmail.com>
Date: Mon, 24 Feb 2020 14:43:56 +0100
Subject: [PATCH 11/36] Make alloc into an attribute tag instead of a
 prost-build feature

---
 Cargo.toml                        |  2 +-
 prost-build/Cargo.toml            |  2 +-
 prost-build/src/code_generator.rs | 20 +++++++++++++++++---
 prost-derive/Cargo.toml           | 15 ---------------
 prost-derive/src/field/group.rs   |  3 +++
 prost-derive/src/field/map.rs     | 18 ++++++++++++------
 prost-derive/src/field/message.rs |  3 +++
 prost-derive/src/field/mod.rs     | 21 ++++++---------------
 prost-derive/src/field/oneof.rs   |  7 +++++--
 prost-derive/src/field/scalar.rs  | 23 ++++++++++++++---------
 prost-types/Cargo.toml            |  4 ++--
 prost-types/src/lib.rs            |  4 ++++
 src/encoding.rs                   |  6 +++---
 tests-alloc/Cargo.toml            |  4 +---
 tests/src/lib.rs                  |  1 -
 15 files changed, 72 insertions(+), 61 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 6830a88c9..a3ee0b30d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ bench = false
 [features]
 default = ["prost-derive", "std"]
 no-recursion-limit = []
-std = ["prost-derive/use_std"]
+std = []
    # When std is disabled, we attempt to provide no_std support in prost
    # Config::use_alloc_collections() should be set when using prost_build in your build.rs
    # so that generated files will not have std:: either, and will use alloc crate instead
diff --git a/prost-build/Cargo.toml b/prost-build/Cargo.toml
index 5b9db389e..7978ac296 100644
--- a/prost-build/Cargo.toml
+++ b/prost-build/Cargo.toml
@@ -17,7 +17,7 @@ log = "0.4"
 multimap = { version = "0.8", default-features = false }
 petgraph = { version = "0.5", default-features = false }
 prost = { version = "0.6.1", path = "..", default-features = false }
-prost-types = { version = "0.6.1", path = "../prost-types" }
+prost-types = { version = "0.6.1", path = "../prost-types", default-features = false }
 tempfile = "3"
 
 [build-dependencies]
diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index 35b0738f6..a9e7418db 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -331,6 +331,11 @@ impl<'a> CodeGenerator<'a> {
         if boxed {
             self.buf.push_str(", boxed");
         }
+
+        if self.config.collections_lib == CollectionsLib::Alloc {
+            self.buf.push_str(", alloc");
+        }
+
         self.buf.push_str(", tag=\"");
         self.buf.push_str(&field.number().to_string());
 
@@ -428,10 +433,13 @@ impl<'a> CodeGenerator<'a> {
         let key_tag = self.field_type_tag(key);
         let value_tag = self.map_value_type_tag(value);
         self.buf.push_str(&format!(
-            "#[prost({}=\"{}, {}\", tag=\"{}\")]\n",
+            "#[prost({}=\"{}, {}\"{}, tag=\"{}\")]\n",
             annotation_ty,
             key_tag,
             value_tag,
+            if self.config.collections_lib == CollectionsLib::Alloc {
+                ", alloc"
+            } else { "" },
             field.number()
         ));
         self.append_field_attributes(msg_name, field.name());
@@ -461,8 +469,11 @@ impl<'a> CodeGenerator<'a> {
         self.append_doc();
         self.push_indent();
         self.buf.push_str(&format!(
-            "#[prost(oneof=\"{}\", tags=\"{}\")]\n",
+            "#[prost(oneof=\"{}\"{}, tags=\"{}\")]\n",
             name,
+            if self.config.collections_lib == CollectionsLib::Alloc {
+                ", alloc"
+            } else { "" },
             fields
                 .iter()
                 .map(|&(ref field, _)| field.number())
@@ -512,8 +523,11 @@ impl<'a> CodeGenerator<'a> {
             self.push_indent();
             let ty_tag = self.field_type_tag(&field);
             self.buf.push_str(&format!(
-                "#[prost({}, tag=\"{}\")]\n",
+                "#[prost({}{}, tag=\"{}\")]\n",
                 ty_tag,
+                if self.config.collections_lib == CollectionsLib::Alloc {
+                    ", alloc"
+                } else { "" },
                 field.number()
             ));
             self.append_field_attributes(&oneof_name, field.name());
diff --git a/prost-derive/Cargo.toml b/prost-derive/Cargo.toml
index 74d6a01e8..75299d1ff 100644
--- a/prost-derive/Cargo.toml
+++ b/prost-derive/Cargo.toml
@@ -12,21 +12,6 @@ edition = "2018"
 [lib]
 proc_macro = true
 
-[features]
-use_std = []
-# std feature means that prost-derive attempts to use std collections
-#
-# When this feature is disabled, we attempt to use alloc.
-# This should be similar to putting `config.use_alloc_collections` in a
-# prost-build config
-#
-# Generated code assumes that user's crate has `extern crate alloc` somewhere
-#
-# Note that prost/std => prost-derive/std, so we don't default prost-derive/std
-# This makes it so that prost with default-features = false => prost-derive
-# without std.
-default = []
-
 [dependencies]
 anyhow = "1"
 itertools = "0.8"
diff --git a/prost-derive/src/field/group.rs b/prost-derive/src/field/group.rs
index b72100d9f..870b1629b 100644
--- a/prost-derive/src/field/group.rs
+++ b/prost-derive/src/field/group.rs
@@ -17,6 +17,7 @@ impl Field {
         let mut label = None;
         let mut tag = None;
         let mut boxed = false;
+        let mut alloc = false;
 
         let mut unknown_attrs = Vec::new();
 
@@ -25,6 +26,8 @@ impl Field {
                 set_bool(&mut group, "duplicate group attributes")?;
             } else if word_attr("boxed", attr) {
                 set_bool(&mut boxed, "duplicate boxed attributes")?;
+            } else if word_attr("alloc", attr) {
+                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
             } else if let Some(l) = Label::from_attr(attr) {
diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index 57db15cad..3ff6de8e2 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -3,7 +3,7 @@ use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{Ident, Lit, Meta, MetaNameValue, NestedMeta};
 
-use crate::field::{scalar, set_option, tag_attr};
+use crate::field::{scalar, set_option, tag_attr, collections_lib_name, word_attr, set_bool};
 
 #[derive(Clone, Debug)]
 pub enum MapTy {
@@ -34,6 +34,7 @@ fn fake_scalar(ty: scalar::Ty) -> scalar::Field {
         ty,
         kind,
         tag: 0, // Not used here
+        alloc: false,
     }
 }
 
@@ -43,17 +44,21 @@ pub struct Field {
     pub key_ty: scalar::Ty,
     pub value_ty: ValueTy,
     pub tag: u32,
+    pub alloc: bool,
 }
 
 impl Field {
     pub fn new(attrs: &[Meta], inferred_tag: Option<u32>) -> Result<Option<Field>, Error> {
         let mut types = None;
         let mut tag = None;
+        let mut alloc = false;
 
         for attr in attrs {
             if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
-            } else if let Some(map_ty) = attr
+            } else if word_attr("alloc", attr) {
+                set_bool(&mut alloc, "duplicate alloc attributes")?;
+            }else if let Some(map_ty) = attr
                 .path()
                 .get_ident()
                 .and_then(|i| MapTy::from_str(&i.to_string()))
@@ -112,6 +117,7 @@ impl Field {
                 key_ty: key_ty,
                 value_ty: val_ty,
                 tag: tag,
+                alloc: alloc,
             }),
             _ => None,
         })
@@ -253,7 +259,7 @@ impl Field {
     /// Returns methods to embed in the message.
     pub fn methods(&self, ident: &Ident) -> Option<TokenStream> {
         if let ValueTy::Scalar(scalar::Ty::Enumeration(ref ty)) = self.value_ty {
-            let key_ty = self.key_ty.rust_type();
+            let key_ty = self.key_ty.rust_type(self.alloc);
             let key_ref_ty = self.key_ty.rust_ref_type();
 
             let get = Ident::new(&format!("get_{}", ident), Span::call_site());
@@ -290,7 +296,7 @@ impl Field {
     /// The Debug tries to convert any enumerations met into the variants if possible, instead of
     /// outputting the raw numbers.
     pub fn debug(&self, wrapper_name: TokenStream) -> TokenStream {
-        let libname = super::collections_lib_name();
+        let libname = collections_lib_name(self.alloc);
 
         let type_name = match self.map_ty {
             MapTy::HashMap => Ident::new("HashMap", Span::call_site()),
@@ -298,7 +304,7 @@ impl Field {
         };
         // A fake field for generating the debug wrapper
         let key_wrapper = fake_scalar(self.key_ty.clone()).debug(quote!(KeyWrapper));
-        let key = self.key_ty.rust_type();
+        let key = self.key_ty.rust_type(self.alloc);
         let value_wrapper = self.value_ty.debug();
         let fmt = quote! {
             fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -313,7 +319,7 @@ impl Field {
         };
         match self.value_ty {
             ValueTy::Scalar(ref ty) => {
-                let value = ty.rust_type();
+                let value = ty.rust_type(self.alloc);
                 quote! {
                     struct #wrapper_name<'a>(&'a ::#libname::collections::#type_name<#key, #value>);
                     impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
diff --git a/prost-derive/src/field/message.rs b/prost-derive/src/field/message.rs
index 4f98f473f..9d4737dd7 100644
--- a/prost-derive/src/field/message.rs
+++ b/prost-derive/src/field/message.rs
@@ -17,6 +17,7 @@ impl Field {
         let mut label = None;
         let mut tag = None;
         let mut boxed = false;
+        let mut alloc = false;
 
         let mut unknown_attrs = Vec::new();
 
@@ -25,6 +26,8 @@ impl Field {
                 set_bool(&mut message, "duplicate message attribute")?;
             } else if word_attr("boxed", attr) {
                 set_bool(&mut boxed, "duplicate boxed attribute")?;
+            } else if word_attr("alloc", attr) {
+                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
             } else if let Some(l) = Label::from_attr(attr) {
diff --git a/prost-derive/src/field/mod.rs b/prost-derive/src/field/mod.rs
index 29e429812..96d333e7a 100644
--- a/prost-derive/src/field/mod.rs
+++ b/prost-derive/src/field/mod.rs
@@ -367,19 +367,10 @@ fn tags_attr(attr: &Meta) -> Result<Option<Vec<u32>>, Error> {
 
 // Helper which builds an identifier corresponding `std` or `alloc` depending
 // on feature selection
-// FIXME(chris): This doesn't seem to work, maybe related to this issue:
-// https://github.com/rust-lang/rust/issues/54863
-// It seems to pick use_std always
-//
-//#[cfg(feature = "use_std")]
-//fn collections_lib_name() -> Ident {
-//    Ident::new("std", Span::call_site())
-//}
-//
-//#[cfg(not(feature = "use_std"))]
-//fn collections_lib_name() -> Ident {
-//    Ident::new("alloc", Span::call_site())
-//}
-fn collections_lib_name() -> Ident {
-    Ident::new("alloc", Span::call_site())
+fn collections_lib_name(alloc: bool) -> Ident {
+    if alloc {
+        Ident::new("alloc", Span::call_site())
+    } else {
+        Ident::new("std", Span::call_site())
+    }
 }
diff --git a/prost-derive/src/field/oneof.rs b/prost-derive/src/field/oneof.rs
index 364c1c9f7..49ea0cf6a 100644
--- a/prost-derive/src/field/oneof.rs
+++ b/prost-derive/src/field/oneof.rs
@@ -3,7 +3,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{parse_str, Lit, Meta, MetaNameValue, NestedMeta, Path};
 
-use crate::field::{set_option, tags_attr};
+use crate::field::{set_option, tags_attr, word_attr, set_bool};
 
 #[derive(Clone)]
 pub struct Field {
@@ -16,6 +16,7 @@ impl Field {
         let mut ty = None;
         let mut tags = None;
         let mut unknown_attrs = Vec::new();
+        let mut alloc = false;
 
         for attr in attrs {
             if attr.path().is_ident("oneof") {
@@ -39,7 +40,9 @@ impl Field {
                     _ => bail!("invalid oneof attribute: {:?}", attr),
                 };
                 set_option(&mut ty, t, "duplicate oneof attribute")?;
-            } else if let Some(t) = tags_attr(attr)? {
+            } else if word_attr("alloc", attr) {
+                set_bool(&mut alloc, "duplicate alloc attributes")?;
+            }  else if let Some(t) = tags_attr(attr)? {
                 set_option(&mut tags, t, "duplicate tags attributes")?;
             } else {
                 unknown_attrs.push(attr);
diff --git a/prost-derive/src/field/scalar.rs b/prost-derive/src/field/scalar.rs
index 6167c83f4..fecc9e0f9 100644
--- a/prost-derive/src/field/scalar.rs
+++ b/prost-derive/src/field/scalar.rs
@@ -8,7 +8,7 @@ use syn::{
     self, parse_str, Ident, Lit, LitByteStr, Meta, MetaList, MetaNameValue, NestedMeta, Path,
 };
 
-use crate::field::{bool_attr, set_option, tag_attr, Label};
+use crate::field::{bool_attr, set_option, tag_attr, Label, collections_lib_name, set_bool, word_attr};
 
 /// A scalar protobuf field.
 #[derive(Clone)]
@@ -16,6 +16,7 @@ pub struct Field {
     pub ty: Ty,
     pub kind: Kind,
     pub tag: u32,
+    pub alloc: bool,
 }
 
 impl Field {
@@ -25,6 +26,7 @@ impl Field {
         let mut packed = None;
         let mut default = None;
         let mut tag = None;
+        let mut alloc = false;
 
         let mut unknown_attrs = Vec::new();
 
@@ -33,6 +35,8 @@ impl Field {
                 set_option(&mut ty, t, "duplicate type attributes")?;
             } else if let Some(p) = bool_attr("packed", attr)? {
                 set_option(&mut packed, p, "duplicate packed attributes")?;
+            } else if word_attr("alloc", attr) {
+                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
             } else if let Some(l) = Label::from_attr(attr) {
@@ -92,6 +96,7 @@ impl Field {
             ty: ty,
             kind: kind,
             tag: tag,
+            alloc: alloc,
         }))
     }
 
@@ -211,9 +216,9 @@ impl Field {
 
     /// Returns an expression which evaluates to the default value of the field.
     pub fn default(&self) -> TokenStream {
-        let libname = super::collections_lib_name();
+        let libname = collections_lib_name(self.alloc);
         match self.kind {
-            Kind::Plain(ref value) | Kind::Required(ref value) => value.owned(),
+            Kind::Plain(ref value) | Kind::Required(ref value) => value.owned(self.alloc),
             Kind::Optional(_) => quote!(::core::option::Option::None),
             Kind::Repeated | Kind::Packed => quote!(::#libname::vec::Vec::new()),
         }
@@ -243,8 +248,8 @@ impl Field {
     /// Returns a fragment for formatting the field `ident` in `Debug`.
     pub fn debug(&self, wrapper_name: TokenStream) -> TokenStream {
         let wrapper = self.debug_inner(quote!(Inner));
-        let libname = super::collections_lib_name();
-        let inner_ty = self.ty.rust_type();
+        let libname = collections_lib_name(self.alloc);
+        let inner_ty = self.ty.rust_type(self.alloc);
         match self.kind {
             Kind::Plain(_) | Kind::Required(_) => self.debug_inner(wrapper_name),
             Kind::Optional(_) => quote! {
@@ -497,8 +502,8 @@ impl Ty {
     }
 
     // TODO: rename to 'owned_type'.
-    pub fn rust_type(&self) -> TokenStream {
-        let libname = super::collections_lib_name();
+    pub fn rust_type(&self, alloc: bool) -> TokenStream {
+        let libname = collections_lib_name(alloc);
         match *self {
             Ty::String => quote!(::#libname::string::String),
             Ty::Bytes => quote!(::#libname::vec::Vec<u8>),
@@ -750,8 +755,8 @@ impl DefaultValue {
         }
     }
 
-    pub fn owned(&self) -> TokenStream {
-        let libname = super::collections_lib_name();
+    pub fn owned(&self, alloc: bool) -> TokenStream {
+        let libname = collections_lib_name(alloc);
         match *self {
             DefaultValue::String(ref value) if value.is_empty() => {
                 quote!(::#libname::string::String::new())
diff --git a/prost-types/Cargo.toml b/prost-types/Cargo.toml
index 328c77571..7a8112f3a 100644
--- a/prost-types/Cargo.toml
+++ b/prost-types/Cargo.toml
@@ -15,8 +15,8 @@ test = false
 
 [features]
 default = ["std"]
-std = []
+std = ["prost/std"]
 
 [dependencies]
 bytes = { version = "0.5", default-features = false }
-prost = { version = "0.6.1", path = ".." }
+prost = { version = "0.6.1", path = "..", default-features = false }
diff --git a/prost-types/src/lib.rs b/prost-types/src/lib.rs
index a6ac1270d..19052594f 100644
--- a/prost-types/src/lib.rs
+++ b/prost-types/src/lib.rs
@@ -14,6 +14,7 @@ extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
+#[cfg(feature = "std")]
 use core::convert::TryFrom;
 use core::i32;
 use core::i64;
@@ -30,6 +31,7 @@ pub mod compiler {
 // because the Protobuf versions are signed. To make them easier to work with, `From` conversions
 // are defined in both directions.
 
+#[cfg(feature = "std")]
 const NANOS_PER_SECOND: i32 = 1_000_000_000;
 
 impl Duration {
@@ -37,6 +39,7 @@ impl Duration {
     ///
     /// Based on [`google::protobuf::util::CreateNormalized`][1].
     /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L79-L100
+    #[cfg(feature = "std")]
     fn normalize(&mut self) {
         // Make sure nanos is in the range.
         if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
@@ -107,6 +110,7 @@ impl Timestamp {
     ///
     /// Based on [`google::protobuf::util::CreateNormalized`][1].
     /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L59-L77
+    #[cfg(feature = "std")]
     fn normalize(&mut self) {
         // Make sure nanos is in the range.
         if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
diff --git a/src/encoding.rs b/src/encoding.rs
index a6db36789..a3391f512 100644
--- a/src/encoding.rs
+++ b/src/encoding.rs
@@ -1286,7 +1286,6 @@ pub mod btree_map {
 mod test {
     use std::borrow::Borrow;
     use std::fmt::Debug;
-    use std::io::Cursor;
     use std::u64;
 
     use ::bytes::{Bytes, BytesMut};
@@ -1374,6 +1373,7 @@ mod test {
             &mut buf,
             DecodeContext::default(),
         ) {
+            use crate::alloc::string::ToString;
             return TestResult::error(error.to_string());
         };
 
@@ -1452,6 +1452,7 @@ mod test {
                 &mut buf,
                 DecodeContext::default(),
             ) {
+                use crate::alloc::string::ToString;
                 return TestResult::error(error.to_string());
             };
         }
@@ -1466,7 +1467,7 @@ mod test {
     #[test]
     fn string_merge_invalid_utf8() {
         let mut s = String::new();
-        let mut buf = Cursor::new(b"\x02\x80\x80");
+        let mut buf = &b"\x02\x80\x80"[..];
 
         let r = string::merge(
             WireType::LengthDelimited,
@@ -1496,7 +1497,6 @@ mod test {
             let roundtrip_value = decode_varint(&mut encoded.clone()).expect("decoding failed");
             assert_eq!(value, roundtrip_value);
 
-            println!("encoding {:?}", encoded);
             let roundtrip_value = decode_varint_slow(&mut encoded).expect("slow decoding failed");
             assert_eq!(value, roundtrip_value);
         }
diff --git a/tests-alloc/Cargo.toml b/tests-alloc/Cargo.toml
index 544d60a37..8358380dd 100644
--- a/tests-alloc/Cargo.toml
+++ b/tests-alloc/Cargo.toml
@@ -14,9 +14,7 @@ name = "tests-alloc"
 path = "src/bin.rs"
 
 [dependencies]
-#TODO bytes = { version = "0.5", default-features = false }
-# Not using patch because it makes it harder for downstream projects
-bytes = { git = "https://github.com/tokio-rs/bytes", rev = "c17e40115f5bb2a2db71ed90dceae6ec643dc024", default-features = false }
+bytes = { version = "0.5", default-features = false }
 cfg-if = "0.1"
 prost = { path = "..", default-features = false }
 prost-derive = { path = "../prost-derive", default-features = false }
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index 0afb02c2f..b6bcb9331 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -219,7 +219,6 @@ mod tests {
 
     use prost::Message;
     use protobuf::test_messages::proto3::TestAllTypesProto3;
-    use tests_infra::*;
 
     #[test]
     fn test_all_types_proto3() {

From 9758c140e628f34686a308cd331d4aed2729e270 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Flemstr=C3=B6m?= <david.flemstrom@gmail.com>
Date: Mon, 24 Feb 2020 15:04:30 +0100
Subject: [PATCH 12/36] Run bootstrap for prost-types

---
 prost-types/src/compiler.rs |  44 +--
 prost-types/src/protobuf.rs | 570 ++++++++++++++++++------------------
 tests/src/bootstrap.rs      |   1 +
 3 files changed, 308 insertions(+), 307 deletions(-)

diff --git a/prost-types/src/compiler.rs b/prost-types/src/compiler.rs
index c2027dd3c..7276a2891 100644
--- a/prost-types/src/compiler.rs
+++ b/prost-types/src/compiler.rs
@@ -1,16 +1,16 @@
 /// The version number of protocol compiler.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Version {
-    #[prost(int32, optional, tag="1")]
+    #[prost(int32, optional, alloc, tag="1")]
     pub major: ::core::option::Option<i32>,
-    #[prost(int32, optional, tag="2")]
+    #[prost(int32, optional, alloc, tag="2")]
     pub minor: ::core::option::Option<i32>,
-    #[prost(int32, optional, tag="3")]
+    #[prost(int32, optional, alloc, tag="3")]
     pub patch: ::core::option::Option<i32>,
     /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     /// be empty for mainline stable releases.
-    #[prost(string, optional, tag="4")]
-    pub suffix: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="4")]
+    pub suffix: ::core::option::Option<::alloc::string::String>,
 }
 /// An encoded CodeGeneratorRequest is written to the plugin's stdin.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -18,11 +18,11 @@ pub struct CodeGeneratorRequest {
     /// The .proto files that were explicitly listed on the command-line.  The
     /// code generator should generate code only for these files.  Each file's
     /// descriptor will be included in proto_file, below.
-    #[prost(string, repeated, tag="1")]
-    pub file_to_generate: ::std::vec::Vec<::std::string::String>,
+    #[prost(string, repeated, alloc, tag="1")]
+    pub file_to_generate: ::alloc::vec::Vec<::alloc::string::String>,
     /// The generator parameter passed on the command-line.
-    #[prost(string, optional, tag="2")]
-    pub parameter: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="2")]
+    pub parameter: ::core::option::Option<::alloc::string::String>,
     /// FileDescriptorProtos for all files in files_to_generate and everything
     /// they import.  The files will appear in topological order, so each file
     /// appears before any file that imports it.
@@ -37,10 +37,10 @@ pub struct CodeGeneratorRequest {
     ///
     /// Type names of fields and extensions in the FileDescriptorProto are always
     /// fully qualified.
-    #[prost(message, repeated, tag="15")]
-    pub proto_file: ::std::vec::Vec<super::FileDescriptorProto>,
+    #[prost(message, repeated, alloc, tag="15")]
+    pub proto_file: ::alloc::vec::Vec<super::FileDescriptorProto>,
     /// The version number of protocol compiler.
-    #[prost(message, optional, tag="3")]
+    #[prost(message, optional, alloc, tag="3")]
     pub compiler_version: ::core::option::Option<Version>,
 }
 /// The plugin writes an encoded CodeGeneratorResponse to stdout.
@@ -54,10 +54,10 @@ pub struct CodeGeneratorResponse {
     /// problem in protoc itself -- such as the input CodeGeneratorRequest being
     /// unparseable -- should be reported by writing a message to stderr and
     /// exiting with a non-zero status code.
-    #[prost(string, optional, tag="1")]
-    pub error: ::core::option::Option<::std::string::String>,
-    #[prost(message, repeated, tag="15")]
-    pub file: ::std::vec::Vec<code_generator_response::File>,
+    #[prost(string, optional, alloc, tag="1")]
+    pub error: ::core::option::Option<::alloc::string::String>,
+    #[prost(message, repeated, alloc, tag="15")]
+    pub file: ::alloc::vec::Vec<code_generator_response::File>,
 }
 pub mod code_generator_response {
     /// Represents a single generated file.
@@ -74,8 +74,8 @@ pub mod code_generator_response {
         /// files need not reside completely in memory at one time.  Note that as of
         /// this writing protoc does not optimize for this -- it will read the entire
         /// CodeGeneratorResponse before writing files to disk.
-        #[prost(string, optional, tag="1")]
-        pub name: ::core::option::Option<::std::string::String>,
+        #[prost(string, optional, alloc, tag="1")]
+        pub name: ::core::option::Option<::alloc::string::String>,
         /// If non-empty, indicates that the named file should already exist, and the
         /// content here is to be inserted into that file at a defined insertion
         /// point.  This feature allows a code generator to extend the output
@@ -113,10 +113,10 @@ pub mod code_generator_response {
         /// command line.
         ///
         /// If |insertion_point| is present, |name| must also be present.
-        #[prost(string, optional, tag="2")]
-        pub insertion_point: ::core::option::Option<::std::string::String>,
+        #[prost(string, optional, alloc, tag="2")]
+        pub insertion_point: ::core::option::Option<::alloc::string::String>,
         /// The file contents.
-        #[prost(string, optional, tag="15")]
-        pub content: ::core::option::Option<::std::string::String>,
+        #[prost(string, optional, alloc, tag="15")]
+        pub content: ::core::option::Option<::alloc::string::String>,
     }
 }
diff --git a/prost-types/src/protobuf.rs b/prost-types/src/protobuf.rs
index 1d57d33e8..cfcb8a1b9 100644
--- a/prost-types/src/protobuf.rs
+++ b/prost-types/src/protobuf.rs
@@ -2,86 +2,86 @@
 /// files it parses.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorSet {
-    #[prost(message, repeated, tag="1")]
-    pub file: ::std::vec::Vec<FileDescriptorProto>,
+    #[prost(message, repeated, alloc, tag="1")]
+    pub file: ::alloc::vec::Vec<FileDescriptorProto>,
 }
 /// Describes a complete .proto file.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorProto {
     /// file name, relative to root of source tree
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
     /// e.g. "foo", "foo.bar", etc.
-    #[prost(string, optional, tag="2")]
-    pub package: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="2")]
+    pub package: ::core::option::Option<::alloc::string::String>,
     /// Names of files imported by this file.
-    #[prost(string, repeated, tag="3")]
-    pub dependency: ::std::vec::Vec<::std::string::String>,
+    #[prost(string, repeated, alloc, tag="3")]
+    pub dependency: ::alloc::vec::Vec<::alloc::string::String>,
     /// Indexes of the public imported files in the dependency list above.
-    #[prost(int32, repeated, packed="false", tag="10")]
-    pub public_dependency: ::std::vec::Vec<i32>,
+    #[prost(int32, repeated, packed="false", alloc, tag="10")]
+    pub public_dependency: ::alloc::vec::Vec<i32>,
     /// Indexes of the weak imported files in the dependency list.
     /// For Google-internal migration only. Do not use.
-    #[prost(int32, repeated, packed="false", tag="11")]
-    pub weak_dependency: ::std::vec::Vec<i32>,
+    #[prost(int32, repeated, packed="false", alloc, tag="11")]
+    pub weak_dependency: ::alloc::vec::Vec<i32>,
     /// All top-level definitions in this file.
-    #[prost(message, repeated, tag="4")]
-    pub message_type: ::std::vec::Vec<DescriptorProto>,
-    #[prost(message, repeated, tag="5")]
-    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
-    #[prost(message, repeated, tag="6")]
-    pub service: ::std::vec::Vec<ServiceDescriptorProto>,
-    #[prost(message, repeated, tag="7")]
-    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
-    #[prost(message, optional, tag="8")]
+    #[prost(message, repeated, alloc, tag="4")]
+    pub message_type: ::alloc::vec::Vec<DescriptorProto>,
+    #[prost(message, repeated, alloc, tag="5")]
+    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
+    #[prost(message, repeated, alloc, tag="6")]
+    pub service: ::alloc::vec::Vec<ServiceDescriptorProto>,
+    #[prost(message, repeated, alloc, tag="7")]
+    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
+    #[prost(message, optional, alloc, tag="8")]
     pub options: ::core::option::Option<FileOptions>,
     /// This field contains optional information about the original source code.
     /// You may safely remove this entire field without harming runtime
     /// functionality of the descriptors -- the information is needed only by
     /// development tools.
-    #[prost(message, optional, tag="9")]
+    #[prost(message, optional, alloc, tag="9")]
     pub source_code_info: ::core::option::Option<SourceCodeInfo>,
     /// The syntax of the proto file.
     /// The supported values are "proto2" and "proto3".
-    #[prost(string, optional, tag="12")]
-    pub syntax: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="12")]
+    pub syntax: ::core::option::Option<::alloc::string::String>,
 }
 /// Describes a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DescriptorProto {
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
-    #[prost(message, repeated, tag="2")]
-    pub field: ::std::vec::Vec<FieldDescriptorProto>,
-    #[prost(message, repeated, tag="6")]
-    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
-    #[prost(message, repeated, tag="3")]
-    pub nested_type: ::std::vec::Vec<DescriptorProto>,
-    #[prost(message, repeated, tag="4")]
-    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
-    #[prost(message, repeated, tag="5")]
-    pub extension_range: ::std::vec::Vec<descriptor_proto::ExtensionRange>,
-    #[prost(message, repeated, tag="8")]
-    pub oneof_decl: ::std::vec::Vec<OneofDescriptorProto>,
-    #[prost(message, optional, tag="7")]
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
+    #[prost(message, repeated, alloc, tag="2")]
+    pub field: ::alloc::vec::Vec<FieldDescriptorProto>,
+    #[prost(message, repeated, alloc, tag="6")]
+    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
+    #[prost(message, repeated, alloc, tag="3")]
+    pub nested_type: ::alloc::vec::Vec<DescriptorProto>,
+    #[prost(message, repeated, alloc, tag="4")]
+    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
+    #[prost(message, repeated, alloc, tag="5")]
+    pub extension_range: ::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
+    #[prost(message, repeated, alloc, tag="8")]
+    pub oneof_decl: ::alloc::vec::Vec<OneofDescriptorProto>,
+    #[prost(message, optional, alloc, tag="7")]
     pub options: ::core::option::Option<MessageOptions>,
-    #[prost(message, repeated, tag="9")]
-    pub reserved_range: ::std::vec::Vec<descriptor_proto::ReservedRange>,
+    #[prost(message, repeated, alloc, tag="9")]
+    pub reserved_range: ::alloc::vec::Vec<descriptor_proto::ReservedRange>,
     /// Reserved field names, which may not be used by fields in the same message.
     /// A given name may only be reserved once.
-    #[prost(string, repeated, tag="10")]
-    pub reserved_name: ::std::vec::Vec<::std::string::String>,
+    #[prost(string, repeated, alloc, tag="10")]
+    pub reserved_name: ::alloc::vec::Vec<::alloc::string::String>,
 }
 pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct ExtensionRange {
         /// Inclusive.
-        #[prost(int32, optional, tag="1")]
+        #[prost(int32, optional, alloc, tag="1")]
         pub start: ::core::option::Option<i32>,
         /// Exclusive.
-        #[prost(int32, optional, tag="2")]
+        #[prost(int32, optional, alloc, tag="2")]
         pub end: ::core::option::Option<i32>,
-        #[prost(message, optional, tag="3")]
+        #[prost(message, optional, alloc, tag="3")]
         pub options: ::core::option::Option<super::ExtensionRangeOptions>,
     }
     /// Range of reserved tag numbers. Reserved tag numbers may not be used by
@@ -90,61 +90,61 @@ pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct ReservedRange {
         /// Inclusive.
-        #[prost(int32, optional, tag="1")]
+        #[prost(int32, optional, alloc, tag="1")]
         pub start: ::core::option::Option<i32>,
         /// Exclusive.
-        #[prost(int32, optional, tag="2")]
+        #[prost(int32, optional, alloc, tag="2")]
         pub end: ::core::option::Option<i32>,
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ExtensionRangeOptions {
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 /// Describes a field within a message.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldDescriptorProto {
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
-    #[prost(int32, optional, tag="3")]
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
+    #[prost(int32, optional, alloc, tag="3")]
     pub number: ::core::option::Option<i32>,
-    #[prost(enumeration="field_descriptor_proto::Label", optional, tag="4")]
+    #[prost(enumeration="field_descriptor_proto::Label", optional, alloc, tag="4")]
     pub label: ::core::option::Option<i32>,
     /// If type_name is set, this need not be set.  If both this and type_name
     /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-    #[prost(enumeration="field_descriptor_proto::Type", optional, tag="5")]
+    #[prost(enumeration="field_descriptor_proto::Type", optional, alloc, tag="5")]
     pub r#type: ::core::option::Option<i32>,
     /// For message and enum types, this is the name of the type.  If the name
     /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
     /// rules are used to find the type (i.e. first the nested types within this
     /// message are searched, then within the parent, on up to the root
     /// namespace).
-    #[prost(string, optional, tag="6")]
-    pub type_name: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="6")]
+    pub type_name: ::core::option::Option<::alloc::string::String>,
     /// For extensions, this is the name of the type being extended.  It is
     /// resolved in the same manner as type_name.
-    #[prost(string, optional, tag="2")]
-    pub extendee: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="2")]
+    pub extendee: ::core::option::Option<::alloc::string::String>,
     /// For numeric types, contains the original text representation of the value.
     /// For booleans, "true" or "false".
     /// For strings, contains the default text contents (not escaped in any way).
     /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
     /// TODO(kenton):  Base-64 encode?
-    #[prost(string, optional, tag="7")]
-    pub default_value: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="7")]
+    pub default_value: ::core::option::Option<::alloc::string::String>,
     /// If set, gives the index of a oneof in the containing type's oneof_decl
     /// list.  This field is a member of that oneof.
-    #[prost(int32, optional, tag="9")]
+    #[prost(int32, optional, alloc, tag="9")]
     pub oneof_index: ::core::option::Option<i32>,
     /// JSON name of this field. The value is set by protocol compiler. If the
     /// user has set a "json_name" option on this field, that option's value
     /// will be used. Otherwise, it's deduced from the field's name by converting
     /// it to camelCase.
-    #[prost(string, optional, tag="10")]
-    pub json_name: ::core::option::Option<::std::string::String>,
-    #[prost(message, optional, tag="8")]
+    #[prost(string, optional, alloc, tag="10")]
+    pub json_name: ::core::option::Option<::alloc::string::String>,
+    #[prost(message, optional, alloc, tag="8")]
     pub options: ::core::option::Option<FieldOptions>,
 }
 pub mod field_descriptor_proto {
@@ -196,29 +196,29 @@ pub mod field_descriptor_proto {
 /// Describes a oneof.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofDescriptorProto {
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
-    #[prost(message, optional, tag="2")]
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
+    #[prost(message, optional, alloc, tag="2")]
     pub options: ::core::option::Option<OneofOptions>,
 }
 /// Describes an enum type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumDescriptorProto {
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
-    #[prost(message, repeated, tag="2")]
-    pub value: ::std::vec::Vec<EnumValueDescriptorProto>,
-    #[prost(message, optional, tag="3")]
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
+    #[prost(message, repeated, alloc, tag="2")]
+    pub value: ::alloc::vec::Vec<EnumValueDescriptorProto>,
+    #[prost(message, optional, alloc, tag="3")]
     pub options: ::core::option::Option<EnumOptions>,
     /// Range of reserved numeric values. Reserved numeric values may not be used
     /// by enum values in the same enum declaration. Reserved ranges may not
     /// overlap.
-    #[prost(message, repeated, tag="4")]
-    pub reserved_range: ::std::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
+    #[prost(message, repeated, alloc, tag="4")]
+    pub reserved_range: ::alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
     /// Reserved enum value names, which may not be reused. A given name may only
     /// be reserved once.
-    #[prost(string, repeated, tag="5")]
-    pub reserved_name: ::std::vec::Vec<::std::string::String>,
+    #[prost(string, repeated, alloc, tag="5")]
+    pub reserved_name: ::alloc::vec::Vec<::alloc::string::String>,
 }
 pub mod enum_descriptor_proto {
     /// Range of reserved numeric values. Reserved values may not be used by
@@ -230,51 +230,51 @@ pub mod enum_descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct EnumReservedRange {
         /// Inclusive.
-        #[prost(int32, optional, tag="1")]
+        #[prost(int32, optional, alloc, tag="1")]
         pub start: ::core::option::Option<i32>,
         /// Inclusive.
-        #[prost(int32, optional, tag="2")]
+        #[prost(int32, optional, alloc, tag="2")]
         pub end: ::core::option::Option<i32>,
     }
 }
 /// Describes a value within an enum.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueDescriptorProto {
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
-    #[prost(int32, optional, tag="2")]
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
+    #[prost(int32, optional, alloc, tag="2")]
     pub number: ::core::option::Option<i32>,
-    #[prost(message, optional, tag="3")]
+    #[prost(message, optional, alloc, tag="3")]
     pub options: ::core::option::Option<EnumValueOptions>,
 }
 /// Describes a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceDescriptorProto {
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
-    #[prost(message, repeated, tag="2")]
-    pub method: ::std::vec::Vec<MethodDescriptorProto>,
-    #[prost(message, optional, tag="3")]
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
+    #[prost(message, repeated, alloc, tag="2")]
+    pub method: ::alloc::vec::Vec<MethodDescriptorProto>,
+    #[prost(message, optional, alloc, tag="3")]
     pub options: ::core::option::Option<ServiceOptions>,
 }
 /// Describes a method of a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodDescriptorProto {
-    #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="1")]
+    pub name: ::core::option::Option<::alloc::string::String>,
     /// Input and output type names.  These are resolved in the same way as
     /// FieldDescriptorProto.type_name, but must refer to a message type.
-    #[prost(string, optional, tag="2")]
-    pub input_type: ::core::option::Option<::std::string::String>,
-    #[prost(string, optional, tag="3")]
-    pub output_type: ::core::option::Option<::std::string::String>,
-    #[prost(message, optional, tag="4")]
+    #[prost(string, optional, alloc, tag="2")]
+    pub input_type: ::core::option::Option<::alloc::string::String>,
+    #[prost(string, optional, alloc, tag="3")]
+    pub output_type: ::core::option::Option<::alloc::string::String>,
+    #[prost(message, optional, alloc, tag="4")]
     pub options: ::core::option::Option<MethodOptions>,
     /// Identifies if client streams multiple client messages
-    #[prost(bool, optional, tag="5", default="false")]
+    #[prost(bool, optional, alloc, tag="5", default="false")]
     pub client_streaming: ::core::option::Option<bool>,
     /// Identifies if server streams multiple server messages
-    #[prost(bool, optional, tag="6", default="false")]
+    #[prost(bool, optional, alloc, tag="6", default="false")]
     pub server_streaming: ::core::option::Option<bool>,
 }
 // ===================================================================
@@ -315,26 +315,26 @@ pub struct FileOptions {
     /// placed.  By default, the proto package is used, but this is often
     /// inappropriate because proto packages do not normally start with backwards
     /// domain names.
-    #[prost(string, optional, tag="1")]
-    pub java_package: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="1")]
+    pub java_package: ::core::option::Option<::alloc::string::String>,
     /// If set, all the classes from the .proto file are wrapped in a single
     /// outer class with the given name.  This applies to both Proto1
     /// (equivalent to the old "--one_java_file" option) and Proto2 (where
     /// a .proto always translates to a single class, but you may want to
     /// explicitly choose the class name).
-    #[prost(string, optional, tag="8")]
-    pub java_outer_classname: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="8")]
+    pub java_outer_classname: ::core::option::Option<::alloc::string::String>,
     /// If set true, then the Java code generator will generate a separate .java
     /// file for each top-level message, enum, and service defined in the .proto
     /// file.  Thus, these types will *not* be nested inside the outer class
     /// named by java_outer_classname.  However, the outer class will still be
     /// generated to contain the file's getDescriptor() method as well as any
     /// top-level extensions defined in the file.
-    #[prost(bool, optional, tag="10", default="false")]
+    #[prost(bool, optional, alloc, tag="10", default="false")]
     pub java_multiple_files: ::core::option::Option<bool>,
     /// This option does nothing.
     #[deprecated]
-    #[prost(bool, optional, tag="20")]
+    #[prost(bool, optional, alloc, tag="20")]
     pub java_generate_equals_and_hash: ::core::option::Option<bool>,
     /// If set true, then the Java2 code generator will generate code that
     /// throws an exception whenever an attempt is made to assign a non-UTF-8
@@ -342,17 +342,17 @@ pub struct FileOptions {
     /// Message reflection will do the same.
     /// However, an extension field still accepts non-UTF-8 byte sequences.
     /// This option has no effect on when used with the lite runtime.
-    #[prost(bool, optional, tag="27", default="false")]
+    #[prost(bool, optional, alloc, tag="27", default="false")]
     pub java_string_check_utf8: ::core::option::Option<bool>,
-    #[prost(enumeration="file_options::OptimizeMode", optional, tag="9", default="Speed")]
+    #[prost(enumeration="file_options::OptimizeMode", optional, alloc, tag="9", default="Speed")]
     pub optimize_for: ::core::option::Option<i32>,
     /// Sets the Go package where structs generated from this .proto will be
     /// placed. If omitted, the Go package will be derived from the following:
     ///   - The basename of the package import path, if provided.
     ///   - Otherwise, the package statement in the .proto file, if present.
     ///   - Otherwise, the basename of the .proto file, without extension.
-    #[prost(string, optional, tag="11")]
-    pub go_package: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="11")]
+    pub go_package: ::core::option::Option<::alloc::string::String>,
     /// Should generic services be generated in each language?  "Generic" services
     /// are not specific to any particular RPC system.  They are generated by the
     /// main code generators in each language (without additional plugins).
@@ -363,60 +363,60 @@ pub struct FileOptions {
     /// that generate code specific to your particular RPC system.  Therefore,
     /// these default to false.  Old code which depends on generic services should
     /// explicitly set them to true.
-    #[prost(bool, optional, tag="16", default="false")]
+    #[prost(bool, optional, alloc, tag="16", default="false")]
     pub cc_generic_services: ::core::option::Option<bool>,
-    #[prost(bool, optional, tag="17", default="false")]
+    #[prost(bool, optional, alloc, tag="17", default="false")]
     pub java_generic_services: ::core::option::Option<bool>,
-    #[prost(bool, optional, tag="18", default="false")]
+    #[prost(bool, optional, alloc, tag="18", default="false")]
     pub py_generic_services: ::core::option::Option<bool>,
-    #[prost(bool, optional, tag="42", default="false")]
+    #[prost(bool, optional, alloc, tag="42", default="false")]
     pub php_generic_services: ::core::option::Option<bool>,
     /// Is this file deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for everything in the file, or it will be completely ignored; in the very
     /// least, this is a formalization for deprecating files.
-    #[prost(bool, optional, tag="23", default="false")]
+    #[prost(bool, optional, alloc, tag="23", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// Enables the use of arenas for the proto messages in this file. This applies
     /// only to generated classes for C++.
-    #[prost(bool, optional, tag="31", default="false")]
+    #[prost(bool, optional, alloc, tag="31", default="false")]
     pub cc_enable_arenas: ::core::option::Option<bool>,
     /// Sets the objective c class prefix which is prepended to all objective c
     /// generated classes from this .proto. There is no default.
-    #[prost(string, optional, tag="36")]
-    pub objc_class_prefix: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="36")]
+    pub objc_class_prefix: ::core::option::Option<::alloc::string::String>,
     /// Namespace for generated classes; defaults to the package.
-    #[prost(string, optional, tag="37")]
-    pub csharp_namespace: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="37")]
+    pub csharp_namespace: ::core::option::Option<::alloc::string::String>,
     /// By default Swift generators will take the proto package and CamelCase it
     /// replacing '.' with underscore and use that to prefix the types/symbols
     /// defined. When this options is provided, they will use this value instead
     /// to prefix the types/symbols defined.
-    #[prost(string, optional, tag="39")]
-    pub swift_prefix: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="39")]
+    pub swift_prefix: ::core::option::Option<::alloc::string::String>,
     /// Sets the php class prefix which is prepended to all php generated classes
     /// from this .proto. Default is empty.
-    #[prost(string, optional, tag="40")]
-    pub php_class_prefix: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="40")]
+    pub php_class_prefix: ::core::option::Option<::alloc::string::String>,
     /// Use this option to change the namespace of php generated classes. Default
     /// is empty. When this option is empty, the package name will be used for
     /// determining the namespace.
-    #[prost(string, optional, tag="41")]
-    pub php_namespace: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="41")]
+    pub php_namespace: ::core::option::Option<::alloc::string::String>,
     /// Use this option to change the namespace of php generated metadata classes.
     /// Default is empty. When this option is empty, the proto file name will be
     /// used for determining the namespace.
-    #[prost(string, optional, tag="44")]
-    pub php_metadata_namespace: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="44")]
+    pub php_metadata_namespace: ::core::option::Option<::alloc::string::String>,
     /// Use this option to change the package of ruby generated classes. Default
     /// is empty. When this option is not set, the package name will be used for
     /// determining the ruby package.
-    #[prost(string, optional, tag="45")]
-    pub ruby_package: ::core::option::Option<::std::string::String>,
+    #[prost(string, optional, alloc, tag="45")]
+    pub ruby_package: ::core::option::Option<::alloc::string::String>,
     /// The parser stores options it doesn't recognize here.
     /// See the documentation for the "Options" section above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod file_options {
     /// Generated classes can be optimized for speed or code size.
@@ -453,18 +453,18 @@ pub struct MessageOptions {
     ///
     /// Because this is an option, the above two restrictions are not enforced by
     /// the protocol compiler.
-    #[prost(bool, optional, tag="1", default="false")]
+    #[prost(bool, optional, alloc, tag="1", default="false")]
     pub message_set_wire_format: ::core::option::Option<bool>,
     /// Disables the generation of the standard "descriptor()" accessor, which can
     /// conflict with a field of the same name.  This is meant to make migration
     /// from proto1 easier; new code should avoid fields named "descriptor".
-    #[prost(bool, optional, tag="2", default="false")]
+    #[prost(bool, optional, alloc, tag="2", default="false")]
     pub no_standard_descriptor_accessor: ::core::option::Option<bool>,
     /// Is this message deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the message, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating messages.
-    #[prost(bool, optional, tag="3", default="false")]
+    #[prost(bool, optional, alloc, tag="3", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// Whether the message is an automatically generated map entry type for the
     /// maps field.
@@ -487,11 +487,11 @@ pub struct MessageOptions {
     /// NOTE: Do not set the option in .proto files. Always use the maps syntax
     /// instead. The option should only be implicitly set by the proto compiler
     /// parser.
-    #[prost(bool, optional, tag="7")]
+    #[prost(bool, optional, alloc, tag="7")]
     pub map_entry: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldOptions {
@@ -499,14 +499,14 @@ pub struct FieldOptions {
     /// representation of the field than it normally would.  See the specific
     /// options below.  This option is not yet implemented in the open source
     /// release -- sorry, we'll try to include it in a future version!
-    #[prost(enumeration="field_options::CType", optional, tag="1", default="String")]
+    #[prost(enumeration="field_options::CType", optional, alloc, tag="1", default="String")]
     pub ctype: ::core::option::Option<i32>,
     /// The packed option can be enabled for repeated primitive fields to enable
     /// a more efficient representation on the wire. Rather than repeatedly
     /// writing the tag and type for each element, the entire array is encoded as
     /// a single length-delimited blob. In proto3, only explicit setting it to
     /// false will avoid using packed encoding.
-    #[prost(bool, optional, tag="2")]
+    #[prost(bool, optional, alloc, tag="2")]
     pub packed: ::core::option::Option<bool>,
     /// The jstype option determines the JavaScript type used for values of the
     /// field.  The option is permitted only for 64 bit integral and fixed types
@@ -519,7 +519,7 @@ pub struct FieldOptions {
     ///
     /// This option is an enum to permit additional types to be added, e.g.
     /// goog.math.Integer.
-    #[prost(enumeration="field_options::JsType", optional, tag="6", default="JsNormal")]
+    #[prost(enumeration="field_options::JsType", optional, alloc, tag="6", default="JsNormal")]
     pub jstype: ::core::option::Option<i32>,
     /// Should this field be parsed lazily?  Lazy applies only to message-type
     /// fields.  It means that when the outer message is initially parsed, the
@@ -549,20 +549,20 @@ pub struct FieldOptions {
     /// implementation must either *always* check its required fields, or *never*
     /// check its required fields, regardless of whether or not the message has
     /// been parsed.
-    #[prost(bool, optional, tag="5", default="false")]
+    #[prost(bool, optional, alloc, tag="5", default="false")]
     pub lazy: ::core::option::Option<bool>,
     /// Is this field deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for accessors, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating fields.
-    #[prost(bool, optional, tag="3", default="false")]
+    #[prost(bool, optional, alloc, tag="3", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// For Google-internal migration only. Do not use.
-    #[prost(bool, optional, tag="10", default="false")]
+    #[prost(bool, optional, alloc, tag="10", default="false")]
     pub weak: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod field_options {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -587,24 +587,24 @@ pub mod field_options {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofOptions {
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumOptions {
     /// Set this option to true to allow mapping different tag names to the same
     /// value.
-    #[prost(bool, optional, tag="2")]
+    #[prost(bool, optional, alloc, tag="2")]
     pub allow_alias: ::core::option::Option<bool>,
     /// Is this enum deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the enum, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating enums.
-    #[prost(bool, optional, tag="3", default="false")]
+    #[prost(bool, optional, alloc, tag="3", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueOptions {
@@ -612,11 +612,11 @@ pub struct EnumValueOptions {
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the enum value, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating enum values.
-    #[prost(bool, optional, tag="1", default="false")]
+    #[prost(bool, optional, alloc, tag="1", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceOptions {
@@ -629,11 +629,11 @@ pub struct ServiceOptions {
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the service, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating services.
-    #[prost(bool, optional, tag="33", default="false")]
+    #[prost(bool, optional, alloc, tag="33", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodOptions {
@@ -646,13 +646,13 @@ pub struct MethodOptions {
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the method, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating methods.
-    #[prost(bool, optional, tag="33", default="false")]
+    #[prost(bool, optional, alloc, tag="33", default="false")]
     pub deprecated: ::core::option::Option<bool>,
-    #[prost(enumeration="method_options::IdempotencyLevel", optional, tag="34", default="IdempotencyUnknown")]
+    #[prost(enumeration="method_options::IdempotencyLevel", optional, alloc, tag="34", default="IdempotencyUnknown")]
     pub idempotency_level: ::core::option::Option<i32>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    #[prost(message, repeated, alloc, tag="999")]
+    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod method_options {
     /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
@@ -676,22 +676,22 @@ pub mod method_options {
 /// in them.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UninterpretedOption {
-    #[prost(message, repeated, tag="2")]
-    pub name: ::std::vec::Vec<uninterpreted_option::NamePart>,
+    #[prost(message, repeated, alloc, tag="2")]
+    pub name: ::alloc::vec::Vec<uninterpreted_option::NamePart>,
     /// The value of the uninterpreted option, in whatever type the tokenizer
     /// identified it as during parsing. Exactly one of these should be set.
-    #[prost(string, optional, tag="3")]
-    pub identifier_value: ::core::option::Option<::std::string::String>,
-    #[prost(uint64, optional, tag="4")]
+    #[prost(string, optional, alloc, tag="3")]
+    pub identifier_value: ::core::option::Option<::alloc::string::String>,
+    #[prost(uint64, optional, alloc, tag="4")]
     pub positive_int_value: ::core::option::Option<u64>,
-    #[prost(int64, optional, tag="5")]
+    #[prost(int64, optional, alloc, tag="5")]
     pub negative_int_value: ::core::option::Option<i64>,
-    #[prost(double, optional, tag="6")]
+    #[prost(double, optional, alloc, tag="6")]
     pub double_value: ::core::option::Option<f64>,
-    #[prost(bytes, optional, tag="7")]
-    pub string_value: ::core::option::Option<::std::vec::Vec<u8>>,
-    #[prost(string, optional, tag="8")]
-    pub aggregate_value: ::core::option::Option<::std::string::String>,
+    #[prost(bytes, optional, alloc, tag="7")]
+    pub string_value: ::core::option::Option<::alloc::vec::Vec<u8>>,
+    #[prost(string, optional, alloc, tag="8")]
+    pub aggregate_value: ::core::option::Option<::alloc::string::String>,
 }
 pub mod uninterpreted_option {
     /// The name of the uninterpreted option.  Each string represents a segment in
@@ -701,9 +701,9 @@ pub mod uninterpreted_option {
     /// "foo.(bar.baz).qux".
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NamePart {
-        #[prost(string, required, tag="1")]
-        pub name_part: ::std::string::String,
-        #[prost(bool, required, tag="2")]
+        #[prost(string, required, alloc, tag="1")]
+        pub name_part: ::alloc::string::String,
+        #[prost(bool, required, alloc, tag="2")]
         pub is_extension: bool,
     }
 }
@@ -757,8 +757,8 @@ pub struct SourceCodeInfo {
     /// - Code which tries to interpret locations should probably be designed to
     ///   ignore those that it doesn't understand, as more types of locations could
     ///   be recorded in the future.
-    #[prost(message, repeated, tag="1")]
-    pub location: ::std::vec::Vec<source_code_info::Location>,
+    #[prost(message, repeated, alloc, tag="1")]
+    pub location: ::alloc::vec::Vec<source_code_info::Location>,
 }
 pub mod source_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -786,15 +786,15 @@ pub mod source_code_info {
         ///   [ 4, 3, 2, 7 ]
         /// this path refers to the whole field declaration (from the beginning
         /// of the label to the terminating semicolon).
-        #[prost(int32, repeated, tag="1")]
-        pub path: ::std::vec::Vec<i32>,
+        #[prost(int32, repeated, alloc, tag="1")]
+        pub path: ::alloc::vec::Vec<i32>,
         /// Always has exactly three or four elements: start line, start column,
         /// end line (optional, otherwise assumed same as start line), end column.
         /// These are packed into a single field for efficiency.  Note that line
         /// and column numbers are zero-based -- typically you will want to add
         /// 1 to each before displaying to a user.
-        #[prost(int32, repeated, tag="2")]
-        pub span: ::std::vec::Vec<i32>,
+        #[prost(int32, repeated, alloc, tag="2")]
+        pub span: ::alloc::vec::Vec<i32>,
         /// If this SourceCodeInfo represents a complete declaration, these are any
         /// comments appearing before and after the declaration which appear to be
         /// attached to the declaration.
@@ -842,12 +842,12 @@ pub mod source_code_info {
         ///   optional int32 grault = 6;
         ///
         ///   // ignored detached comments.
-        #[prost(string, optional, tag="3")]
-        pub leading_comments: ::core::option::Option<::std::string::String>,
-        #[prost(string, optional, tag="4")]
-        pub trailing_comments: ::core::option::Option<::std::string::String>,
-        #[prost(string, repeated, tag="6")]
-        pub leading_detached_comments: ::std::vec::Vec<::std::string::String>,
+        #[prost(string, optional, alloc, tag="3")]
+        pub leading_comments: ::core::option::Option<::alloc::string::String>,
+        #[prost(string, optional, alloc, tag="4")]
+        pub trailing_comments: ::core::option::Option<::alloc::string::String>,
+        #[prost(string, repeated, alloc, tag="6")]
+        pub leading_detached_comments: ::alloc::vec::Vec<::alloc::string::String>,
     }
 }
 /// Describes the relationship between generated code and its original source
@@ -857,27 +857,27 @@ pub mod source_code_info {
 pub struct GeneratedCodeInfo {
     /// An Annotation connects some span of text in generated code to an element
     /// of its generating .proto file.
-    #[prost(message, repeated, tag="1")]
-    pub annotation: ::std::vec::Vec<generated_code_info::Annotation>,
+    #[prost(message, repeated, alloc, tag="1")]
+    pub annotation: ::alloc::vec::Vec<generated_code_info::Annotation>,
 }
 pub mod generated_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct Annotation {
         /// Identifies the element in the original source .proto file. This field
         /// is formatted the same as SourceCodeInfo.Location.path.
-        #[prost(int32, repeated, tag="1")]
-        pub path: ::std::vec::Vec<i32>,
+        #[prost(int32, repeated, alloc, tag="1")]
+        pub path: ::alloc::vec::Vec<i32>,
         /// Identifies the filesystem path to the original source .proto.
-        #[prost(string, optional, tag="2")]
-        pub source_file: ::core::option::Option<::std::string::String>,
+        #[prost(string, optional, alloc, tag="2")]
+        pub source_file: ::core::option::Option<::alloc::string::String>,
         /// Identifies the starting offset in bytes in the generated code
         /// that relates to the identified object.
-        #[prost(int32, optional, tag="3")]
+        #[prost(int32, optional, alloc, tag="3")]
         pub begin: ::core::option::Option<i32>,
         /// Identifies the ending offset in bytes in the generated code that
         /// relates to the identified offset. The end offset should be one past
         /// the last relevant byte (so the length of the text = end - begin).
-        #[prost(int32, optional, tag="4")]
+        #[prost(int32, optional, alloc, tag="4")]
         pub end: ::core::option::Option<i32>,
     }
 }
@@ -991,11 +991,11 @@ pub struct Any {
     /// Schemes other than `http`, `https` (or the empty scheme) might be
     /// used with implementation specific semantics.
     ///
-    #[prost(string, tag="1")]
-    pub type_url: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub type_url: ::alloc::string::String,
     /// Must be a valid serialized protocol buffer of the above specified type.
-    #[prost(bytes, tag="2")]
-    pub value: ::std::vec::Vec<u8>,
+    #[prost(bytes, alloc, tag="2")]
+    pub value: ::alloc::vec::Vec<u8>,
 }
 /// `SourceContext` represents information about the source of a
 /// protobuf element, like the file in which it is defined.
@@ -1003,66 +1003,66 @@ pub struct Any {
 pub struct SourceContext {
     /// The path-qualified name of the .proto file that contained the associated
     /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
-    #[prost(string, tag="1")]
-    pub file_name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub file_name: ::alloc::string::String,
 }
 /// A protocol buffer message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Type {
     /// The fully qualified message name.
-    #[prost(string, tag="1")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub name: ::alloc::string::String,
     /// The list of fields.
-    #[prost(message, repeated, tag="2")]
-    pub fields: ::std::vec::Vec<Field>,
+    #[prost(message, repeated, alloc, tag="2")]
+    pub fields: ::alloc::vec::Vec<Field>,
     /// The list of types appearing in `oneof` definitions in this type.
-    #[prost(string, repeated, tag="3")]
-    pub oneofs: ::std::vec::Vec<::std::string::String>,
+    #[prost(string, repeated, alloc, tag="3")]
+    pub oneofs: ::alloc::vec::Vec<::alloc::string::String>,
     /// The protocol buffer options.
-    #[prost(message, repeated, tag="4")]
-    pub options: ::std::vec::Vec<Option>,
+    #[prost(message, repeated, alloc, tag="4")]
+    pub options: ::alloc::vec::Vec<Option>,
     /// The source context.
-    #[prost(message, optional, tag="5")]
+    #[prost(message, optional, alloc, tag="5")]
     pub source_context: ::core::option::Option<SourceContext>,
     /// The source syntax.
-    #[prost(enumeration="Syntax", tag="6")]
+    #[prost(enumeration="Syntax", alloc, tag="6")]
     pub syntax: i32,
 }
 /// A single field of a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Field {
     /// The field type.
-    #[prost(enumeration="field::Kind", tag="1")]
+    #[prost(enumeration="field::Kind", alloc, tag="1")]
     pub kind: i32,
     /// The field cardinality.
-    #[prost(enumeration="field::Cardinality", tag="2")]
+    #[prost(enumeration="field::Cardinality", alloc, tag="2")]
     pub cardinality: i32,
     /// The field number.
-    #[prost(int32, tag="3")]
+    #[prost(int32, alloc, tag="3")]
     pub number: i32,
     /// The field name.
-    #[prost(string, tag="4")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="4")]
+    pub name: ::alloc::string::String,
     /// The field type URL, without the scheme, for message or enumeration
     /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
-    #[prost(string, tag="6")]
-    pub type_url: ::std::string::String,
+    #[prost(string, alloc, tag="6")]
+    pub type_url: ::alloc::string::String,
     /// The index of the field type in `Type.oneofs`, for message or enumeration
     /// types. The first type has index 1; zero means the type is not in the list.
-    #[prost(int32, tag="7")]
+    #[prost(int32, alloc, tag="7")]
     pub oneof_index: i32,
     /// Whether to use alternative packed wire representation.
-    #[prost(bool, tag="8")]
+    #[prost(bool, alloc, tag="8")]
     pub packed: bool,
     /// The protocol buffer options.
-    #[prost(message, repeated, tag="9")]
-    pub options: ::std::vec::Vec<Option>,
+    #[prost(message, repeated, alloc, tag="9")]
+    pub options: ::alloc::vec::Vec<Option>,
     /// The field JSON name.
-    #[prost(string, tag="10")]
-    pub json_name: ::std::string::String,
+    #[prost(string, alloc, tag="10")]
+    pub json_name: ::alloc::string::String,
     /// The string value of the default value of this field. Proto2 syntax only.
-    #[prost(string, tag="11")]
-    pub default_value: ::std::string::String,
+    #[prost(string, alloc, tag="11")]
+    pub default_value: ::alloc::string::String,
 }
 pub mod field {
     /// Basic field types.
@@ -1126,33 +1126,33 @@ pub mod field {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Enum {
     /// Enum type name.
-    #[prost(string, tag="1")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub name: ::alloc::string::String,
     /// Enum value definitions.
-    #[prost(message, repeated, tag="2")]
-    pub enumvalue: ::std::vec::Vec<EnumValue>,
+    #[prost(message, repeated, alloc, tag="2")]
+    pub enumvalue: ::alloc::vec::Vec<EnumValue>,
     /// Protocol buffer options.
-    #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    #[prost(message, repeated, alloc, tag="3")]
+    pub options: ::alloc::vec::Vec<Option>,
     /// The source context.
-    #[prost(message, optional, tag="4")]
+    #[prost(message, optional, alloc, tag="4")]
     pub source_context: ::core::option::Option<SourceContext>,
     /// The source syntax.
-    #[prost(enumeration="Syntax", tag="5")]
+    #[prost(enumeration="Syntax", alloc, tag="5")]
     pub syntax: i32,
 }
 /// Enum value definition.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValue {
     /// Enum value name.
-    #[prost(string, tag="1")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub name: ::alloc::string::String,
     /// Enum value number.
-    #[prost(int32, tag="2")]
+    #[prost(int32, alloc, tag="2")]
     pub number: i32,
     /// Protocol buffer options.
-    #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    #[prost(message, repeated, alloc, tag="3")]
+    pub options: ::alloc::vec::Vec<Option>,
 }
 /// A protocol buffer option, which can be attached to a message, field,
 /// enumeration, etc.
@@ -1162,13 +1162,13 @@ pub struct Option {
     /// descriptor.proto), this is the short name. For example, `"map_entry"`.
     /// For custom options, it should be the fully-qualified name. For example,
     /// `"google.api.http"`.
-    #[prost(string, tag="1")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub name: ::alloc::string::String,
     /// The option's value packed in an Any message. If the value is a primitive,
     /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
     /// should be used. If the value is an enum, it should be stored as an int32
     /// value using the google.protobuf.Int32Value type.
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, alloc, tag="2")]
     pub value: ::core::option::Option<Any>,
 }
 /// The syntax in which a protocol buffer element is defined.
@@ -1193,14 +1193,14 @@ pub enum Syntax {
 pub struct Api {
     /// The fully qualified name of this interface, including package name
     /// followed by the interface's simple name.
-    #[prost(string, tag="1")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub name: ::alloc::string::String,
     /// The methods of this interface, in unspecified order.
-    #[prost(message, repeated, tag="2")]
-    pub methods: ::std::vec::Vec<Method>,
+    #[prost(message, repeated, alloc, tag="2")]
+    pub methods: ::alloc::vec::Vec<Method>,
     /// Any metadata attached to the interface.
-    #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    #[prost(message, repeated, alloc, tag="3")]
+    pub options: ::alloc::vec::Vec<Option>,
     /// A version string for this interface. If specified, must have the form
     /// `major-version.minor-version`, as in `1.10`. If the minor version is
     /// omitted, it defaults to zero. If the entire version field is empty, the
@@ -1222,42 +1222,42 @@ pub struct Api {
     /// experimental, non-GA interfaces.
     ///
     ///
-    #[prost(string, tag="4")]
-    pub version: ::std::string::String,
+    #[prost(string, alloc, tag="4")]
+    pub version: ::alloc::string::String,
     /// Source context for the protocol buffer service represented by this
     /// message.
-    #[prost(message, optional, tag="5")]
+    #[prost(message, optional, alloc, tag="5")]
     pub source_context: ::core::option::Option<SourceContext>,
     /// Included interfaces. See [Mixin][].
-    #[prost(message, repeated, tag="6")]
-    pub mixins: ::std::vec::Vec<Mixin>,
+    #[prost(message, repeated, alloc, tag="6")]
+    pub mixins: ::alloc::vec::Vec<Mixin>,
     /// The source syntax of the service.
-    #[prost(enumeration="Syntax", tag="7")]
+    #[prost(enumeration="Syntax", alloc, tag="7")]
     pub syntax: i32,
 }
 /// Method represents a method of an API interface.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Method {
     /// The simple name of this method.
-    #[prost(string, tag="1")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub name: ::alloc::string::String,
     /// A URL of the input message type.
-    #[prost(string, tag="2")]
-    pub request_type_url: ::std::string::String,
+    #[prost(string, alloc, tag="2")]
+    pub request_type_url: ::alloc::string::String,
     /// If true, the request is streamed.
-    #[prost(bool, tag="3")]
+    #[prost(bool, alloc, tag="3")]
     pub request_streaming: bool,
     /// The URL of the output message type.
-    #[prost(string, tag="4")]
-    pub response_type_url: ::std::string::String,
+    #[prost(string, alloc, tag="4")]
+    pub response_type_url: ::alloc::string::String,
     /// If true, the response is streamed.
-    #[prost(bool, tag="5")]
+    #[prost(bool, alloc, tag="5")]
     pub response_streaming: bool,
     /// Any metadata attached to the method.
-    #[prost(message, repeated, tag="6")]
-    pub options: ::std::vec::Vec<Option>,
+    #[prost(message, repeated, alloc, tag="6")]
+    pub options: ::alloc::vec::Vec<Option>,
     /// The source syntax of this method.
-    #[prost(enumeration="Syntax", tag="7")]
+    #[prost(enumeration="Syntax", alloc, tag="7")]
     pub syntax: i32,
 }
 /// Declares an API Interface to be included in this interface. The including
@@ -1341,12 +1341,12 @@ pub struct Method {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Mixin {
     /// The fully qualified name of the interface which is included.
-    #[prost(string, tag="1")]
-    pub name: ::std::string::String,
+    #[prost(string, alloc, tag="1")]
+    pub name: ::alloc::string::String,
     /// If non-empty specifies a path under which inherited HTTP paths
     /// are rooted.
-    #[prost(string, tag="2")]
-    pub root: ::std::string::String,
+    #[prost(string, alloc, tag="2")]
+    pub root: ::alloc::string::String,
 }
 /// A Duration represents a signed, fixed-length span of time represented
 /// as a count of seconds and fractions of seconds at nanosecond
@@ -1413,7 +1413,7 @@ pub struct Duration {
     /// Signed seconds of the span of time. Must be from -315,576,000,000
     /// to +315,576,000,000 inclusive. Note: these bounds are computed from:
     /// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
-    #[prost(int64, tag="1")]
+    #[prost(int64, alloc, tag="1")]
     pub seconds: i64,
     /// Signed fractions of a second at nanosecond resolution of the span
     /// of time. Durations less than one second are represented with a 0
@@ -1421,7 +1421,7 @@ pub struct Duration {
     /// of one second or more, a non-zero value for the `nanos` field must be
     /// of the same sign as the `seconds` field. Must be from -999,999,999
     /// to +999,999,999 inclusive.
-    #[prost(int32, tag="2")]
+    #[prost(int32, alloc, tag="2")]
     pub nanos: i32,
 }
 /// `FieldMask` represents a set of symbolic field paths, for example:
@@ -1626,8 +1626,8 @@ pub struct Duration {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldMask {
     /// The set of field mask paths.
-    #[prost(string, repeated, tag="1")]
-    pub paths: ::std::vec::Vec<::std::string::String>,
+    #[prost(string, repeated, alloc, tag="1")]
+    pub paths: ::alloc::vec::Vec<::alloc::string::String>,
 }
 /// `Struct` represents a structured data value, consisting of fields
 /// which map to dynamically typed values. In some languages, `Struct`
@@ -1640,8 +1640,8 @@ pub struct FieldMask {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Struct {
     /// Unordered map of dynamically typed values.
-    #[prost(btree_map="string, message", tag="1")]
-    pub fields: ::std::collections::BTreeMap<::std::string::String, Value>,
+    #[prost(btree_map="string, message", alloc, tag="1")]
+    pub fields: ::alloc::collections::BTreeMap<::alloc::string::String, Value>,
 }
 /// `Value` represents a dynamically typed value which can be either
 /// null, a number, a string, a boolean, a recursive struct value, or a
@@ -1652,7 +1652,7 @@ pub struct Struct {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Value {
     /// The kind of value.
-    #[prost(oneof="value::Kind", tags="1, 2, 3, 4, 5, 6")]
+    #[prost(oneof="value::Kind", alloc, tags="1, 2, 3, 4, 5, 6")]
     pub kind: ::core::option::Option<value::Kind>,
 }
 pub mod value {
@@ -1660,22 +1660,22 @@ pub mod value {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum Kind {
         /// Represents a null value.
-        #[prost(enumeration="super::NullValue", tag="1")]
+        #[prost(enumeration="super::NullValue", alloc, tag="1")]
         NullValue(i32),
         /// Represents a double value.
-        #[prost(double, tag="2")]
+        #[prost(double, alloc, tag="2")]
         NumberValue(f64),
         /// Represents a string value.
-        #[prost(string, tag="3")]
-        StringValue(::std::string::String),
+        #[prost(string, alloc, tag="3")]
+        StringValue(::alloc::string::String),
         /// Represents a boolean value.
-        #[prost(bool, tag="4")]
+        #[prost(bool, alloc, tag="4")]
         BoolValue(bool),
         /// Represents a structured value.
-        #[prost(message, tag="5")]
+        #[prost(message, alloc, tag="5")]
         StructValue(super::Struct),
         /// Represents a repeated `Value`.
-        #[prost(message, tag="6")]
+        #[prost(message, alloc, tag="6")]
         ListValue(super::ListValue),
     }
 }
@@ -1685,8 +1685,8 @@ pub mod value {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ListValue {
     /// Repeated field of dynamically typed values.
-    #[prost(message, repeated, tag="1")]
-    pub values: ::std::vec::Vec<Value>,
+    #[prost(message, repeated, alloc, tag="1")]
+    pub values: ::alloc::vec::Vec<Value>,
 }
 /// `NullValue` is a singleton enumeration to represent the null value for the
 /// `Value` type union.
@@ -1787,12 +1787,12 @@ pub struct Timestamp {
     /// Represents seconds of UTC time since Unix epoch
     /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
     /// 9999-12-31T23:59:59Z inclusive.
-    #[prost(int64, tag="1")]
+    #[prost(int64, alloc, tag="1")]
     pub seconds: i64,
     /// Non-negative fractions of a second at nanosecond resolution. Negative
     /// second values with fractions must still have non-negative nanos values
     /// that count forward in time. Must be from 0 to 999,999,999
     /// inclusive.
-    #[prost(int32, tag="2")]
+    #[prost(int32, alloc, tag="2")]
     pub nanos: i32,
 }
diff --git a/tests/src/bootstrap.rs b/tests/src/bootstrap.rs
index e7d725f6d..4ec5b011a 100644
--- a/tests/src/bootstrap.rs
+++ b/tests/src/bootstrap.rs
@@ -21,6 +21,7 @@ fn bootstrap() {
 
     prost_build::Config::new()
         .compile_well_known_types()
+        .use_alloc_collections_lib()
         .btree_map(&["."])
         .out_dir(tempdir.path())
         .compile_protos(

From 4d1e923dd1416c58c6fabad667e918da1f3b0f90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Flemstr=C3=B6m?= <david.flemstrom@gmail.com>
Date: Mon, 24 Feb 2020 15:07:06 +0100
Subject: [PATCH 13/36] Manually map to io::Error in prost-build

---
 prost-build/src/lib.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/prost-build/src/lib.rs b/prost-build/src/lib.rs
index d1abd273d..51188bf52 100644
--- a/prost-build/src/lib.rs
+++ b/prost-build/src/lib.rs
@@ -577,7 +577,10 @@ impl Config {
         }
 
         let buf = fs::read(descriptor_set)?;
-        let descriptor_set = FileDescriptorSet::decode(&buf[..])?;
+        // Manually map error, because in no_std mode, prost::DecodeError will not implement
+        // Into<io::Error>
+        let descriptor_set = FileDescriptorSet::decode(&buf[..])
+            .map_err(|error| Error::new(ErrorKind::InvalidData, format!("{}", error)))?;
 
         let modules = self.generate(descriptor_set.file)?;
         for (module, content) in modules {

From e3015a6a35b10f7e63fc00c46e961d0821ba98ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Flemstr=C3=B6m?= <david.flemstrom@gmail.com>
Date: Mon, 24 Feb 2020 15:07:49 +0100
Subject: [PATCH 14/36] Run cargo fmt

---
 prost-build/src/code_generator.rs | 31 +++++++++++++++++++++----------
 prost-build/src/lib.rs            |  4 ++--
 prost-derive/src/field/map.rs     |  4 ++--
 prost-derive/src/field/oneof.rs   |  4 ++--
 prost-derive/src/field/scalar.rs  | 10 +++++++---
 prost-derive/src/lib.rs           |  2 +-
 src/encoding.rs                   | 13 +++++++++----
 src/lib.rs                        |  1 -
 tests-alloc/src/bin.rs            |  2 +-
 tests-infra/src/lib.rs            |  4 ++--
 10 files changed, 47 insertions(+), 28 deletions(-)

diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index a9e7418db..44586f022 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -419,11 +419,12 @@ impl<'a> CodeGenerator<'a> {
         self.append_doc();
         self.push_indent();
 
-        let btree_map = (self.config.collections_lib != CollectionsLib::Std) || self
-            .config
-            .btree_map
-            .iter()
-            .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
+        let btree_map = (self.config.collections_lib != CollectionsLib::Std)
+            || self
+                .config
+                .btree_map
+                .iter()
+                .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
         let (annotation_ty, rust_ty) = if btree_map {
             ("btree_map", "BTreeMap")
         } else {
@@ -439,7 +440,9 @@ impl<'a> CodeGenerator<'a> {
             value_tag,
             if self.config.collections_lib == CollectionsLib::Alloc {
                 ", alloc"
-            } else { "" },
+            } else {
+                ""
+            },
             field.number()
         ));
         self.append_field_attributes(msg_name, field.name());
@@ -473,7 +476,9 @@ impl<'a> CodeGenerator<'a> {
             name,
             if self.config.collections_lib == CollectionsLib::Alloc {
                 ", alloc"
-            } else { "" },
+            } else {
+                ""
+            },
             fields
                 .iter()
                 .map(|&(ref field, _)| field.number())
@@ -527,7 +532,9 @@ impl<'a> CodeGenerator<'a> {
                 ty_tag,
                 if self.config.collections_lib == CollectionsLib::Alloc {
                     ", alloc"
-                } else { "" },
+                } else {
+                    ""
+                },
                 field.number()
             ));
             self.append_field_attributes(&oneof_name, field.name());
@@ -546,8 +553,12 @@ impl<'a> CodeGenerator<'a> {
             );
 
             if boxed {
-                self.buf
-                    .push_str(&format!("{}({}::boxed::Box<{}>),\n",to_upper_camel(field.name()), self.config.collections_lib.to_str(), ty));
+                self.buf.push_str(&format!(
+                    "{}({}::boxed::Box<{}>),\n",
+                    to_upper_camel(field.name()),
+                    self.config.collections_lib.to_str(),
+                    ty
+                ));
             } else {
                 self.buf
                     .push_str(&format!("{}({}),\n", to_upper_camel(field.name()), ty));
diff --git a/prost-build/src/lib.rs b/prost-build/src/lib.rs
index 51188bf52..617c6425b 100644
--- a/prost-build/src/lib.rs
+++ b/prost-build/src/lib.rs
@@ -189,8 +189,8 @@ pub enum CollectionsLib {
 impl CollectionsLib {
     pub fn to_str(&self) -> &'static str {
         match self {
-            CollectionsLib::Std => { "::std" },
-            CollectionsLib::Alloc => { "::alloc" },
+            CollectionsLib::Std => "::std",
+            CollectionsLib::Alloc => "::alloc",
         }
     }
 }
diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index 3ff6de8e2..e460b388e 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -3,7 +3,7 @@ use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{Ident, Lit, Meta, MetaNameValue, NestedMeta};
 
-use crate::field::{scalar, set_option, tag_attr, collections_lib_name, word_attr, set_bool};
+use crate::field::{collections_lib_name, scalar, set_bool, set_option, tag_attr, word_attr};
 
 #[derive(Clone, Debug)]
 pub enum MapTy {
@@ -58,7 +58,7 @@ impl Field {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
             } else if word_attr("alloc", attr) {
                 set_bool(&mut alloc, "duplicate alloc attributes")?;
-            }else if let Some(map_ty) = attr
+            } else if let Some(map_ty) = attr
                 .path()
                 .get_ident()
                 .and_then(|i| MapTy::from_str(&i.to_string()))
diff --git a/prost-derive/src/field/oneof.rs b/prost-derive/src/field/oneof.rs
index 49ea0cf6a..e993fc9c7 100644
--- a/prost-derive/src/field/oneof.rs
+++ b/prost-derive/src/field/oneof.rs
@@ -3,7 +3,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{parse_str, Lit, Meta, MetaNameValue, NestedMeta, Path};
 
-use crate::field::{set_option, tags_attr, word_attr, set_bool};
+use crate::field::{set_bool, set_option, tags_attr, word_attr};
 
 #[derive(Clone)]
 pub struct Field {
@@ -42,7 +42,7 @@ impl Field {
                 set_option(&mut ty, t, "duplicate oneof attribute")?;
             } else if word_attr("alloc", attr) {
                 set_bool(&mut alloc, "duplicate alloc attributes")?;
-            }  else if let Some(t) = tags_attr(attr)? {
+            } else if let Some(t) = tags_attr(attr)? {
                 set_option(&mut tags, t, "duplicate tags attributes")?;
             } else {
                 unknown_attrs.push(attr);
diff --git a/prost-derive/src/field/scalar.rs b/prost-derive/src/field/scalar.rs
index fecc9e0f9..7d76f3eae 100644
--- a/prost-derive/src/field/scalar.rs
+++ b/prost-derive/src/field/scalar.rs
@@ -1,5 +1,5 @@
-use std::convert::TryFrom;
 use core::fmt;
+use std::convert::TryFrom;
 
 use anyhow::{anyhow, bail, Error};
 use proc_macro2::{Span, TokenStream};
@@ -8,7 +8,9 @@ use syn::{
     self, parse_str, Ident, Lit, LitByteStr, Meta, MetaList, MetaNameValue, NestedMeta, Path,
 };
 
-use crate::field::{bool_attr, set_option, tag_attr, Label, collections_lib_name, set_bool, word_attr};
+use crate::field::{
+    bool_attr, collections_lib_name, set_bool, set_option, tag_attr, word_attr, Label,
+};
 
 /// A scalar protobuf field.
 #[derive(Clone)]
@@ -762,7 +764,9 @@ impl DefaultValue {
                 quote!(::#libname::string::String::new())
             }
             DefaultValue::String(ref value) => quote!(#value.to_owned()),
-            DefaultValue::Bytes(ref value) if value.is_empty() => quote!(::#libname::vec::Vec::new()),
+            DefaultValue::Bytes(ref value) if value.is_empty() => {
+                quote!(::#libname::vec::Vec::new())
+            }
             DefaultValue::Bytes(ref value) => {
                 let lit = LitByteStr::new(value, Span::call_site());
                 quote!(#lit.to_owned())
diff --git a/prost-derive/src/lib.rs b/prost-derive/src/lib.rs
index 39fe379b3..2dce81127 100644
--- a/prost-derive/src/lib.rs
+++ b/prost-derive/src/lib.rs
@@ -2,8 +2,8 @@
 // The `quote!` macro requires deep recursion.
 #![recursion_limit = "4096"]
 
-extern crate proc_macro;
 extern crate alloc;
+extern crate proc_macro;
 
 use anyhow::bail;
 use quote::quote;
diff --git a/src/encoding.rs b/src/encoding.rs
index a3391f512..44869f017 100644
--- a/src/encoding.rs
+++ b/src/encoding.rs
@@ -40,7 +40,7 @@ where
                 *byte = mem::MaybeUninit::new(value as u8);
                 break 'outer;
             } else {
-                *byte =  mem::MaybeUninit::new(((value & 0x7F) | 0x80) as u8);
+                *byte = mem::MaybeUninit::new(((value & 0x7F) | 0x80) as u8);
                 value >>= 7;
             }
         }
@@ -385,7 +385,12 @@ where
     Ok(())
 }
 
-pub fn skip_field<B>(wire_type: WireType, tag: u32, buf: &mut B, ctx: DecodeContext) -> Result<(), DecodeError>
+pub fn skip_field<B>(
+    wire_type: WireType,
+    tag: u32,
+    buf: &mut B,
+    ctx: DecodeContext,
+) -> Result<(), DecodeError>
 where
     B: Buf,
 {
@@ -1275,10 +1280,10 @@ pub mod hash_map {
 }
 
 pub mod btree_map {
-    #[cfg(feature = "std")]
-    use std::collections::BTreeMap;
     #[cfg(not(feature = "std"))]
     use alloc::collections::BTreeMap;
+    #[cfg(feature = "std")]
+    use std::collections::BTreeMap;
     map!(BTreeMap);
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 4528fe33e..9fddf00fb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,4 @@
 #![doc(html_root_url = "https://docs.rs/prost/0.6.1")]
-
 #![no_std]
 
 extern crate alloc;
diff --git a/tests-alloc/src/bin.rs b/tests-alloc/src/bin.rs
index 64c957e33..591732377 100644
--- a/tests-alloc/src/bin.rs
+++ b/tests-alloc/src/bin.rs
@@ -412,5 +412,5 @@ fn main() {
     test_recursive_oneof();
     test_default_enum();
     test_group();
-    test_group_oneof();   
+    test_group_oneof();
 }
diff --git a/tests-infra/src/lib.rs b/tests-infra/src/lib.rs
index d652628fe..4677cd12e 100644
--- a/tests-infra/src/lib.rs
+++ b/tests-infra/src/lib.rs
@@ -2,12 +2,12 @@
 
 extern crate alloc;
 
+use alloc::format;
 use alloc::string::String;
 use alloc::vec::Vec;
-use alloc::format;
 
-use core::default::Default;
 use core::cmp::PartialEq;
+use core::default::Default;
 use core::fmt::Display;
 
 #[macro_use]

From 3939650cf976ae10c924ba7a557992b13d030198 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 12:20:18 -0800
Subject: [PATCH 15/36] Remove "collections_lib_name" and "alloc" config tags

---
 prost-derive/src/field/map.rs    | 17 +++++++++-------
 prost-derive/src/field/mod.rs    | 12 +-----------
 prost-derive/src/field/scalar.rs | 33 ++++++++++++--------------------
 3 files changed, 23 insertions(+), 39 deletions(-)

diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index e460b388e..d89e9bdf9 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -3,7 +3,7 @@ use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{Ident, Lit, Meta, MetaNameValue, NestedMeta};
 
-use crate::field::{collections_lib_name, scalar, set_bool, set_option, tag_attr, word_attr};
+use crate::field::{scalar, set_bool, set_option, tag_attr, word_attr};
 
 #[derive(Clone, Debug)]
 pub enum MapTy {
@@ -34,7 +34,6 @@ fn fake_scalar(ty: scalar::Ty) -> scalar::Field {
         ty,
         kind,
         tag: 0, // Not used here
-        alloc: false,
     }
 }
 
@@ -259,7 +258,7 @@ impl Field {
     /// Returns methods to embed in the message.
     pub fn methods(&self, ident: &Ident) -> Option<TokenStream> {
         if let ValueTy::Scalar(scalar::Ty::Enumeration(ref ty)) = self.value_ty {
-            let key_ty = self.key_ty.rust_type(self.alloc);
+            let key_ty = self.key_ty.rust_type();
             let key_ref_ty = self.key_ty.rust_ref_type();
 
             let get = Ident::new(&format!("get_{}", ident), Span::call_site());
@@ -296,15 +295,19 @@ impl Field {
     /// The Debug tries to convert any enumerations met into the variants if possible, instead of
     /// outputting the raw numbers.
     pub fn debug(&self, wrapper_name: TokenStream) -> TokenStream {
-        let libname = collections_lib_name(self.alloc);
-
         let type_name = match self.map_ty {
             MapTy::HashMap => Ident::new("HashMap", Span::call_site()),
             MapTy::BTreeMap => Ident::new("BTreeMap", Span::call_site()),
         };
+        // HashMap is in std, BTreeMap is in alloc
+        let libname = match self.map_ty {
+            MapTy::HashMap => Ident::new("std", Span::call_site()),
+            MapTy::BTreeMap => Ident::new("alloc", Span::call_site()),
+        };
+
         // A fake field for generating the debug wrapper
         let key_wrapper = fake_scalar(self.key_ty.clone()).debug(quote!(KeyWrapper));
-        let key = self.key_ty.rust_type(self.alloc);
+        let key = self.key_ty.rust_type();
         let value_wrapper = self.value_ty.debug();
         let fmt = quote! {
             fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -319,7 +322,7 @@ impl Field {
         };
         match self.value_ty {
             ValueTy::Scalar(ref ty) => {
-                let value = ty.rust_type(self.alloc);
+                let value = ty.rust_type();
                 quote! {
                     struct #wrapper_name<'a>(&'a ::#libname::collections::#type_name<#key, #value>);
                     impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
diff --git a/prost-derive/src/field/mod.rs b/prost-derive/src/field/mod.rs
index 96d333e7a..1e7818361 100644
--- a/prost-derive/src/field/mod.rs
+++ b/prost-derive/src/field/mod.rs
@@ -8,7 +8,7 @@ use core::fmt;
 use core::slice;
 
 use anyhow::{bail, Error};
-use proc_macro2::{Span, TokenStream};
+use proc_macro2::{TokenStream};
 use quote::quote;
 use syn::{Attribute, Ident, Lit, LitBool, Meta, MetaList, MetaNameValue, NestedMeta};
 
@@ -364,13 +364,3 @@ fn tags_attr(attr: &Meta) -> Result<Option<Vec<u32>>, Error> {
         _ => bail!("invalid tag attribute: {:?}", attr),
     }
 }
-
-// Helper which builds an identifier corresponding `std` or `alloc` depending
-// on feature selection
-fn collections_lib_name(alloc: bool) -> Ident {
-    if alloc {
-        Ident::new("alloc", Span::call_site())
-    } else {
-        Ident::new("std", Span::call_site())
-    }
-}
diff --git a/prost-derive/src/field/scalar.rs b/prost-derive/src/field/scalar.rs
index 7d76f3eae..54549792e 100644
--- a/prost-derive/src/field/scalar.rs
+++ b/prost-derive/src/field/scalar.rs
@@ -9,7 +9,7 @@ use syn::{
 };
 
 use crate::field::{
-    bool_attr, collections_lib_name, set_bool, set_option, tag_attr, word_attr, Label,
+    bool_attr, set_option, tag_attr, Label,
 };
 
 /// A scalar protobuf field.
@@ -18,7 +18,6 @@ pub struct Field {
     pub ty: Ty,
     pub kind: Kind,
     pub tag: u32,
-    pub alloc: bool,
 }
 
 impl Field {
@@ -28,7 +27,6 @@ impl Field {
         let mut packed = None;
         let mut default = None;
         let mut tag = None;
-        let mut alloc = false;
 
         let mut unknown_attrs = Vec::new();
 
@@ -37,8 +35,6 @@ impl Field {
                 set_option(&mut ty, t, "duplicate type attributes")?;
             } else if let Some(p) = bool_attr("packed", attr)? {
                 set_option(&mut packed, p, "duplicate packed attributes")?;
-            } else if word_attr("alloc", attr) {
-                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
             } else if let Some(l) = Label::from_attr(attr) {
@@ -98,7 +94,6 @@ impl Field {
             ty: ty,
             kind: kind,
             tag: tag,
-            alloc: alloc,
         }))
     }
 
@@ -218,11 +213,10 @@ impl Field {
 
     /// Returns an expression which evaluates to the default value of the field.
     pub fn default(&self) -> TokenStream {
-        let libname = collections_lib_name(self.alloc);
         match self.kind {
-            Kind::Plain(ref value) | Kind::Required(ref value) => value.owned(self.alloc),
+            Kind::Plain(ref value) | Kind::Required(ref value) => value.owned(),
             Kind::Optional(_) => quote!(::core::option::Option::None),
-            Kind::Repeated | Kind::Packed => quote!(::#libname::vec::Vec::new()),
+            Kind::Repeated | Kind::Packed => quote!(::alloc::vec::Vec::new()),
         }
     }
 
@@ -250,8 +244,7 @@ impl Field {
     /// Returns a fragment for formatting the field `ident` in `Debug`.
     pub fn debug(&self, wrapper_name: TokenStream) -> TokenStream {
         let wrapper = self.debug_inner(quote!(Inner));
-        let libname = collections_lib_name(self.alloc);
-        let inner_ty = self.ty.rust_type(self.alloc);
+        let inner_ty = self.ty.rust_type();
         match self.kind {
             Kind::Plain(_) | Kind::Required(_) => self.debug_inner(wrapper_name),
             Kind::Optional(_) => quote! {
@@ -265,7 +258,7 @@ impl Field {
             },
             Kind::Repeated | Kind::Packed => {
                 quote! {
-                    struct #wrapper_name<'a>(&'a ::#libname::vec::Vec<#inner_ty>);
+                    struct #wrapper_name<'a>(&'a ::alloc::vec::Vec<#inner_ty>);
                     impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
                         fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                             let mut vec_builder = f.debug_list();
@@ -339,7 +332,7 @@ impl Field {
                         #[doc=#iter_doc]
                         pub fn #ident(&self) -> ::core::iter::FilterMap<
                             ::core::iter::Cloned<::core::slice::Iter<i32>>,
-                            fn(i32) -> ::std::option::Option<#ty>,
+                            fn(i32) -> ::core::option::Option<#ty>,
                         > {
                             self.#ident.iter().cloned().filter_map(#ty::from_i32)
                         }
@@ -504,11 +497,10 @@ impl Ty {
     }
 
     // TODO: rename to 'owned_type'.
-    pub fn rust_type(&self, alloc: bool) -> TokenStream {
-        let libname = collections_lib_name(alloc);
+    pub fn rust_type(&self) -> TokenStream {
         match *self {
-            Ty::String => quote!(::#libname::string::String),
-            Ty::Bytes => quote!(::#libname::vec::Vec<u8>),
+            Ty::String => quote!(::alloc::string::String),
+            Ty::Bytes => quote!(::alloc::vec::Vec<u8>),
             _ => self.rust_ref_type(),
         }
     }
@@ -757,15 +749,14 @@ impl DefaultValue {
         }
     }
 
-    pub fn owned(&self, alloc: bool) -> TokenStream {
-        let libname = collections_lib_name(alloc);
+    pub fn owned(&self) -> TokenStream {
         match *self {
             DefaultValue::String(ref value) if value.is_empty() => {
-                quote!(::#libname::string::String::new())
+                quote!(::alloc::string::String::new())
             }
             DefaultValue::String(ref value) => quote!(#value.to_owned()),
             DefaultValue::Bytes(ref value) if value.is_empty() => {
-                quote!(::#libname::vec::Vec::new())
+                quote!(::alloc::vec::Vec::new())
             }
             DefaultValue::Bytes(ref value) => {
                 let lit = LitByteStr::new(value, Span::call_site());

From d61beeefebf2253ee3c7d2dcf59a36aad22bb285 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 13:33:57 -0800
Subject: [PATCH 16/36] Remove `alloc` proc_macro attributes from prost-types

---
 prost-types/src/protobuf.rs | 366 ++++++++++++++++++------------------
 1 file changed, 183 insertions(+), 183 deletions(-)

diff --git a/prost-types/src/protobuf.rs b/prost-types/src/protobuf.rs
index cfcb8a1b9..df58d42dc 100644
--- a/prost-types/src/protobuf.rs
+++ b/prost-types/src/protobuf.rs
@@ -2,86 +2,86 @@
 /// files it parses.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorSet {
-    #[prost(message, repeated, alloc, tag="1")]
+    #[prost(message, repeated, tag="1")]
     pub file: ::alloc::vec::Vec<FileDescriptorProto>,
 }
 /// Describes a complete .proto file.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorProto {
     /// file name, relative to root of source tree
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
     /// e.g. "foo", "foo.bar", etc.
-    #[prost(string, optional, alloc, tag="2")]
+    #[prost(string, optional, tag="2")]
     pub package: ::core::option::Option<::alloc::string::String>,
     /// Names of files imported by this file.
-    #[prost(string, repeated, alloc, tag="3")]
+    #[prost(string, repeated, tag="3")]
     pub dependency: ::alloc::vec::Vec<::alloc::string::String>,
     /// Indexes of the public imported files in the dependency list above.
-    #[prost(int32, repeated, packed="false", alloc, tag="10")]
+    #[prost(int32, repeated, packed="false", tag="10")]
     pub public_dependency: ::alloc::vec::Vec<i32>,
     /// Indexes of the weak imported files in the dependency list.
     /// For Google-internal migration only. Do not use.
-    #[prost(int32, repeated, packed="false", alloc, tag="11")]
+    #[prost(int32, repeated, packed="false", tag="11")]
     pub weak_dependency: ::alloc::vec::Vec<i32>,
     /// All top-level definitions in this file.
-    #[prost(message, repeated, alloc, tag="4")]
+    #[prost(message, repeated, tag="4")]
     pub message_type: ::alloc::vec::Vec<DescriptorProto>,
-    #[prost(message, repeated, alloc, tag="5")]
+    #[prost(message, repeated, tag="5")]
     pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
-    #[prost(message, repeated, alloc, tag="6")]
+    #[prost(message, repeated, tag="6")]
     pub service: ::alloc::vec::Vec<ServiceDescriptorProto>,
-    #[prost(message, repeated, alloc, tag="7")]
+    #[prost(message, repeated, tag="7")]
     pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
-    #[prost(message, optional, alloc, tag="8")]
+    #[prost(message, optional, tag="8")]
     pub options: ::core::option::Option<FileOptions>,
     /// This field contains optional information about the original source code.
     /// You may safely remove this entire field without harming runtime
     /// functionality of the descriptors -- the information is needed only by
     /// development tools.
-    #[prost(message, optional, alloc, tag="9")]
+    #[prost(message, optional, tag="9")]
     pub source_code_info: ::core::option::Option<SourceCodeInfo>,
     /// The syntax of the proto file.
     /// The supported values are "proto2" and "proto3".
-    #[prost(string, optional, alloc, tag="12")]
+    #[prost(string, optional, tag="12")]
     pub syntax: ::core::option::Option<::alloc::string::String>,
 }
 /// Describes a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DescriptorProto {
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
-    #[prost(message, repeated, alloc, tag="2")]
+    #[prost(message, repeated, tag="2")]
     pub field: ::alloc::vec::Vec<FieldDescriptorProto>,
-    #[prost(message, repeated, alloc, tag="6")]
+    #[prost(message, repeated, tag="6")]
     pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
-    #[prost(message, repeated, alloc, tag="3")]
+    #[prost(message, repeated, tag="3")]
     pub nested_type: ::alloc::vec::Vec<DescriptorProto>,
-    #[prost(message, repeated, alloc, tag="4")]
+    #[prost(message, repeated, tag="4")]
     pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
-    #[prost(message, repeated, alloc, tag="5")]
+    #[prost(message, repeated, tag="5")]
     pub extension_range: ::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
-    #[prost(message, repeated, alloc, tag="8")]
+    #[prost(message, repeated, tag="8")]
     pub oneof_decl: ::alloc::vec::Vec<OneofDescriptorProto>,
-    #[prost(message, optional, alloc, tag="7")]
+    #[prost(message, optional, tag="7")]
     pub options: ::core::option::Option<MessageOptions>,
-    #[prost(message, repeated, alloc, tag="9")]
+    #[prost(message, repeated, tag="9")]
     pub reserved_range: ::alloc::vec::Vec<descriptor_proto::ReservedRange>,
     /// Reserved field names, which may not be used by fields in the same message.
     /// A given name may only be reserved once.
-    #[prost(string, repeated, alloc, tag="10")]
+    #[prost(string, repeated, tag="10")]
     pub reserved_name: ::alloc::vec::Vec<::alloc::string::String>,
 }
 pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct ExtensionRange {
         /// Inclusive.
-        #[prost(int32, optional, alloc, tag="1")]
+        #[prost(int32, optional, tag="1")]
         pub start: ::core::option::Option<i32>,
         /// Exclusive.
-        #[prost(int32, optional, alloc, tag="2")]
+        #[prost(int32, optional, tag="2")]
         pub end: ::core::option::Option<i32>,
-        #[prost(message, optional, alloc, tag="3")]
+        #[prost(message, optional, tag="3")]
         pub options: ::core::option::Option<super::ExtensionRangeOptions>,
     }
     /// Range of reserved tag numbers. Reserved tag numbers may not be used by
@@ -90,61 +90,61 @@ pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct ReservedRange {
         /// Inclusive.
-        #[prost(int32, optional, alloc, tag="1")]
+        #[prost(int32, optional, tag="1")]
         pub start: ::core::option::Option<i32>,
         /// Exclusive.
-        #[prost(int32, optional, alloc, tag="2")]
+        #[prost(int32, optional, tag="2")]
         pub end: ::core::option::Option<i32>,
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ExtensionRangeOptions {
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 /// Describes a field within a message.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldDescriptorProto {
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
-    #[prost(int32, optional, alloc, tag="3")]
+    #[prost(int32, optional, tag="3")]
     pub number: ::core::option::Option<i32>,
-    #[prost(enumeration="field_descriptor_proto::Label", optional, alloc, tag="4")]
+    #[prost(enumeration="field_descriptor_proto::Label", optional, tag="4")]
     pub label: ::core::option::Option<i32>,
     /// If type_name is set, this need not be set.  If both this and type_name
     /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
-    #[prost(enumeration="field_descriptor_proto::Type", optional, alloc, tag="5")]
+    #[prost(enumeration="field_descriptor_proto::Type", optional, tag="5")]
     pub r#type: ::core::option::Option<i32>,
     /// For message and enum types, this is the name of the type.  If the name
     /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
     /// rules are used to find the type (i.e. first the nested types within this
     /// message are searched, then within the parent, on up to the root
     /// namespace).
-    #[prost(string, optional, alloc, tag="6")]
+    #[prost(string, optional, tag="6")]
     pub type_name: ::core::option::Option<::alloc::string::String>,
     /// For extensions, this is the name of the type being extended.  It is
     /// resolved in the same manner as type_name.
-    #[prost(string, optional, alloc, tag="2")]
+    #[prost(string, optional, tag="2")]
     pub extendee: ::core::option::Option<::alloc::string::String>,
     /// For numeric types, contains the original text representation of the value.
     /// For booleans, "true" or "false".
     /// For strings, contains the default text contents (not escaped in any way).
     /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
     /// TODO(kenton):  Base-64 encode?
-    #[prost(string, optional, alloc, tag="7")]
+    #[prost(string, optional, tag="7")]
     pub default_value: ::core::option::Option<::alloc::string::String>,
     /// If set, gives the index of a oneof in the containing type's oneof_decl
     /// list.  This field is a member of that oneof.
-    #[prost(int32, optional, alloc, tag="9")]
+    #[prost(int32, optional, tag="9")]
     pub oneof_index: ::core::option::Option<i32>,
     /// JSON name of this field. The value is set by protocol compiler. If the
     /// user has set a "json_name" option on this field, that option's value
     /// will be used. Otherwise, it's deduced from the field's name by converting
     /// it to camelCase.
-    #[prost(string, optional, alloc, tag="10")]
+    #[prost(string, optional, tag="10")]
     pub json_name: ::core::option::Option<::alloc::string::String>,
-    #[prost(message, optional, alloc, tag="8")]
+    #[prost(message, optional, tag="8")]
     pub options: ::core::option::Option<FieldOptions>,
 }
 pub mod field_descriptor_proto {
@@ -196,28 +196,28 @@ pub mod field_descriptor_proto {
 /// Describes a oneof.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofDescriptorProto {
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
-    #[prost(message, optional, alloc, tag="2")]
+    #[prost(message, optional, tag="2")]
     pub options: ::core::option::Option<OneofOptions>,
 }
 /// Describes an enum type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumDescriptorProto {
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
-    #[prost(message, repeated, alloc, tag="2")]
+    #[prost(message, repeated, tag="2")]
     pub value: ::alloc::vec::Vec<EnumValueDescriptorProto>,
-    #[prost(message, optional, alloc, tag="3")]
+    #[prost(message, optional, tag="3")]
     pub options: ::core::option::Option<EnumOptions>,
     /// Range of reserved numeric values. Reserved numeric values may not be used
     /// by enum values in the same enum declaration. Reserved ranges may not
     /// overlap.
-    #[prost(message, repeated, alloc, tag="4")]
+    #[prost(message, repeated, tag="4")]
     pub reserved_range: ::alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
     /// Reserved enum value names, which may not be reused. A given name may only
     /// be reserved once.
-    #[prost(string, repeated, alloc, tag="5")]
+    #[prost(string, repeated, tag="5")]
     pub reserved_name: ::alloc::vec::Vec<::alloc::string::String>,
 }
 pub mod enum_descriptor_proto {
@@ -230,51 +230,51 @@ pub mod enum_descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct EnumReservedRange {
         /// Inclusive.
-        #[prost(int32, optional, alloc, tag="1")]
+        #[prost(int32, optional, tag="1")]
         pub start: ::core::option::Option<i32>,
         /// Inclusive.
-        #[prost(int32, optional, alloc, tag="2")]
+        #[prost(int32, optional, tag="2")]
         pub end: ::core::option::Option<i32>,
     }
 }
 /// Describes a value within an enum.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueDescriptorProto {
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
-    #[prost(int32, optional, alloc, tag="2")]
+    #[prost(int32, optional, tag="2")]
     pub number: ::core::option::Option<i32>,
-    #[prost(message, optional, alloc, tag="3")]
+    #[prost(message, optional, tag="3")]
     pub options: ::core::option::Option<EnumValueOptions>,
 }
 /// Describes a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceDescriptorProto {
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
-    #[prost(message, repeated, alloc, tag="2")]
+    #[prost(message, repeated, tag="2")]
     pub method: ::alloc::vec::Vec<MethodDescriptorProto>,
-    #[prost(message, optional, alloc, tag="3")]
+    #[prost(message, optional, tag="3")]
     pub options: ::core::option::Option<ServiceOptions>,
 }
 /// Describes a method of a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodDescriptorProto {
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub name: ::core::option::Option<::alloc::string::String>,
     /// Input and output type names.  These are resolved in the same way as
     /// FieldDescriptorProto.type_name, but must refer to a message type.
-    #[prost(string, optional, alloc, tag="2")]
+    #[prost(string, optional, tag="2")]
     pub input_type: ::core::option::Option<::alloc::string::String>,
-    #[prost(string, optional, alloc, tag="3")]
+    #[prost(string, optional, tag="3")]
     pub output_type: ::core::option::Option<::alloc::string::String>,
-    #[prost(message, optional, alloc, tag="4")]
+    #[prost(message, optional, tag="4")]
     pub options: ::core::option::Option<MethodOptions>,
     /// Identifies if client streams multiple client messages
-    #[prost(bool, optional, alloc, tag="5", default="false")]
+    #[prost(bool, optional, tag="5", default="false")]
     pub client_streaming: ::core::option::Option<bool>,
     /// Identifies if server streams multiple server messages
-    #[prost(bool, optional, alloc, tag="6", default="false")]
+    #[prost(bool, optional, tag="6", default="false")]
     pub server_streaming: ::core::option::Option<bool>,
 }
 // ===================================================================
@@ -315,14 +315,14 @@ pub struct FileOptions {
     /// placed.  By default, the proto package is used, but this is often
     /// inappropriate because proto packages do not normally start with backwards
     /// domain names.
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub java_package: ::core::option::Option<::alloc::string::String>,
     /// If set, all the classes from the .proto file are wrapped in a single
     /// outer class with the given name.  This applies to both Proto1
     /// (equivalent to the old "--one_java_file" option) and Proto2 (where
     /// a .proto always translates to a single class, but you may want to
     /// explicitly choose the class name).
-    #[prost(string, optional, alloc, tag="8")]
+    #[prost(string, optional, tag="8")]
     pub java_outer_classname: ::core::option::Option<::alloc::string::String>,
     /// If set true, then the Java code generator will generate a separate .java
     /// file for each top-level message, enum, and service defined in the .proto
@@ -330,11 +330,11 @@ pub struct FileOptions {
     /// named by java_outer_classname.  However, the outer class will still be
     /// generated to contain the file's getDescriptor() method as well as any
     /// top-level extensions defined in the file.
-    #[prost(bool, optional, alloc, tag="10", default="false")]
+    #[prost(bool, optional, tag="10", default="false")]
     pub java_multiple_files: ::core::option::Option<bool>,
     /// This option does nothing.
     #[deprecated]
-    #[prost(bool, optional, alloc, tag="20")]
+    #[prost(bool, optional, tag="20")]
     pub java_generate_equals_and_hash: ::core::option::Option<bool>,
     /// If set true, then the Java2 code generator will generate code that
     /// throws an exception whenever an attempt is made to assign a non-UTF-8
@@ -342,16 +342,16 @@ pub struct FileOptions {
     /// Message reflection will do the same.
     /// However, an extension field still accepts non-UTF-8 byte sequences.
     /// This option has no effect on when used with the lite runtime.
-    #[prost(bool, optional, alloc, tag="27", default="false")]
+    #[prost(bool, optional, tag="27", default="false")]
     pub java_string_check_utf8: ::core::option::Option<bool>,
-    #[prost(enumeration="file_options::OptimizeMode", optional, alloc, tag="9", default="Speed")]
+    #[prost(enumeration="file_options::OptimizeMode", optional, tag="9", default="Speed")]
     pub optimize_for: ::core::option::Option<i32>,
     /// Sets the Go package where structs generated from this .proto will be
     /// placed. If omitted, the Go package will be derived from the following:
     ///   - The basename of the package import path, if provided.
     ///   - Otherwise, the package statement in the .proto file, if present.
     ///   - Otherwise, the basename of the .proto file, without extension.
-    #[prost(string, optional, alloc, tag="11")]
+    #[prost(string, optional, tag="11")]
     pub go_package: ::core::option::Option<::alloc::string::String>,
     /// Should generic services be generated in each language?  "Generic" services
     /// are not specific to any particular RPC system.  They are generated by the
@@ -363,59 +363,59 @@ pub struct FileOptions {
     /// that generate code specific to your particular RPC system.  Therefore,
     /// these default to false.  Old code which depends on generic services should
     /// explicitly set them to true.
-    #[prost(bool, optional, alloc, tag="16", default="false")]
+    #[prost(bool, optional, tag="16", default="false")]
     pub cc_generic_services: ::core::option::Option<bool>,
-    #[prost(bool, optional, alloc, tag="17", default="false")]
+    #[prost(bool, optional, tag="17", default="false")]
     pub java_generic_services: ::core::option::Option<bool>,
-    #[prost(bool, optional, alloc, tag="18", default="false")]
+    #[prost(bool, optional, tag="18", default="false")]
     pub py_generic_services: ::core::option::Option<bool>,
-    #[prost(bool, optional, alloc, tag="42", default="false")]
+    #[prost(bool, optional, tag="42", default="false")]
     pub php_generic_services: ::core::option::Option<bool>,
     /// Is this file deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for everything in the file, or it will be completely ignored; in the very
     /// least, this is a formalization for deprecating files.
-    #[prost(bool, optional, alloc, tag="23", default="false")]
+    #[prost(bool, optional, tag="23", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// Enables the use of arenas for the proto messages in this file. This applies
     /// only to generated classes for C++.
-    #[prost(bool, optional, alloc, tag="31", default="false")]
+    #[prost(bool, optional, tag="31", default="false")]
     pub cc_enable_arenas: ::core::option::Option<bool>,
     /// Sets the objective c class prefix which is prepended to all objective c
     /// generated classes from this .proto. There is no default.
-    #[prost(string, optional, alloc, tag="36")]
+    #[prost(string, optional, tag="36")]
     pub objc_class_prefix: ::core::option::Option<::alloc::string::String>,
     /// Namespace for generated classes; defaults to the package.
-    #[prost(string, optional, alloc, tag="37")]
+    #[prost(string, optional, tag="37")]
     pub csharp_namespace: ::core::option::Option<::alloc::string::String>,
     /// By default Swift generators will take the proto package and CamelCase it
     /// replacing '.' with underscore and use that to prefix the types/symbols
     /// defined. When this options is provided, they will use this value instead
     /// to prefix the types/symbols defined.
-    #[prost(string, optional, alloc, tag="39")]
+    #[prost(string, optional, tag="39")]
     pub swift_prefix: ::core::option::Option<::alloc::string::String>,
     /// Sets the php class prefix which is prepended to all php generated classes
     /// from this .proto. Default is empty.
-    #[prost(string, optional, alloc, tag="40")]
+    #[prost(string, optional, tag="40")]
     pub php_class_prefix: ::core::option::Option<::alloc::string::String>,
     /// Use this option to change the namespace of php generated classes. Default
     /// is empty. When this option is empty, the package name will be used for
     /// determining the namespace.
-    #[prost(string, optional, alloc, tag="41")]
+    #[prost(string, optional, tag="41")]
     pub php_namespace: ::core::option::Option<::alloc::string::String>,
     /// Use this option to change the namespace of php generated metadata classes.
     /// Default is empty. When this option is empty, the proto file name will be
     /// used for determining the namespace.
-    #[prost(string, optional, alloc, tag="44")]
+    #[prost(string, optional, tag="44")]
     pub php_metadata_namespace: ::core::option::Option<::alloc::string::String>,
     /// Use this option to change the package of ruby generated classes. Default
     /// is empty. When this option is not set, the package name will be used for
     /// determining the ruby package.
-    #[prost(string, optional, alloc, tag="45")]
+    #[prost(string, optional, tag="45")]
     pub ruby_package: ::core::option::Option<::alloc::string::String>,
     /// The parser stores options it doesn't recognize here.
     /// See the documentation for the "Options" section above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod file_options {
@@ -453,18 +453,18 @@ pub struct MessageOptions {
     ///
     /// Because this is an option, the above two restrictions are not enforced by
     /// the protocol compiler.
-    #[prost(bool, optional, alloc, tag="1", default="false")]
+    #[prost(bool, optional, tag="1", default="false")]
     pub message_set_wire_format: ::core::option::Option<bool>,
     /// Disables the generation of the standard "descriptor()" accessor, which can
     /// conflict with a field of the same name.  This is meant to make migration
     /// from proto1 easier; new code should avoid fields named "descriptor".
-    #[prost(bool, optional, alloc, tag="2", default="false")]
+    #[prost(bool, optional, tag="2", default="false")]
     pub no_standard_descriptor_accessor: ::core::option::Option<bool>,
     /// Is this message deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the message, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating messages.
-    #[prost(bool, optional, alloc, tag="3", default="false")]
+    #[prost(bool, optional, tag="3", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// Whether the message is an automatically generated map entry type for the
     /// maps field.
@@ -487,10 +487,10 @@ pub struct MessageOptions {
     /// NOTE: Do not set the option in .proto files. Always use the maps syntax
     /// instead. The option should only be implicitly set by the proto compiler
     /// parser.
-    #[prost(bool, optional, alloc, tag="7")]
+    #[prost(bool, optional, tag="7")]
     pub map_entry: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -499,14 +499,14 @@ pub struct FieldOptions {
     /// representation of the field than it normally would.  See the specific
     /// options below.  This option is not yet implemented in the open source
     /// release -- sorry, we'll try to include it in a future version!
-    #[prost(enumeration="field_options::CType", optional, alloc, tag="1", default="String")]
+    #[prost(enumeration="field_options::CType", optional, tag="1", default="String")]
     pub ctype: ::core::option::Option<i32>,
     /// The packed option can be enabled for repeated primitive fields to enable
     /// a more efficient representation on the wire. Rather than repeatedly
     /// writing the tag and type for each element, the entire array is encoded as
     /// a single length-delimited blob. In proto3, only explicit setting it to
     /// false will avoid using packed encoding.
-    #[prost(bool, optional, alloc, tag="2")]
+    #[prost(bool, optional, tag="2")]
     pub packed: ::core::option::Option<bool>,
     /// The jstype option determines the JavaScript type used for values of the
     /// field.  The option is permitted only for 64 bit integral and fixed types
@@ -519,7 +519,7 @@ pub struct FieldOptions {
     ///
     /// This option is an enum to permit additional types to be added, e.g.
     /// goog.math.Integer.
-    #[prost(enumeration="field_options::JsType", optional, alloc, tag="6", default="JsNormal")]
+    #[prost(enumeration="field_options::JsType", optional, tag="6", default="JsNormal")]
     pub jstype: ::core::option::Option<i32>,
     /// Should this field be parsed lazily?  Lazy applies only to message-type
     /// fields.  It means that when the outer message is initially parsed, the
@@ -549,19 +549,19 @@ pub struct FieldOptions {
     /// implementation must either *always* check its required fields, or *never*
     /// check its required fields, regardless of whether or not the message has
     /// been parsed.
-    #[prost(bool, optional, alloc, tag="5", default="false")]
+    #[prost(bool, optional, tag="5", default="false")]
     pub lazy: ::core::option::Option<bool>,
     /// Is this field deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for accessors, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating fields.
-    #[prost(bool, optional, alloc, tag="3", default="false")]
+    #[prost(bool, optional, tag="3", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// For Google-internal migration only. Do not use.
-    #[prost(bool, optional, alloc, tag="10", default="false")]
+    #[prost(bool, optional, tag="10", default="false")]
     pub weak: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod field_options {
@@ -587,23 +587,23 @@ pub mod field_options {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofOptions {
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumOptions {
     /// Set this option to true to allow mapping different tag names to the same
     /// value.
-    #[prost(bool, optional, alloc, tag="2")]
+    #[prost(bool, optional, tag="2")]
     pub allow_alias: ::core::option::Option<bool>,
     /// Is this enum deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the enum, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating enums.
-    #[prost(bool, optional, alloc, tag="3", default="false")]
+    #[prost(bool, optional, tag="3", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -612,10 +612,10 @@ pub struct EnumValueOptions {
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the enum value, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating enum values.
-    #[prost(bool, optional, alloc, tag="1", default="false")]
+    #[prost(bool, optional, tag="1", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -629,10 +629,10 @@ pub struct ServiceOptions {
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the service, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating services.
-    #[prost(bool, optional, alloc, tag="33", default="false")]
+    #[prost(bool, optional, tag="33", default="false")]
     pub deprecated: ::core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -646,12 +646,12 @@ pub struct MethodOptions {
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the method, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating methods.
-    #[prost(bool, optional, alloc, tag="33", default="false")]
+    #[prost(bool, optional, tag="33", default="false")]
     pub deprecated: ::core::option::Option<bool>,
-    #[prost(enumeration="method_options::IdempotencyLevel", optional, alloc, tag="34", default="IdempotencyUnknown")]
+    #[prost(enumeration="method_options::IdempotencyLevel", optional, tag="34", default="IdempotencyUnknown")]
     pub idempotency_level: ::core::option::Option<i32>,
     /// The parser stores options it doesn't recognize here. See above.
-    #[prost(message, repeated, alloc, tag="999")]
+    #[prost(message, repeated, tag="999")]
     pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod method_options {
@@ -676,21 +676,21 @@ pub mod method_options {
 /// in them.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UninterpretedOption {
-    #[prost(message, repeated, alloc, tag="2")]
+    #[prost(message, repeated, tag="2")]
     pub name: ::alloc::vec::Vec<uninterpreted_option::NamePart>,
     /// The value of the uninterpreted option, in whatever type the tokenizer
     /// identified it as during parsing. Exactly one of these should be set.
-    #[prost(string, optional, alloc, tag="3")]
+    #[prost(string, optional, tag="3")]
     pub identifier_value: ::core::option::Option<::alloc::string::String>,
-    #[prost(uint64, optional, alloc, tag="4")]
+    #[prost(uint64, optional, tag="4")]
     pub positive_int_value: ::core::option::Option<u64>,
-    #[prost(int64, optional, alloc, tag="5")]
+    #[prost(int64, optional, tag="5")]
     pub negative_int_value: ::core::option::Option<i64>,
-    #[prost(double, optional, alloc, tag="6")]
+    #[prost(double, optional, tag="6")]
     pub double_value: ::core::option::Option<f64>,
-    #[prost(bytes, optional, alloc, tag="7")]
+    #[prost(bytes, optional, tag="7")]
     pub string_value: ::core::option::Option<::alloc::vec::Vec<u8>>,
-    #[prost(string, optional, alloc, tag="8")]
+    #[prost(string, optional, tag="8")]
     pub aggregate_value: ::core::option::Option<::alloc::string::String>,
 }
 pub mod uninterpreted_option {
@@ -701,9 +701,9 @@ pub mod uninterpreted_option {
     /// "foo.(bar.baz).qux".
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NamePart {
-        #[prost(string, required, alloc, tag="1")]
+        #[prost(string, required, tag="1")]
         pub name_part: ::alloc::string::String,
-        #[prost(bool, required, alloc, tag="2")]
+        #[prost(bool, required, tag="2")]
         pub is_extension: bool,
     }
 }
@@ -757,7 +757,7 @@ pub struct SourceCodeInfo {
     /// - Code which tries to interpret locations should probably be designed to
     ///   ignore those that it doesn't understand, as more types of locations could
     ///   be recorded in the future.
-    #[prost(message, repeated, alloc, tag="1")]
+    #[prost(message, repeated, tag="1")]
     pub location: ::alloc::vec::Vec<source_code_info::Location>,
 }
 pub mod source_code_info {
@@ -786,14 +786,14 @@ pub mod source_code_info {
         ///   [ 4, 3, 2, 7 ]
         /// this path refers to the whole field declaration (from the beginning
         /// of the label to the terminating semicolon).
-        #[prost(int32, repeated, alloc, tag="1")]
+        #[prost(int32, repeated, tag="1")]
         pub path: ::alloc::vec::Vec<i32>,
         /// Always has exactly three or four elements: start line, start column,
         /// end line (optional, otherwise assumed same as start line), end column.
         /// These are packed into a single field for efficiency.  Note that line
         /// and column numbers are zero-based -- typically you will want to add
         /// 1 to each before displaying to a user.
-        #[prost(int32, repeated, alloc, tag="2")]
+        #[prost(int32, repeated, tag="2")]
         pub span: ::alloc::vec::Vec<i32>,
         /// If this SourceCodeInfo represents a complete declaration, these are any
         /// comments appearing before and after the declaration which appear to be
@@ -842,11 +842,11 @@ pub mod source_code_info {
         ///   optional int32 grault = 6;
         ///
         ///   // ignored detached comments.
-        #[prost(string, optional, alloc, tag="3")]
+        #[prost(string, optional, tag="3")]
         pub leading_comments: ::core::option::Option<::alloc::string::String>,
-        #[prost(string, optional, alloc, tag="4")]
+        #[prost(string, optional, tag="4")]
         pub trailing_comments: ::core::option::Option<::alloc::string::String>,
-        #[prost(string, repeated, alloc, tag="6")]
+        #[prost(string, repeated, tag="6")]
         pub leading_detached_comments: ::alloc::vec::Vec<::alloc::string::String>,
     }
 }
@@ -857,7 +857,7 @@ pub mod source_code_info {
 pub struct GeneratedCodeInfo {
     /// An Annotation connects some span of text in generated code to an element
     /// of its generating .proto file.
-    #[prost(message, repeated, alloc, tag="1")]
+    #[prost(message, repeated, tag="1")]
     pub annotation: ::alloc::vec::Vec<generated_code_info::Annotation>,
 }
 pub mod generated_code_info {
@@ -865,19 +865,19 @@ pub mod generated_code_info {
     pub struct Annotation {
         /// Identifies the element in the original source .proto file. This field
         /// is formatted the same as SourceCodeInfo.Location.path.
-        #[prost(int32, repeated, alloc, tag="1")]
+        #[prost(int32, repeated, tag="1")]
         pub path: ::alloc::vec::Vec<i32>,
         /// Identifies the filesystem path to the original source .proto.
-        #[prost(string, optional, alloc, tag="2")]
+        #[prost(string, optional, tag="2")]
         pub source_file: ::core::option::Option<::alloc::string::String>,
         /// Identifies the starting offset in bytes in the generated code
         /// that relates to the identified object.
-        #[prost(int32, optional, alloc, tag="3")]
+        #[prost(int32, optional, tag="3")]
         pub begin: ::core::option::Option<i32>,
         /// Identifies the ending offset in bytes in the generated code that
         /// relates to the identified offset. The end offset should be one past
         /// the last relevant byte (so the length of the text = end - begin).
-        #[prost(int32, optional, alloc, tag="4")]
+        #[prost(int32, optional, tag="4")]
         pub end: ::core::option::Option<i32>,
     }
 }
@@ -991,10 +991,10 @@ pub struct Any {
     /// Schemes other than `http`, `https` (or the empty scheme) might be
     /// used with implementation specific semantics.
     ///
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub type_url: ::alloc::string::String,
     /// Must be a valid serialized protocol buffer of the above specified type.
-    #[prost(bytes, alloc, tag="2")]
+    #[prost(bytes, tag="2")]
     pub value: ::alloc::vec::Vec<u8>,
 }
 /// `SourceContext` represents information about the source of a
@@ -1003,65 +1003,65 @@ pub struct Any {
 pub struct SourceContext {
     /// The path-qualified name of the .proto file that contained the associated
     /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub file_name: ::alloc::string::String,
 }
 /// A protocol buffer message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Type {
     /// The fully qualified message name.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub name: ::alloc::string::String,
     /// The list of fields.
-    #[prost(message, repeated, alloc, tag="2")]
+    #[prost(message, repeated, tag="2")]
     pub fields: ::alloc::vec::Vec<Field>,
     /// The list of types appearing in `oneof` definitions in this type.
-    #[prost(string, repeated, alloc, tag="3")]
+    #[prost(string, repeated, tag="3")]
     pub oneofs: ::alloc::vec::Vec<::alloc::string::String>,
     /// The protocol buffer options.
-    #[prost(message, repeated, alloc, tag="4")]
+    #[prost(message, repeated, tag="4")]
     pub options: ::alloc::vec::Vec<Option>,
     /// The source context.
-    #[prost(message, optional, alloc, tag="5")]
+    #[prost(message, optional, tag="5")]
     pub source_context: ::core::option::Option<SourceContext>,
     /// The source syntax.
-    #[prost(enumeration="Syntax", alloc, tag="6")]
+    #[prost(enumeration="Syntax", tag="6")]
     pub syntax: i32,
 }
 /// A single field of a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Field {
     /// The field type.
-    #[prost(enumeration="field::Kind", alloc, tag="1")]
+    #[prost(enumeration="field::Kind", tag="1")]
     pub kind: i32,
     /// The field cardinality.
-    #[prost(enumeration="field::Cardinality", alloc, tag="2")]
+    #[prost(enumeration="field::Cardinality", tag="2")]
     pub cardinality: i32,
     /// The field number.
-    #[prost(int32, alloc, tag="3")]
+    #[prost(int32, tag="3")]
     pub number: i32,
     /// The field name.
-    #[prost(string, alloc, tag="4")]
+    #[prost(string, tag="4")]
     pub name: ::alloc::string::String,
     /// The field type URL, without the scheme, for message or enumeration
     /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
-    #[prost(string, alloc, tag="6")]
+    #[prost(string, tag="6")]
     pub type_url: ::alloc::string::String,
     /// The index of the field type in `Type.oneofs`, for message or enumeration
     /// types. The first type has index 1; zero means the type is not in the list.
-    #[prost(int32, alloc, tag="7")]
+    #[prost(int32, tag="7")]
     pub oneof_index: i32,
     /// Whether to use alternative packed wire representation.
-    #[prost(bool, alloc, tag="8")]
+    #[prost(bool, tag="8")]
     pub packed: bool,
     /// The protocol buffer options.
-    #[prost(message, repeated, alloc, tag="9")]
+    #[prost(message, repeated, tag="9")]
     pub options: ::alloc::vec::Vec<Option>,
     /// The field JSON name.
-    #[prost(string, alloc, tag="10")]
+    #[prost(string, tag="10")]
     pub json_name: ::alloc::string::String,
     /// The string value of the default value of this field. Proto2 syntax only.
-    #[prost(string, alloc, tag="11")]
+    #[prost(string, tag="11")]
     pub default_value: ::alloc::string::String,
 }
 pub mod field {
@@ -1126,32 +1126,32 @@ pub mod field {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Enum {
     /// Enum type name.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub name: ::alloc::string::String,
     /// Enum value definitions.
-    #[prost(message, repeated, alloc, tag="2")]
+    #[prost(message, repeated, tag="2")]
     pub enumvalue: ::alloc::vec::Vec<EnumValue>,
     /// Protocol buffer options.
-    #[prost(message, repeated, alloc, tag="3")]
+    #[prost(message, repeated, tag="3")]
     pub options: ::alloc::vec::Vec<Option>,
     /// The source context.
-    #[prost(message, optional, alloc, tag="4")]
+    #[prost(message, optional, tag="4")]
     pub source_context: ::core::option::Option<SourceContext>,
     /// The source syntax.
-    #[prost(enumeration="Syntax", alloc, tag="5")]
+    #[prost(enumeration="Syntax", tag="5")]
     pub syntax: i32,
 }
 /// Enum value definition.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValue {
     /// Enum value name.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub name: ::alloc::string::String,
     /// Enum value number.
-    #[prost(int32, alloc, tag="2")]
+    #[prost(int32, tag="2")]
     pub number: i32,
     /// Protocol buffer options.
-    #[prost(message, repeated, alloc, tag="3")]
+    #[prost(message, repeated, tag="3")]
     pub options: ::alloc::vec::Vec<Option>,
 }
 /// A protocol buffer option, which can be attached to a message, field,
@@ -1162,13 +1162,13 @@ pub struct Option {
     /// descriptor.proto), this is the short name. For example, `"map_entry"`.
     /// For custom options, it should be the fully-qualified name. For example,
     /// `"google.api.http"`.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub name: ::alloc::string::String,
     /// The option's value packed in an Any message. If the value is a primitive,
     /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
     /// should be used. If the value is an enum, it should be stored as an int32
     /// value using the google.protobuf.Int32Value type.
-    #[prost(message, optional, alloc, tag="2")]
+    #[prost(message, optional, tag="2")]
     pub value: ::core::option::Option<Any>,
 }
 /// The syntax in which a protocol buffer element is defined.
@@ -1193,13 +1193,13 @@ pub enum Syntax {
 pub struct Api {
     /// The fully qualified name of this interface, including package name
     /// followed by the interface's simple name.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub name: ::alloc::string::String,
     /// The methods of this interface, in unspecified order.
-    #[prost(message, repeated, alloc, tag="2")]
+    #[prost(message, repeated, tag="2")]
     pub methods: ::alloc::vec::Vec<Method>,
     /// Any metadata attached to the interface.
-    #[prost(message, repeated, alloc, tag="3")]
+    #[prost(message, repeated, tag="3")]
     pub options: ::alloc::vec::Vec<Option>,
     /// A version string for this interface. If specified, must have the form
     /// `major-version.minor-version`, as in `1.10`. If the minor version is
@@ -1222,42 +1222,42 @@ pub struct Api {
     /// experimental, non-GA interfaces.
     ///
     ///
-    #[prost(string, alloc, tag="4")]
+    #[prost(string, tag="4")]
     pub version: ::alloc::string::String,
     /// Source context for the protocol buffer service represented by this
     /// message.
-    #[prost(message, optional, alloc, tag="5")]
+    #[prost(message, optional, tag="5")]
     pub source_context: ::core::option::Option<SourceContext>,
     /// Included interfaces. See [Mixin][].
-    #[prost(message, repeated, alloc, tag="6")]
+    #[prost(message, repeated, tag="6")]
     pub mixins: ::alloc::vec::Vec<Mixin>,
     /// The source syntax of the service.
-    #[prost(enumeration="Syntax", alloc, tag="7")]
+    #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
 }
 /// Method represents a method of an API interface.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Method {
     /// The simple name of this method.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub name: ::alloc::string::String,
     /// A URL of the input message type.
-    #[prost(string, alloc, tag="2")]
+    #[prost(string, tag="2")]
     pub request_type_url: ::alloc::string::String,
     /// If true, the request is streamed.
-    #[prost(bool, alloc, tag="3")]
+    #[prost(bool, tag="3")]
     pub request_streaming: bool,
     /// The URL of the output message type.
-    #[prost(string, alloc, tag="4")]
+    #[prost(string, tag="4")]
     pub response_type_url: ::alloc::string::String,
     /// If true, the response is streamed.
-    #[prost(bool, alloc, tag="5")]
+    #[prost(bool, tag="5")]
     pub response_streaming: bool,
     /// Any metadata attached to the method.
-    #[prost(message, repeated, alloc, tag="6")]
+    #[prost(message, repeated, tag="6")]
     pub options: ::alloc::vec::Vec<Option>,
     /// The source syntax of this method.
-    #[prost(enumeration="Syntax", alloc, tag="7")]
+    #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
 }
 /// Declares an API Interface to be included in this interface. The including
@@ -1341,11 +1341,11 @@ pub struct Method {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Mixin {
     /// The fully qualified name of the interface which is included.
-    #[prost(string, alloc, tag="1")]
+    #[prost(string, tag="1")]
     pub name: ::alloc::string::String,
     /// If non-empty specifies a path under which inherited HTTP paths
     /// are rooted.
-    #[prost(string, alloc, tag="2")]
+    #[prost(string, tag="2")]
     pub root: ::alloc::string::String,
 }
 /// A Duration represents a signed, fixed-length span of time represented
@@ -1413,7 +1413,7 @@ pub struct Duration {
     /// Signed seconds of the span of time. Must be from -315,576,000,000
     /// to +315,576,000,000 inclusive. Note: these bounds are computed from:
     /// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
-    #[prost(int64, alloc, tag="1")]
+    #[prost(int64, tag="1")]
     pub seconds: i64,
     /// Signed fractions of a second at nanosecond resolution of the span
     /// of time. Durations less than one second are represented with a 0
@@ -1421,7 +1421,7 @@ pub struct Duration {
     /// of one second or more, a non-zero value for the `nanos` field must be
     /// of the same sign as the `seconds` field. Must be from -999,999,999
     /// to +999,999,999 inclusive.
-    #[prost(int32, alloc, tag="2")]
+    #[prost(int32, tag="2")]
     pub nanos: i32,
 }
 /// `FieldMask` represents a set of symbolic field paths, for example:
@@ -1626,7 +1626,7 @@ pub struct Duration {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldMask {
     /// The set of field mask paths.
-    #[prost(string, repeated, alloc, tag="1")]
+    #[prost(string, repeated, tag="1")]
     pub paths: ::alloc::vec::Vec<::alloc::string::String>,
 }
 /// `Struct` represents a structured data value, consisting of fields
@@ -1640,7 +1640,7 @@ pub struct FieldMask {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Struct {
     /// Unordered map of dynamically typed values.
-    #[prost(btree_map="string, message", alloc, tag="1")]
+    #[prost(btree_map="string, message", tag="1")]
     pub fields: ::alloc::collections::BTreeMap<::alloc::string::String, Value>,
 }
 /// `Value` represents a dynamically typed value which can be either
@@ -1652,7 +1652,7 @@ pub struct Struct {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Value {
     /// The kind of value.
-    #[prost(oneof="value::Kind", alloc, tags="1, 2, 3, 4, 5, 6")]
+    #[prost(oneof="value::Kind", tags="1, 2, 3, 4, 5, 6")]
     pub kind: ::core::option::Option<value::Kind>,
 }
 pub mod value {
@@ -1660,22 +1660,22 @@ pub mod value {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum Kind {
         /// Represents a null value.
-        #[prost(enumeration="super::NullValue", alloc, tag="1")]
+        #[prost(enumeration="super::NullValue", tag="1")]
         NullValue(i32),
         /// Represents a double value.
-        #[prost(double, alloc, tag="2")]
+        #[prost(double, tag="2")]
         NumberValue(f64),
         /// Represents a string value.
-        #[prost(string, alloc, tag="3")]
+        #[prost(string, tag="3")]
         StringValue(::alloc::string::String),
         /// Represents a boolean value.
-        #[prost(bool, alloc, tag="4")]
+        #[prost(bool, tag="4")]
         BoolValue(bool),
         /// Represents a structured value.
-        #[prost(message, alloc, tag="5")]
+        #[prost(message, tag="5")]
         StructValue(super::Struct),
         /// Represents a repeated `Value`.
-        #[prost(message, alloc, tag="6")]
+        #[prost(message, tag="6")]
         ListValue(super::ListValue),
     }
 }
@@ -1685,7 +1685,7 @@ pub mod value {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ListValue {
     /// Repeated field of dynamically typed values.
-    #[prost(message, repeated, alloc, tag="1")]
+    #[prost(message, repeated, tag="1")]
     pub values: ::alloc::vec::Vec<Value>,
 }
 /// `NullValue` is a singleton enumeration to represent the null value for the
@@ -1787,12 +1787,12 @@ pub struct Timestamp {
     /// Represents seconds of UTC time since Unix epoch
     /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
     /// 9999-12-31T23:59:59Z inclusive.
-    #[prost(int64, alloc, tag="1")]
+    #[prost(int64, tag="1")]
     pub seconds: i64,
     /// Non-negative fractions of a second at nanosecond resolution. Negative
     /// second values with fractions must still have non-negative nanos values
     /// that count forward in time. Must be from 0 to 999,999,999
     /// inclusive.
-    #[prost(int32, alloc, tag="2")]
+    #[prost(int32, tag="2")]
     pub nanos: i32,
 }

From 2d77d5f9f73801dfd8f832ebcda2ec62a78a6f6d Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 13:46:21 -0800
Subject: [PATCH 17/36] more fixes in prost-types

---
 prost-types/src/compiler.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/prost-types/src/compiler.rs b/prost-types/src/compiler.rs
index 7276a2891..8ab83e837 100644
--- a/prost-types/src/compiler.rs
+++ b/prost-types/src/compiler.rs
@@ -1,15 +1,15 @@
 /// The version number of protocol compiler.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Version {
-    #[prost(int32, optional, alloc, tag="1")]
+    #[prost(int32, optional, tag="1")]
     pub major: ::core::option::Option<i32>,
-    #[prost(int32, optional, alloc, tag="2")]
+    #[prost(int32, optional, tag="2")]
     pub minor: ::core::option::Option<i32>,
-    #[prost(int32, optional, alloc, tag="3")]
+    #[prost(int32, optional, tag="3")]
     pub patch: ::core::option::Option<i32>,
     /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     /// be empty for mainline stable releases.
-    #[prost(string, optional, alloc, tag="4")]
+    #[prost(string, optional, tag="4")]
     pub suffix: ::core::option::Option<::alloc::string::String>,
 }
 /// An encoded CodeGeneratorRequest is written to the plugin's stdin.
@@ -18,10 +18,10 @@ pub struct CodeGeneratorRequest {
     /// The .proto files that were explicitly listed on the command-line.  The
     /// code generator should generate code only for these files.  Each file's
     /// descriptor will be included in proto_file, below.
-    #[prost(string, repeated, alloc, tag="1")]
+    #[prost(string, repeated, tag="1")]
     pub file_to_generate: ::alloc::vec::Vec<::alloc::string::String>,
     /// The generator parameter passed on the command-line.
-    #[prost(string, optional, alloc, tag="2")]
+    #[prost(string, optional, tag="2")]
     pub parameter: ::core::option::Option<::alloc::string::String>,
     /// FileDescriptorProtos for all files in files_to_generate and everything
     /// they import.  The files will appear in topological order, so each file
@@ -37,10 +37,10 @@ pub struct CodeGeneratorRequest {
     ///
     /// Type names of fields and extensions in the FileDescriptorProto are always
     /// fully qualified.
-    #[prost(message, repeated, alloc, tag="15")]
+    #[prost(message, repeated, tag="15")]
     pub proto_file: ::alloc::vec::Vec<super::FileDescriptorProto>,
     /// The version number of protocol compiler.
-    #[prost(message, optional, alloc, tag="3")]
+    #[prost(message, optional, tag="3")]
     pub compiler_version: ::core::option::Option<Version>,
 }
 /// The plugin writes an encoded CodeGeneratorResponse to stdout.
@@ -54,9 +54,9 @@ pub struct CodeGeneratorResponse {
     /// problem in protoc itself -- such as the input CodeGeneratorRequest being
     /// unparseable -- should be reported by writing a message to stderr and
     /// exiting with a non-zero status code.
-    #[prost(string, optional, alloc, tag="1")]
+    #[prost(string, optional, tag="1")]
     pub error: ::core::option::Option<::alloc::string::String>,
-    #[prost(message, repeated, alloc, tag="15")]
+    #[prost(message, repeated, tag="15")]
     pub file: ::alloc::vec::Vec<code_generator_response::File>,
 }
 pub mod code_generator_response {
@@ -74,7 +74,7 @@ pub mod code_generator_response {
         /// files need not reside completely in memory at one time.  Note that as of
         /// this writing protoc does not optimize for this -- it will read the entire
         /// CodeGeneratorResponse before writing files to disk.
-        #[prost(string, optional, alloc, tag="1")]
+        #[prost(string, optional, tag="1")]
         pub name: ::core::option::Option<::alloc::string::String>,
         /// If non-empty, indicates that the named file should already exist, and the
         /// content here is to be inserted into that file at a defined insertion
@@ -113,10 +113,10 @@ pub mod code_generator_response {
         /// command line.
         ///
         /// If |insertion_point| is present, |name| must also be present.
-        #[prost(string, optional, alloc, tag="2")]
+        #[prost(string, optional, tag="2")]
         pub insertion_point: ::core::option::Option<::alloc::string::String>,
         /// The file contents.
-        #[prost(string, optional, alloc, tag="15")]
+        #[prost(string, optional, tag="15")]
         pub content: ::core::option::Option<::alloc::string::String>,
     }
 }

From 64af5737b270f2cb44b58d7fee64d8704fa32477 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 13:50:39 -0800
Subject: [PATCH 18/36] more fixes in prost-derive

---
 prost-derive/src/field/group.rs   | 3 ---
 prost-derive/src/field/map.rs     | 7 +------
 prost-derive/src/field/message.rs | 3 ---
 prost-derive/src/field/oneof.rs   | 5 +----
 4 files changed, 2 insertions(+), 16 deletions(-)

diff --git a/prost-derive/src/field/group.rs b/prost-derive/src/field/group.rs
index 870b1629b..b72100d9f 100644
--- a/prost-derive/src/field/group.rs
+++ b/prost-derive/src/field/group.rs
@@ -17,7 +17,6 @@ impl Field {
         let mut label = None;
         let mut tag = None;
         let mut boxed = false;
-        let mut alloc = false;
 
         let mut unknown_attrs = Vec::new();
 
@@ -26,8 +25,6 @@ impl Field {
                 set_bool(&mut group, "duplicate group attributes")?;
             } else if word_attr("boxed", attr) {
                 set_bool(&mut boxed, "duplicate boxed attributes")?;
-            } else if word_attr("alloc", attr) {
-                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
             } else if let Some(l) = Label::from_attr(attr) {
diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index d89e9bdf9..d130498c3 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -3,7 +3,7 @@ use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{Ident, Lit, Meta, MetaNameValue, NestedMeta};
 
-use crate::field::{scalar, set_bool, set_option, tag_attr, word_attr};
+use crate::field::{scalar, set_option, tag_attr};
 
 #[derive(Clone, Debug)]
 pub enum MapTy {
@@ -43,20 +43,16 @@ pub struct Field {
     pub key_ty: scalar::Ty,
     pub value_ty: ValueTy,
     pub tag: u32,
-    pub alloc: bool,
 }
 
 impl Field {
     pub fn new(attrs: &[Meta], inferred_tag: Option<u32>) -> Result<Option<Field>, Error> {
         let mut types = None;
         let mut tag = None;
-        let mut alloc = false;
 
         for attr in attrs {
             if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
-            } else if word_attr("alloc", attr) {
-                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(map_ty) = attr
                 .path()
                 .get_ident()
@@ -116,7 +112,6 @@ impl Field {
                 key_ty: key_ty,
                 value_ty: val_ty,
                 tag: tag,
-                alloc: alloc,
             }),
             _ => None,
         })
diff --git a/prost-derive/src/field/message.rs b/prost-derive/src/field/message.rs
index 9d4737dd7..4f98f473f 100644
--- a/prost-derive/src/field/message.rs
+++ b/prost-derive/src/field/message.rs
@@ -17,7 +17,6 @@ impl Field {
         let mut label = None;
         let mut tag = None;
         let mut boxed = false;
-        let mut alloc = false;
 
         let mut unknown_attrs = Vec::new();
 
@@ -26,8 +25,6 @@ impl Field {
                 set_bool(&mut message, "duplicate message attribute")?;
             } else if word_attr("boxed", attr) {
                 set_bool(&mut boxed, "duplicate boxed attribute")?;
-            } else if word_attr("alloc", attr) {
-                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(t) = tag_attr(attr)? {
                 set_option(&mut tag, t, "duplicate tag attributes")?;
             } else if let Some(l) = Label::from_attr(attr) {
diff --git a/prost-derive/src/field/oneof.rs b/prost-derive/src/field/oneof.rs
index e993fc9c7..364c1c9f7 100644
--- a/prost-derive/src/field/oneof.rs
+++ b/prost-derive/src/field/oneof.rs
@@ -3,7 +3,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{parse_str, Lit, Meta, MetaNameValue, NestedMeta, Path};
 
-use crate::field::{set_bool, set_option, tags_attr, word_attr};
+use crate::field::{set_option, tags_attr};
 
 #[derive(Clone)]
 pub struct Field {
@@ -16,7 +16,6 @@ impl Field {
         let mut ty = None;
         let mut tags = None;
         let mut unknown_attrs = Vec::new();
-        let mut alloc = false;
 
         for attr in attrs {
             if attr.path().is_ident("oneof") {
@@ -40,8 +39,6 @@ impl Field {
                     _ => bail!("invalid oneof attribute: {:?}", attr),
                 };
                 set_option(&mut ty, t, "duplicate oneof attribute")?;
-            } else if word_attr("alloc", attr) {
-                set_bool(&mut alloc, "duplicate alloc attributes")?;
             } else if let Some(t) = tags_attr(attr)? {
                 set_option(&mut tags, t, "duplicate tags attributes")?;
             } else {

From fa0a5edac2a03296e7f292349a6df663c2047798 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 14:53:02 -0800
Subject: [PATCH 19/36] Make prost-build not insert `, alloc` proc-macro
 attributes

Leaves the "use_alloc_collections_lib" stuff because that helps
people who don't want to write BTreeMap everywhere. But maybe it
should go also, and they should have to do that.
---
 prost-build/src/code_generator.rs | 25 +++----------------------
 1 file changed, 3 insertions(+), 22 deletions(-)

diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index 44586f022..6649a2507 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -332,10 +332,6 @@ impl<'a> CodeGenerator<'a> {
             self.buf.push_str(", boxed");
         }
 
-        if self.config.collections_lib == CollectionsLib::Alloc {
-            self.buf.push_str(", alloc");
-        }
-
         self.buf.push_str(", tag=\"");
         self.buf.push_str(&field.number().to_string());
 
@@ -434,15 +430,10 @@ impl<'a> CodeGenerator<'a> {
         let key_tag = self.field_type_tag(key);
         let value_tag = self.map_value_type_tag(value);
         self.buf.push_str(&format!(
-            "#[prost({}=\"{}, {}\"{}, tag=\"{}\")]\n",
+            "#[prost({}=\"{}, {}\", tag=\"{}\")]\n",
             annotation_ty,
             key_tag,
             value_tag,
-            if self.config.collections_lib == CollectionsLib::Alloc {
-                ", alloc"
-            } else {
-                ""
-            },
             field.number()
         ));
         self.append_field_attributes(msg_name, field.name());
@@ -472,13 +463,8 @@ impl<'a> CodeGenerator<'a> {
         self.append_doc();
         self.push_indent();
         self.buf.push_str(&format!(
-            "#[prost(oneof=\"{}\"{}, tags=\"{}\")]\n",
+            "#[prost(oneof=\"{}\", tags=\"{}\")]\n",
             name,
-            if self.config.collections_lib == CollectionsLib::Alloc {
-                ", alloc"
-            } else {
-                ""
-            },
             fields
                 .iter()
                 .map(|&(ref field, _)| field.number())
@@ -528,13 +514,8 @@ impl<'a> CodeGenerator<'a> {
             self.push_indent();
             let ty_tag = self.field_type_tag(&field);
             self.buf.push_str(&format!(
-                "#[prost({}{}, tag=\"{}\")]\n",
+                "#[prost({}, tag=\"{}\")]\n",
                 ty_tag,
-                if self.config.collections_lib == CollectionsLib::Alloc {
-                    ", alloc"
-                } else {
-                    ""
-                },
                 field.number()
             ));
             self.append_field_attributes(&oneof_name, field.name());

From 51e453925527453beb9a6c152bdb42999ffadb2c Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 15:49:25 -0800
Subject: [PATCH 20/36] Remove code comments, which I think are from bad merge
 resolution

---
 src/message.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index d1ad7a98e..e6acae713 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -92,8 +92,6 @@ pub trait Message: Debug + Send + Sync {
     }
 
     /// Decodes a length-delimited instance of the message from the buffer.
-    ///
-    /// The entire buffer will be consumed.
     fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>
     where
         B: Buf,
@@ -122,8 +120,6 @@ pub trait Message: Debug + Send + Sync {
 
     /// Decodes a length-delimited instance of the message from buffer, and
     /// merges it into `self`.
-    ///
-    /// The entire buffer will be consumed.
     fn merge_length_delimited<B>(&mut self, mut buf: B) -> Result<(), DecodeError>
     where
         B: Buf,

From db72894135f4e208aefcef97ee43de673ef396ad Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 16:33:05 -0800
Subject: [PATCH 21/36] Remove "CollectionsLib" from prost-build, but leave
 "force_btree_map"

This option is helpful if someone needs to make the code-gen be
no_std compatible, otherwise they have to enumerate all the btree types
in their build.rs which is onerous
---
 prost-build/src/code_generator.rs | 28 +++++++++------------
 prost-build/src/lib.rs            | 41 ++++++++-----------------------
 tests-alloc/src/build.rs          |  9 ++-----
 3 files changed, 24 insertions(+), 54 deletions(-)

diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index 6649a2507..55a7200db 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -18,7 +18,6 @@ use crate::ast::{Comments, Method, Service};
 use crate::extern_paths::ExternPaths;
 use crate::ident::{match_ident, to_snake, to_upper_camel};
 use crate::message_graph::MessageGraph;
-use crate::CollectionsLib;
 use crate::Config;
 
 #[derive(PartialEq)]
@@ -376,14 +375,12 @@ impl<'a> CodeGenerator<'a> {
         self.buf.push_str(&to_snake(field.name()));
         self.buf.push_str(": ");
         if repeated {
-            self.buf.push_str(self.config.collections_lib.to_str());
-            self.buf.push_str("::vec::Vec<");
+            self.buf.push_str("::alloc::vec::Vec<");
         } else if optional {
             self.buf.push_str("::core::option::Option<");
         }
         if boxed {
-            self.buf.push_str(self.config.collections_lib.to_str());
-            self.buf.push_str("::boxed::Box<");
+            self.buf.push_str("::alloc::boxed::Box<");
         }
         self.buf.push_str(&ty);
         if boxed {
@@ -415,16 +412,16 @@ impl<'a> CodeGenerator<'a> {
         self.append_doc();
         self.push_indent();
 
-        let btree_map = (self.config.collections_lib != CollectionsLib::Std)
-            || self
+        let btree_map = self.config.force_btree_map ||
+            self
                 .config
                 .btree_map
                 .iter()
                 .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
-        let (annotation_ty, rust_ty) = if btree_map {
-            ("btree_map", "BTreeMap")
+        let (annotation_ty, lib_name, rust_ty) = if btree_map {
+            ("btree_map", "::alloc::collections", "BTreeMap")
         } else {
-            ("map", "HashMap")
+            ("map", "::std::collections", "HashMap")
         };
 
         let key_tag = self.field_type_tag(key);
@@ -439,9 +436,9 @@ impl<'a> CodeGenerator<'a> {
         self.append_field_attributes(msg_name, field.name());
         self.push_indent();
         self.buf.push_str(&format!(
-            "pub {}: {}::collections::{}<{}, {}>,\n",
+            "pub {}: {}::{}<{}, {}>,\n",
             to_snake(field.name()),
-            self.config.collections_lib.to_str(),
+            lib_name,
             rust_ty,
             key_ty,
             value_ty
@@ -535,9 +532,8 @@ impl<'a> CodeGenerator<'a> {
 
             if boxed {
                 self.buf.push_str(&format!(
-                    "{}({}::boxed::Box<{}>),\n",
+                    "{}(::alloc::boxed::Box<{}>),\n",
                     to_upper_camel(field.name()),
-                    self.config.collections_lib.to_str(),
                     ty
                 ));
             } else {
@@ -731,8 +727,8 @@ impl<'a> CodeGenerator<'a> {
             Type::Int32 | Type::Sfixed32 | Type::Sint32 | Type::Enum => String::from("i32"),
             Type::Int64 | Type::Sfixed64 | Type::Sint64 => String::from("i64"),
             Type::Bool => String::from("bool"),
-            Type::String => format!("{}::string::String", self.config.collections_lib.to_str()),
-            Type::Bytes => format!("{}::vec::Vec<u8>", self.config.collections_lib.to_str()),
+            Type::String => String::from("::alloc::string::String"),
+            Type::Bytes => String::from("::alloc::vec::Vec<u8>"),
             Type::Group | Type::Message => self.resolve_ident(field.type_name()),
         }
     }
diff --git a/prost-build/src/lib.rs b/prost-build/src/lib.rs
index 617c6425b..a19f92966 100644
--- a/prost-build/src/lib.rs
+++ b/prost-build/src/lib.rs
@@ -175,32 +175,12 @@ pub trait ServiceGenerator {
     fn finalize_package(&mut self, _package: &str, _buf: &mut String) {}
 }
 
-/// Configuration enum for whether to use `std` prefixes or `alloc` prefixes in generated code
-///
-/// This option also forces Btree everywhere, overriding the BtreeMap options,
-/// since HashMap is not in alloc::collections, only std (it requires randomness)
-///
-#[derive(PartialEq)]
-pub enum CollectionsLib {
-    Std,
-    Alloc,
-}
-
-impl CollectionsLib {
-    pub fn to_str(&self) -> &'static str {
-        match self {
-            CollectionsLib::Std => "::std",
-            CollectionsLib::Alloc => "::alloc",
-        }
-    }
-}
-
 /// Configuration options for Protobuf code generation.
 ///
 /// This configuration builder can be used to set non-default code generation options.
 pub struct Config {
     service_generator: Option<Box<dyn ServiceGenerator>>,
-    collections_lib: CollectionsLib,
+    force_btree_map: bool,
     btree_map: Vec<String>,
     type_attributes: Vec<(String, String)>,
     field_attributes: Vec<(String, String)>,
@@ -273,6 +253,14 @@ impl Config {
         self
     }
 
+    /// Configure the code generator to use btree_map for all protobuf map types
+    /// and never HashMap. This is useful if the generated code must be no_std.
+    pub fn force_btree_map(&mut self) -> &mut Self {
+        self.force_btree_map = true;
+        self
+    }
+
+
     /// Add additional attribute to matched fields.
     ///
     /// # Arguments
@@ -491,15 +479,6 @@ impl Config {
         self
     }
 
-    /// Configure the code generator to use the `::alloc` namespace rather than `::std`, and Btree everywhere
-    /// rather than `std`.
-    ///
-    /// This allows generated code to be used in a `#![no_std]` crate
-    pub fn use_alloc_collections_lib(&mut self) -> &mut Self {
-        self.collections_lib = CollectionsLib::Alloc;
-        self
-    }
-
     /// Configures the output directory where generated Rust files will be written.
     ///
     /// If unset, defaults to the `OUT_DIR` environment variable. `OUT_DIR` is set by Cargo when
@@ -649,7 +628,7 @@ impl default::Default for Config {
     fn default() -> Config {
         Config {
             service_generator: None,
-            collections_lib: CollectionsLib::Std,
+            force_btree_map: true,
             btree_map: Vec::new(),
             type_attributes: Vec::new(),
             field_attributes: Vec::new(),
diff --git a/tests-alloc/src/build.rs b/tests-alloc/src/build.rs
index c8e39abb9..97815e454 100644
--- a/tests-alloc/src/build.rs
+++ b/tests-alloc/src/build.rs
@@ -14,13 +14,8 @@ fn main() {
 
     let mut config = prost_build::Config::new();
 
-    // Generate BTreeMap fields for all messages. This forces encoded output to be consistent, so
-    // that encode/decode roundtrips can use encoded output for comparison. Otherwise trying to
-    // compare based on the Rust PartialEq implementations is difficult, due to presence of NaN
-    // values.
-    //
-    // Note nostd collections implies Btree everywhere anyways
-    config.use_alloc_collections_lib();
+    // Force btree_map everywhere for no_std compat
+    config.force_btree_map();
 
     // Tests for custom attributes
     config.type_attribute("Foo.Bar_Baz.Foo_barBaz", "#[derive(Eq, PartialOrd, Ord)]");

From abe20052da7cc0e504f667f7b2c1be9beb1aec1e Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 16:39:49 -0800
Subject: [PATCH 22/36] Simplifications in prost crate itself

---
 Cargo.toml      | 2 --
 src/encoding.rs | 3 ---
 2 files changed, 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index a3ee0b30d..01bcf4900 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,8 +41,6 @@ default = ["prost-derive", "std"]
 no-recursion-limit = []
 std = []
    # When std is disabled, we attempt to provide no_std support in prost
-   # Config::use_alloc_collections() should be set when using prost_build in your build.rs
-   # so that generated files will not have std:: either, and will use alloc crate instead
 
 [dependencies]
 bytes = { version = "0.5", default-features = false }
diff --git a/src/encoding.rs b/src/encoding.rs
index 44869f017..86169ae51 100644
--- a/src/encoding.rs
+++ b/src/encoding.rs
@@ -1280,10 +1280,7 @@ pub mod hash_map {
 }
 
 pub mod btree_map {
-    #[cfg(not(feature = "std"))]
     use alloc::collections::BTreeMap;
-    #[cfg(feature = "std")]
-    use std::collections::BTreeMap;
     map!(BTreeMap);
 }
 

From f2a241d41d69657414f8713aa6f04cec56ebacdc Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 16:40:44 -0800
Subject: [PATCH 23/36] fixup in tests

---
 tests/src/bootstrap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/src/bootstrap.rs b/tests/src/bootstrap.rs
index 4ec5b011a..61f19164a 100644
--- a/tests/src/bootstrap.rs
+++ b/tests/src/bootstrap.rs
@@ -21,7 +21,7 @@ fn bootstrap() {
 
     prost_build::Config::new()
         .compile_well_known_types()
-        .use_alloc_collections_lib()
+        .force_btree_map()
         .btree_map(&["."])
         .out_dir(tempdir.path())
         .compile_protos(

From 4d7bf10d0590e5a0e8a175c3b15b1e027afc4f97 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 22:29:28 -0800
Subject: [PATCH 24/36] address many review comments

---
 Cargo.toml                        |  4 +---
 prost-build/src/code_generator.rs | 11 +++++------
 prost-build/src/lib.rs            | 10 ----------
 prost-derive/src/field/mod.rs     |  2 +-
 prost-derive/src/field/scalar.rs  |  6 ++----
 src/encoding.rs                   |  4 ++--
 src/lib.rs                        |  6 +-----
 tests/src/build.rs                |  3 +--
 8 files changed, 13 insertions(+), 33 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 01bcf4900..1de0432ea 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,8 +39,7 @@ bench = false
 [features]
 default = ["prost-derive", "std"]
 no-recursion-limit = []
-std = []
-   # When std is disabled, we attempt to provide no_std support in prost
+std = [] # When std is disabled, we provide no_std support in prost
 
 [dependencies]
 bytes = { version = "0.5", default-features = false }
@@ -49,7 +48,6 @@ prost-derive = { version = "0.6.1", path = "prost-derive", default-features = fa
 [dev-dependencies]
 criterion = "0.3"
 env_logger = { version = "0.7", default-features = false }
-failure = { version = "0.1", default-features = false }
 log = "0.4"
 quickcheck = "0.9"
 rand = "0.7"
diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index 55a7200db..36112f428 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -412,12 +412,11 @@ impl<'a> CodeGenerator<'a> {
         self.append_doc();
         self.push_indent();
 
-        let btree_map = self.config.force_btree_map ||
-            self
-                .config
-                .btree_map
-                .iter()
-                .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
+        let btree_map = self
+            .config
+            .btree_map
+            .iter()
+            .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
         let (annotation_ty, lib_name, rust_ty) = if btree_map {
             ("btree_map", "::alloc::collections", "BTreeMap")
         } else {
diff --git a/prost-build/src/lib.rs b/prost-build/src/lib.rs
index a19f92966..73a4a9c84 100644
--- a/prost-build/src/lib.rs
+++ b/prost-build/src/lib.rs
@@ -180,7 +180,6 @@ pub trait ServiceGenerator {
 /// This configuration builder can be used to set non-default code generation options.
 pub struct Config {
     service_generator: Option<Box<dyn ServiceGenerator>>,
-    force_btree_map: bool,
     btree_map: Vec<String>,
     type_attributes: Vec<(String, String)>,
     field_attributes: Vec<(String, String)>,
@@ -253,14 +252,6 @@ impl Config {
         self
     }
 
-    /// Configure the code generator to use btree_map for all protobuf map types
-    /// and never HashMap. This is useful if the generated code must be no_std.
-    pub fn force_btree_map(&mut self) -> &mut Self {
-        self.force_btree_map = true;
-        self
-    }
-
-
     /// Add additional attribute to matched fields.
     ///
     /// # Arguments
@@ -628,7 +619,6 @@ impl default::Default for Config {
     fn default() -> Config {
         Config {
             service_generator: None,
-            force_btree_map: true,
             btree_map: Vec::new(),
             type_attributes: Vec::new(),
             field_attributes: Vec::new(),
diff --git a/prost-derive/src/field/mod.rs b/prost-derive/src/field/mod.rs
index 1e7818361..df0afbd20 100644
--- a/prost-derive/src/field/mod.rs
+++ b/prost-derive/src/field/mod.rs
@@ -8,7 +8,7 @@ use core::fmt;
 use core::slice;
 
 use anyhow::{bail, Error};
-use proc_macro2::{TokenStream};
+use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{Attribute, Ident, Lit, LitBool, Meta, MetaList, MetaNameValue, NestedMeta};
 
diff --git a/prost-derive/src/field/scalar.rs b/prost-derive/src/field/scalar.rs
index 54549792e..55deaafa7 100644
--- a/prost-derive/src/field/scalar.rs
+++ b/prost-derive/src/field/scalar.rs
@@ -1,5 +1,5 @@
-use core::fmt;
 use std::convert::TryFrom;
+use std::fmt;
 
 use anyhow::{anyhow, bail, Error};
 use proc_macro2::{Span, TokenStream};
@@ -8,9 +8,7 @@ use syn::{
     self, parse_str, Ident, Lit, LitByteStr, Meta, MetaList, MetaNameValue, NestedMeta, Path,
 };
 
-use crate::field::{
-    bool_attr, set_option, tag_attr, Label,
-};
+use crate::field::{bool_attr, set_option, tag_attr, Label};
 
 /// A scalar protobuf field.
 #[derive(Clone)]
diff --git a/src/encoding.rs b/src/encoding.rs
index 86169ae51..7510f33e0 100644
--- a/src/encoding.rs
+++ b/src/encoding.rs
@@ -1375,7 +1375,7 @@ mod test {
             &mut buf,
             DecodeContext::default(),
         ) {
-            use crate::alloc::string::ToString;
+            use alloc::string::ToString;
             return TestResult::error(error.to_string());
         };
 
@@ -1454,7 +1454,7 @@ mod test {
                 &mut buf,
                 DecodeContext::default(),
             ) {
-                use crate::alloc::string::ToString;
+                use alloc::string::ToString;
                 return TestResult::error(error.to_string());
             };
         }
diff --git a/src/lib.rs b/src/lib.rs
index 9fddf00fb..dbbed9cae 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,10 +16,6 @@ pub mod encoding;
 pub use crate::error::{DecodeError, EncodeError};
 pub use crate::message::Message;
 
-// This allows people to use prost and prost-derive without declaring dependency
-// on bytes in their Cargo.toml
-pub use bytes as _bytes;
-
 use bytes::{Buf, BufMut};
 
 use crate::encoding::{decode_varint, encode_varint, encoded_len_varint};
@@ -68,7 +64,7 @@ pub fn length_delimiter_len(length: usize) -> usize {
 ///    input is required to decode the full delimiter.
 ///  * If the supplied buffer contains more than 10 bytes, then the buffer contains an invalid
 ///    delimiter, and typically the buffer should be considered corrupt.
-pub fn decode_length_delimiter<B>(buf: &mut B) -> Result<usize, DecodeError>
+pub fn decode_length_delimiter<B>(mut buf: B) -> Result<usize, DecodeError>
 where
     B: Buf,
 {
diff --git a/tests/src/build.rs b/tests/src/build.rs
index b92e12e53..0e474f763 100644
--- a/tests/src/build.rs
+++ b/tests/src/build.rs
@@ -20,14 +20,13 @@ fn main() {
     let src = PathBuf::from("../tests/src");
     let includes = &[src.clone()];
 
-    let mut config = prost_build::Config::new();
 
     // Generate BTreeMap fields for all messages. This forces encoded output to be consistent, so
     // that encode/decode roundtrips can use encoded output for comparison. Otherwise trying to
     // compare based on the Rust PartialEq implementations is difficult, due to presence of NaN
     // values.
+    let mut config = prost_build::Config::new();
     config.btree_map(&["."]);
-
     // Tests for custom attributes
     config.type_attribute("Foo.Bar_Baz.Foo_barBaz", "#[derive(Eq, PartialOrd, Ord)]");
     config.type_attribute(

From 41e5bf7e0979f2f3e02208f0a66ead174e11f384 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 22:34:39 -0800
Subject: [PATCH 25/36] remove unnecessary `extern crate alloc;`

---
 prost-derive/src/lib.rs | 1 -
 protobuf/src/lib.rs     | 2 --
 2 files changed, 3 deletions(-)

diff --git a/prost-derive/src/lib.rs b/prost-derive/src/lib.rs
index 2dce81127..2809e8ce6 100644
--- a/prost-derive/src/lib.rs
+++ b/prost-derive/src/lib.rs
@@ -2,7 +2,6 @@
 // The `quote!` macro requires deep recursion.
 #![recursion_limit = "4096"]
 
-extern crate alloc;
 extern crate proc_macro;
 
 use anyhow::bail;
diff --git a/protobuf/src/lib.rs b/protobuf/src/lib.rs
index 255649e5a..9f8048fb7 100644
--- a/protobuf/src/lib.rs
+++ b/protobuf/src/lib.rs
@@ -1,5 +1,3 @@
-extern crate alloc;
-
 pub mod benchmarks {
     include!(concat!(env!("OUT_DIR"), "/benchmarks.rs"));
 

From f2bf50028cfd879cdbac4ec99d4a32b64bf31318 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 22:41:20 -0800
Subject: [PATCH 26/36] Move std-dependent stuff into an inline module, per
 review

---
 src/error.rs | 38 +++++++++++++++++---------------------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/src/error.rs b/src/error.rs
index badbf932d..9e06e275a 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -3,14 +3,8 @@
 use alloc::borrow::Cow;
 use alloc::vec::Vec;
 
-#[cfg(feature = "std")]
-use std::error;
-
 use core::fmt;
 
-#[cfg(feature = "std")]
-use std::io;
-
 /// A Protobuf message decoding error.
 ///
 /// `DecodeError` indicates that the input buffer does not caontain a valid
@@ -60,16 +54,6 @@ impl fmt::Display for DecodeError {
     }
 }
 
-#[cfg(feature = "std")]
-impl error::Error for DecodeError {}
-
-#[cfg(feature = "std")]
-impl From<DecodeError> for io::Error {
-    fn from(error: DecodeError) -> io::Error {
-        io::Error::new(io::ErrorKind::InvalidData, error)
-    }
-}
-
 /// A Protobuf message encoding error.
 ///
 /// `EncodeError` always indicates that a message failed to encode because the
@@ -112,11 +96,23 @@ impl fmt::Display for EncodeError {
 }
 
 #[cfg(feature = "std")]
-impl error::Error for EncodeError {}
+mod std_details {
+    use std::{error, io};
+    use super::{DecodeError, EncodeError};
 
-#[cfg(feature = "std")]
-impl From<EncodeError> for io::Error {
-    fn from(error: EncodeError) -> io::Error {
-        io::Error::new(io::ErrorKind::InvalidInput, error)
+    impl error::Error for DecodeError {}
+
+    impl From<DecodeError> for io::Error {
+        fn from(error: DecodeError) -> io::Error {
+            io::Error::new(io::ErrorKind::InvalidData, error)
+        }
+    }
+
+    impl error::Error for EncodeError {}
+
+    impl From<EncodeError> for io::Error {
+        fn from(error: EncodeError) -> io::Error {
+            io::Error::new(io::ErrorKind::InvalidInput, error)
+        }
     }
 }

From 4dab985d022b38e904aa4bd02430a1bba7a12825 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 22:41:39 -0800
Subject: [PATCH 27/36] fixup an earlier commit

---
 src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index dbbed9cae..33a5712a0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -68,7 +68,7 @@ pub fn decode_length_delimiter<B>(mut buf: B) -> Result<usize, DecodeError>
 where
     B: Buf,
 {
-    let length = decode_varint(buf)?;
+    let length = decode_varint(&mut buf)?;
     if length > usize::max_value() as u64 {
         return Err(DecodeError::new(
             "length delimiter exceeds maximum usize value",

From 8f2ba494de3667747241db8f170fb23b46f8f332 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 23:14:38 -0800
Subject: [PATCH 28/36] fix build

---
 protobuf/src/lib.rs      | 2 ++
 tests-alloc/src/build.rs | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/protobuf/src/lib.rs b/protobuf/src/lib.rs
index 9f8048fb7..255649e5a 100644
--- a/protobuf/src/lib.rs
+++ b/protobuf/src/lib.rs
@@ -1,3 +1,5 @@
+extern crate alloc;
+
 pub mod benchmarks {
     include!(concat!(env!("OUT_DIR"), "/benchmarks.rs"));
 
diff --git a/tests-alloc/src/build.rs b/tests-alloc/src/build.rs
index 97815e454..336dc35a0 100644
--- a/tests-alloc/src/build.rs
+++ b/tests-alloc/src/build.rs
@@ -15,7 +15,7 @@ fn main() {
     let mut config = prost_build::Config::new();
 
     // Force btree_map everywhere for no_std compat
-    config.force_btree_map();
+    config.btree_map(&["."]);
 
     // Tests for custom attributes
     config.type_attribute("Foo.Bar_Baz.Foo_barBaz", "#[derive(Eq, PartialOrd, Ord)]");

From cc3574b4b8bca19ece93557ab31c82b49e34f038 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 23:15:01 -0800
Subject: [PATCH 29/36] Make std_conversions inline module and move stuff
 there, per review

---
 prost-types/src/lib.rs | 241 ++++++++++++++++++++---------------------
 1 file changed, 118 insertions(+), 123 deletions(-)

diff --git a/prost-types/src/lib.rs b/prost-types/src/lib.rs
index 19052594f..38858fbbe 100644
--- a/prost-types/src/lib.rs
+++ b/prost-types/src/lib.rs
@@ -11,17 +11,10 @@
 
 #![no_std]
 extern crate alloc;
-#[cfg(feature = "std")]
-extern crate std;
 
-#[cfg(feature = "std")]
-use core::convert::TryFrom;
 use core::i32;
 use core::i64;
 
-#[cfg(feature = "std")]
-use std::time;
-
 include!("protobuf.rs");
 pub mod compiler {
     include!("compiler.rs");
@@ -32,137 +25,139 @@ pub mod compiler {
 // are defined in both directions.
 
 #[cfg(feature = "std")]
-const NANOS_PER_SECOND: i32 = 1_000_000_000;
-
-impl Duration {
-    /// Normalizes the duration to a canonical format.
-    ///
-    /// Based on [`google::protobuf::util::CreateNormalized`][1].
-    /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L79-L100
-    #[cfg(feature = "std")]
-    fn normalize(&mut self) {
-        // Make sure nanos is in the range.
-        if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
-            self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
-            self.nanos %= NANOS_PER_SECOND;
+mod std_conversions {
+    use super::*;
+    extern crate std;
+
+    use std::time;
+    use core::convert::TryFrom;
+
+    const NANOS_PER_SECOND: i32 = 1_000_000_000;
+
+    impl Duration {
+        /// Normalizes the duration to a canonical format.
+        ///
+        /// Based on [`google::protobuf::util::CreateNormalized`][1].
+        /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L79-L100
+        fn normalize(&mut self) {
+            // Make sure nanos is in the range.
+            if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
+                self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
+                self.nanos %= NANOS_PER_SECOND;
+            }
+
+            // nanos should have the same sign as seconds.
+            if self.seconds < 0 && self.nanos > 0 {
+                self.seconds += 1;
+                self.nanos -= NANOS_PER_SECOND;
+            } else if self.seconds > 0 && self.nanos < 0 {
+                self.seconds -= 1;
+                self.nanos += NANOS_PER_SECOND;
+            }
+            // TODO: should this be checked?
+            // debug_assert!(self.seconds >= -315_576_000_000 && self.seconds <= 315_576_000_000,
+            //               "invalid duration: {:?}", self);
         }
+    }
 
-        // nanos should have the same sign as seconds.
-        if self.seconds < 0 && self.nanos > 0 {
-            self.seconds += 1;
-            self.nanos -= NANOS_PER_SECOND;
-        } else if self.seconds > 0 && self.nanos < 0 {
-            self.seconds -= 1;
-            self.nanos += NANOS_PER_SECOND;
+    /// Converts a `std::time::Duration` to a `Duration`.
+    impl From<time::Duration> for Duration {
+        fn from(duration: time::Duration) -> Duration {
+            let seconds = duration.as_secs();
+            let seconds = if seconds > i64::MAX as u64 {
+                i64::MAX
+            } else {
+                seconds as i64
+            };
+            let nanos = duration.subsec_nanos();
+            let nanos = if nanos > i32::MAX as u32 {
+                i32::MAX
+            } else {
+                nanos as i32
+            };
+            let mut duration = Duration { seconds, nanos };
+            duration.normalize();
+            duration
         }
-        // TODO: should this be checked?
-        // debug_assert!(self.seconds >= -315_576_000_000 && self.seconds <= 315_576_000_000,
-        //               "invalid duration: {:?}", self);
     }
-}
 
-/// Converts a `std::time::Duration` to a `Duration`.
-#[cfg(feature = "std")]
-impl From<time::Duration> for Duration {
-    fn from(duration: time::Duration) -> Duration {
-        let seconds = duration.as_secs();
-        let seconds = if seconds > i64::MAX as u64 {
-            i64::MAX
-        } else {
-            seconds as i64
-        };
-        let nanos = duration.subsec_nanos();
-        let nanos = if nanos > i32::MAX as u32 {
-            i32::MAX
-        } else {
-            nanos as i32
-        };
-        let mut duration = Duration { seconds, nanos };
-        duration.normalize();
-        duration
-    }
-}
+    impl TryFrom<Duration> for time::Duration {
+        type Error = time::Duration;
 
-#[cfg(feature = "std")]
-impl TryFrom<Duration> for time::Duration {
-    type Error = time::Duration;
-
-    /// Converts a `Duration` to a result containing a positive (`Ok`) or negative (`Err`)
-    /// `std::time::Duration`.
-    fn try_from(mut duration: Duration) -> Result<time::Duration, time::Duration> {
-        duration.normalize();
-        if duration.seconds >= 0 {
-            Ok(time::Duration::new(
-                duration.seconds as u64,
-                duration.nanos as u32,
-            ))
-        } else {
-            Err(time::Duration::new(
-                (-duration.seconds) as u64,
-                (-duration.nanos) as u32,
-            ))
+        /// Converts a `Duration` to a result containing a positive (`Ok`) or negative (`Err`)
+        /// `std::time::Duration`.
+        fn try_from(mut duration: Duration) -> Result<time::Duration, time::Duration> {
+            duration.normalize();
+            if duration.seconds >= 0 {
+                Ok(time::Duration::new(
+                    duration.seconds as u64,
+                    duration.nanos as u32,
+                ))
+            } else {
+                Err(time::Duration::new(
+                    (-duration.seconds) as u64,
+                    (-duration.nanos) as u32,
+                ))
+            }
         }
     }
-}
 
-impl Timestamp {
-    /// Normalizes the timestamp to a canonical format.
-    ///
-    /// Based on [`google::protobuf::util::CreateNormalized`][1].
-    /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L59-L77
-    #[cfg(feature = "std")]
-    fn normalize(&mut self) {
-        // Make sure nanos is in the range.
-        if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
-            self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
-            self.nanos %= NANOS_PER_SECOND;
+    impl Timestamp {
+        /// Normalizes the timestamp to a canonical format.
+        ///
+        /// Based on [`google::protobuf::util::CreateNormalized`][1].
+        /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L59-L77
+        fn normalize(&mut self) {
+            // Make sure nanos is in the range.
+            if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
+                self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
+                self.nanos %= NANOS_PER_SECOND;
+            }
+
+            // For Timestamp nanos should be in the range [0, 999999999].
+            if self.nanos < 0 {
+                self.seconds -= 1;
+                self.nanos += NANOS_PER_SECOND;
+            }
+
+            // TODO: should this be checked?
+            // debug_assert!(self.seconds >= -62_135_596_800 && self.seconds <= 253_402_300_799,
+            //               "invalid timestamp: {:?}", self);
         }
-
-        // For Timestamp nanos should be in the range [0, 999999999].
-        if self.nanos < 0 {
-            self.seconds -= 1;
-            self.nanos += NANOS_PER_SECOND;
-        }
-
-        // TODO: should this be checked?
-        // debug_assert!(self.seconds >= -62_135_596_800 && self.seconds <= 253_402_300_799,
-        //               "invalid timestamp: {:?}", self);
     }
-}
 
-/// Converts a `std::time::SystemTime` to a `Timestamp`.
-#[cfg(feature = "std")]
-impl From<time::SystemTime> for Timestamp {
-    fn from(time: time::SystemTime) -> Timestamp {
-        let duration = Duration::from(time.duration_since(time::UNIX_EPOCH).unwrap());
-        Timestamp {
-            seconds: duration.seconds,
-            nanos: duration.nanos,
+    /// Converts a `std::time::SystemTime` to a `Timestamp`.
+    impl From<time::SystemTime> for Timestamp {
+        fn from(time: time::SystemTime) -> Timestamp {
+            let duration = Duration::from(time.duration_since(time::UNIX_EPOCH).unwrap());
+            Timestamp {
+                seconds: duration.seconds,
+                nanos: duration.nanos,
+            }
         }
     }
-}
 
-#[cfg(feature = "std")]
-impl TryFrom<Timestamp> for time::SystemTime {
-    type Error = time::Duration;
-
-    /// Converts a `Timestamp` to a `SystemTime`, or if the timestamp falls before the Unix epoch,
-    /// a duration containing the difference.
-    fn try_from(mut timestamp: Timestamp) -> Result<time::SystemTime, time::Duration> {
-        timestamp.normalize();
-        if timestamp.seconds >= 0 {
-            Ok(time::UNIX_EPOCH
-                + time::Duration::new(timestamp.seconds as u64, timestamp.nanos as u32))
-        } else {
-            let mut duration = Duration {
-                seconds: -timestamp.seconds,
-                nanos: timestamp.nanos,
-            };
-            duration.normalize();
-            Err(time::Duration::new(
-                duration.seconds as u64,
-                duration.nanos as u32,
-            ))
+    impl TryFrom<Timestamp> for time::SystemTime {
+        type Error = time::Duration;
+
+        /// Converts a `Timestamp` to a `SystemTime`, or if the timestamp falls before the Unix epoch,
+        /// a duration containing the difference.
+        fn try_from(mut timestamp: Timestamp) -> Result<time::SystemTime, time::Duration> {
+            timestamp.normalize();
+            if timestamp.seconds >= 0 {
+                Ok(time::UNIX_EPOCH
+                    + time::Duration::new(timestamp.seconds as u64, timestamp.nanos as u32))
+            } else {
+                let mut duration = Duration {
+                    seconds: -timestamp.seconds,
+                    nanos: timestamp.nanos,
+                };
+                duration.normalize();
+                Err(time::Duration::new(
+                    duration.seconds as u64,
+                    duration.nanos as u32,
+                ))
+            }
         }
     }
 }

From f5a7d00c985f686e5a53b238f5a932bd29bea8ee Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 23:31:08 -0800
Subject: [PATCH 30/36] Remove tests-infra and tests-alloc

---
 .travis.yml              |   1 -
 tests-2015/Cargo.toml    |   1 -
 tests-alloc/Cargo.toml   |  34 ----
 tests-alloc/src/bin.rs   | 416 ---------------------------------------
 tests-alloc/src/build.rs | 105 ----------
 tests-infra/Cargo.toml   |  14 --
 tests-infra/src/lib.rs   | 162 ---------------
 tests/Cargo.toml         |   1 -
 8 files changed, 734 deletions(-)
 delete mode 100644 tests-alloc/Cargo.toml
 delete mode 100644 tests-alloc/src/bin.rs
 delete mode 100644 tests-alloc/src/build.rs
 delete mode 100644 tests-infra/Cargo.toml
 delete mode 100644 tests-infra/src/lib.rs

diff --git a/.travis.yml b/.travis.yml
index 490c00ff8..57406dab7 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,7 +14,6 @@ rust:
 script:
   - cargo build --verbose --all --exclude benchmarks
   - cargo test --verbose --all --exclude benchmarks
-  - cargo run -p tests-alloc --verbose
   - if [[ $TRAVIS_RUST_VERSION = nightly* ]]; then
       cargo bench --verbose --no-run;
     fi
diff --git a/tests-2015/Cargo.toml b/tests-2015/Cargo.toml
index 0683c4724..aaced88c4 100644
--- a/tests-2015/Cargo.toml
+++ b/tests-2015/Cargo.toml
@@ -21,7 +21,6 @@ cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
 protobuf = { path = "../protobuf" }
-tests-infra = { path = "../tests-infra" }
 
 [dev-dependencies]
 diff = "0.1"
diff --git a/tests-alloc/Cargo.toml b/tests-alloc/Cargo.toml
deleted file mode 100644
index 8358380dd..000000000
--- a/tests-alloc/Cargo.toml
+++ /dev/null
@@ -1,34 +0,0 @@
-[package]
-name = "tests-alloc"
-version = "0.0.0"
-authors = ["Dan Burkert <dan@danburkert.com>"]
-publish = false
-edition = "2018"
-
-build = "src/build.rs"
-
-# The standard libtest relies on std, so if we want to test no_std builds,
-# we should make a binary and not use #[test]
-[[bin]]
-name = "tests-alloc"
-path = "src/bin.rs"
-
-[dependencies]
-bytes = { version = "0.5", default-features = false }
-cfg-if = "0.1"
-prost = { path = "..", default-features = false }
-prost-derive = { path = "../prost-derive", default-features = false }
-prost-types = { path = "../prost-types", default-features = false }
-protobuf = { path = "../protobuf" }
-tests-infra = { path = "../tests-infra" }
-
-[dev-dependencies]
-diff = "0.1"
-prost-build = { path = "../prost-build" }
-tempfile = "3"
-
-[build-dependencies]
-cfg-if = "0.1"
-env_logger = { version = "0.6", default-features = false }
-prost-build = { path = "../prost-build" }
-protobuf = { path = "../protobuf" }
diff --git a/tests-alloc/src/bin.rs b/tests-alloc/src/bin.rs
deleted file mode 100644
index 591732377..000000000
--- a/tests-alloc/src/bin.rs
+++ /dev/null
@@ -1,416 +0,0 @@
-#![no_std]
-
-extern crate alloc;
-
-use alloc::borrow::ToOwned;
-use alloc::boxed::Box;
-use alloc::string::ToString;
-use alloc::vec;
-use alloc::vec::Vec;
-
-use prost::Message;
-
-extern crate tests_infra;
-
-pub mod foo {
-    pub mod bar_baz {
-        include!(concat!(env!("OUT_DIR"), "/foo.bar_baz.rs"));
-    }
-}
-
-pub mod nesting {
-    include!(concat!(env!("OUT_DIR"), "/nesting.rs"));
-}
-
-pub mod recursive_oneof {
-    include!(concat!(env!("OUT_DIR"), "/recursive_oneof.rs"));
-}
-
-/// This tests the custom attributes support by abusing docs.
-///
-/// Docs really are full-blown attributes. So we use them to ensure we can place them on everything
-/// we need. If they aren't put onto something or allowed not to be there (by the generator),
-/// compilation fails.
-#[deny(missing_docs)]
-pub mod custom_attributes {
-    include!(concat!(env!("OUT_DIR"), "/foo.custom.attrs.rs"));
-}
-
-/// Also for testing custom attributes, but on oneofs.
-///
-/// Unfortunately, an OneOf field generates a companion module in the .rs file. There's no
-/// reasonable way to place a doc comment on that, so we do the test with `derive(Ord)` and have it
-/// in a separate file.
-pub mod oneof_attributes {
-    include!(concat!(env!("OUT_DIR"), "/foo.custom.one_of_attrs.rs"));
-}
-
-/// Issue https://github.com/danburkert/prost/issues/118
-///
-/// When a message contains an enum field with a default value, we
-/// must ensure that the appropriate name conventions are used.
-pub mod default_enum_value {
-    include!(concat!(env!("OUT_DIR"), "/default_enum_value.rs"));
-}
-
-pub mod groups {
-    include!(concat!(env!("OUT_DIR"), "/groups.rs"));
-}
-
-use tests_infra::*;
-
-use alloc::collections::{BTreeMap, BTreeSet};
-
-use protobuf::test_messages::proto3::TestAllTypesProto3;
-
-// Tests
-
-mod tests {
-    use super::*;
-
-    pub fn test_all_types_proto3() {
-        // Some selected encoded messages, mostly collected from failed fuzz runs.
-        let msgs: &[&[u8]] = &[
-            &[0x28, 0x28, 0x28, 0xFF, 0xFF, 0xFF, 0xFF, 0x68],
-            &[0x92, 0x01, 0x00, 0x92, 0xF4, 0x01, 0x02, 0x00, 0x00],
-            &[0x5d, 0xff, 0xff, 0xff, 0xff, 0x28, 0xff, 0xff, 0x21],
-            &[0x98, 0x04, 0x02, 0x08, 0x0B, 0x98, 0x04, 0x02, 0x08, 0x02],
-            // optional_int32: -1
-            &[0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x08],
-            // repeated_bool: [true, true]
-            &[0xDA, 0x02, 0x02, 0x2A, 0x03],
-            // oneof_double: nan
-            &[0xb1, 0x07, 0xf6, 0x3d, 0xf5, 0xff, 0x27, 0x3d, 0xf5, 0xff],
-            // optional_float: -0.0
-            &[0xdd, 0x00, 0x00, 0x00, 0x00, 0x80],
-            // optional_value: nan
-            &[
-                0xE2, 0x13, 0x1B, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
-                0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-                0xFF, 0xFF, 0x08, 0xFF, 0x0E,
-            ],
-        ];
-
-        for msg in msgs {
-            roundtrip::<TestAllTypesProto3>(msg).unwrap();
-        }
-    }
-
-    pub fn test_ident_conversions() {
-        let msg = foo::bar_baz::FooBarBaz {
-            foo_bar_baz: 42,
-            fuzz_busters: vec![foo::bar_baz::foo_bar_baz::FuzzBuster {
-                t: BTreeMap::<i32, foo::bar_baz::FooBarBaz>::new(),
-                nested_self: None,
-            }],
-            p_i_e: 0,
-            r#as: 4,
-            r#break: 5,
-            r#const: 6,
-            r#continue: 7,
-            r#else: 8,
-            r#enum: 9,
-            r#false: 10,
-            r#fn: 11,
-            r#for: 12,
-            r#if: 13,
-            r#impl: 14,
-            r#in: 15,
-            r#let: 16,
-            r#loop: 17,
-            r#match: 18,
-            r#mod: 19,
-            r#move: 20,
-            r#mut: 21,
-            r#pub: 22,
-            r#ref: 23,
-            r#return: 24,
-            r#static: 25,
-            r#struct: 26,
-            r#trait: 27,
-            r#true: 28,
-            r#type: 29,
-            r#unsafe: 30,
-            r#use: 31,
-            r#where: 32,
-            r#while: 33,
-            r#dyn: 34,
-            r#abstract: 35,
-            r#become: 36,
-            r#box: 37,
-            r#do: 38,
-            r#final: 39,
-            r#macro: 40,
-            r#override: 41,
-            r#priv: 42,
-            r#typeof: 43,
-            r#unsized: 44,
-            r#virtual: 45,
-            r#yield: 46,
-            r#async: 47,
-            r#await: 48,
-            r#try: 49,
-            self_: 50,
-            super_: 51,
-            extern_: 52,
-            crate_: 53,
-        };
-
-        let _ = foo::bar_baz::foo_bar_baz::Self_ {};
-
-        // Test enum ident conversion.
-        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::Foo;
-        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::Bar;
-        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::FooBar;
-        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::FuzzBuster;
-        let _ = foo::bar_baz::foo_bar_baz::StrawberryRhubarbPie::NormalRustEnumCase;
-
-        let mut buf = Vec::new();
-        msg.encode(&mut buf).expect("encode");
-        roundtrip::<foo::bar_baz::FooBarBaz>(&buf).unwrap();
-    }
-
-    pub fn test_custom_type_attributes() {
-        // We abuse the ident conversion protobuf for the custom attribute additions. We placed
-        // `Ord` on the FooBarBaz (which is not implemented by ordinary messages).
-        let mut set1 = BTreeSet::new();
-        let msg1 = foo::bar_baz::FooBarBaz::default();
-        set1.insert(msg1);
-        // Similar, but for oneof fields
-        let mut set2 = BTreeSet::new();
-        let msg2 = oneof_attributes::Msg::default();
-        set2.insert(msg2.field);
-    }
-
-    pub fn test_nesting() {
-        use crate::nesting::{A, B};
-        let _ = A {
-            a: Some(Box::new(A::default())),
-            repeated_a: Vec::<A>::new(),
-            map_a: BTreeMap::<i32, A>::new(),
-            b: Some(Box::new(B::default())),
-            repeated_b: Vec::<B>::new(),
-            map_b: BTreeMap::<i32, B>::new(),
-        };
-    }
-
-    pub fn test_deep_nesting() {
-        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
-            use crate::nesting::A;
-
-            let mut a = Box::new(A::default());
-            for _ in 0..depth {
-                let mut next = Box::new(A::default());
-                next.a = Some(a);
-                a = next;
-            }
-
-            let mut buf = Vec::new();
-            a.encode(&mut buf).unwrap();
-            A::decode(&buf[..]).map(|_| ())
-        }
-
-        assert!(build_and_roundtrip(100).is_ok());
-        assert!(build_and_roundtrip(101).is_err());
-    }
-
-    pub fn test_deep_nesting_oneof() {
-        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
-            use crate::recursive_oneof::{a, A, C};
-
-            let mut a = Box::new(A {
-                kind: Some(a::Kind::C(C {})),
-            });
-            for _ in 0..depth {
-                a = Box::new(A {
-                    kind: Some(a::Kind::A(a)),
-                });
-            }
-
-            let mut buf = Vec::new();
-            a.encode(&mut buf).unwrap();
-            A::decode(&buf[..]).map(|_| ())
-        }
-
-        assert!(build_and_roundtrip(99).is_ok());
-        assert!(build_and_roundtrip(100).is_err());
-    }
-
-    pub fn test_deep_nesting_group() {
-        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
-            use crate::groups::{nested_group2::OptionalGroup, NestedGroup2};
-
-            let mut a = NestedGroup2::default();
-            for _ in 0..depth {
-                a = NestedGroup2 {
-                    optionalgroup: Some(Box::new(OptionalGroup {
-                        nested_group: Some(a),
-                    })),
-                };
-            }
-
-            let mut buf = Vec::new();
-            a.encode(&mut buf).unwrap();
-            NestedGroup2::decode(&buf[..]).map(|_| ())
-        }
-
-        assert!(build_and_roundtrip(50).is_ok());
-        assert!(build_and_roundtrip(51).is_err());
-    }
-
-    pub fn test_deep_nesting_repeated() {
-        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
-            use crate::nesting::C;
-
-            let mut c = C::default();
-            for _ in 0..depth {
-                let mut next = C::default();
-                next.r.push(c);
-                c = next;
-            }
-
-            let mut buf = Vec::new();
-            c.encode(&mut buf).unwrap();
-            C::decode(&buf[..]).map(|_| ())
-        }
-
-        assert!(build_and_roundtrip(100).is_ok());
-        assert!(build_and_roundtrip(101).is_err());
-    }
-
-    pub fn test_deep_nesting_map() {
-        fn build_and_roundtrip(depth: usize) -> Result<(), prost::DecodeError> {
-            use crate::nesting::D;
-
-            let mut d = D::default();
-            for _ in 0..depth {
-                let mut next = D::default();
-                next.m.insert("foo".to_owned(), d);
-                d = next;
-            }
-
-            let mut buf = Vec::new();
-            d.encode(&mut buf).unwrap();
-            D::decode(&buf[..]).map(|_| ())
-        }
-
-        assert!(build_and_roundtrip(50).is_ok());
-        assert!(build_and_roundtrip(51).is_err());
-    }
-
-    pub fn test_recursive_oneof() {
-        use crate::recursive_oneof::{a, A, B, C};
-        let _ = A {
-            kind: Some(a::Kind::B(Box::new(B {
-                a: Some(Box::new(A {
-                    kind: Some(a::Kind::C(C {})),
-                })),
-            }))),
-        };
-    }
-
-    pub fn test_default_enum() {
-        let msg = default_enum_value::Test::default();
-        assert_eq!(msg.privacy_level_1(), default_enum_value::PrivacyLevel::One);
-        assert_eq!(
-            msg.privacy_level_3(),
-            default_enum_value::PrivacyLevel::PrivacyLevelThree
-        );
-        assert_eq!(
-            msg.privacy_level_4(),
-            default_enum_value::PrivacyLevel::PrivacyLevelprivacyLevelFour
-        );
-    }
-
-    pub fn test_group() {
-        // optional group
-        let msg1_bytes = &[0x0B, 0x10, 0x20, 0x0C];
-
-        let msg1 = groups::Test1 {
-            groupa: Some(groups::test1::GroupA { i2: Some(32) }),
-        };
-
-        let mut bytes = Vec::new();
-        msg1.encode(&mut bytes).unwrap();
-        assert_eq!(&bytes, msg1_bytes);
-
-        // skip group while decoding
-        let data: &[u8] = &[
-            0x0B, // start group (tag=1)
-            0x30, 0x01, // unused int32 (tag=6)
-            0x2B, 0x30, 0xFF, 0x01, 0x2C, // unused group (tag=5)
-            0x10, 0x20, // int32 (tag=2)
-            0x0C, // end group (tag=1)
-        ];
-        assert_eq!(groups::Test1::decode(data), Ok(msg1));
-
-        // repeated group
-        let msg2_bytes: &[u8] = &[
-            0x20, 0x40, 0x2B, 0x30, 0xFF, 0x01, 0x2C, 0x2B, 0x30, 0x01, 0x2C, 0x38, 0x64,
-        ];
-
-        let msg2 = groups::Test2 {
-            i14: Some(64),
-            groupb: vec![
-                groups::test2::GroupB { i16: Some(255) },
-                groups::test2::GroupB { i16: Some(1) },
-            ],
-            i17: Some(100),
-        };
-
-        let mut bytes = Vec::new();
-        msg2.encode(&mut bytes).unwrap();
-        assert_eq!(&*bytes, msg2_bytes);
-
-        assert_eq!(groups::Test2::decode(msg2_bytes), Ok(msg2));
-    }
-
-    pub fn test_group_oneof() {
-        let msg = groups::OneofGroup {
-            i1: Some(42),
-            field: Some(groups::oneof_group::Field::S2("foo".to_string())),
-        };
-        check_message(&msg);
-
-        let msg = groups::OneofGroup {
-            i1: Some(42),
-            field: Some(groups::oneof_group::Field::G(groups::oneof_group::G {
-                i2: None,
-                s1: "foo".to_string(),
-                t1: None,
-            })),
-        };
-        check_message(&msg);
-
-        let msg = groups::OneofGroup {
-            i1: Some(42),
-            field: Some(groups::oneof_group::Field::G(groups::oneof_group::G {
-                i2: Some(99),
-                s1: "foo".to_string(),
-                t1: Some(groups::Test1 {
-                    groupa: Some(groups::test1::GroupA { i2: None }),
-                }),
-            })),
-        };
-        check_message(&msg);
-
-        check_message(&groups::OneofGroup::default());
-    }
-}
-
-fn main() {
-    use tests::*;
-    test_all_types_proto3();
-    test_ident_conversions();
-    test_custom_type_attributes();
-    test_nesting();
-    test_deep_nesting();
-    test_deep_nesting_oneof();
-    test_deep_nesting_group();
-    test_deep_nesting_repeated();
-    test_deep_nesting_map();
-    test_recursive_oneof();
-    test_default_enum();
-    test_group();
-    test_group_oneof();
-}
diff --git a/tests-alloc/src/build.rs b/tests-alloc/src/build.rs
deleted file mode 100644
index 336dc35a0..000000000
--- a/tests-alloc/src/build.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-#[macro_use]
-extern crate cfg_if;
-
-use std::env;
-use std::fs;
-use std::path::PathBuf;
-
-fn main() {
-    let _ = env_logger::init();
-
-    // The source directory.
-    let src = PathBuf::from("../tests/src");
-    let includes = &[src.clone()];
-
-    let mut config = prost_build::Config::new();
-
-    // Force btree_map everywhere for no_std compat
-    config.btree_map(&["."]);
-
-    // Tests for custom attributes
-    config.type_attribute("Foo.Bar_Baz.Foo_barBaz", "#[derive(Eq, PartialOrd, Ord)]");
-    config.type_attribute(
-        "Foo.Bar_Baz.Foo_barBaz.fuzz_buster",
-        "#[derive(Eq, PartialOrd, Ord)]",
-    );
-    config.type_attribute("Foo.Custom.Attrs.Msg", "#[allow(missing_docs)]");
-    config.type_attribute("Foo.Custom.Attrs.Msg.field", "/// Oneof docs");
-    config.type_attribute("Foo.Custom.Attrs.AnEnum", "#[allow(missing_docs)]");
-    config.type_attribute("Foo.Custom.Attrs.AnotherEnum", "/// Oneof docs");
-    config.type_attribute(
-        "Foo.Custom.OneOfAttrs.Msg.field",
-        "#[derive(Eq, PartialOrd, Ord)]",
-    );
-    config.field_attribute("Foo.Custom.Attrs.AnotherEnum.C", "/// The C docs");
-    config.field_attribute("Foo.Custom.Attrs.AnotherEnum.D", "/// The D docs");
-    config.field_attribute("Foo.Custom.Attrs.Msg.field.a", "/// Oneof A docs");
-    config.field_attribute("Foo.Custom.Attrs.Msg.field.b", "/// Oneof B docs");
-
-    config
-        .compile_protos(&[src.join("ident_conversion.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("nesting.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("recursive_oneof.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("custom_attributes.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("oneof_attributes.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("no_unused_results.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("default_enum_value.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("groups.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(&[src.join("well_known_types.proto")], includes)
-        .unwrap();
-
-    config
-        .compile_protos(
-            &[src.join("packages/widget_factory.proto")],
-            &[src.join("packages")],
-        )
-        .unwrap();
-
-    let out_dir =
-        &PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR environment variable not set"))
-            .join("extern_paths");
-    fs::create_dir_all(out_dir).expect("failed to create prefix directory");
-    config.out_dir(out_dir);
-
-    // Compile some of the module examples as an extern path. The extern path syntax is edition
-    // specific, since the way crate-internal fully qualified paths has changed.
-    cfg_if! {
-        if #[cfg(feature = "edition-2015")] {
-            const EXTERN_PATH: &str = "::packages::gizmo";
-        } else {
-            const EXTERN_PATH: &str = "crate::packages::gizmo";
-        }
-    };
-    config.extern_path(".packages.gizmo", EXTERN_PATH);
-
-    config
-        .compile_protos(
-            &[src.join("packages").join("widget_factory.proto")],
-            &[src.join("packages")],
-        )
-        .unwrap();
-}
diff --git a/tests-infra/Cargo.toml b/tests-infra/Cargo.toml
deleted file mode 100644
index 57c1e9d90..000000000
--- a/tests-infra/Cargo.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-[package]
-name = "tests-infra"
-version = "0.0.0"
-authors = ["Dan Burkert <dan@danburkert.com>"]
-publish = false
-edition = "2018"
-
-[lib]
-doctest = false
-
-[dependencies]
-bytes = { version = "0.5", default-features = false }
-cfg-if = "0.1"
-prost = { path = "..", default-features = false }
diff --git a/tests-infra/src/lib.rs b/tests-infra/src/lib.rs
deleted file mode 100644
index 4677cd12e..000000000
--- a/tests-infra/src/lib.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-#![no_std]
-
-extern crate alloc;
-
-use alloc::format;
-use alloc::string::String;
-use alloc::vec::Vec;
-
-use core::cmp::PartialEq;
-use core::default::Default;
-use core::fmt::Display;
-
-#[macro_use]
-extern crate cfg_if;
-
-use prost;
-use prost::Message;
-
-cfg_if! {
-    if #[cfg(feature = "edition-2015")] {
-        extern crate bytes;
-        extern crate prost;
-        extern crate prost_types;
-        extern crate protobuf;
-        #[cfg(test)]
-        extern crate prost_build;
-        #[cfg(test)]
-        extern crate tempfile;
-        #[cfg(test)]
-        extern crate tests_infra;
-    }
-}
-
-pub enum RoundtripResult {
-    /// The roundtrip succeeded.
-    Ok(Vec<u8>),
-    /// The data could not be decoded. This could indicate a bug in prost,
-    /// or it could indicate that the input was bogus.
-    DecodeError(prost::DecodeError),
-    /// Re-encoding or validating the data failed.  This indicates a bug in `prost`.
-    Error(String),
-}
-
-impl RoundtripResult {
-    /// Unwrap the roundtrip result.
-    pub fn unwrap(self) -> Vec<u8> {
-        match self {
-            RoundtripResult::Ok(buf) => buf,
-            RoundtripResult::DecodeError(error) => {
-                panic!("failed to decode the roundtrip data: {}", error)
-            }
-            RoundtripResult::Error(error) => panic!("failed roundtrip: {}", error),
-        }
-    }
-
-    /// Unwrap the roundtrip result. Panics if the result was a validation or re-encoding error.
-    pub fn unwrap_error(self) -> Result<Vec<u8>, prost::DecodeError> {
-        match self {
-            RoundtripResult::Ok(buf) => Ok(buf),
-            RoundtripResult::DecodeError(error) => Err(error),
-            RoundtripResult::Error(error) => panic!("failed roundtrip: {}", error),
-        }
-    }
-}
-
-/// Tests round-tripping a message type. The message should be compiled with `BTreeMap` fields,
-/// otherwise the comparison may fail due to inconsistent `HashMap` entry encoding ordering.
-pub fn roundtrip<M>(data: &[u8]) -> RoundtripResult
-where
-    M: Message + Default,
-{
-    // Try to decode a message from the data. If decoding fails, continue.
-    let all_types = match M::decode(data) {
-        Ok(all_types) => all_types,
-        Err(error) => return RoundtripResult::DecodeError(error),
-    };
-
-    let encoded_len = all_types.encoded_len();
-
-    // TODO: Reenable this once sign-extension in negative int32s is figured out.
-    // assert!(encoded_len <= data.len(), "encoded_len: {}, len: {}, all_types: {:?}",
-    //         encoded_len, data.len(), all_types);
-
-    let mut buf1 = Vec::new();
-    if let Err(error) = all_types.encode(&mut buf1) {
-        return RoundtripResult::Error(to_string(&error));
-    }
-    if encoded_len != buf1.len() {
-        return RoundtripResult::Error(
-            format!(
-                "expected encoded len ({}) did not match actual encoded len ({})",
-                encoded_len,
-                buf1.len()
-            )
-            .into(),
-        );
-    }
-
-    let roundtrip = match M::decode(&buf1[..]) {
-        Ok(roundtrip) => roundtrip,
-        Err(error) => return RoundtripResult::Error(to_string(&error)),
-    };
-
-    let mut buf2 = Vec::new();
-    if let Err(error) = roundtrip.encode(&mut buf2) {
-        return RoundtripResult::Error(to_string(&error));
-    }
-
-    /*
-    // Useful for debugging:
-    eprintln!(" data: {:?}", data.iter().map(|x| format!("0x{:x}", x)).collect::<Vec<_>>());
-    eprintln!(" buf1: {:?}", buf1.iter().map(|x| format!("0x{:x}", x)).collect::<Vec<_>>());
-    eprintln!("a: {:?}\nb: {:?}", all_types, roundtrip);
-    */
-
-    if buf1 != buf2 {
-        return RoundtripResult::Error("roundtripped encoded buffers do not match".into());
-    }
-
-    RoundtripResult::Ok(buf1)
-}
-
-/// Generic rountrip serialization check for messages.
-pub fn check_message<M>(msg: &M)
-where
-    M: Message + Default + PartialEq,
-{
-    let expected_len = msg.encoded_len();
-
-    let mut buf = Vec::with_capacity(18);
-    msg.encode(&mut buf).unwrap();
-    assert_eq!(expected_len, buf.len());
-
-    use bytes::Buf;
-    let buf = (&buf[..]).to_bytes();
-    let roundtrip = M::decode(buf).unwrap();
-
-    // FIXME(chris)
-    // if buf.has_remaining() {
-    //    panic!("expected buffer to be empty: {}", buf.remaining());
-    // }
-
-    assert_eq!(msg, &roundtrip);
-}
-
-/// Serialize from A should equal Serialize from B
-pub fn check_serialize_equivalent<M, N>(msg_a: &M, msg_b: &N)
-where
-    M: Message + Default + PartialEq,
-    N: Message + Default + PartialEq,
-{
-    let mut buf_a = Vec::new();
-    msg_a.encode(&mut buf_a).unwrap();
-    let mut buf_b = Vec::new();
-    msg_b.encode(&mut buf_b).unwrap();
-    assert_eq!(buf_a, buf_b);
-}
-
-// helper
-fn to_string<T: Display>(obj: &T) -> String {
-    format!("{}", obj)
-}
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index e29460e77..4fbd3fd4f 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -16,7 +16,6 @@ cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
 protobuf = { path = "../protobuf" }
-tests-infra = { path = "../tests-infra" }
 
 [dev-dependencies]
 diff = "0.1"

From 490247d44f61b37fb6bd25c91153fbecac2aa079 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 23:31:29 -0800
Subject: [PATCH 31/36] Remove reference to removed config function

---
 tests/src/bootstrap.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/src/bootstrap.rs b/tests/src/bootstrap.rs
index 61f19164a..e7d725f6d 100644
--- a/tests/src/bootstrap.rs
+++ b/tests/src/bootstrap.rs
@@ -21,7 +21,6 @@ fn bootstrap() {
 
     prost_build::Config::new()
         .compile_well_known_types()
-        .force_btree_map()
         .btree_map(&["."])
         .out_dir(tempdir.path())
         .compile_protos(

From 7a292b5f99dab4ca135f8728763a8a30ac361918 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 23:33:33 -0800
Subject: [PATCH 32/36] Fix build

---
 Cargo.toml                    | 1 -
 tests/src/lib.rs              | 2 --
 tests/src/message_encoding.rs | 4 ++--
 tests/src/well_known_types.rs | 2 +-
 4 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 1de0432ea..bf2aa5f09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,6 @@ members = [
   "protobuf",
   "tests",
   "tests-2015",
-  "tests-alloc",
 ]
 exclude = [
   # The fuzz crate can't be compiled or tested without the 'cargo fuzz' command,
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index b6bcb9331..c61be7254 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -14,8 +14,6 @@ cfg_if! {
         extern crate prost_build;
         #[cfg(test)]
         extern crate tempfile;
-        #[cfg(test)]
-        extern crate tests_infra;
     }
 }
 
diff --git a/tests/src/message_encoding.rs b/tests/src/message_encoding.rs
index e03691373..2ee8c94b4 100644
--- a/tests/src/message_encoding.rs
+++ b/tests/src/message_encoding.rs
@@ -1,7 +1,7 @@
 use prost::{Enumeration, Message, Oneof};
 
-use tests_infra::check_message;
-use tests_infra::check_serialize_equivalent;
+use crate::check_message;
+use crate::check_serialize_equivalent;
 
 #[derive(Clone, PartialEq, Message)]
 pub struct RepeatedFloats {
diff --git a/tests/src/well_known_types.rs b/tests/src/well_known_types.rs
index 923210dc2..d7ced9553 100644
--- a/tests/src/well_known_types.rs
+++ b/tests/src/well_known_types.rs
@@ -10,5 +10,5 @@ fn test_well_known_types() {
         }),
     };
 
-    tests_infra::check_message(&msg);
+    crate::check_message(&msg);
 }

From 7a0b294d0fb00594360bd71aa3db912ee46f364e Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 23:33:59 -0800
Subject: [PATCH 33/36] remove noise in the diff

---
 tests/src/build.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/src/build.rs b/tests/src/build.rs
index 0e474f763..f39169512 100644
--- a/tests/src/build.rs
+++ b/tests/src/build.rs
@@ -20,7 +20,6 @@ fn main() {
     let src = PathBuf::from("../tests/src");
     let includes = &[src.clone()];
 
-
     // Generate BTreeMap fields for all messages. This forces encoded output to be consistent, so
     // that encode/decode roundtrips can use encoded output for comparison. Otherwise trying to
     // compare based on the Rust PartialEq implementations is difficult, due to presence of NaN

From 454a01d144311f7923abbc6e6ebb2b078a560015 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Mon, 2 Mar 2020 23:47:22 -0800
Subject: [PATCH 34/36] Add missing alloc tests mod to tests lib

---
 tests/src/lib.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index c61be7254..ebf229cec 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -30,6 +30,8 @@ mod deprecated_field;
 #[cfg(test)]
 mod message_encoding;
 #[cfg(test)]
+mod message_encoding_alloc;
+#[cfg(test)]
 mod no_unused_results;
 #[cfg(test)]
 mod well_known_types;

From 59d36dde0159045fa4757a4006dfbf446b0b965e Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Tue, 3 Mar 2020 19:08:14 -0800
Subject: [PATCH 35/36] Remove leading :: in many prost-types and prost-build
 code generator

This allows simplifying tests a bit, removing unnecessary `extern crate alloc;`
---
 prost-build/src/code_generator.rs |  18 +-
 prost-types/src/compiler.rs       |  26 +--
 prost-types/src/protobuf.rs       | 322 +++++++++++++++---------------
 tests/src/lib.rs                  |   3 +-
 4 files changed, 184 insertions(+), 185 deletions(-)

diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index 36112f428..dbbe00e13 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -375,12 +375,12 @@ impl<'a> CodeGenerator<'a> {
         self.buf.push_str(&to_snake(field.name()));
         self.buf.push_str(": ");
         if repeated {
-            self.buf.push_str("::alloc::vec::Vec<");
+            self.buf.push_str("alloc::vec::Vec<");
         } else if optional {
-            self.buf.push_str("::core::option::Option<");
+            self.buf.push_str("core::option::Option<");
         }
         if boxed {
-            self.buf.push_str("::alloc::boxed::Box<");
+            self.buf.push_str("alloc::boxed::Box<");
         }
         self.buf.push_str(&ty);
         if boxed {
@@ -418,9 +418,9 @@ impl<'a> CodeGenerator<'a> {
             .iter()
             .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
         let (annotation_ty, lib_name, rust_ty) = if btree_map {
-            ("btree_map", "::alloc::collections", "BTreeMap")
+            ("btree_map", "alloc::collections", "BTreeMap")
         } else {
-            ("map", "::std::collections", "HashMap")
+            ("map", "std::collections", "HashMap")
         };
 
         let key_tag = self.field_type_tag(key);
@@ -469,7 +469,7 @@ impl<'a> CodeGenerator<'a> {
         self.append_field_attributes(fq_message_name, oneof.name());
         self.push_indent();
         self.buf.push_str(&format!(
-            "pub {}: ::core::option::Option<{}>,\n",
+            "pub {}: core::option::Option<{}>,\n",
             to_snake(oneof.name()),
             name
         ));
@@ -531,7 +531,7 @@ impl<'a> CodeGenerator<'a> {
 
             if boxed {
                 self.buf.push_str(&format!(
-                    "{}(::alloc::boxed::Box<{}>),\n",
+                    "{}(alloc::boxed::Box<{}>),\n",
                     to_upper_camel(field.name()),
                     ty
                 ));
@@ -726,8 +726,8 @@ impl<'a> CodeGenerator<'a> {
             Type::Int32 | Type::Sfixed32 | Type::Sint32 | Type::Enum => String::from("i32"),
             Type::Int64 | Type::Sfixed64 | Type::Sint64 => String::from("i64"),
             Type::Bool => String::from("bool"),
-            Type::String => String::from("::alloc::string::String"),
-            Type::Bytes => String::from("::alloc::vec::Vec<u8>"),
+            Type::String => String::from("alloc::string::String"),
+            Type::Bytes => String::from("alloc::vec::Vec<u8>"),
             Type::Group | Type::Message => self.resolve_ident(field.type_name()),
         }
     }
diff --git a/prost-types/src/compiler.rs b/prost-types/src/compiler.rs
index 8ab83e837..e3b3c8dca 100644
--- a/prost-types/src/compiler.rs
+++ b/prost-types/src/compiler.rs
@@ -2,15 +2,15 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Version {
     #[prost(int32, optional, tag="1")]
-    pub major: ::core::option::Option<i32>,
+    pub major: core::option::Option<i32>,
     #[prost(int32, optional, tag="2")]
-    pub minor: ::core::option::Option<i32>,
+    pub minor: core::option::Option<i32>,
     #[prost(int32, optional, tag="3")]
-    pub patch: ::core::option::Option<i32>,
+    pub patch: core::option::Option<i32>,
     /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     /// be empty for mainline stable releases.
     #[prost(string, optional, tag="4")]
-    pub suffix: ::core::option::Option<::alloc::string::String>,
+    pub suffix: core::option::Option<alloc::string::String>,
 }
 /// An encoded CodeGeneratorRequest is written to the plugin's stdin.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -19,10 +19,10 @@ pub struct CodeGeneratorRequest {
     /// code generator should generate code only for these files.  Each file's
     /// descriptor will be included in proto_file, below.
     #[prost(string, repeated, tag="1")]
-    pub file_to_generate: ::alloc::vec::Vec<::alloc::string::String>,
+    pub file_to_generate: alloc::vec::Vec<alloc::string::String>,
     /// The generator parameter passed on the command-line.
     #[prost(string, optional, tag="2")]
-    pub parameter: ::core::option::Option<::alloc::string::String>,
+    pub parameter: core::option::Option<alloc::string::String>,
     /// FileDescriptorProtos for all files in files_to_generate and everything
     /// they import.  The files will appear in topological order, so each file
     /// appears before any file that imports it.
@@ -38,10 +38,10 @@ pub struct CodeGeneratorRequest {
     /// Type names of fields and extensions in the FileDescriptorProto are always
     /// fully qualified.
     #[prost(message, repeated, tag="15")]
-    pub proto_file: ::alloc::vec::Vec<super::FileDescriptorProto>,
+    pub proto_file: alloc::vec::Vec<super::FileDescriptorProto>,
     /// The version number of protocol compiler.
     #[prost(message, optional, tag="3")]
-    pub compiler_version: ::core::option::Option<Version>,
+    pub compiler_version: core::option::Option<Version>,
 }
 /// The plugin writes an encoded CodeGeneratorResponse to stdout.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -55,9 +55,9 @@ pub struct CodeGeneratorResponse {
     /// unparseable -- should be reported by writing a message to stderr and
     /// exiting with a non-zero status code.
     #[prost(string, optional, tag="1")]
-    pub error: ::core::option::Option<::alloc::string::String>,
+    pub error: core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="15")]
-    pub file: ::alloc::vec::Vec<code_generator_response::File>,
+    pub file: alloc::vec::Vec<code_generator_response::File>,
 }
 pub mod code_generator_response {
     /// Represents a single generated file.
@@ -75,7 +75,7 @@ pub mod code_generator_response {
         /// this writing protoc does not optimize for this -- it will read the entire
         /// CodeGeneratorResponse before writing files to disk.
         #[prost(string, optional, tag="1")]
-        pub name: ::core::option::Option<::alloc::string::String>,
+        pub name: core::option::Option<alloc::string::String>,
         /// If non-empty, indicates that the named file should already exist, and the
         /// content here is to be inserted into that file at a defined insertion
         /// point.  This feature allows a code generator to extend the output
@@ -114,9 +114,9 @@ pub mod code_generator_response {
         ///
         /// If |insertion_point| is present, |name| must also be present.
         #[prost(string, optional, tag="2")]
-        pub insertion_point: ::core::option::Option<::alloc::string::String>,
+        pub insertion_point: core::option::Option<alloc::string::String>,
         /// The file contents.
         #[prost(string, optional, tag="15")]
-        pub content: ::core::option::Option<::alloc::string::String>,
+        pub content: core::option::Option<alloc::string::String>,
     }
 }
diff --git a/prost-types/src/protobuf.rs b/prost-types/src/protobuf.rs
index df58d42dc..4026c60ce 100644
--- a/prost-types/src/protobuf.rs
+++ b/prost-types/src/protobuf.rs
@@ -3,86 +3,86 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorSet {
     #[prost(message, repeated, tag="1")]
-    pub file: ::alloc::vec::Vec<FileDescriptorProto>,
+    pub file: alloc::vec::Vec<FileDescriptorProto>,
 }
 /// Describes a complete .proto file.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorProto {
     /// file name, relative to root of source tree
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     /// e.g. "foo", "foo.bar", etc.
     #[prost(string, optional, tag="2")]
-    pub package: ::core::option::Option<::alloc::string::String>,
+    pub package: core::option::Option<alloc::string::String>,
     /// Names of files imported by this file.
     #[prost(string, repeated, tag="3")]
-    pub dependency: ::alloc::vec::Vec<::alloc::string::String>,
+    pub dependency: alloc::vec::Vec<alloc::string::String>,
     /// Indexes of the public imported files in the dependency list above.
     #[prost(int32, repeated, packed="false", tag="10")]
-    pub public_dependency: ::alloc::vec::Vec<i32>,
+    pub public_dependency: alloc::vec::Vec<i32>,
     /// Indexes of the weak imported files in the dependency list.
     /// For Google-internal migration only. Do not use.
     #[prost(int32, repeated, packed="false", tag="11")]
-    pub weak_dependency: ::alloc::vec::Vec<i32>,
+    pub weak_dependency: alloc::vec::Vec<i32>,
     /// All top-level definitions in this file.
     #[prost(message, repeated, tag="4")]
-    pub message_type: ::alloc::vec::Vec<DescriptorProto>,
+    pub message_type: alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub service: ::alloc::vec::Vec<ServiceDescriptorProto>,
+    pub service: alloc::vec::Vec<ServiceDescriptorProto>,
     #[prost(message, repeated, tag="7")]
-    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
+    pub extension: alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, optional, tag="8")]
-    pub options: ::core::option::Option<FileOptions>,
+    pub options: core::option::Option<FileOptions>,
     /// This field contains optional information about the original source code.
     /// You may safely remove this entire field without harming runtime
     /// functionality of the descriptors -- the information is needed only by
     /// development tools.
     #[prost(message, optional, tag="9")]
-    pub source_code_info: ::core::option::Option<SourceCodeInfo>,
+    pub source_code_info: core::option::Option<SourceCodeInfo>,
     /// The syntax of the proto file.
     /// The supported values are "proto2" and "proto3".
     #[prost(string, optional, tag="12")]
-    pub syntax: ::core::option::Option<::alloc::string::String>,
+    pub syntax: core::option::Option<alloc::string::String>,
 }
 /// Describes a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub field: ::alloc::vec::Vec<FieldDescriptorProto>,
+    pub field: alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub extension: ::alloc::vec::Vec<FieldDescriptorProto>,
+    pub extension: alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="3")]
-    pub nested_type: ::alloc::vec::Vec<DescriptorProto>,
+    pub nested_type: alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="4")]
-    pub enum_type: ::alloc::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub extension_range: ::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
+    pub extension_range: alloc::vec::Vec<descriptor_proto::ExtensionRange>,
     #[prost(message, repeated, tag="8")]
-    pub oneof_decl: ::alloc::vec::Vec<OneofDescriptorProto>,
+    pub oneof_decl: alloc::vec::Vec<OneofDescriptorProto>,
     #[prost(message, optional, tag="7")]
-    pub options: ::core::option::Option<MessageOptions>,
+    pub options: core::option::Option<MessageOptions>,
     #[prost(message, repeated, tag="9")]
-    pub reserved_range: ::alloc::vec::Vec<descriptor_proto::ReservedRange>,
+    pub reserved_range: alloc::vec::Vec<descriptor_proto::ReservedRange>,
     /// Reserved field names, which may not be used by fields in the same message.
     /// A given name may only be reserved once.
     #[prost(string, repeated, tag="10")]
-    pub reserved_name: ::alloc::vec::Vec<::alloc::string::String>,
+    pub reserved_name: alloc::vec::Vec<alloc::string::String>,
 }
 pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct ExtensionRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::core::option::Option<i32>,
+        pub start: core::option::Option<i32>,
         /// Exclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::core::option::Option<i32>,
+        pub end: core::option::Option<i32>,
         #[prost(message, optional, tag="3")]
-        pub options: ::core::option::Option<super::ExtensionRangeOptions>,
+        pub options: core::option::Option<super::ExtensionRangeOptions>,
     }
     /// Range of reserved tag numbers. Reserved tag numbers may not be used by
     /// fields or extension ranges in the same message. Reserved ranges may
@@ -91,61 +91,61 @@ pub mod descriptor_proto {
     pub struct ReservedRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::core::option::Option<i32>,
+        pub start: core::option::Option<i32>,
         /// Exclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::core::option::Option<i32>,
+        pub end: core::option::Option<i32>,
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ExtensionRangeOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 /// Describes a field within a message.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     #[prost(int32, optional, tag="3")]
-    pub number: ::core::option::Option<i32>,
+    pub number: core::option::Option<i32>,
     #[prost(enumeration="field_descriptor_proto::Label", optional, tag="4")]
-    pub label: ::core::option::Option<i32>,
+    pub label: core::option::Option<i32>,
     /// If type_name is set, this need not be set.  If both this and type_name
     /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
     #[prost(enumeration="field_descriptor_proto::Type", optional, tag="5")]
-    pub r#type: ::core::option::Option<i32>,
+    pub r#type: core::option::Option<i32>,
     /// For message and enum types, this is the name of the type.  If the name
     /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
     /// rules are used to find the type (i.e. first the nested types within this
     /// message are searched, then within the parent, on up to the root
     /// namespace).
     #[prost(string, optional, tag="6")]
-    pub type_name: ::core::option::Option<::alloc::string::String>,
+    pub type_name: core::option::Option<alloc::string::String>,
     /// For extensions, this is the name of the type being extended.  It is
     /// resolved in the same manner as type_name.
     #[prost(string, optional, tag="2")]
-    pub extendee: ::core::option::Option<::alloc::string::String>,
+    pub extendee: core::option::Option<alloc::string::String>,
     /// For numeric types, contains the original text representation of the value.
     /// For booleans, "true" or "false".
     /// For strings, contains the default text contents (not escaped in any way).
     /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
     /// TODO(kenton):  Base-64 encode?
     #[prost(string, optional, tag="7")]
-    pub default_value: ::core::option::Option<::alloc::string::String>,
+    pub default_value: core::option::Option<alloc::string::String>,
     /// If set, gives the index of a oneof in the containing type's oneof_decl
     /// list.  This field is a member of that oneof.
     #[prost(int32, optional, tag="9")]
-    pub oneof_index: ::core::option::Option<i32>,
+    pub oneof_index: core::option::Option<i32>,
     /// JSON name of this field. The value is set by protocol compiler. If the
     /// user has set a "json_name" option on this field, that option's value
     /// will be used. Otherwise, it's deduced from the field's name by converting
     /// it to camelCase.
     #[prost(string, optional, tag="10")]
-    pub json_name: ::core::option::Option<::alloc::string::String>,
+    pub json_name: core::option::Option<alloc::string::String>,
     #[prost(message, optional, tag="8")]
-    pub options: ::core::option::Option<FieldOptions>,
+    pub options: core::option::Option<FieldOptions>,
 }
 pub mod field_descriptor_proto {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -197,28 +197,28 @@ pub mod field_descriptor_proto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     #[prost(message, optional, tag="2")]
-    pub options: ::core::option::Option<OneofOptions>,
+    pub options: core::option::Option<OneofOptions>,
 }
 /// Describes an enum type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub value: ::alloc::vec::Vec<EnumValueDescriptorProto>,
+    pub value: alloc::vec::Vec<EnumValueDescriptorProto>,
     #[prost(message, optional, tag="3")]
-    pub options: ::core::option::Option<EnumOptions>,
+    pub options: core::option::Option<EnumOptions>,
     /// Range of reserved numeric values. Reserved numeric values may not be used
     /// by enum values in the same enum declaration. Reserved ranges may not
     /// overlap.
     #[prost(message, repeated, tag="4")]
-    pub reserved_range: ::alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
+    pub reserved_range: alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
     /// Reserved enum value names, which may not be reused. A given name may only
     /// be reserved once.
     #[prost(string, repeated, tag="5")]
-    pub reserved_name: ::alloc::vec::Vec<::alloc::string::String>,
+    pub reserved_name: alloc::vec::Vec<alloc::string::String>,
 }
 pub mod enum_descriptor_proto {
     /// Range of reserved numeric values. Reserved values may not be used by
@@ -231,51 +231,51 @@ pub mod enum_descriptor_proto {
     pub struct EnumReservedRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::core::option::Option<i32>,
+        pub start: core::option::Option<i32>,
         /// Inclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::core::option::Option<i32>,
+        pub end: core::option::Option<i32>,
     }
 }
 /// Describes a value within an enum.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     #[prost(int32, optional, tag="2")]
-    pub number: ::core::option::Option<i32>,
+    pub number: core::option::Option<i32>,
     #[prost(message, optional, tag="3")]
-    pub options: ::core::option::Option<EnumValueOptions>,
+    pub options: core::option::Option<EnumValueOptions>,
 }
 /// Describes a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub method: ::alloc::vec::Vec<MethodDescriptorProto>,
+    pub method: alloc::vec::Vec<MethodDescriptorProto>,
     #[prost(message, optional, tag="3")]
-    pub options: ::core::option::Option<ServiceOptions>,
+    pub options: core::option::Option<ServiceOptions>,
 }
 /// Describes a method of a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::core::option::Option<::alloc::string::String>,
+    pub name: core::option::Option<alloc::string::String>,
     /// Input and output type names.  These are resolved in the same way as
     /// FieldDescriptorProto.type_name, but must refer to a message type.
     #[prost(string, optional, tag="2")]
-    pub input_type: ::core::option::Option<::alloc::string::String>,
+    pub input_type: core::option::Option<alloc::string::String>,
     #[prost(string, optional, tag="3")]
-    pub output_type: ::core::option::Option<::alloc::string::String>,
+    pub output_type: core::option::Option<alloc::string::String>,
     #[prost(message, optional, tag="4")]
-    pub options: ::core::option::Option<MethodOptions>,
+    pub options: core::option::Option<MethodOptions>,
     /// Identifies if client streams multiple client messages
     #[prost(bool, optional, tag="5", default="false")]
-    pub client_streaming: ::core::option::Option<bool>,
+    pub client_streaming: core::option::Option<bool>,
     /// Identifies if server streams multiple server messages
     #[prost(bool, optional, tag="6", default="false")]
-    pub server_streaming: ::core::option::Option<bool>,
+    pub server_streaming: core::option::Option<bool>,
 }
 // ===================================================================
 // Options
@@ -316,14 +316,14 @@ pub struct FileOptions {
     /// inappropriate because proto packages do not normally start with backwards
     /// domain names.
     #[prost(string, optional, tag="1")]
-    pub java_package: ::core::option::Option<::alloc::string::String>,
+    pub java_package: core::option::Option<alloc::string::String>,
     /// If set, all the classes from the .proto file are wrapped in a single
     /// outer class with the given name.  This applies to both Proto1
     /// (equivalent to the old "--one_java_file" option) and Proto2 (where
     /// a .proto always translates to a single class, but you may want to
     /// explicitly choose the class name).
     #[prost(string, optional, tag="8")]
-    pub java_outer_classname: ::core::option::Option<::alloc::string::String>,
+    pub java_outer_classname: core::option::Option<alloc::string::String>,
     /// If set true, then the Java code generator will generate a separate .java
     /// file for each top-level message, enum, and service defined in the .proto
     /// file.  Thus, these types will *not* be nested inside the outer class
@@ -331,11 +331,11 @@ pub struct FileOptions {
     /// generated to contain the file's getDescriptor() method as well as any
     /// top-level extensions defined in the file.
     #[prost(bool, optional, tag="10", default="false")]
-    pub java_multiple_files: ::core::option::Option<bool>,
+    pub java_multiple_files: core::option::Option<bool>,
     /// This option does nothing.
     #[deprecated]
     #[prost(bool, optional, tag="20")]
-    pub java_generate_equals_and_hash: ::core::option::Option<bool>,
+    pub java_generate_equals_and_hash: core::option::Option<bool>,
     /// If set true, then the Java2 code generator will generate code that
     /// throws an exception whenever an attempt is made to assign a non-UTF-8
     /// byte sequence to a string field.
@@ -343,16 +343,16 @@ pub struct FileOptions {
     /// However, an extension field still accepts non-UTF-8 byte sequences.
     /// This option has no effect on when used with the lite runtime.
     #[prost(bool, optional, tag="27", default="false")]
-    pub java_string_check_utf8: ::core::option::Option<bool>,
+    pub java_string_check_utf8: core::option::Option<bool>,
     #[prost(enumeration="file_options::OptimizeMode", optional, tag="9", default="Speed")]
-    pub optimize_for: ::core::option::Option<i32>,
+    pub optimize_for: core::option::Option<i32>,
     /// Sets the Go package where structs generated from this .proto will be
     /// placed. If omitted, the Go package will be derived from the following:
     ///   - The basename of the package import path, if provided.
     ///   - Otherwise, the package statement in the .proto file, if present.
     ///   - Otherwise, the basename of the .proto file, without extension.
     #[prost(string, optional, tag="11")]
-    pub go_package: ::core::option::Option<::alloc::string::String>,
+    pub go_package: core::option::Option<alloc::string::String>,
     /// Should generic services be generated in each language?  "Generic" services
     /// are not specific to any particular RPC system.  They are generated by the
     /// main code generators in each language (without additional plugins).
@@ -364,59 +364,59 @@ pub struct FileOptions {
     /// these default to false.  Old code which depends on generic services should
     /// explicitly set them to true.
     #[prost(bool, optional, tag="16", default="false")]
-    pub cc_generic_services: ::core::option::Option<bool>,
+    pub cc_generic_services: core::option::Option<bool>,
     #[prost(bool, optional, tag="17", default="false")]
-    pub java_generic_services: ::core::option::Option<bool>,
+    pub java_generic_services: core::option::Option<bool>,
     #[prost(bool, optional, tag="18", default="false")]
-    pub py_generic_services: ::core::option::Option<bool>,
+    pub py_generic_services: core::option::Option<bool>,
     #[prost(bool, optional, tag="42", default="false")]
-    pub php_generic_services: ::core::option::Option<bool>,
+    pub php_generic_services: core::option::Option<bool>,
     /// Is this file deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for everything in the file, or it will be completely ignored; in the very
     /// least, this is a formalization for deprecating files.
     #[prost(bool, optional, tag="23", default="false")]
-    pub deprecated: ::core::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// Enables the use of arenas for the proto messages in this file. This applies
     /// only to generated classes for C++.
     #[prost(bool, optional, tag="31", default="false")]
-    pub cc_enable_arenas: ::core::option::Option<bool>,
+    pub cc_enable_arenas: core::option::Option<bool>,
     /// Sets the objective c class prefix which is prepended to all objective c
     /// generated classes from this .proto. There is no default.
     #[prost(string, optional, tag="36")]
-    pub objc_class_prefix: ::core::option::Option<::alloc::string::String>,
+    pub objc_class_prefix: core::option::Option<alloc::string::String>,
     /// Namespace for generated classes; defaults to the package.
     #[prost(string, optional, tag="37")]
-    pub csharp_namespace: ::core::option::Option<::alloc::string::String>,
+    pub csharp_namespace: core::option::Option<alloc::string::String>,
     /// By default Swift generators will take the proto package and CamelCase it
     /// replacing '.' with underscore and use that to prefix the types/symbols
     /// defined. When this options is provided, they will use this value instead
     /// to prefix the types/symbols defined.
     #[prost(string, optional, tag="39")]
-    pub swift_prefix: ::core::option::Option<::alloc::string::String>,
+    pub swift_prefix: core::option::Option<alloc::string::String>,
     /// Sets the php class prefix which is prepended to all php generated classes
     /// from this .proto. Default is empty.
     #[prost(string, optional, tag="40")]
-    pub php_class_prefix: ::core::option::Option<::alloc::string::String>,
+    pub php_class_prefix: core::option::Option<alloc::string::String>,
     /// Use this option to change the namespace of php generated classes. Default
     /// is empty. When this option is empty, the package name will be used for
     /// determining the namespace.
     #[prost(string, optional, tag="41")]
-    pub php_namespace: ::core::option::Option<::alloc::string::String>,
+    pub php_namespace: core::option::Option<alloc::string::String>,
     /// Use this option to change the namespace of php generated metadata classes.
     /// Default is empty. When this option is empty, the proto file name will be
     /// used for determining the namespace.
     #[prost(string, optional, tag="44")]
-    pub php_metadata_namespace: ::core::option::Option<::alloc::string::String>,
+    pub php_metadata_namespace: core::option::Option<alloc::string::String>,
     /// Use this option to change the package of ruby generated classes. Default
     /// is empty. When this option is not set, the package name will be used for
     /// determining the ruby package.
     #[prost(string, optional, tag="45")]
-    pub ruby_package: ::core::option::Option<::alloc::string::String>,
+    pub ruby_package: core::option::Option<alloc::string::String>,
     /// The parser stores options it doesn't recognize here.
     /// See the documentation for the "Options" section above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod file_options {
     /// Generated classes can be optimized for speed or code size.
@@ -454,18 +454,18 @@ pub struct MessageOptions {
     /// Because this is an option, the above two restrictions are not enforced by
     /// the protocol compiler.
     #[prost(bool, optional, tag="1", default="false")]
-    pub message_set_wire_format: ::core::option::Option<bool>,
+    pub message_set_wire_format: core::option::Option<bool>,
     /// Disables the generation of the standard "descriptor()" accessor, which can
     /// conflict with a field of the same name.  This is meant to make migration
     /// from proto1 easier; new code should avoid fields named "descriptor".
     #[prost(bool, optional, tag="2", default="false")]
-    pub no_standard_descriptor_accessor: ::core::option::Option<bool>,
+    pub no_standard_descriptor_accessor: core::option::Option<bool>,
     /// Is this message deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the message, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating messages.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::core::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// Whether the message is an automatically generated map entry type for the
     /// maps field.
     ///
@@ -488,10 +488,10 @@ pub struct MessageOptions {
     /// instead. The option should only be implicitly set by the proto compiler
     /// parser.
     #[prost(bool, optional, tag="7")]
-    pub map_entry: ::core::option::Option<bool>,
+    pub map_entry: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldOptions {
@@ -500,14 +500,14 @@ pub struct FieldOptions {
     /// options below.  This option is not yet implemented in the open source
     /// release -- sorry, we'll try to include it in a future version!
     #[prost(enumeration="field_options::CType", optional, tag="1", default="String")]
-    pub ctype: ::core::option::Option<i32>,
+    pub ctype: core::option::Option<i32>,
     /// The packed option can be enabled for repeated primitive fields to enable
     /// a more efficient representation on the wire. Rather than repeatedly
     /// writing the tag and type for each element, the entire array is encoded as
     /// a single length-delimited blob. In proto3, only explicit setting it to
     /// false will avoid using packed encoding.
     #[prost(bool, optional, tag="2")]
-    pub packed: ::core::option::Option<bool>,
+    pub packed: core::option::Option<bool>,
     /// The jstype option determines the JavaScript type used for values of the
     /// field.  The option is permitted only for 64 bit integral and fixed types
     /// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
@@ -520,7 +520,7 @@ pub struct FieldOptions {
     /// This option is an enum to permit additional types to be added, e.g.
     /// goog.math.Integer.
     #[prost(enumeration="field_options::JsType", optional, tag="6", default="JsNormal")]
-    pub jstype: ::core::option::Option<i32>,
+    pub jstype: core::option::Option<i32>,
     /// Should this field be parsed lazily?  Lazy applies only to message-type
     /// fields.  It means that when the outer message is initially parsed, the
     /// inner message's contents will not be parsed but instead stored in encoded
@@ -550,19 +550,19 @@ pub struct FieldOptions {
     /// check its required fields, regardless of whether or not the message has
     /// been parsed.
     #[prost(bool, optional, tag="5", default="false")]
-    pub lazy: ::core::option::Option<bool>,
+    pub lazy: core::option::Option<bool>,
     /// Is this field deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for accessors, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating fields.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::core::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// For Google-internal migration only. Do not use.
     #[prost(bool, optional, tag="10", default="false")]
-    pub weak: ::core::option::Option<bool>,
+    pub weak: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod field_options {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -588,23 +588,23 @@ pub mod field_options {
 pub struct OneofOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumOptions {
     /// Set this option to true to allow mapping different tag names to the same
     /// value.
     #[prost(bool, optional, tag="2")]
-    pub allow_alias: ::core::option::Option<bool>,
+    pub allow_alias: core::option::Option<bool>,
     /// Is this enum deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the enum, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating enums.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::core::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueOptions {
@@ -613,10 +613,10 @@ pub struct EnumValueOptions {
     /// for the enum value, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating enum values.
     #[prost(bool, optional, tag="1", default="false")]
-    pub deprecated: ::core::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceOptions {
@@ -630,10 +630,10 @@ pub struct ServiceOptions {
     /// for the service, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating services.
     #[prost(bool, optional, tag="33", default="false")]
-    pub deprecated: ::core::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodOptions {
@@ -647,12 +647,12 @@ pub struct MethodOptions {
     /// for the method, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating methods.
     #[prost(bool, optional, tag="33", default="false")]
-    pub deprecated: ::core::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     #[prost(enumeration="method_options::IdempotencyLevel", optional, tag="34", default="IdempotencyUnknown")]
-    pub idempotency_level: ::core::option::Option<i32>,
+    pub idempotency_level: core::option::Option<i32>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod method_options {
     /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
@@ -677,21 +677,21 @@ pub mod method_options {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UninterpretedOption {
     #[prost(message, repeated, tag="2")]
-    pub name: ::alloc::vec::Vec<uninterpreted_option::NamePart>,
+    pub name: alloc::vec::Vec<uninterpreted_option::NamePart>,
     /// The value of the uninterpreted option, in whatever type the tokenizer
     /// identified it as during parsing. Exactly one of these should be set.
     #[prost(string, optional, tag="3")]
-    pub identifier_value: ::core::option::Option<::alloc::string::String>,
+    pub identifier_value: core::option::Option<alloc::string::String>,
     #[prost(uint64, optional, tag="4")]
-    pub positive_int_value: ::core::option::Option<u64>,
+    pub positive_int_value: core::option::Option<u64>,
     #[prost(int64, optional, tag="5")]
-    pub negative_int_value: ::core::option::Option<i64>,
+    pub negative_int_value: core::option::Option<i64>,
     #[prost(double, optional, tag="6")]
-    pub double_value: ::core::option::Option<f64>,
+    pub double_value: core::option::Option<f64>,
     #[prost(bytes, optional, tag="7")]
-    pub string_value: ::core::option::Option<::alloc::vec::Vec<u8>>,
+    pub string_value: core::option::Option<alloc::vec::Vec<u8>>,
     #[prost(string, optional, tag="8")]
-    pub aggregate_value: ::core::option::Option<::alloc::string::String>,
+    pub aggregate_value: core::option::Option<alloc::string::String>,
 }
 pub mod uninterpreted_option {
     /// The name of the uninterpreted option.  Each string represents a segment in
@@ -702,7 +702,7 @@ pub mod uninterpreted_option {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NamePart {
         #[prost(string, required, tag="1")]
-        pub name_part: ::alloc::string::String,
+        pub name_part: alloc::string::String,
         #[prost(bool, required, tag="2")]
         pub is_extension: bool,
     }
@@ -758,7 +758,7 @@ pub struct SourceCodeInfo {
     ///   ignore those that it doesn't understand, as more types of locations could
     ///   be recorded in the future.
     #[prost(message, repeated, tag="1")]
-    pub location: ::alloc::vec::Vec<source_code_info::Location>,
+    pub location: alloc::vec::Vec<source_code_info::Location>,
 }
 pub mod source_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -787,14 +787,14 @@ pub mod source_code_info {
         /// this path refers to the whole field declaration (from the beginning
         /// of the label to the terminating semicolon).
         #[prost(int32, repeated, tag="1")]
-        pub path: ::alloc::vec::Vec<i32>,
+        pub path: alloc::vec::Vec<i32>,
         /// Always has exactly three or four elements: start line, start column,
         /// end line (optional, otherwise assumed same as start line), end column.
         /// These are packed into a single field for efficiency.  Note that line
         /// and column numbers are zero-based -- typically you will want to add
         /// 1 to each before displaying to a user.
         #[prost(int32, repeated, tag="2")]
-        pub span: ::alloc::vec::Vec<i32>,
+        pub span: alloc::vec::Vec<i32>,
         /// If this SourceCodeInfo represents a complete declaration, these are any
         /// comments appearing before and after the declaration which appear to be
         /// attached to the declaration.
@@ -843,11 +843,11 @@ pub mod source_code_info {
         ///
         ///   // ignored detached comments.
         #[prost(string, optional, tag="3")]
-        pub leading_comments: ::core::option::Option<::alloc::string::String>,
+        pub leading_comments: core::option::Option<alloc::string::String>,
         #[prost(string, optional, tag="4")]
-        pub trailing_comments: ::core::option::Option<::alloc::string::String>,
+        pub trailing_comments: core::option::Option<alloc::string::String>,
         #[prost(string, repeated, tag="6")]
-        pub leading_detached_comments: ::alloc::vec::Vec<::alloc::string::String>,
+        pub leading_detached_comments: alloc::vec::Vec<alloc::string::String>,
     }
 }
 /// Describes the relationship between generated code and its original source
@@ -858,7 +858,7 @@ pub struct GeneratedCodeInfo {
     /// An Annotation connects some span of text in generated code to an element
     /// of its generating .proto file.
     #[prost(message, repeated, tag="1")]
-    pub annotation: ::alloc::vec::Vec<generated_code_info::Annotation>,
+    pub annotation: alloc::vec::Vec<generated_code_info::Annotation>,
 }
 pub mod generated_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -866,19 +866,19 @@ pub mod generated_code_info {
         /// Identifies the element in the original source .proto file. This field
         /// is formatted the same as SourceCodeInfo.Location.path.
         #[prost(int32, repeated, tag="1")]
-        pub path: ::alloc::vec::Vec<i32>,
+        pub path: alloc::vec::Vec<i32>,
         /// Identifies the filesystem path to the original source .proto.
         #[prost(string, optional, tag="2")]
-        pub source_file: ::core::option::Option<::alloc::string::String>,
+        pub source_file: core::option::Option<alloc::string::String>,
         /// Identifies the starting offset in bytes in the generated code
         /// that relates to the identified object.
         #[prost(int32, optional, tag="3")]
-        pub begin: ::core::option::Option<i32>,
+        pub begin: core::option::Option<i32>,
         /// Identifies the ending offset in bytes in the generated code that
         /// relates to the identified offset. The end offset should be one past
         /// the last relevant byte (so the length of the text = end - begin).
         #[prost(int32, optional, tag="4")]
-        pub end: ::core::option::Option<i32>,
+        pub end: core::option::Option<i32>,
     }
 }
 /// `Any` contains an arbitrary serialized protocol buffer message along with a
@@ -992,10 +992,10 @@ pub struct Any {
     /// used with implementation specific semantics.
     ///
     #[prost(string, tag="1")]
-    pub type_url: ::alloc::string::String,
+    pub type_url: alloc::string::String,
     /// Must be a valid serialized protocol buffer of the above specified type.
     #[prost(bytes, tag="2")]
-    pub value: ::alloc::vec::Vec<u8>,
+    pub value: alloc::vec::Vec<u8>,
 }
 /// `SourceContext` represents information about the source of a
 /// protobuf element, like the file in which it is defined.
@@ -1004,26 +1004,26 @@ pub struct SourceContext {
     /// The path-qualified name of the .proto file that contained the associated
     /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
     #[prost(string, tag="1")]
-    pub file_name: ::alloc::string::String,
+    pub file_name: alloc::string::String,
 }
 /// A protocol buffer message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Type {
     /// The fully qualified message name.
     #[prost(string, tag="1")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// The list of fields.
     #[prost(message, repeated, tag="2")]
-    pub fields: ::alloc::vec::Vec<Field>,
+    pub fields: alloc::vec::Vec<Field>,
     /// The list of types appearing in `oneof` definitions in this type.
     #[prost(string, repeated, tag="3")]
-    pub oneofs: ::alloc::vec::Vec<::alloc::string::String>,
+    pub oneofs: alloc::vec::Vec<alloc::string::String>,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="4")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="5")]
-    pub source_context: ::core::option::Option<SourceContext>,
+    pub source_context: core::option::Option<SourceContext>,
     /// The source syntax.
     #[prost(enumeration="Syntax", tag="6")]
     pub syntax: i32,
@@ -1042,11 +1042,11 @@ pub struct Field {
     pub number: i32,
     /// The field name.
     #[prost(string, tag="4")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// The field type URL, without the scheme, for message or enumeration
     /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
     #[prost(string, tag="6")]
-    pub type_url: ::alloc::string::String,
+    pub type_url: alloc::string::String,
     /// The index of the field type in `Type.oneofs`, for message or enumeration
     /// types. The first type has index 1; zero means the type is not in the list.
     #[prost(int32, tag="7")]
@@ -1056,13 +1056,13 @@ pub struct Field {
     pub packed: bool,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="9")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: alloc::vec::Vec<Option>,
     /// The field JSON name.
     #[prost(string, tag="10")]
-    pub json_name: ::alloc::string::String,
+    pub json_name: alloc::string::String,
     /// The string value of the default value of this field. Proto2 syntax only.
     #[prost(string, tag="11")]
-    pub default_value: ::alloc::string::String,
+    pub default_value: alloc::string::String,
 }
 pub mod field {
     /// Basic field types.
@@ -1127,16 +1127,16 @@ pub mod field {
 pub struct Enum {
     /// Enum type name.
     #[prost(string, tag="1")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// Enum value definitions.
     #[prost(message, repeated, tag="2")]
-    pub enumvalue: ::alloc::vec::Vec<EnumValue>,
+    pub enumvalue: alloc::vec::Vec<EnumValue>,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="4")]
-    pub source_context: ::core::option::Option<SourceContext>,
+    pub source_context: core::option::Option<SourceContext>,
     /// The source syntax.
     #[prost(enumeration="Syntax", tag="5")]
     pub syntax: i32,
@@ -1146,13 +1146,13 @@ pub struct Enum {
 pub struct EnumValue {
     /// Enum value name.
     #[prost(string, tag="1")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// Enum value number.
     #[prost(int32, tag="2")]
     pub number: i32,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: alloc::vec::Vec<Option>,
 }
 /// A protocol buffer option, which can be attached to a message, field,
 /// enumeration, etc.
@@ -1163,13 +1163,13 @@ pub struct Option {
     /// For custom options, it should be the fully-qualified name. For example,
     /// `"google.api.http"`.
     #[prost(string, tag="1")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// The option's value packed in an Any message. If the value is a primitive,
     /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
     /// should be used. If the value is an enum, it should be stored as an int32
     /// value using the google.protobuf.Int32Value type.
     #[prost(message, optional, tag="2")]
-    pub value: ::core::option::Option<Any>,
+    pub value: core::option::Option<Any>,
 }
 /// The syntax in which a protocol buffer element is defined.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -1194,13 +1194,13 @@ pub struct Api {
     /// The fully qualified name of this interface, including package name
     /// followed by the interface's simple name.
     #[prost(string, tag="1")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// The methods of this interface, in unspecified order.
     #[prost(message, repeated, tag="2")]
-    pub methods: ::alloc::vec::Vec<Method>,
+    pub methods: alloc::vec::Vec<Method>,
     /// Any metadata attached to the interface.
     #[prost(message, repeated, tag="3")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: alloc::vec::Vec<Option>,
     /// A version string for this interface. If specified, must have the form
     /// `major-version.minor-version`, as in `1.10`. If the minor version is
     /// omitted, it defaults to zero. If the entire version field is empty, the
@@ -1223,14 +1223,14 @@ pub struct Api {
     ///
     ///
     #[prost(string, tag="4")]
-    pub version: ::alloc::string::String,
+    pub version: alloc::string::String,
     /// Source context for the protocol buffer service represented by this
     /// message.
     #[prost(message, optional, tag="5")]
-    pub source_context: ::core::option::Option<SourceContext>,
+    pub source_context: core::option::Option<SourceContext>,
     /// Included interfaces. See [Mixin][].
     #[prost(message, repeated, tag="6")]
-    pub mixins: ::alloc::vec::Vec<Mixin>,
+    pub mixins: alloc::vec::Vec<Mixin>,
     /// The source syntax of the service.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1240,22 +1240,22 @@ pub struct Api {
 pub struct Method {
     /// The simple name of this method.
     #[prost(string, tag="1")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// A URL of the input message type.
     #[prost(string, tag="2")]
-    pub request_type_url: ::alloc::string::String,
+    pub request_type_url: alloc::string::String,
     /// If true, the request is streamed.
     #[prost(bool, tag="3")]
     pub request_streaming: bool,
     /// The URL of the output message type.
     #[prost(string, tag="4")]
-    pub response_type_url: ::alloc::string::String,
+    pub response_type_url: alloc::string::String,
     /// If true, the response is streamed.
     #[prost(bool, tag="5")]
     pub response_streaming: bool,
     /// Any metadata attached to the method.
     #[prost(message, repeated, tag="6")]
-    pub options: ::alloc::vec::Vec<Option>,
+    pub options: alloc::vec::Vec<Option>,
     /// The source syntax of this method.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1342,11 +1342,11 @@ pub struct Method {
 pub struct Mixin {
     /// The fully qualified name of the interface which is included.
     #[prost(string, tag="1")]
-    pub name: ::alloc::string::String,
+    pub name: alloc::string::String,
     /// If non-empty specifies a path under which inherited HTTP paths
     /// are rooted.
     #[prost(string, tag="2")]
-    pub root: ::alloc::string::String,
+    pub root: alloc::string::String,
 }
 /// A Duration represents a signed, fixed-length span of time represented
 /// as a count of seconds and fractions of seconds at nanosecond
@@ -1627,7 +1627,7 @@ pub struct Duration {
 pub struct FieldMask {
     /// The set of field mask paths.
     #[prost(string, repeated, tag="1")]
-    pub paths: ::alloc::vec::Vec<::alloc::string::String>,
+    pub paths: alloc::vec::Vec<alloc::string::String>,
 }
 /// `Struct` represents a structured data value, consisting of fields
 /// which map to dynamically typed values. In some languages, `Struct`
@@ -1641,7 +1641,7 @@ pub struct FieldMask {
 pub struct Struct {
     /// Unordered map of dynamically typed values.
     #[prost(btree_map="string, message", tag="1")]
-    pub fields: ::alloc::collections::BTreeMap<::alloc::string::String, Value>,
+    pub fields: alloc::collections::BTreeMap<alloc::string::String, Value>,
 }
 /// `Value` represents a dynamically typed value which can be either
 /// null, a number, a string, a boolean, a recursive struct value, or a
@@ -1653,7 +1653,7 @@ pub struct Struct {
 pub struct Value {
     /// The kind of value.
     #[prost(oneof="value::Kind", tags="1, 2, 3, 4, 5, 6")]
-    pub kind: ::core::option::Option<value::Kind>,
+    pub kind: core::option::Option<value::Kind>,
 }
 pub mod value {
     /// The kind of value.
@@ -1667,7 +1667,7 @@ pub mod value {
         NumberValue(f64),
         /// Represents a string value.
         #[prost(string, tag="3")]
-        StringValue(::alloc::string::String),
+        StringValue(alloc::string::String),
         /// Represents a boolean value.
         #[prost(bool, tag="4")]
         BoolValue(bool),
@@ -1686,7 +1686,7 @@ pub mod value {
 pub struct ListValue {
     /// Repeated field of dynamically typed values.
     #[prost(message, repeated, tag="1")]
-    pub values: ::alloc::vec::Vec<Value>,
+    pub values: alloc::vec::Vec<Value>,
 }
 /// `NullValue` is a singleton enumeration to represent the null value for the
 /// `Value` type union.
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index ebf229cec..a137b07af 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -1,10 +1,9 @@
 #[macro_use]
 extern crate cfg_if;
 
-extern crate alloc;
-
 cfg_if! {
     if #[cfg(feature = "edition-2015")] {
+        extern crate alloc;
         extern crate bytes;
         extern crate core;
         extern crate prost;

From 4e1905329369ca7a1cac3eda978ee9379167ee95 Mon Sep 17 00:00:00 2001
From: Chris Beck <beck.ct@gmail.com>
Date: Thu, 5 Mar 2020 11:53:26 -0800
Subject: [PATCH 36/36] Do hidden re-export of alloc crate from prost, use in
 prost-build, prost-derive

This allows to remove `extern crate alloc;` from `protobuf` crate,
and I think it means that users who don't care about `no_std` don't
have to write `extern crate alloc;` to use prost
---
 prost-build/src/code_generator.rs   |  12 +-
 prost-derive/src/field/map.rs       |   6 +-
 prost-derive/src/field/scalar.rs    |  12 +-
 prost-types/src/compiler.rs         |  18 +--
 prost-types/src/protobuf.rs         | 204 ++++++++++++++--------------
 protobuf/src/lib.rs                 |   2 -
 src/lib.rs                          |   5 +-
 tests/src/message_encoding_alloc.rs |  16 +--
 8 files changed, 138 insertions(+), 137 deletions(-)

diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index dbbe00e13..b042cf228 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -375,12 +375,12 @@ impl<'a> CodeGenerator<'a> {
         self.buf.push_str(&to_snake(field.name()));
         self.buf.push_str(": ");
         if repeated {
-            self.buf.push_str("alloc::vec::Vec<");
+            self.buf.push_str("prost::alloc::vec::Vec<");
         } else if optional {
             self.buf.push_str("core::option::Option<");
         }
         if boxed {
-            self.buf.push_str("alloc::boxed::Box<");
+            self.buf.push_str("prost::alloc::boxed::Box<");
         }
         self.buf.push_str(&ty);
         if boxed {
@@ -418,7 +418,7 @@ impl<'a> CodeGenerator<'a> {
             .iter()
             .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
         let (annotation_ty, lib_name, rust_ty) = if btree_map {
-            ("btree_map", "alloc::collections", "BTreeMap")
+            ("btree_map", "prost::alloc::collections", "BTreeMap")
         } else {
             ("map", "std::collections", "HashMap")
         };
@@ -531,7 +531,7 @@ impl<'a> CodeGenerator<'a> {
 
             if boxed {
                 self.buf.push_str(&format!(
-                    "{}(alloc::boxed::Box<{}>),\n",
+                    "{}(prost::alloc::boxed::Box<{}>),\n",
                     to_upper_camel(field.name()),
                     ty
                 ));
@@ -726,8 +726,8 @@ impl<'a> CodeGenerator<'a> {
             Type::Int32 | Type::Sfixed32 | Type::Sint32 | Type::Enum => String::from("i32"),
             Type::Int64 | Type::Sfixed64 | Type::Sint64 => String::from("i64"),
             Type::Bool => String::from("bool"),
-            Type::String => String::from("alloc::string::String"),
-            Type::Bytes => String::from("alloc::vec::Vec<u8>"),
+            Type::String => String::from("prost::alloc::string::String"),
+            Type::Bytes => String::from("prost::alloc::vec::Vec<u8>"),
             Type::Group | Type::Message => self.resolve_ident(field.type_name()),
         }
     }
diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index d130498c3..760ae413e 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -294,10 +294,10 @@ impl Field {
             MapTy::HashMap => Ident::new("HashMap", Span::call_site()),
             MapTy::BTreeMap => Ident::new("BTreeMap", Span::call_site()),
         };
-        // HashMap is in std, BTreeMap is in alloc
+        // HashMap is in std, BTreeMap is in alloc (re-exported as prost::alloc)
         let libname = match self.map_ty {
-            MapTy::HashMap => Ident::new("std", Span::call_site()),
-            MapTy::BTreeMap => Ident::new("alloc", Span::call_site()),
+            MapTy::HashMap => quote! { std },
+            MapTy::BTreeMap => quote! { prost::alloc },
         };
 
         // A fake field for generating the debug wrapper
diff --git a/prost-derive/src/field/scalar.rs b/prost-derive/src/field/scalar.rs
index 55deaafa7..b55b2a8c1 100644
--- a/prost-derive/src/field/scalar.rs
+++ b/prost-derive/src/field/scalar.rs
@@ -214,7 +214,7 @@ impl Field {
         match self.kind {
             Kind::Plain(ref value) | Kind::Required(ref value) => value.owned(),
             Kind::Optional(_) => quote!(::core::option::Option::None),
-            Kind::Repeated | Kind::Packed => quote!(::alloc::vec::Vec::new()),
+            Kind::Repeated | Kind::Packed => quote!(::prost::alloc::vec::Vec::new()),
         }
     }
 
@@ -256,7 +256,7 @@ impl Field {
             },
             Kind::Repeated | Kind::Packed => {
                 quote! {
-                    struct #wrapper_name<'a>(&'a ::alloc::vec::Vec<#inner_ty>);
+                    struct #wrapper_name<'a>(&'a ::prost::alloc::vec::Vec<#inner_ty>);
                     impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
                         fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                             let mut vec_builder = f.debug_list();
@@ -497,8 +497,8 @@ impl Ty {
     // TODO: rename to 'owned_type'.
     pub fn rust_type(&self) -> TokenStream {
         match *self {
-            Ty::String => quote!(::alloc::string::String),
-            Ty::Bytes => quote!(::alloc::vec::Vec<u8>),
+            Ty::String => quote!(::prost::alloc::string::String),
+            Ty::Bytes => quote!(::prost::alloc::vec::Vec<u8>),
             _ => self.rust_ref_type(),
         }
     }
@@ -750,11 +750,11 @@ impl DefaultValue {
     pub fn owned(&self) -> TokenStream {
         match *self {
             DefaultValue::String(ref value) if value.is_empty() => {
-                quote!(::alloc::string::String::new())
+                quote!(::prost::alloc::string::String::new())
             }
             DefaultValue::String(ref value) => quote!(#value.to_owned()),
             DefaultValue::Bytes(ref value) if value.is_empty() => {
-                quote!(::alloc::vec::Vec::new())
+                quote!(::prost::alloc::vec::Vec::new())
             }
             DefaultValue::Bytes(ref value) => {
                 let lit = LitByteStr::new(value, Span::call_site());
diff --git a/prost-types/src/compiler.rs b/prost-types/src/compiler.rs
index e3b3c8dca..ebae62473 100644
--- a/prost-types/src/compiler.rs
+++ b/prost-types/src/compiler.rs
@@ -10,7 +10,7 @@ pub struct Version {
     /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     /// be empty for mainline stable releases.
     #[prost(string, optional, tag="4")]
-    pub suffix: core::option::Option<alloc::string::String>,
+    pub suffix: core::option::Option<prost::alloc::string::String>,
 }
 /// An encoded CodeGeneratorRequest is written to the plugin's stdin.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -19,10 +19,10 @@ pub struct CodeGeneratorRequest {
     /// code generator should generate code only for these files.  Each file's
     /// descriptor will be included in proto_file, below.
     #[prost(string, repeated, tag="1")]
-    pub file_to_generate: alloc::vec::Vec<alloc::string::String>,
+    pub file_to_generate: prost::alloc::vec::Vec<prost::alloc::string::String>,
     /// The generator parameter passed on the command-line.
     #[prost(string, optional, tag="2")]
-    pub parameter: core::option::Option<alloc::string::String>,
+    pub parameter: core::option::Option<prost::alloc::string::String>,
     /// FileDescriptorProtos for all files in files_to_generate and everything
     /// they import.  The files will appear in topological order, so each file
     /// appears before any file that imports it.
@@ -38,7 +38,7 @@ pub struct CodeGeneratorRequest {
     /// Type names of fields and extensions in the FileDescriptorProto are always
     /// fully qualified.
     #[prost(message, repeated, tag="15")]
-    pub proto_file: alloc::vec::Vec<super::FileDescriptorProto>,
+    pub proto_file: prost::alloc::vec::Vec<super::FileDescriptorProto>,
     /// The version number of protocol compiler.
     #[prost(message, optional, tag="3")]
     pub compiler_version: core::option::Option<Version>,
@@ -55,9 +55,9 @@ pub struct CodeGeneratorResponse {
     /// unparseable -- should be reported by writing a message to stderr and
     /// exiting with a non-zero status code.
     #[prost(string, optional, tag="1")]
-    pub error: core::option::Option<alloc::string::String>,
+    pub error: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="15")]
-    pub file: alloc::vec::Vec<code_generator_response::File>,
+    pub file: prost::alloc::vec::Vec<code_generator_response::File>,
 }
 pub mod code_generator_response {
     /// Represents a single generated file.
@@ -75,7 +75,7 @@ pub mod code_generator_response {
         /// this writing protoc does not optimize for this -- it will read the entire
         /// CodeGeneratorResponse before writing files to disk.
         #[prost(string, optional, tag="1")]
-        pub name: core::option::Option<alloc::string::String>,
+        pub name: core::option::Option<prost::alloc::string::String>,
         /// If non-empty, indicates that the named file should already exist, and the
         /// content here is to be inserted into that file at a defined insertion
         /// point.  This feature allows a code generator to extend the output
@@ -114,9 +114,9 @@ pub mod code_generator_response {
         ///
         /// If |insertion_point| is present, |name| must also be present.
         #[prost(string, optional, tag="2")]
-        pub insertion_point: core::option::Option<alloc::string::String>,
+        pub insertion_point: core::option::Option<prost::alloc::string::String>,
         /// The file contents.
         #[prost(string, optional, tag="15")]
-        pub content: core::option::Option<alloc::string::String>,
+        pub content: core::option::Option<prost::alloc::string::String>,
     }
 }
diff --git a/prost-types/src/protobuf.rs b/prost-types/src/protobuf.rs
index 4026c60ce..c18b3e836 100644
--- a/prost-types/src/protobuf.rs
+++ b/prost-types/src/protobuf.rs
@@ -3,36 +3,36 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorSet {
     #[prost(message, repeated, tag="1")]
-    pub file: alloc::vec::Vec<FileDescriptorProto>,
+    pub file: prost::alloc::vec::Vec<FileDescriptorProto>,
 }
 /// Describes a complete .proto file.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorProto {
     /// file name, relative to root of source tree
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     /// e.g. "foo", "foo.bar", etc.
     #[prost(string, optional, tag="2")]
-    pub package: core::option::Option<alloc::string::String>,
+    pub package: core::option::Option<prost::alloc::string::String>,
     /// Names of files imported by this file.
     #[prost(string, repeated, tag="3")]
-    pub dependency: alloc::vec::Vec<alloc::string::String>,
+    pub dependency: prost::alloc::vec::Vec<prost::alloc::string::String>,
     /// Indexes of the public imported files in the dependency list above.
     #[prost(int32, repeated, packed="false", tag="10")]
-    pub public_dependency: alloc::vec::Vec<i32>,
+    pub public_dependency: prost::alloc::vec::Vec<i32>,
     /// Indexes of the weak imported files in the dependency list.
     /// For Google-internal migration only. Do not use.
     #[prost(int32, repeated, packed="false", tag="11")]
-    pub weak_dependency: alloc::vec::Vec<i32>,
+    pub weak_dependency: prost::alloc::vec::Vec<i32>,
     /// All top-level definitions in this file.
     #[prost(message, repeated, tag="4")]
-    pub message_type: alloc::vec::Vec<DescriptorProto>,
+    pub message_type: prost::alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub enum_type: alloc::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: prost::alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub service: alloc::vec::Vec<ServiceDescriptorProto>,
+    pub service: prost::alloc::vec::Vec<ServiceDescriptorProto>,
     #[prost(message, repeated, tag="7")]
-    pub extension: alloc::vec::Vec<FieldDescriptorProto>,
+    pub extension: prost::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, optional, tag="8")]
     pub options: core::option::Option<FileOptions>,
     /// This field contains optional information about the original source code.
@@ -44,33 +44,33 @@ pub struct FileDescriptorProto {
     /// The syntax of the proto file.
     /// The supported values are "proto2" and "proto3".
     #[prost(string, optional, tag="12")]
-    pub syntax: core::option::Option<alloc::string::String>,
+    pub syntax: core::option::Option<prost::alloc::string::String>,
 }
 /// Describes a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub field: alloc::vec::Vec<FieldDescriptorProto>,
+    pub field: prost::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub extension: alloc::vec::Vec<FieldDescriptorProto>,
+    pub extension: prost::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="3")]
-    pub nested_type: alloc::vec::Vec<DescriptorProto>,
+    pub nested_type: prost::alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="4")]
-    pub enum_type: alloc::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: prost::alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub extension_range: alloc::vec::Vec<descriptor_proto::ExtensionRange>,
+    pub extension_range: prost::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
     #[prost(message, repeated, tag="8")]
-    pub oneof_decl: alloc::vec::Vec<OneofDescriptorProto>,
+    pub oneof_decl: prost::alloc::vec::Vec<OneofDescriptorProto>,
     #[prost(message, optional, tag="7")]
     pub options: core::option::Option<MessageOptions>,
     #[prost(message, repeated, tag="9")]
-    pub reserved_range: alloc::vec::Vec<descriptor_proto::ReservedRange>,
+    pub reserved_range: prost::alloc::vec::Vec<descriptor_proto::ReservedRange>,
     /// Reserved field names, which may not be used by fields in the same message.
     /// A given name may only be reserved once.
     #[prost(string, repeated, tag="10")]
-    pub reserved_name: alloc::vec::Vec<alloc::string::String>,
+    pub reserved_name: prost::alloc::vec::Vec<prost::alloc::string::String>,
 }
 pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -101,13 +101,13 @@ pub mod descriptor_proto {
 pub struct ExtensionRangeOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 /// Describes a field within a message.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(int32, optional, tag="3")]
     pub number: core::option::Option<i32>,
     #[prost(enumeration="field_descriptor_proto::Label", optional, tag="4")]
@@ -122,18 +122,18 @@ pub struct FieldDescriptorProto {
     /// message are searched, then within the parent, on up to the root
     /// namespace).
     #[prost(string, optional, tag="6")]
-    pub type_name: core::option::Option<alloc::string::String>,
+    pub type_name: core::option::Option<prost::alloc::string::String>,
     /// For extensions, this is the name of the type being extended.  It is
     /// resolved in the same manner as type_name.
     #[prost(string, optional, tag="2")]
-    pub extendee: core::option::Option<alloc::string::String>,
+    pub extendee: core::option::Option<prost::alloc::string::String>,
     /// For numeric types, contains the original text representation of the value.
     /// For booleans, "true" or "false".
     /// For strings, contains the default text contents (not escaped in any way).
     /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
     /// TODO(kenton):  Base-64 encode?
     #[prost(string, optional, tag="7")]
-    pub default_value: core::option::Option<alloc::string::String>,
+    pub default_value: core::option::Option<prost::alloc::string::String>,
     /// If set, gives the index of a oneof in the containing type's oneof_decl
     /// list.  This field is a member of that oneof.
     #[prost(int32, optional, tag="9")]
@@ -143,7 +143,7 @@ pub struct FieldDescriptorProto {
     /// will be used. Otherwise, it's deduced from the field's name by converting
     /// it to camelCase.
     #[prost(string, optional, tag="10")]
-    pub json_name: core::option::Option<alloc::string::String>,
+    pub json_name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, optional, tag="8")]
     pub options: core::option::Option<FieldOptions>,
 }
@@ -197,7 +197,7 @@ pub mod field_descriptor_proto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, optional, tag="2")]
     pub options: core::option::Option<OneofOptions>,
 }
@@ -205,20 +205,20 @@ pub struct OneofDescriptorProto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub value: alloc::vec::Vec<EnumValueDescriptorProto>,
+    pub value: prost::alloc::vec::Vec<EnumValueDescriptorProto>,
     #[prost(message, optional, tag="3")]
     pub options: core::option::Option<EnumOptions>,
     /// Range of reserved numeric values. Reserved numeric values may not be used
     /// by enum values in the same enum declaration. Reserved ranges may not
     /// overlap.
     #[prost(message, repeated, tag="4")]
-    pub reserved_range: alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
+    pub reserved_range: prost::alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
     /// Reserved enum value names, which may not be reused. A given name may only
     /// be reserved once.
     #[prost(string, repeated, tag="5")]
-    pub reserved_name: alloc::vec::Vec<alloc::string::String>,
+    pub reserved_name: prost::alloc::vec::Vec<prost::alloc::string::String>,
 }
 pub mod enum_descriptor_proto {
     /// Range of reserved numeric values. Reserved values may not be used by
@@ -241,7 +241,7 @@ pub mod enum_descriptor_proto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(int32, optional, tag="2")]
     pub number: core::option::Option<i32>,
     #[prost(message, optional, tag="3")]
@@ -251,9 +251,9 @@ pub struct EnumValueDescriptorProto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub method: alloc::vec::Vec<MethodDescriptorProto>,
+    pub method: prost::alloc::vec::Vec<MethodDescriptorProto>,
     #[prost(message, optional, tag="3")]
     pub options: core::option::Option<ServiceOptions>,
 }
@@ -261,13 +261,13 @@ pub struct ServiceDescriptorProto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: core::option::Option<alloc::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     /// Input and output type names.  These are resolved in the same way as
     /// FieldDescriptorProto.type_name, but must refer to a message type.
     #[prost(string, optional, tag="2")]
-    pub input_type: core::option::Option<alloc::string::String>,
+    pub input_type: core::option::Option<prost::alloc::string::String>,
     #[prost(string, optional, tag="3")]
-    pub output_type: core::option::Option<alloc::string::String>,
+    pub output_type: core::option::Option<prost::alloc::string::String>,
     #[prost(message, optional, tag="4")]
     pub options: core::option::Option<MethodOptions>,
     /// Identifies if client streams multiple client messages
@@ -316,14 +316,14 @@ pub struct FileOptions {
     /// inappropriate because proto packages do not normally start with backwards
     /// domain names.
     #[prost(string, optional, tag="1")]
-    pub java_package: core::option::Option<alloc::string::String>,
+    pub java_package: core::option::Option<prost::alloc::string::String>,
     /// If set, all the classes from the .proto file are wrapped in a single
     /// outer class with the given name.  This applies to both Proto1
     /// (equivalent to the old "--one_java_file" option) and Proto2 (where
     /// a .proto always translates to a single class, but you may want to
     /// explicitly choose the class name).
     #[prost(string, optional, tag="8")]
-    pub java_outer_classname: core::option::Option<alloc::string::String>,
+    pub java_outer_classname: core::option::Option<prost::alloc::string::String>,
     /// If set true, then the Java code generator will generate a separate .java
     /// file for each top-level message, enum, and service defined in the .proto
     /// file.  Thus, these types will *not* be nested inside the outer class
@@ -352,7 +352,7 @@ pub struct FileOptions {
     ///   - Otherwise, the package statement in the .proto file, if present.
     ///   - Otherwise, the basename of the .proto file, without extension.
     #[prost(string, optional, tag="11")]
-    pub go_package: core::option::Option<alloc::string::String>,
+    pub go_package: core::option::Option<prost::alloc::string::String>,
     /// Should generic services be generated in each language?  "Generic" services
     /// are not specific to any particular RPC system.  They are generated by the
     /// main code generators in each language (without additional plugins).
@@ -384,39 +384,39 @@ pub struct FileOptions {
     /// Sets the objective c class prefix which is prepended to all objective c
     /// generated classes from this .proto. There is no default.
     #[prost(string, optional, tag="36")]
-    pub objc_class_prefix: core::option::Option<alloc::string::String>,
+    pub objc_class_prefix: core::option::Option<prost::alloc::string::String>,
     /// Namespace for generated classes; defaults to the package.
     #[prost(string, optional, tag="37")]
-    pub csharp_namespace: core::option::Option<alloc::string::String>,
+    pub csharp_namespace: core::option::Option<prost::alloc::string::String>,
     /// By default Swift generators will take the proto package and CamelCase it
     /// replacing '.' with underscore and use that to prefix the types/symbols
     /// defined. When this options is provided, they will use this value instead
     /// to prefix the types/symbols defined.
     #[prost(string, optional, tag="39")]
-    pub swift_prefix: core::option::Option<alloc::string::String>,
+    pub swift_prefix: core::option::Option<prost::alloc::string::String>,
     /// Sets the php class prefix which is prepended to all php generated classes
     /// from this .proto. Default is empty.
     #[prost(string, optional, tag="40")]
-    pub php_class_prefix: core::option::Option<alloc::string::String>,
+    pub php_class_prefix: core::option::Option<prost::alloc::string::String>,
     /// Use this option to change the namespace of php generated classes. Default
     /// is empty. When this option is empty, the package name will be used for
     /// determining the namespace.
     #[prost(string, optional, tag="41")]
-    pub php_namespace: core::option::Option<alloc::string::String>,
+    pub php_namespace: core::option::Option<prost::alloc::string::String>,
     /// Use this option to change the namespace of php generated metadata classes.
     /// Default is empty. When this option is empty, the proto file name will be
     /// used for determining the namespace.
     #[prost(string, optional, tag="44")]
-    pub php_metadata_namespace: core::option::Option<alloc::string::String>,
+    pub php_metadata_namespace: core::option::Option<prost::alloc::string::String>,
     /// Use this option to change the package of ruby generated classes. Default
     /// is empty. When this option is not set, the package name will be used for
     /// determining the ruby package.
     #[prost(string, optional, tag="45")]
-    pub ruby_package: core::option::Option<alloc::string::String>,
+    pub ruby_package: core::option::Option<prost::alloc::string::String>,
     /// The parser stores options it doesn't recognize here.
     /// See the documentation for the "Options" section above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod file_options {
     /// Generated classes can be optimized for speed or code size.
@@ -491,7 +491,7 @@ pub struct MessageOptions {
     pub map_entry: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldOptions {
@@ -562,7 +562,7 @@ pub struct FieldOptions {
     pub weak: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod field_options {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -588,7 +588,7 @@ pub mod field_options {
 pub struct OneofOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumOptions {
@@ -604,7 +604,7 @@ pub struct EnumOptions {
     pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueOptions {
@@ -616,7 +616,7 @@ pub struct EnumValueOptions {
     pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceOptions {
@@ -633,7 +633,7 @@ pub struct ServiceOptions {
     pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodOptions {
@@ -652,7 +652,7 @@ pub struct MethodOptions {
     pub idempotency_level: core::option::Option<i32>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: alloc::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod method_options {
     /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
@@ -677,11 +677,11 @@ pub mod method_options {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UninterpretedOption {
     #[prost(message, repeated, tag="2")]
-    pub name: alloc::vec::Vec<uninterpreted_option::NamePart>,
+    pub name: prost::alloc::vec::Vec<uninterpreted_option::NamePart>,
     /// The value of the uninterpreted option, in whatever type the tokenizer
     /// identified it as during parsing. Exactly one of these should be set.
     #[prost(string, optional, tag="3")]
-    pub identifier_value: core::option::Option<alloc::string::String>,
+    pub identifier_value: core::option::Option<prost::alloc::string::String>,
     #[prost(uint64, optional, tag="4")]
     pub positive_int_value: core::option::Option<u64>,
     #[prost(int64, optional, tag="5")]
@@ -689,9 +689,9 @@ pub struct UninterpretedOption {
     #[prost(double, optional, tag="6")]
     pub double_value: core::option::Option<f64>,
     #[prost(bytes, optional, tag="7")]
-    pub string_value: core::option::Option<alloc::vec::Vec<u8>>,
+    pub string_value: core::option::Option<prost::alloc::vec::Vec<u8>>,
     #[prost(string, optional, tag="8")]
-    pub aggregate_value: core::option::Option<alloc::string::String>,
+    pub aggregate_value: core::option::Option<prost::alloc::string::String>,
 }
 pub mod uninterpreted_option {
     /// The name of the uninterpreted option.  Each string represents a segment in
@@ -702,7 +702,7 @@ pub mod uninterpreted_option {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NamePart {
         #[prost(string, required, tag="1")]
-        pub name_part: alloc::string::String,
+        pub name_part: prost::alloc::string::String,
         #[prost(bool, required, tag="2")]
         pub is_extension: bool,
     }
@@ -758,7 +758,7 @@ pub struct SourceCodeInfo {
     ///   ignore those that it doesn't understand, as more types of locations could
     ///   be recorded in the future.
     #[prost(message, repeated, tag="1")]
-    pub location: alloc::vec::Vec<source_code_info::Location>,
+    pub location: prost::alloc::vec::Vec<source_code_info::Location>,
 }
 pub mod source_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -787,14 +787,14 @@ pub mod source_code_info {
         /// this path refers to the whole field declaration (from the beginning
         /// of the label to the terminating semicolon).
         #[prost(int32, repeated, tag="1")]
-        pub path: alloc::vec::Vec<i32>,
+        pub path: prost::alloc::vec::Vec<i32>,
         /// Always has exactly three or four elements: start line, start column,
         /// end line (optional, otherwise assumed same as start line), end column.
         /// These are packed into a single field for efficiency.  Note that line
         /// and column numbers are zero-based -- typically you will want to add
         /// 1 to each before displaying to a user.
         #[prost(int32, repeated, tag="2")]
-        pub span: alloc::vec::Vec<i32>,
+        pub span: prost::alloc::vec::Vec<i32>,
         /// If this SourceCodeInfo represents a complete declaration, these are any
         /// comments appearing before and after the declaration which appear to be
         /// attached to the declaration.
@@ -843,11 +843,11 @@ pub mod source_code_info {
         ///
         ///   // ignored detached comments.
         #[prost(string, optional, tag="3")]
-        pub leading_comments: core::option::Option<alloc::string::String>,
+        pub leading_comments: core::option::Option<prost::alloc::string::String>,
         #[prost(string, optional, tag="4")]
-        pub trailing_comments: core::option::Option<alloc::string::String>,
+        pub trailing_comments: core::option::Option<prost::alloc::string::String>,
         #[prost(string, repeated, tag="6")]
-        pub leading_detached_comments: alloc::vec::Vec<alloc::string::String>,
+        pub leading_detached_comments: prost::alloc::vec::Vec<prost::alloc::string::String>,
     }
 }
 /// Describes the relationship between generated code and its original source
@@ -858,7 +858,7 @@ pub struct GeneratedCodeInfo {
     /// An Annotation connects some span of text in generated code to an element
     /// of its generating .proto file.
     #[prost(message, repeated, tag="1")]
-    pub annotation: alloc::vec::Vec<generated_code_info::Annotation>,
+    pub annotation: prost::alloc::vec::Vec<generated_code_info::Annotation>,
 }
 pub mod generated_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -866,10 +866,10 @@ pub mod generated_code_info {
         /// Identifies the element in the original source .proto file. This field
         /// is formatted the same as SourceCodeInfo.Location.path.
         #[prost(int32, repeated, tag="1")]
-        pub path: alloc::vec::Vec<i32>,
+        pub path: prost::alloc::vec::Vec<i32>,
         /// Identifies the filesystem path to the original source .proto.
         #[prost(string, optional, tag="2")]
-        pub source_file: core::option::Option<alloc::string::String>,
+        pub source_file: core::option::Option<prost::alloc::string::String>,
         /// Identifies the starting offset in bytes in the generated code
         /// that relates to the identified object.
         #[prost(int32, optional, tag="3")]
@@ -992,10 +992,10 @@ pub struct Any {
     /// used with implementation specific semantics.
     ///
     #[prost(string, tag="1")]
-    pub type_url: alloc::string::String,
+    pub type_url: prost::alloc::string::String,
     /// Must be a valid serialized protocol buffer of the above specified type.
     #[prost(bytes, tag="2")]
-    pub value: alloc::vec::Vec<u8>,
+    pub value: prost::alloc::vec::Vec<u8>,
 }
 /// `SourceContext` represents information about the source of a
 /// protobuf element, like the file in which it is defined.
@@ -1004,23 +1004,23 @@ pub struct SourceContext {
     /// The path-qualified name of the .proto file that contained the associated
     /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
     #[prost(string, tag="1")]
-    pub file_name: alloc::string::String,
+    pub file_name: prost::alloc::string::String,
 }
 /// A protocol buffer message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Type {
     /// The fully qualified message name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// The list of fields.
     #[prost(message, repeated, tag="2")]
-    pub fields: alloc::vec::Vec<Field>,
+    pub fields: prost::alloc::vec::Vec<Field>,
     /// The list of types appearing in `oneof` definitions in this type.
     #[prost(string, repeated, tag="3")]
-    pub oneofs: alloc::vec::Vec<alloc::string::String>,
+    pub oneofs: prost::alloc::vec::Vec<prost::alloc::string::String>,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="4")]
-    pub options: alloc::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="5")]
     pub source_context: core::option::Option<SourceContext>,
@@ -1042,11 +1042,11 @@ pub struct Field {
     pub number: i32,
     /// The field name.
     #[prost(string, tag="4")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// The field type URL, without the scheme, for message or enumeration
     /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
     #[prost(string, tag="6")]
-    pub type_url: alloc::string::String,
+    pub type_url: prost::alloc::string::String,
     /// The index of the field type in `Type.oneofs`, for message or enumeration
     /// types. The first type has index 1; zero means the type is not in the list.
     #[prost(int32, tag="7")]
@@ -1056,13 +1056,13 @@ pub struct Field {
     pub packed: bool,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="9")]
-    pub options: alloc::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The field JSON name.
     #[prost(string, tag="10")]
-    pub json_name: alloc::string::String,
+    pub json_name: prost::alloc::string::String,
     /// The string value of the default value of this field. Proto2 syntax only.
     #[prost(string, tag="11")]
-    pub default_value: alloc::string::String,
+    pub default_value: prost::alloc::string::String,
 }
 pub mod field {
     /// Basic field types.
@@ -1127,13 +1127,13 @@ pub mod field {
 pub struct Enum {
     /// Enum type name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// Enum value definitions.
     #[prost(message, repeated, tag="2")]
-    pub enumvalue: alloc::vec::Vec<EnumValue>,
+    pub enumvalue: prost::alloc::vec::Vec<EnumValue>,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: alloc::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="4")]
     pub source_context: core::option::Option<SourceContext>,
@@ -1146,13 +1146,13 @@ pub struct Enum {
 pub struct EnumValue {
     /// Enum value name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// Enum value number.
     #[prost(int32, tag="2")]
     pub number: i32,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: alloc::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
 }
 /// A protocol buffer option, which can be attached to a message, field,
 /// enumeration, etc.
@@ -1163,7 +1163,7 @@ pub struct Option {
     /// For custom options, it should be the fully-qualified name. For example,
     /// `"google.api.http"`.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// The option's value packed in an Any message. If the value is a primitive,
     /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
     /// should be used. If the value is an enum, it should be stored as an int32
@@ -1194,13 +1194,13 @@ pub struct Api {
     /// The fully qualified name of this interface, including package name
     /// followed by the interface's simple name.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// The methods of this interface, in unspecified order.
     #[prost(message, repeated, tag="2")]
-    pub methods: alloc::vec::Vec<Method>,
+    pub methods: prost::alloc::vec::Vec<Method>,
     /// Any metadata attached to the interface.
     #[prost(message, repeated, tag="3")]
-    pub options: alloc::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// A version string for this interface. If specified, must have the form
     /// `major-version.minor-version`, as in `1.10`. If the minor version is
     /// omitted, it defaults to zero. If the entire version field is empty, the
@@ -1223,14 +1223,14 @@ pub struct Api {
     ///
     ///
     #[prost(string, tag="4")]
-    pub version: alloc::string::String,
+    pub version: prost::alloc::string::String,
     /// Source context for the protocol buffer service represented by this
     /// message.
     #[prost(message, optional, tag="5")]
     pub source_context: core::option::Option<SourceContext>,
     /// Included interfaces. See [Mixin][].
     #[prost(message, repeated, tag="6")]
-    pub mixins: alloc::vec::Vec<Mixin>,
+    pub mixins: prost::alloc::vec::Vec<Mixin>,
     /// The source syntax of the service.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1240,22 +1240,22 @@ pub struct Api {
 pub struct Method {
     /// The simple name of this method.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// A URL of the input message type.
     #[prost(string, tag="2")]
-    pub request_type_url: alloc::string::String,
+    pub request_type_url: prost::alloc::string::String,
     /// If true, the request is streamed.
     #[prost(bool, tag="3")]
     pub request_streaming: bool,
     /// The URL of the output message type.
     #[prost(string, tag="4")]
-    pub response_type_url: alloc::string::String,
+    pub response_type_url: prost::alloc::string::String,
     /// If true, the response is streamed.
     #[prost(bool, tag="5")]
     pub response_streaming: bool,
     /// Any metadata attached to the method.
     #[prost(message, repeated, tag="6")]
-    pub options: alloc::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The source syntax of this method.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1342,11 +1342,11 @@ pub struct Method {
 pub struct Mixin {
     /// The fully qualified name of the interface which is included.
     #[prost(string, tag="1")]
-    pub name: alloc::string::String,
+    pub name: prost::alloc::string::String,
     /// If non-empty specifies a path under which inherited HTTP paths
     /// are rooted.
     #[prost(string, tag="2")]
-    pub root: alloc::string::String,
+    pub root: prost::alloc::string::String,
 }
 /// A Duration represents a signed, fixed-length span of time represented
 /// as a count of seconds and fractions of seconds at nanosecond
@@ -1627,7 +1627,7 @@ pub struct Duration {
 pub struct FieldMask {
     /// The set of field mask paths.
     #[prost(string, repeated, tag="1")]
-    pub paths: alloc::vec::Vec<alloc::string::String>,
+    pub paths: prost::alloc::vec::Vec<prost::alloc::string::String>,
 }
 /// `Struct` represents a structured data value, consisting of fields
 /// which map to dynamically typed values. In some languages, `Struct`
@@ -1641,7 +1641,7 @@ pub struct FieldMask {
 pub struct Struct {
     /// Unordered map of dynamically typed values.
     #[prost(btree_map="string, message", tag="1")]
-    pub fields: alloc::collections::BTreeMap<alloc::string::String, Value>,
+    pub fields: prost::alloc::collections::BTreeMap<prost::alloc::string::String, Value>,
 }
 /// `Value` represents a dynamically typed value which can be either
 /// null, a number, a string, a boolean, a recursive struct value, or a
@@ -1667,7 +1667,7 @@ pub mod value {
         NumberValue(f64),
         /// Represents a string value.
         #[prost(string, tag="3")]
-        StringValue(alloc::string::String),
+        StringValue(prost::alloc::string::String),
         /// Represents a boolean value.
         #[prost(bool, tag="4")]
         BoolValue(bool),
@@ -1686,7 +1686,7 @@ pub mod value {
 pub struct ListValue {
     /// Repeated field of dynamically typed values.
     #[prost(message, repeated, tag="1")]
-    pub values: alloc::vec::Vec<Value>,
+    pub values: prost::alloc::vec::Vec<Value>,
 }
 /// `NullValue` is a singleton enumeration to represent the null value for the
 /// `Value` type union.
diff --git a/protobuf/src/lib.rs b/protobuf/src/lib.rs
index 255649e5a..9f8048fb7 100644
--- a/protobuf/src/lib.rs
+++ b/protobuf/src/lib.rs
@@ -1,5 +1,3 @@
-extern crate alloc;
-
 pub mod benchmarks {
     include!(concat!(env!("OUT_DIR"), "/benchmarks.rs"));
 
diff --git a/src/lib.rs b/src/lib.rs
index 33a5712a0..f4854b8a6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,10 @@
 #![doc(html_root_url = "https://docs.rs/prost/0.6.1")]
 #![no_std]
 
-extern crate alloc;
+// This hidden re-export of alloc crate gives prost-derive a way to get alloc types,
+// without forcing users of prost-derive to write `extern crate alloc;`
+#[doc(hidden)]
+pub extern crate alloc;
 
 #[cfg(feature = "std")]
 extern crate std;
diff --git a/tests/src/message_encoding_alloc.rs b/tests/src/message_encoding_alloc.rs
index 2d0c34b5f..d0f4f4855 100644
--- a/tests/src/message_encoding_alloc.rs
+++ b/tests/src/message_encoding_alloc.rs
@@ -236,7 +236,7 @@ pub struct TagsInferred {
     #[prost(enumeration = "BasicEnumeration", default = "ONE")]
     pub ten: i32,
     #[prost(btree_map = "string, string")]
-    pub eleven: ::alloc::collections::BTreeMap<String, String>,
+    pub eleven: prost::alloc::collections::BTreeMap<String, String>,
 
     #[prost(tag = "5", bytes)]
     pub back_to_five: Vec<u8>,
@@ -263,7 +263,7 @@ pub struct TagsQualified {
     #[prost(tag = "10", enumeration = "BasicEnumeration", default = "ONE")]
     pub ten: i32,
     #[prost(tag = "11", btree_map = "string, string")]
-    pub eleven: ::alloc::collections::BTreeMap<String, String>,
+    pub eleven: prost::alloc::collections::BTreeMap<String, String>,
 }
 
 /// A prost message with default value.
@@ -327,16 +327,16 @@ pub struct Basic {
     pub enumeration: i32,
 
     #[prost(btree_map = "int32, enumeration(BasicEnumeration)", tag = "6")]
-    pub enumeration_map: ::alloc::collections::BTreeMap<i32, i32>,
+    pub enumeration_map: prost::alloc::collections::BTreeMap<i32, i32>,
 
     #[prost(btree_map = "string, string", tag = "7")]
-    pub string_map: ::alloc::collections::BTreeMap<String, String>,
+    pub string_map: prost::alloc::collections::BTreeMap<String, String>,
 
     #[prost(btree_map = "int32, enumeration(BasicEnumeration)", tag = "10")]
-    pub enumeration_btree_map: ::alloc::collections::BTreeMap<i32, i32>,
+    pub enumeration_btree_map: prost::alloc::collections::BTreeMap<i32, i32>,
 
     #[prost(btree_map = "string, string", tag = "11")]
-    pub string_btree_map: ::alloc::collections::BTreeMap<String, String>,
+    pub string_btree_map: prost::alloc::collections::BTreeMap<String, String>,
 
     #[prost(oneof = "BasicOneof", tags = "8, 9")]
     pub oneof: Option<BasicOneof>,
@@ -354,10 +354,10 @@ pub struct Compound {
     pub repeated_message: Vec<Basic>,
 
     #[prost(btree_map = "sint32, message", tag = "4")]
-    pub message_map: ::alloc::collections::BTreeMap<i32, Basic>,
+    pub message_map: prost::alloc::collections::BTreeMap<i32, Basic>,
 
     #[prost(btree_map = "sint32, message", tag = "5")]
-    pub message_btree_map: ::alloc::collections::BTreeMap<i32, Basic>,
+    pub message_btree_map: prost::alloc::collections::BTreeMap<i32, Basic>,
 }
 
 #[derive(Clone, PartialEq, Oneof)]